1 /* Support for the generic parts of most COFF variants, for BFD. 2 Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 1998 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 [email protected] 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_linno_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 PARAMS ((bfd *, PTR, const char *)); 317 static boolean coff_bad_format_hook PARAMS ((bfd *, PTR)); 318 static boolean coff_new_section_hook PARAMS ((bfd *, asection *)); 319 static boolean coff_set_arch_mach_hook PARAMS ((bfd *, PTR)); 320 static boolean coff_write_relocs PARAMS ((bfd *, int)); 321 static boolean coff_set_flags 322 PARAMS ((bfd *, unsigned int *, unsigned short *)); 323 static boolean coff_set_arch_mach 324 PARAMS ((bfd *, enum bfd_architecture, unsigned long)); 325 static boolean coff_compute_section_file_positions PARAMS ((bfd *)); 326 static boolean coff_write_object_contents PARAMS ((bfd *)); 327 static boolean coff_set_section_contents 328 PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type)); 329 static PTR buy_and_read PARAMS ((bfd *, file_ptr, int, size_t)); 330 static boolean coff_slurp_line_table PARAMS ((bfd *, asection *)); 331 static boolean coff_slurp_symbol_table PARAMS ((bfd *)); 332 static boolean coff_slurp_reloc_table PARAMS ((bfd *, asection *, asymbol **)); 333 static long coff_canonicalize_reloc 334 PARAMS ((bfd *, asection *, arelent **, asymbol **)); 335 #ifndef coff_mkobject_hook 336 static PTR coff_mkobject_hook PARAMS ((bfd *, PTR, PTR)); 337 #endif 338 339 /* void warning(); */ 340 341 /* 342 * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the 343 * incoming SEC_* flags. The inverse of this function is styp_to_sec_flags(). 344 * NOTE: If you add to/change this routine, you should mirror the changes 345 * in styp_to_sec_flags(). 346 */ 347 static long 348 sec_to_styp_flags (sec_name, sec_flags) 349 CONST char *sec_name; 350 flagword sec_flags; 351 { 352 long styp_flags = 0; 353 354 if (!strcmp (sec_name, _TEXT)) 355 { 356 styp_flags = STYP_TEXT; 357 } 358 else if (!strcmp (sec_name, _DATA)) 359 { 360 styp_flags = STYP_DATA; 361 } 362 else if (!strcmp (sec_name, _BSS)) 363 { 364 styp_flags = STYP_BSS; 365 #ifdef _COMMENT 366 } 367 else if (!strcmp (sec_name, _COMMENT)) 368 { 369 styp_flags = STYP_INFO; 370 #endif /* _COMMENT */ 371 #ifdef _LIB 372 } 373 else if (!strcmp (sec_name, _LIB)) 374 { 375 styp_flags = STYP_LIB; 376 #endif /* _LIB */ 377 #ifdef _LIT 378 } 379 else if (!strcmp (sec_name, _LIT)) 380 { 381 styp_flags = STYP_LIT; 382 #endif /* _LIT */ 383 } 384 else if (!strcmp (sec_name, ".debug")) 385 { 386 #ifdef STYP_DEBUG 387 styp_flags = STYP_DEBUG; 388 #else 389 styp_flags = STYP_INFO; 390 #endif 391 } 392 else if (!strncmp (sec_name, ".stab", 5)) 393 { 394 styp_flags = STYP_INFO; 395 } 396 #ifdef COFF_WITH_PE 397 else if (!strcmp (sec_name, ".edata")) 398 { 399 styp_flags = STYP_DATA; 400 } 401 #endif 402 #ifdef RS6000COFF_C 403 else if (!strcmp (sec_name, _PAD)) 404 { 405 styp_flags = STYP_PAD; 406 } 407 else if (!strcmp (sec_name, _LOADER)) 408 { 409 styp_flags = STYP_LOADER; 410 } 411 #endif 412 /* Try and figure out what it should be */ 413 else if (sec_flags & SEC_CODE) 414 { 415 styp_flags = STYP_TEXT; 416 } 417 else if (sec_flags & SEC_DATA) 418 { 419 styp_flags = STYP_DATA; 420 } 421 else if (sec_flags & SEC_READONLY) 422 { 423 #ifdef STYP_LIT /* 29k readonly text/data section */ 424 styp_flags = STYP_LIT; 425 #else 426 styp_flags = STYP_TEXT; 427 #endif /* STYP_LIT */ 428 } 429 else if (sec_flags & SEC_LOAD) 430 { 431 styp_flags = STYP_TEXT; 432 } 433 else if (sec_flags & SEC_ALLOC) 434 { 435 styp_flags = STYP_BSS; 436 } 437 438 #ifdef STYP_NOLOAD 439 if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0) 440 styp_flags |= STYP_NOLOAD; 441 #endif 442 443 #ifdef COFF_WITH_PE 444 if (sec_flags & SEC_LINK_ONCE) 445 styp_flags |= IMAGE_SCN_LNK_COMDAT; 446 #endif 447 448 return (styp_flags); 449 } 450 /* 451 * Return a word with SEC_* flags set to represent the incoming 452 * STYP_* flags (from scnhdr.s_flags). The inverse of this 453 * function is sec_to_styp_flags(). 454 * NOTE: If you add to/change this routine, you should mirror the changes 455 * in sec_to_styp_flags(). 456 */ 457 static flagword 458 styp_to_sec_flags (abfd, hdr, name) 459 bfd *abfd; 460 PTR hdr; 461 const char *name; 462 { 463 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr; 464 long styp_flags = internal_s->s_flags; 465 flagword sec_flags = 0; 466 467 #ifdef STYP_NOLOAD 468 if (styp_flags & STYP_NOLOAD) 469 { 470 sec_flags |= SEC_NEVER_LOAD; 471 } 472 #endif /* STYP_NOLOAD */ 473 474 /* For 386 COFF, at least, an unloadable text or data section is 475 actually a shared library section. */ 476 if (styp_flags & STYP_TEXT) 477 { 478 if (sec_flags & SEC_NEVER_LOAD) 479 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY; 480 else 481 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC; 482 } 483 else if (styp_flags & STYP_DATA) 484 { 485 if (sec_flags & SEC_NEVER_LOAD) 486 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY; 487 else 488 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC; 489 } 490 else if (styp_flags & STYP_BSS) 491 { 492 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY 493 if (sec_flags & SEC_NEVER_LOAD) 494 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY; 495 else 496 #endif 497 sec_flags |= SEC_ALLOC; 498 } 499 else if (styp_flags & STYP_INFO) 500 { 501 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is 502 defined. coff_compute_section_file_positions uses 503 COFF_PAGE_SIZE to ensure that the low order bits of the 504 section VMA and the file offset match. If we don't know 505 COFF_PAGE_SIZE, we can't ensure the correct correspondence, 506 and demand page loading of the file will fail. */ 507 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS) 508 sec_flags |= SEC_DEBUGGING; 509 #endif 510 } 511 else if (styp_flags & STYP_PAD) 512 { 513 sec_flags = 0; 514 } 515 else if (strcmp (name, _TEXT) == 0) 516 { 517 if (sec_flags & SEC_NEVER_LOAD) 518 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY; 519 else 520 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC; 521 } 522 else if (strcmp (name, _DATA) == 0) 523 { 524 if (sec_flags & SEC_NEVER_LOAD) 525 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY; 526 else 527 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC; 528 } 529 else if (strcmp (name, _BSS) == 0) 530 { 531 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY 532 if (sec_flags & SEC_NEVER_LOAD) 533 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY; 534 else 535 #endif 536 sec_flags |= SEC_ALLOC; 537 } 538 else if (strcmp (name, ".debug") == 0 539 #ifdef _COMMENT 540 || strcmp (name, _COMMENT) == 0 541 #endif 542 || strncmp (name, ".stab", 5) == 0) 543 { 544 #ifdef COFF_PAGE_SIZE 545 sec_flags |= SEC_DEBUGGING; 546 #endif 547 } 548 #ifdef _LIB 549 else if (strcmp (name, _LIB) == 0) 550 ; 551 #endif 552 #ifdef _LIT 553 else if (strcmp (name, _LIT) == 0) 554 { 555 sec_flags = SEC_LOAD | SEC_ALLOC | SEC_READONLY; 556 } 557 #endif 558 else 559 { 560 sec_flags |= SEC_ALLOC | SEC_LOAD; 561 } 562 563 #ifdef STYP_LIT /* A29k readonly text/data section type */ 564 if ((styp_flags & STYP_LIT) == STYP_LIT) 565 { 566 sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY); 567 } 568 #endif /* STYP_LIT */ 569 #ifdef STYP_OTHER_LOAD /* Other loaded sections */ 570 if (styp_flags & STYP_OTHER_LOAD) 571 { 572 sec_flags = (SEC_LOAD | SEC_ALLOC); 573 } 574 #endif /* STYP_SDATA */ 575 576 #ifdef COFF_WITH_PE 577 if (styp_flags & IMAGE_SCN_LNK_REMOVE) 578 sec_flags |= SEC_EXCLUDE; 579 580 if (styp_flags & IMAGE_SCN_LNK_COMDAT) 581 { 582 sec_flags |= SEC_LINK_ONCE; 583 584 /* Unfortunately, the PE format stores essential information in 585 the symbol table, of all places. We need to extract that 586 information now, so that objdump and the linker will know how 587 to handle the section without worrying about the symbols. We 588 can't call slurp_symtab, because the linker doesn't want the 589 swapped symbols. */ 590 591 if (_bfd_coff_get_external_symbols (abfd)) 592 { 593 bfd_byte *esym, *esymend; 594 595 esym = (bfd_byte *) obj_coff_external_syms (abfd); 596 esymend = esym + obj_raw_syment_count (abfd) * SYMESZ; 597 598 while (esym < esymend) 599 { 600 struct internal_syment isym; 601 602 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &isym); 603 604 if (sizeof (internal_s->s_name) > SYMNMLEN) 605 { 606 /* This case implies that the matching symbol name 607 will be in the string table. */ 608 abort (); 609 } 610 611 if (isym.n_sclass == C_STAT 612 && isym.n_type == T_NULL 613 && isym.n_numaux == 1) 614 { 615 char buf[SYMNMLEN + 1]; 616 const char *symname; 617 618 symname = _bfd_coff_internal_syment_name (abfd, &isym, buf); 619 if (symname == NULL) 620 abort (); 621 622 if (strcmp (name, symname) == 0) 623 { 624 union internal_auxent aux; 625 626 /* This is the section symbol. */ 627 628 bfd_coff_swap_aux_in (abfd, (PTR) (esym + SYMESZ), 629 isym.n_type, isym.n_sclass, 630 0, isym.n_numaux, (PTR) &aux); 631 632 switch (aux.x_scn.x_comdat) 633 { 634 case IMAGE_COMDAT_SELECT_NODUPLICATES: 635 sec_flags |= SEC_LINK_DUPLICATES_ONE_ONLY; 636 break; 637 638 default: 639 case IMAGE_COMDAT_SELECT_ANY: 640 sec_flags |= SEC_LINK_DUPLICATES_DISCARD; 641 break; 642 643 case IMAGE_COMDAT_SELECT_SAME_SIZE: 644 sec_flags |= SEC_LINK_DUPLICATES_SAME_SIZE; 645 break; 646 647 case IMAGE_COMDAT_SELECT_EXACT_MATCH: 648 sec_flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS; 649 break; 650 651 case IMAGE_COMDAT_SELECT_ASSOCIATIVE: 652 /* FIXME: This is not currently implemented. */ 653 sec_flags |= SEC_LINK_DUPLICATES_DISCARD; 654 break; 655 } 656 657 break; 658 } 659 } 660 661 esym += (isym.n_numaux + 1) * SYMESZ; 662 } 663 } 664 } 665 #endif 666 667 return (sec_flags); 668 } 669 670 #define get_index(symbol) ((symbol)->udata.i) 671 672 /* 673 INTERNAL_DEFINITION 674 bfd_coff_backend_data 675 676 CODE_FRAGMENT 677 678 Special entry points for gdb to swap in coff symbol table parts: 679 .typedef struct 680 .{ 681 . void (*_bfd_coff_swap_aux_in) PARAMS (( 682 . bfd *abfd, 683 . PTR ext, 684 . int type, 685 . int class, 686 . int indaux, 687 . int numaux, 688 . PTR in)); 689 . 690 . void (*_bfd_coff_swap_sym_in) PARAMS (( 691 . bfd *abfd , 692 . PTR ext, 693 . PTR in)); 694 . 695 . void (*_bfd_coff_swap_lineno_in) PARAMS (( 696 . bfd *abfd, 697 . PTR ext, 698 . PTR in)); 699 . 700 701 Special entry points for gas to swap out coff parts: 702 703 . unsigned int (*_bfd_coff_swap_aux_out) PARAMS (( 704 . bfd *abfd, 705 . PTR in, 706 . int type, 707 . int class, 708 . int indaux, 709 . int numaux, 710 . PTR ext)); 711 . 712 . unsigned int (*_bfd_coff_swap_sym_out) PARAMS (( 713 . bfd *abfd, 714 . PTR in, 715 . PTR ext)); 716 . 717 . unsigned int (*_bfd_coff_swap_lineno_out) PARAMS (( 718 . bfd *abfd, 719 . PTR in, 720 . PTR ext)); 721 . 722 . unsigned int (*_bfd_coff_swap_reloc_out) PARAMS (( 723 . bfd *abfd, 724 . PTR src, 725 . PTR dst)); 726 . 727 . unsigned int (*_bfd_coff_swap_filehdr_out) PARAMS (( 728 . bfd *abfd, 729 . PTR in, 730 . PTR out)); 731 . 732 . unsigned int (*_bfd_coff_swap_aouthdr_out) PARAMS (( 733 . bfd *abfd, 734 . PTR in, 735 . PTR out)); 736 . 737 . unsigned int (*_bfd_coff_swap_scnhdr_out) PARAMS (( 738 . bfd *abfd, 739 . PTR in, 740 . PTR out)); 741 . 742 743 Special entry points for generic COFF routines to call target 744 dependent COFF routines: 745 746 . unsigned int _bfd_filhsz; 747 . unsigned int _bfd_aoutsz; 748 . unsigned int _bfd_scnhsz; 749 . unsigned int _bfd_symesz; 750 . unsigned int _bfd_auxesz; 751 . unsigned int _bfd_relsz; 752 . unsigned int _bfd_linesz; 753 . boolean _bfd_coff_long_filenames; 754 . boolean _bfd_coff_long_section_names; 755 . unsigned int _bfd_coff_default_section_alignment_power; 756 . void (*_bfd_coff_swap_filehdr_in) PARAMS (( 757 . bfd *abfd, 758 . PTR ext, 759 . PTR in)); 760 . void (*_bfd_coff_swap_aouthdr_in) PARAMS (( 761 . bfd *abfd, 762 . PTR ext, 763 . PTR in)); 764 . void (*_bfd_coff_swap_scnhdr_in) PARAMS (( 765 . bfd *abfd, 766 . PTR ext, 767 . PTR in)); 768 . void (*_bfd_coff_swap_reloc_in) PARAMS (( 769 . bfd *abfd, 770 . PTR ext, 771 . PTR in)); 772 . boolean (*_bfd_coff_bad_format_hook) PARAMS (( 773 . bfd *abfd, 774 . PTR internal_filehdr)); 775 . boolean (*_bfd_coff_set_arch_mach_hook) PARAMS (( 776 . bfd *abfd, 777 . PTR internal_filehdr)); 778 . PTR (*_bfd_coff_mkobject_hook) PARAMS (( 779 . bfd *abfd, 780 . PTR internal_filehdr, 781 . PTR internal_aouthdr)); 782 . flagword (*_bfd_styp_to_sec_flags_hook) PARAMS (( 783 . bfd *abfd, 784 . PTR internal_scnhdr, 785 . const char *name)); 786 . void (*_bfd_set_alignment_hook) PARAMS (( 787 . bfd *abfd, 788 . asection *sec, 789 . PTR internal_scnhdr)); 790 . boolean (*_bfd_coff_slurp_symbol_table) PARAMS (( 791 . bfd *abfd)); 792 . boolean (*_bfd_coff_symname_in_debug) PARAMS (( 793 . bfd *abfd, 794 . struct internal_syment *sym)); 795 . boolean (*_bfd_coff_pointerize_aux_hook) PARAMS (( 796 . bfd *abfd, 797 . combined_entry_type *table_base, 798 . combined_entry_type *symbol, 799 . unsigned int indaux, 800 . combined_entry_type *aux)); 801 . boolean (*_bfd_coff_print_aux) PARAMS (( 802 . bfd *abfd, 803 . FILE *file, 804 . combined_entry_type *table_base, 805 . combined_entry_type *symbol, 806 . combined_entry_type *aux, 807 . unsigned int indaux)); 808 . void (*_bfd_coff_reloc16_extra_cases) PARAMS (( 809 . bfd *abfd, 810 . struct bfd_link_info *link_info, 811 . struct bfd_link_order *link_order, 812 . arelent *reloc, 813 . bfd_byte *data, 814 . unsigned int *src_ptr, 815 . unsigned int *dst_ptr)); 816 . int (*_bfd_coff_reloc16_estimate) PARAMS (( 817 . bfd *abfd, 818 . asection *input_section, 819 . arelent *r, 820 . unsigned int shrink, 821 . struct bfd_link_info *link_info)); 822 . boolean (*_bfd_coff_sym_is_global) PARAMS (( 823 . bfd *abfd, 824 . struct internal_syment *)); 825 . boolean (*_bfd_coff_compute_section_file_positions) PARAMS (( 826 . bfd *abfd)); 827 . boolean (*_bfd_coff_start_final_link) PARAMS (( 828 . bfd *output_bfd, 829 . struct bfd_link_info *info)); 830 . boolean (*_bfd_coff_relocate_section) PARAMS (( 831 . bfd *output_bfd, 832 . struct bfd_link_info *info, 833 . bfd *input_bfd, 834 . asection *input_section, 835 . bfd_byte *contents, 836 . struct internal_reloc *relocs, 837 . struct internal_syment *syms, 838 . asection **sections)); 839 . reloc_howto_type *(*_bfd_coff_rtype_to_howto) PARAMS (( 840 . bfd *abfd, 841 . asection *sec, 842 . struct internal_reloc *rel, 843 . struct coff_link_hash_entry *h, 844 . struct internal_syment *sym, 845 . bfd_vma *addendp)); 846 . boolean (*_bfd_coff_adjust_symndx) PARAMS (( 847 . bfd *obfd, 848 . struct bfd_link_info *info, 849 . bfd *ibfd, 850 . asection *sec, 851 . struct internal_reloc *reloc, 852 . boolean *adjustedp)); 853 . boolean (*_bfd_coff_link_add_one_symbol) PARAMS (( 854 . struct bfd_link_info *info, 855 . bfd *abfd, 856 . const char *name, 857 . flagword flags, 858 . asection *section, 859 . bfd_vma value, 860 . const char *string, 861 . boolean copy, 862 . boolean collect, 863 . struct bfd_link_hash_entry **hashp)); 864 . 865 . boolean (*_bfd_coff_link_output_has_begun) PARAMS (( 866 . bfd * abfd )); 867 . boolean (*_bfd_coff_final_link_postscript) PARAMS (( 868 . bfd * abfd, 869 . struct coff_final_link_info * pfinfo)); 870 . 871 .} bfd_coff_backend_data; 872 . 873 .#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data) 874 . 875 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \ 876 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i)) 877 . 878 .#define bfd_coff_swap_sym_in(a,e,i) \ 879 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i)) 880 . 881 .#define bfd_coff_swap_lineno_in(a,e,i) \ 882 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i)) 883 . 884 .#define bfd_coff_swap_reloc_out(abfd, i, o) \ 885 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o)) 886 . 887 .#define bfd_coff_swap_lineno_out(abfd, i, o) \ 888 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o)) 889 . 890 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \ 891 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o)) 892 . 893 .#define bfd_coff_swap_sym_out(abfd, i,o) \ 894 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o)) 895 . 896 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \ 897 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o)) 898 . 899 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \ 900 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o)) 901 . 902 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \ 903 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o)) 904 . 905 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz) 906 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz) 907 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz) 908 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz) 909 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz) 910 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz) 911 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz) 912 .#define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames) 913 .#define bfd_coff_long_section_names(abfd) \ 914 . (coff_backend_info (abfd)->_bfd_coff_long_section_names) 915 .#define bfd_coff_default_section_alignment_power(abfd) \ 916 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power) 917 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \ 918 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o)) 919 . 920 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \ 921 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o)) 922 . 923 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \ 924 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o)) 925 . 926 .#define bfd_coff_swap_reloc_in(abfd, i, o) \ 927 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o)) 928 . 929 .#define bfd_coff_bad_format_hook(abfd, filehdr) \ 930 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr)) 931 . 932 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\ 933 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr)) 934 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\ 935 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr)) 936 . 937 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name)\ 938 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook) (abfd, scnhdr, name)) 939 . 940 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\ 941 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr)) 942 . 943 .#define bfd_coff_slurp_symbol_table(abfd)\ 944 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd)) 945 . 946 .#define bfd_coff_symname_in_debug(abfd, sym)\ 947 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym)) 948 . 949 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\ 950 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\ 951 . (abfd, file, base, symbol, aux, indaux)) 952 . 953 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\ 954 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\ 955 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)) 956 . 957 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\ 958 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\ 959 . (abfd, section, reloc, shrink, link_info)) 960 . 961 .#define bfd_coff_sym_is_global(abfd, sym)\ 962 . ((coff_backend_info (abfd)->_bfd_coff_sym_is_global)\ 963 . (abfd, sym)) 964 . 965 .#define bfd_coff_compute_section_file_positions(abfd)\ 966 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\ 967 . (abfd)) 968 . 969 .#define bfd_coff_start_final_link(obfd, info)\ 970 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\ 971 . (obfd, info)) 972 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\ 973 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\ 974 . (obfd, info, ibfd, o, con, rel, isyms, secs)) 975 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\ 976 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\ 977 . (abfd, sec, rel, h, sym, addendp)) 978 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\ 979 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\ 980 . (obfd, info, ibfd, sec, rel, adjustedp)) 981 .#define bfd_coff_link_add_one_symbol(info,abfd,name,flags,section,value,string,cp,coll,hashp)\ 982 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\ 983 . (info, abfd, name, flags, section, value, string, cp, coll, hashp)) 984 . 985 .#define bfd_coff_link_output_has_begun(a) \ 986 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a)) 987 .#define bfd_coff_final_link_postscript(a,p) \ 988 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p)) 989 . 990 */ 991 992 /* See whether the magic number matches. */ 993 994 static boolean 995 coff_bad_format_hook (abfd, filehdr) 996 bfd * abfd; 997 PTR filehdr; 998 { 999 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; 1000 1001 if (BADMAG (*internal_f)) 1002 return false; 1003 1004 /* if the optional header is NULL or not the correct size then 1005 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC) 1006 and Intel 960 readwrite headers (I960WRMAGIC) is that the 1007 optional header is of a different size. 1008 1009 But the mips keeps extra stuff in it's opthdr, so dont check 1010 when doing that 1011 */ 1012 1013 #if defined(M88) || defined(I960) 1014 if (internal_f->f_opthdr != 0 && AOUTSZ != internal_f->f_opthdr) 1015 return false; 1016 #endif 1017 1018 return true; 1019 } 1020 1021 /* 1022 initialize a section structure with information peculiar to this 1023 particular implementation of coff 1024 */ 1025 1026 static boolean 1027 coff_new_section_hook (abfd, section) 1028 bfd * abfd; 1029 asection * section; 1030 { 1031 combined_entry_type *native; 1032 1033 section->alignment_power = COFF_DEFAULT_SECTION_ALIGNMENT_POWER; 1034 1035 #ifdef RS6000COFF_C 1036 if (xcoff_data (abfd)->text_align_power != 0 1037 && strcmp (bfd_get_section_name (abfd, section), ".text") == 0) 1038 section->alignment_power = xcoff_data (abfd)->text_align_power; 1039 if (xcoff_data (abfd)->data_align_power != 0 1040 && strcmp (bfd_get_section_name (abfd, section), ".data") == 0) 1041 section->alignment_power = xcoff_data (abfd)->data_align_power; 1042 #endif 1043 1044 /* Allocate aux records for section symbols, to store size and 1045 related info. 1046 1047 @@ The 10 is a guess at a plausible maximum number of aux entries 1048 (but shouldn't be a constant). */ 1049 native = ((combined_entry_type *) 1050 bfd_zalloc (abfd, sizeof (combined_entry_type) * 10)); 1051 if (native == NULL) 1052 return false; 1053 1054 /* We don't need to set up n_name, n_value, or n_scnum in the native 1055 symbol information, since they'll be overriden by the BFD symbol 1056 anyhow. However, we do need to set the type and storage class, 1057 in case this symbol winds up getting written out. The value 0 1058 for n_numaux is already correct. */ 1059 1060 native->u.syment.n_type = T_NULL; 1061 native->u.syment.n_sclass = C_STAT; 1062 1063 coffsymbol (section->symbol)->native = native; 1064 1065 /* The .stab section must be aligned to 2**2 at most, because 1066 otherwise there may be gaps in the section which gdb will not 1067 know how to interpret. Examining the section name is a hack, but 1068 that is also how gdb locates the section. 1069 We need to handle the .ctors and .dtors sections similarly, to 1070 avoid introducing null words in the tables. */ 1071 if (COFF_DEFAULT_SECTION_ALIGNMENT_POWER > 2 1072 && (strncmp (section->name, ".stab", 5) == 0 1073 || strcmp (section->name, ".ctors") == 0 1074 || strcmp (section->name, ".dtors") == 0)) 1075 section->alignment_power = 2; 1076 1077 /* Similarly, the .stabstr section must be aligned to 2**0 at most. */ 1078 if (COFF_DEFAULT_SECTION_ALIGNMENT_POWER > 0 1079 && strncmp (section->name, ".stabstr", 8) == 0) 1080 section->alignment_power = 0; 1081 1082 return true; 1083 } 1084 1085 #ifdef COFF_ALIGN_IN_SECTION_HEADER 1086 1087 /* Set the alignment of a BFD section. */ 1088 1089 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR)); 1090 1091 static void 1092 coff_set_alignment_hook (abfd, section, scnhdr) 1093 bfd * abfd; 1094 asection * section; 1095 PTR scnhdr; 1096 { 1097 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr; 1098 unsigned int i; 1099 1100 #ifdef I960 1101 /* Extract ALIGN from 2**ALIGN stored in section header */ 1102 for (i = 0; i < 32; i++) 1103 if ((1 << i) >= hdr->s_align) 1104 break; 1105 #endif 1106 section->alignment_power = i; 1107 } 1108 1109 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */ 1110 #ifdef COFF_WITH_PE 1111 1112 /* a couple of macros to help setting the alignment power field */ 1113 #define ALIGN_SET(field,x,y) \ 1114 if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\ 1115 {\ 1116 section->alignment_power = y;\ 1117 } 1118 1119 #define ELIFALIGN_SET(field,x,y) \ 1120 else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \ 1121 {\ 1122 section->alignment_power = y;\ 1123 } 1124 1125 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR)); 1126 1127 static void 1128 coff_set_alignment_hook (abfd, section, scnhdr) 1129 bfd * abfd; 1130 asection * section; 1131 PTR scnhdr; 1132 { 1133 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr; 1134 1135 ALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_64BYTES, 6) 1136 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_32BYTES, 5) 1137 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_16BYTES, 4) 1138 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_8BYTES, 3) 1139 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_4BYTES, 2) 1140 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_2BYTES, 1) 1141 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_1BYTES, 0) 1142 1143 #ifdef POWERPC_LE_PE 1144 if (strcmp (section->name, ".idata$2") == 0) 1145 { 1146 section->alignment_power = 0; 1147 } 1148 else if (strcmp (section->name, ".idata$3") == 0) 1149 { 1150 section->alignment_power = 0; 1151 } 1152 else if (strcmp (section->name, ".idata$4") == 0) 1153 { 1154 section->alignment_power = 2; 1155 } 1156 else if (strcmp (section->name, ".idata$5") == 0) 1157 { 1158 section->alignment_power = 2; 1159 } 1160 else if (strcmp (section->name, ".idata$6") == 0) 1161 { 1162 section->alignment_power = 1; 1163 } 1164 else if (strcmp (section->name, ".reloc") == 0) 1165 { 1166 section->alignment_power = 1; 1167 } 1168 else if (strncmp (section->name, ".stab", 5) == 0) 1169 { 1170 section->alignment_power = 2; 1171 } 1172 #endif 1173 1174 #ifdef COFF_IMAGE_WITH_PE 1175 /* In a PE image file, the s_paddr field holds the virtual size of a 1176 section, while the s_size field holds the raw size. */ 1177 if (hdr->s_paddr != 0) 1178 { 1179 if (coff_section_data (abfd, section) == NULL) 1180 { 1181 section->used_by_bfd = 1182 (PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata)); 1183 if (section->used_by_bfd == NULL) 1184 { 1185 /* FIXME: Return error. */ 1186 abort (); 1187 } 1188 } 1189 if (pei_section_data (abfd, section) == NULL) 1190 { 1191 coff_section_data (abfd, section)->tdata = 1192 (PTR) bfd_zalloc (abfd, sizeof (struct pei_section_tdata)); 1193 if (coff_section_data (abfd, section)->tdata == NULL) 1194 { 1195 /* FIXME: Return error. */ 1196 abort (); 1197 } 1198 } 1199 pei_section_data (abfd, section)->virt_size = hdr->s_paddr; 1200 } 1201 #endif 1202 1203 } 1204 #undef ALIGN_SET 1205 #undef ELIFALIGN_SET 1206 1207 #else /* ! COFF_WITH_PE */ 1208 #ifdef RS6000COFF_C 1209 1210 /* We grossly abuse this function to handle XCOFF overflow headers. 1211 When we see one, we correct the reloc and line number counts in the 1212 real header, and remove the section we just created. */ 1213 1214 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR)); 1215 1216 static void 1217 coff_set_alignment_hook (abfd, section, scnhdr) 1218 bfd *abfd; 1219 asection *section; 1220 PTR scnhdr; 1221 { 1222 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr; 1223 asection *real_sec; 1224 asection **ps; 1225 1226 if ((hdr->s_flags & STYP_OVRFLO) == 0) 1227 return; 1228 1229 real_sec = coff_section_from_bfd_index (abfd, hdr->s_nreloc); 1230 if (real_sec == NULL) 1231 return; 1232 1233 real_sec->reloc_count = hdr->s_paddr; 1234 real_sec->lineno_count = hdr->s_vaddr; 1235 1236 for (ps = &abfd->sections; *ps != NULL; ps = &(*ps)->next) 1237 { 1238 if (*ps == section) 1239 { 1240 *ps = (*ps)->next; 1241 --abfd->section_count; 1242 break; 1243 } 1244 } 1245 } 1246 1247 #else /* ! RS6000COFF_C */ 1248 1249 #define coff_set_alignment_hook \ 1250 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void) 1251 1252 #endif /* ! RS6000COFF_C */ 1253 #endif /* ! COFF_WITH_PE */ 1254 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */ 1255 1256 #ifndef coff_mkobject 1257 1258 static boolean coff_mkobject PARAMS ((bfd *)); 1259 1260 static boolean 1261 coff_mkobject (abfd) 1262 bfd * abfd; 1263 { 1264 coff_data_type *coff; 1265 1266 abfd->tdata.coff_obj_data = (struct coff_tdata *) bfd_zalloc (abfd, sizeof (coff_data_type)); 1267 if (abfd->tdata.coff_obj_data == 0) 1268 return false; 1269 coff = coff_data (abfd); 1270 coff->symbols = (coff_symbol_type *) NULL; 1271 coff->conversion_table = (unsigned int *) NULL; 1272 coff->raw_syments = (struct coff_ptr_struct *) NULL; 1273 coff->relocbase = 0; 1274 coff->local_toc_sym_map = 0; 1275 1276 /* make_abs_section(abfd);*/ 1277 1278 return true; 1279 } 1280 #endif 1281 1282 /* Create the COFF backend specific information. */ 1283 #ifndef coff_mkobject_hook 1284 static PTR 1285 coff_mkobject_hook (abfd, filehdr, aouthdr) 1286 bfd * abfd; 1287 PTR filehdr; 1288 PTR aouthdr; 1289 { 1290 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; 1291 coff_data_type *coff; 1292 1293 if (coff_mkobject (abfd) == false) 1294 return NULL; 1295 1296 coff = coff_data (abfd); 1297 1298 coff->sym_filepos = internal_f->f_symptr; 1299 1300 /* These members communicate important constants about the symbol 1301 table to GDB's symbol-reading code. These `constants' 1302 unfortunately vary among coff implementations... */ 1303 coff->local_n_btmask = N_BTMASK; 1304 coff->local_n_btshft = N_BTSHFT; 1305 coff->local_n_tmask = N_TMASK; 1306 coff->local_n_tshift = N_TSHIFT; 1307 coff->local_symesz = SYMESZ; 1308 coff->local_auxesz = AUXESZ; 1309 coff->local_linesz = LINESZ; 1310 1311 obj_raw_syment_count (abfd) = 1312 obj_conv_table_size (abfd) = 1313 internal_f->f_nsyms; 1314 1315 #ifdef RS6000COFF_C 1316 if ((internal_f->f_flags & F_SHROBJ) != 0) 1317 abfd->flags |= DYNAMIC; 1318 if (aouthdr != NULL && internal_f->f_opthdr >= AOUTSZ) 1319 { 1320 struct internal_aouthdr *internal_a = 1321 (struct internal_aouthdr *) aouthdr; 1322 struct xcoff_tdata *xcoff; 1323 1324 xcoff = xcoff_data (abfd); 1325 xcoff->full_aouthdr = true; 1326 xcoff->toc = internal_a->o_toc; 1327 xcoff->sntoc = internal_a->o_sntoc; 1328 xcoff->snentry = internal_a->o_snentry; 1329 xcoff->text_align_power = internal_a->o_algntext; 1330 xcoff->data_align_power = internal_a->o_algndata; 1331 xcoff->modtype = internal_a->o_modtype; 1332 xcoff->cputype = internal_a->o_cputype; 1333 xcoff->maxdata = internal_a->o_maxdata; 1334 xcoff->maxstack = internal_a->o_maxstack; 1335 } 1336 #endif 1337 1338 #ifdef ARM 1339 /* Set the flags field from the COFF header read in */ 1340 if (! coff_arm_bfd_set_private_flags (abfd, internal_f->f_flags)) 1341 coff->flags = 0; 1342 #endif 1343 1344 return (PTR) coff; 1345 } 1346 #endif 1347 1348 /* Determine the machine architecture and type. FIXME: This is target 1349 dependent because the magic numbers are defined in the target 1350 dependent header files. But there is no particular need for this. 1351 If the magic numbers were moved to a separate file, this function 1352 would be target independent and would also be much more successful 1353 at linking together COFF files for different architectures. */ 1354 1355 static boolean 1356 coff_set_arch_mach_hook (abfd, filehdr) 1357 bfd *abfd; 1358 PTR filehdr; 1359 { 1360 long machine; 1361 enum bfd_architecture arch; 1362 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; 1363 1364 machine = 0; 1365 switch (internal_f->f_magic) 1366 { 1367 #ifdef PPCMAGIC 1368 case PPCMAGIC: 1369 arch = bfd_arch_powerpc; 1370 machine = 0; /* what does this mean? (krk) */ 1371 break; 1372 #endif 1373 #ifdef I386MAGIC 1374 case I386MAGIC: 1375 case I386PTXMAGIC: 1376 case I386AIXMAGIC: /* Danbury PS/2 AIX C Compiler */ 1377 case LYNXCOFFMAGIC: /* shadows the m68k Lynx number below, sigh */ 1378 arch = bfd_arch_i386; 1379 machine = 0; 1380 break; 1381 #endif 1382 #ifdef A29K_MAGIC_BIG 1383 case A29K_MAGIC_BIG: 1384 case A29K_MAGIC_LITTLE: 1385 arch = bfd_arch_a29k; 1386 machine = 0; 1387 break; 1388 #endif 1389 #ifdef ARMMAGIC 1390 case ARMMAGIC: 1391 arch = bfd_arch_arm; 1392 switch (internal_f->f_flags & F_ARM_ARCHITECTURE_MASK) 1393 { 1394 case F_ARM_2: machine = bfd_mach_arm_2; break; 1395 case F_ARM_2a: machine = bfd_mach_arm_2a; break; 1396 case F_ARM_3: machine = bfd_mach_arm_3; break; 1397 default: 1398 case F_ARM_3M: machine = bfd_mach_arm_3M; break; 1399 case F_ARM_4: machine = bfd_mach_arm_4; break; 1400 case F_ARM_4T: machine = bfd_mach_arm_4T; break; 1401 } 1402 break; 1403 #endif 1404 #ifdef MC68MAGIC 1405 case MC68MAGIC: 1406 case M68MAGIC: 1407 #ifdef MC68KBCSMAGIC 1408 case MC68KBCSMAGIC: 1409 #endif 1410 #ifdef APOLLOM68KMAGIC 1411 case APOLLOM68KMAGIC: 1412 #endif 1413 #ifdef LYNXCOFFMAGIC 1414 case LYNXCOFFMAGIC: 1415 #endif 1416 arch = bfd_arch_m68k; 1417 machine = bfd_mach_m68020; 1418 break; 1419 #endif 1420 #ifdef MC88MAGIC 1421 case MC88MAGIC: 1422 case MC88DMAGIC: 1423 case MC88OMAGIC: 1424 arch = bfd_arch_m88k; 1425 machine = 88100; 1426 break; 1427 #endif 1428 #ifdef Z8KMAGIC 1429 case Z8KMAGIC: 1430 arch = bfd_arch_z8k; 1431 switch (internal_f->f_flags & F_MACHMASK) 1432 { 1433 case F_Z8001: 1434 machine = bfd_mach_z8001; 1435 break; 1436 case F_Z8002: 1437 machine = bfd_mach_z8002; 1438 break; 1439 default: 1440 return false; 1441 } 1442 break; 1443 #endif 1444 #ifdef I860 1445 case I860MAGIC: 1446 arch = bfd_arch_i860; 1447 break; 1448 #endif 1449 #ifdef I960 1450 #ifdef I960ROMAGIC 1451 case I960ROMAGIC: 1452 case I960RWMAGIC: 1453 arch = bfd_arch_i960; 1454 switch (F_I960TYPE & internal_f->f_flags) 1455 { 1456 default: 1457 case F_I960CORE: 1458 machine = bfd_mach_i960_core; 1459 break; 1460 case F_I960KB: 1461 machine = bfd_mach_i960_kb_sb; 1462 break; 1463 case F_I960MC: 1464 machine = bfd_mach_i960_mc; 1465 break; 1466 case F_I960XA: 1467 machine = bfd_mach_i960_xa; 1468 break; 1469 case F_I960CA: 1470 machine = bfd_mach_i960_ca; 1471 break; 1472 case F_I960KA: 1473 machine = bfd_mach_i960_ka_sa; 1474 break; 1475 case F_I960JX: 1476 machine = bfd_mach_i960_jx; 1477 break; 1478 case F_I960HX: 1479 machine = bfd_mach_i960_hx; 1480 break; 1481 } 1482 break; 1483 #endif 1484 #endif 1485 1486 #ifdef RS6000COFF_C 1487 case U802ROMAGIC: 1488 case U802WRMAGIC: 1489 case U802TOCMAGIC: 1490 { 1491 int cputype; 1492 1493 if (xcoff_data (abfd)->cputype != -1) 1494 cputype = xcoff_data (abfd)->cputype & 0xff; 1495 else 1496 { 1497 /* We did not get a value from the a.out header. If the 1498 file has not been stripped, we may be able to get the 1499 architecture information from the first symbol, if it 1500 is a .file symbol. */ 1501 if (obj_raw_syment_count (abfd) == 0) 1502 cputype = 0; 1503 else 1504 { 1505 bfd_byte buf[SYMESZ]; 1506 struct internal_syment sym; 1507 1508 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0 1509 || bfd_read (buf, 1, SYMESZ, abfd) != SYMESZ) 1510 return false; 1511 coff_swap_sym_in (abfd, (PTR) buf, (PTR) &sym); 1512 if (sym.n_sclass == C_FILE) 1513 cputype = sym.n_type & 0xff; 1514 else 1515 cputype = 0; 1516 } 1517 } 1518 1519 /* FIXME: We don't handle all cases here. */ 1520 switch (cputype) 1521 { 1522 default: 1523 case 0: 1524 #ifdef POWERMAC 1525 /* PowerPC Macs use the same magic numbers as RS/6000 1526 (because that's how they were bootstrapped originally), 1527 but they are always PowerPC architecture. */ 1528 arch = bfd_arch_powerpc; 1529 machine = 0; 1530 #else 1531 arch = bfd_arch_rs6000; 1532 machine = 6000; 1533 #endif /* POWERMAC */ 1534 break; 1535 1536 case 1: 1537 arch = bfd_arch_powerpc; 1538 machine = 601; 1539 break; 1540 case 2: /* 64 bit PowerPC */ 1541 arch = bfd_arch_powerpc; 1542 machine = 620; 1543 break; 1544 case 3: 1545 arch = bfd_arch_powerpc; 1546 machine = 0; 1547 break; 1548 case 4: 1549 arch = bfd_arch_rs6000; 1550 machine = 6000; 1551 break; 1552 } 1553 } 1554 break; 1555 #endif 1556 1557 #ifdef WE32KMAGIC 1558 case WE32KMAGIC: 1559 arch = bfd_arch_we32k; 1560 machine = 0; 1561 break; 1562 #endif 1563 1564 #ifdef H8300MAGIC 1565 case H8300MAGIC: 1566 arch = bfd_arch_h8300; 1567 machine = bfd_mach_h8300; 1568 /* !! FIXME this probably isn't the right place for this */ 1569 abfd->flags |= BFD_IS_RELAXABLE; 1570 break; 1571 #endif 1572 1573 #ifdef H8300HMAGIC 1574 case H8300HMAGIC: 1575 arch = bfd_arch_h8300; 1576 machine = bfd_mach_h8300h; 1577 /* !! FIXME this probably isn't the right place for this */ 1578 abfd->flags |= BFD_IS_RELAXABLE; 1579 break; 1580 #endif 1581 1582 #ifdef H8300SMAGIC 1583 case H8300SMAGIC: 1584 arch = bfd_arch_h8300; 1585 machine = bfd_mach_h8300s; 1586 /* !! FIXME this probably isn't the right place for this */ 1587 abfd->flags |= BFD_IS_RELAXABLE; 1588 break; 1589 #endif 1590 1591 #ifdef SH_ARCH_MAGIC_BIG 1592 case SH_ARCH_MAGIC_BIG: 1593 case SH_ARCH_MAGIC_LITTLE: 1594 arch = bfd_arch_sh; 1595 machine = 0; 1596 break; 1597 #endif 1598 1599 #ifdef H8500MAGIC 1600 case H8500MAGIC: 1601 arch = bfd_arch_h8500; 1602 machine = 0; 1603 break; 1604 #endif 1605 1606 #ifdef SPARCMAGIC 1607 case SPARCMAGIC: 1608 #ifdef LYNXCOFFMAGIC 1609 case LYNXCOFFMAGIC: 1610 #endif 1611 arch = bfd_arch_sparc; 1612 machine = 0; 1613 break; 1614 #endif 1615 1616 #ifdef TIC30MAGIC 1617 case TIC30MAGIC: 1618 arch = bfd_arch_tic30; 1619 break; 1620 #endif 1621 1622 1623 default: /* Unreadable input file type */ 1624 arch = bfd_arch_obscure; 1625 break; 1626 } 1627 1628 bfd_default_set_arch_mach (abfd, arch, machine); 1629 return true; 1630 } 1631 1632 #ifdef SYMNAME_IN_DEBUG 1633 1634 static boolean symname_in_debug_hook 1635 PARAMS ((bfd *, struct internal_syment *)); 1636 1637 static boolean 1638 symname_in_debug_hook (abfd, sym) 1639 bfd * abfd; 1640 struct internal_syment *sym; 1641 { 1642 return SYMNAME_IN_DEBUG (sym) ? true : false; 1643 } 1644 1645 #else 1646 1647 #define symname_in_debug_hook \ 1648 (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false 1649 1650 #endif 1651 1652 #ifdef RS6000COFF_C 1653 1654 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */ 1655 1656 static boolean coff_pointerize_aux_hook 1657 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *, 1658 unsigned int, combined_entry_type *)); 1659 1660 /*ARGSUSED*/ 1661 static boolean 1662 coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux) 1663 bfd *abfd; 1664 combined_entry_type *table_base; 1665 combined_entry_type *symbol; 1666 unsigned int indaux; 1667 combined_entry_type *aux; 1668 { 1669 int class = symbol->u.syment.n_sclass; 1670 1671 if ((class == C_EXT || class == C_HIDEXT) 1672 && indaux + 1 == symbol->u.syment.n_numaux) 1673 { 1674 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD) 1675 { 1676 aux->u.auxent.x_csect.x_scnlen.p = 1677 table_base + aux->u.auxent.x_csect.x_scnlen.l; 1678 aux->fix_scnlen = 1; 1679 } 1680 1681 /* Return true to indicate that the caller should not do any 1682 further work on this auxent. */ 1683 return true; 1684 } 1685 1686 /* Return false to indicate that this auxent should be handled by 1687 the caller. */ 1688 return false; 1689 } 1690 1691 #else 1692 #ifdef I960 1693 1694 /* We don't want to pointerize bal entries. */ 1695 1696 static boolean coff_pointerize_aux_hook 1697 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *, 1698 unsigned int, combined_entry_type *)); 1699 1700 /*ARGSUSED*/ 1701 static boolean 1702 coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux) 1703 bfd *abfd; 1704 combined_entry_type *table_base; 1705 combined_entry_type *symbol; 1706 unsigned int indaux; 1707 combined_entry_type *aux; 1708 { 1709 /* Return true if we don't want to pointerize this aux entry, which 1710 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */ 1711 return (indaux == 1 1712 && (symbol->u.syment.n_sclass == C_LEAFPROC 1713 || symbol->u.syment.n_sclass == C_LEAFSTAT 1714 || symbol->u.syment.n_sclass == C_LEAFEXT)); 1715 } 1716 1717 #else /* ! I960 */ 1718 1719 #define coff_pointerize_aux_hook 0 1720 1721 #endif /* ! I960 */ 1722 #endif /* ! RS6000COFF_C */ 1723 1724 /* Print an aux entry. This returns true if it has printed it. */ 1725 1726 static boolean coff_print_aux 1727 PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *, 1728 combined_entry_type *, unsigned int)); 1729 1730 static boolean 1731 coff_print_aux (abfd, file, table_base, symbol, aux, indaux) 1732 bfd *abfd; 1733 FILE *file; 1734 combined_entry_type *table_base; 1735 combined_entry_type *symbol; 1736 combined_entry_type *aux; 1737 unsigned int indaux; 1738 { 1739 #ifdef RS6000COFF_C 1740 if ((symbol->u.syment.n_sclass == C_EXT 1741 || symbol->u.syment.n_sclass == C_HIDEXT) 1742 && indaux + 1 == symbol->u.syment.n_numaux) 1743 { 1744 /* This is a csect entry. */ 1745 fprintf (file, "AUX "); 1746 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD) 1747 { 1748 BFD_ASSERT (! aux->fix_scnlen); 1749 fprintf (file, "val %5ld", aux->u.auxent.x_csect.x_scnlen.l); 1750 } 1751 else 1752 { 1753 fprintf (file, "indx "); 1754 if (! aux->fix_scnlen) 1755 fprintf (file, "%4ld", aux->u.auxent.x_csect.x_scnlen.l); 1756 else 1757 fprintf (file, "%4ld", 1758 (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base)); 1759 } 1760 fprintf (file, 1761 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u", 1762 aux->u.auxent.x_csect.x_parmhash, 1763 (unsigned int) aux->u.auxent.x_csect.x_snhash, 1764 SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp), 1765 SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp), 1766 (unsigned int) aux->u.auxent.x_csect.x_smclas, 1767 aux->u.auxent.x_csect.x_stab, 1768 (unsigned int) aux->u.auxent.x_csect.x_snstab); 1769 return true; 1770 } 1771 #endif 1772 1773 /* Return false to indicate that no special action was taken. */ 1774 return false; 1775 } 1776 1777 /* 1778 SUBSUBSECTION 1779 Writing relocations 1780 1781 To write relocations, the back end steps though the 1782 canonical relocation table and create an 1783 @code{internal_reloc}. The symbol index to use is removed from 1784 the @code{offset} field in the symbol table supplied. The 1785 address comes directly from the sum of the section base 1786 address and the relocation offset; the type is dug directly 1787 from the howto field. Then the @code{internal_reloc} is 1788 swapped into the shape of an @code{external_reloc} and written 1789 out to disk. 1790 1791 */ 1792 1793 #ifdef TARG_AUX 1794 1795 static int compare_arelent_ptr PARAMS ((const PTR, const PTR)); 1796 1797 /* AUX's ld wants relocations to be sorted */ 1798 static int 1799 compare_arelent_ptr (x, y) 1800 const PTR x; 1801 const PTR y; 1802 { 1803 const arelent **a = (const arelent **) x; 1804 const arelent **b = (const arelent **) y; 1805 bfd_size_type aadr = (*a)->address; 1806 bfd_size_type badr = (*b)->address; 1807 1808 return (aadr < badr ? -1 : badr < aadr ? 1 : 0); 1809 } 1810 1811 #endif /* TARG_AUX */ 1812 1813 static boolean 1814 coff_write_relocs (abfd, first_undef) 1815 bfd * abfd; 1816 int first_undef; 1817 { 1818 asection *s; 1819 1820 for (s = abfd->sections; s != (asection *) NULL; s = s->next) 1821 { 1822 unsigned int i; 1823 struct external_reloc dst; 1824 arelent **p; 1825 1826 #ifndef TARG_AUX 1827 p = s->orelocation; 1828 #else 1829 /* sort relocations before we write them out */ 1830 p = (arelent **) bfd_malloc (s->reloc_count * sizeof (arelent *)); 1831 if (p == NULL && s->reloc_count > 0) 1832 return false; 1833 memcpy (p, s->orelocation, s->reloc_count * sizeof (arelent *)); 1834 qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr); 1835 #endif 1836 1837 if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0) 1838 return false; 1839 for (i = 0; i < s->reloc_count; i++) 1840 { 1841 struct internal_reloc n; 1842 arelent *q = p[i]; 1843 memset ((PTR) & n, 0, sizeof (n)); 1844 1845 /* Now we've renumbered the symbols we know where the 1846 undefined symbols live in the table. Check the reloc 1847 entries for symbols who's output bfd isn't the right one. 1848 This is because the symbol was undefined (which means 1849 that all the pointers are never made to point to the same 1850 place). This is a bad thing,'cause the symbols attached 1851 to the output bfd are indexed, so that the relocation 1852 entries know which symbol index they point to. So we 1853 have to look up the output symbol here. */ 1854 1855 if (q->sym_ptr_ptr[0]->the_bfd != abfd) 1856 { 1857 int i; 1858 const char *sname = q->sym_ptr_ptr[0]->name; 1859 asymbol **outsyms = abfd->outsymbols; 1860 for (i = first_undef; outsyms[i]; i++) 1861 { 1862 const char *intable = outsyms[i]->name; 1863 if (strcmp (intable, sname) == 0) { 1864 /* got a hit, so repoint the reloc */ 1865 q->sym_ptr_ptr = outsyms + i; 1866 break; 1867 } 1868 } 1869 } 1870 1871 n.r_vaddr = q->address + s->vma; 1872 1873 #ifdef R_IHCONST 1874 /* The 29k const/consth reloc pair is a real kludge. The consth 1875 part doesn't have a symbol; it has an offset. So rebuilt 1876 that here. */ 1877 if (q->howto->type == R_IHCONST) 1878 n.r_symndx = q->addend; 1879 else 1880 #endif 1881 if (q->sym_ptr_ptr) 1882 { 1883 if (q->sym_ptr_ptr == bfd_abs_section_ptr->symbol_ptr_ptr) 1884 /* This is a relocation relative to the absolute symbol. */ 1885 n.r_symndx = -1; 1886 else 1887 { 1888 n.r_symndx = get_index ((*(q->sym_ptr_ptr))); 1889 /* Take notice if the symbol reloc points to a symbol 1890 we don't have in our symbol table. What should we 1891 do for this?? */ 1892 if (n.r_symndx > obj_conv_table_size (abfd)) 1893 abort (); 1894 } 1895 } 1896 1897 #ifdef SWAP_OUT_RELOC_OFFSET 1898 n.r_offset = q->addend; 1899 #endif 1900 1901 #ifdef SELECT_RELOC 1902 /* Work out reloc type from what is required */ 1903 SELECT_RELOC (n, q->howto); 1904 #else 1905 n.r_type = q->howto->type; 1906 #endif 1907 coff_swap_reloc_out (abfd, &n, &dst); 1908 if (bfd_write ((PTR) & dst, 1, RELSZ, abfd) != RELSZ) 1909 return false; 1910 } 1911 1912 #ifdef TARG_AUX 1913 if (p != NULL) 1914 free (p); 1915 #endif 1916 } 1917 1918 return true; 1919 } 1920 1921 /* Set flags and magic number of a coff file from architecture and machine 1922 type. Result is true if we can represent the arch&type, false if not. */ 1923 1924 static boolean 1925 coff_set_flags (abfd, magicp, flagsp) 1926 bfd * abfd; 1927 unsigned int *magicp; 1928 unsigned short *flagsp; 1929 { 1930 switch (bfd_get_arch (abfd)) 1931 { 1932 #ifdef Z8KMAGIC 1933 case bfd_arch_z8k: 1934 *magicp = Z8KMAGIC; 1935 switch (bfd_get_mach (abfd)) 1936 { 1937 case bfd_mach_z8001: 1938 *flagsp = F_Z8001; 1939 break; 1940 case bfd_mach_z8002: 1941 *flagsp = F_Z8002; 1942 break; 1943 default: 1944 return false; 1945 } 1946 return true; 1947 #endif 1948 #ifdef I960ROMAGIC 1949 1950 case bfd_arch_i960: 1951 1952 { 1953 unsigned flags; 1954 *magicp = I960ROMAGIC; 1955 /* 1956 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC : 1957 I960RWMAGIC); FIXME??? 1958 */ 1959 switch (bfd_get_mach (abfd)) 1960 { 1961 case bfd_mach_i960_core: 1962 flags = F_I960CORE; 1963 break; 1964 case bfd_mach_i960_kb_sb: 1965 flags = F_I960KB; 1966 break; 1967 case bfd_mach_i960_mc: 1968 flags = F_I960MC; 1969 break; 1970 case bfd_mach_i960_xa: 1971 flags = F_I960XA; 1972 break; 1973 case bfd_mach_i960_ca: 1974 flags = F_I960CA; 1975 break; 1976 case bfd_mach_i960_ka_sa: 1977 flags = F_I960KA; 1978 break; 1979 case bfd_mach_i960_jx: 1980 flags = F_I960JX; 1981 break; 1982 case bfd_mach_i960_hx: 1983 flags = F_I960HX; 1984 break; 1985 default: 1986 return false; 1987 } 1988 *flagsp = flags; 1989 return true; 1990 } 1991 break; 1992 #endif 1993 1994 #ifdef TIC30MAGIC 1995 case bfd_arch_tic30: 1996 *magicp = TIC30MAGIC; 1997 return true; 1998 #endif 1999 #ifdef ARMMAGIC 2000 case bfd_arch_arm: 2001 * magicp = ARMMAGIC; 2002 * flagsp = 0; 2003 if (APCS_SET (abfd)) 2004 { 2005 if (APCS_26_FLAG (abfd)) 2006 * flagsp |= F_APCS26; 2007 2008 if (APCS_FLOAT_FLAG (abfd)) 2009 * flagsp |= F_APCS_FLOAT; 2010 2011 if (PIC_FLAG (abfd)) 2012 * flagsp |= F_PIC; 2013 } 2014 if (INTERWORK_SET (abfd) && INTERWORK_FLAG (abfd)) 2015 * flagsp |= F_INTERWORK; 2016 switch (bfd_get_mach (abfd)) 2017 { 2018 case bfd_mach_arm_2: * flagsp |= F_ARM_2; break; 2019 case bfd_mach_arm_2a: * flagsp |= F_ARM_2a; break; 2020 case bfd_mach_arm_3: * flagsp |= F_ARM_3; break; 2021 case bfd_mach_arm_3M: * flagsp |= F_ARM_3M; break; 2022 case bfd_mach_arm_4: * flagsp |= F_ARM_4; break; 2023 case bfd_mach_arm_4T: * flagsp |= F_ARM_4T; break; 2024 } 2025 return true; 2026 #endif 2027 #ifdef PPCMAGIC 2028 case bfd_arch_powerpc: 2029 *magicp = PPCMAGIC; 2030 return true; 2031 break; 2032 #endif 2033 #ifdef I386MAGIC 2034 case bfd_arch_i386: 2035 *magicp = I386MAGIC; 2036 #ifdef LYNXOS 2037 /* Just overwrite the usual value if we're doing Lynx. */ 2038 *magicp = LYNXCOFFMAGIC; 2039 #endif 2040 return true; 2041 break; 2042 #endif 2043 #ifdef I860MAGIC 2044 case bfd_arch_i860: 2045 *magicp = I860MAGIC; 2046 return true; 2047 break; 2048 #endif 2049 #ifdef MC68MAGIC 2050 case bfd_arch_m68k: 2051 #ifdef APOLLOM68KMAGIC 2052 *magicp = APOLLO_COFF_VERSION_NUMBER; 2053 #else 2054 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */ 2055 #ifdef NAMES_HAVE_UNDERSCORE 2056 *magicp = MC68KBCSMAGIC; 2057 #else 2058 *magicp = MC68MAGIC; 2059 #endif 2060 #endif 2061 #ifdef LYNXOS 2062 /* Just overwrite the usual value if we're doing Lynx. */ 2063 *magicp = LYNXCOFFMAGIC; 2064 #endif 2065 return true; 2066 break; 2067 #endif 2068 2069 #ifdef MC88MAGIC 2070 case bfd_arch_m88k: 2071 *magicp = MC88OMAGIC; 2072 return true; 2073 break; 2074 #endif 2075 #ifdef H8300MAGIC 2076 case bfd_arch_h8300: 2077 switch (bfd_get_mach (abfd)) 2078 { 2079 case bfd_mach_h8300: 2080 *magicp = H8300MAGIC; 2081 return true; 2082 case bfd_mach_h8300h: 2083 *magicp = H8300HMAGIC; 2084 return true; 2085 case bfd_mach_h8300s: 2086 *magicp = H8300SMAGIC; 2087 return true; 2088 } 2089 break; 2090 #endif 2091 2092 #ifdef SH_ARCH_MAGIC_BIG 2093 case bfd_arch_sh: 2094 if (bfd_big_endian (abfd)) 2095 *magicp = SH_ARCH_MAGIC_BIG; 2096 else 2097 *magicp = SH_ARCH_MAGIC_LITTLE; 2098 return true; 2099 break; 2100 #endif 2101 2102 #ifdef SPARCMAGIC 2103 case bfd_arch_sparc: 2104 *magicp = SPARCMAGIC; 2105 #ifdef LYNXOS 2106 /* Just overwrite the usual value if we're doing Lynx. */ 2107 *magicp = LYNXCOFFMAGIC; 2108 #endif 2109 return true; 2110 break; 2111 #endif 2112 2113 #ifdef H8500MAGIC 2114 case bfd_arch_h8500: 2115 *magicp = H8500MAGIC; 2116 return true; 2117 break; 2118 #endif 2119 #ifdef A29K_MAGIC_BIG 2120 case bfd_arch_a29k: 2121 if (bfd_big_endian (abfd)) 2122 *magicp = A29K_MAGIC_BIG; 2123 else 2124 *magicp = A29K_MAGIC_LITTLE; 2125 return true; 2126 break; 2127 #endif 2128 2129 #ifdef WE32KMAGIC 2130 case bfd_arch_we32k: 2131 *magicp = WE32KMAGIC; 2132 return true; 2133 break; 2134 #endif 2135 2136 #ifdef U802TOCMAGIC 2137 case bfd_arch_rs6000: 2138 #ifndef PPCMAGIC 2139 case bfd_arch_powerpc: 2140 #endif 2141 *magicp = U802TOCMAGIC; 2142 return true; 2143 break; 2144 #endif 2145 2146 default: /* Unknown architecture */ 2147 /* return false; -- fall through to "return false" below, to avoid 2148 "statement never reached" errors on the one below. */ 2149 break; 2150 } 2151 2152 return false; 2153 } 2154 2155 2156 static boolean 2157 coff_set_arch_mach (abfd, arch, machine) 2158 bfd * abfd; 2159 enum bfd_architecture arch; 2160 unsigned long machine; 2161 { 2162 unsigned dummy1; 2163 unsigned short dummy2; 2164 2165 if (! bfd_default_set_arch_mach (abfd, arch, machine)) 2166 return false; 2167 2168 if (arch != bfd_arch_unknown && 2169 coff_set_flags (abfd, &dummy1, &dummy2) != true) 2170 return false; /* We can't represent this type */ 2171 2172 return true; /* We're easy ... */ 2173 } 2174 2175 2176 /* Calculate the file position for each section. */ 2177 2178 #ifndef I960 2179 #define ALIGN_SECTIONS_IN_FILE 2180 #endif 2181 2182 static boolean 2183 coff_compute_section_file_positions (abfd) 2184 bfd * abfd; 2185 { 2186 asection *current; 2187 asection *previous = (asection *) NULL; 2188 file_ptr sofar = FILHSZ; 2189 boolean align_adjust; 2190 unsigned int count; 2191 #ifdef ALIGN_SECTIONS_IN_FILE 2192 file_ptr old_sofar; 2193 #endif 2194 2195 #ifdef RS6000COFF_C 2196 /* On XCOFF, if we have symbols, set up the .debug section. */ 2197 if (bfd_get_symcount (abfd) > 0) 2198 { 2199 bfd_size_type sz; 2200 bfd_size_type i, symcount; 2201 asymbol **symp; 2202 2203 sz = 0; 2204 symcount = bfd_get_symcount (abfd); 2205 for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++) 2206 { 2207 coff_symbol_type *cf; 2208 2209 cf = coff_symbol_from (abfd, *symp); 2210 if (cf != NULL 2211 && cf->native != NULL 2212 && SYMNAME_IN_DEBUG (&cf->native->u.syment)) 2213 { 2214 size_t len; 2215 2216 len = strlen (bfd_asymbol_name (*symp)); 2217 if (len > SYMNMLEN) 2218 sz += len + 3; 2219 } 2220 } 2221 if (sz > 0) 2222 { 2223 asection *dsec; 2224 2225 dsec = bfd_make_section_old_way (abfd, ".debug"); 2226 if (dsec == NULL) 2227 abort (); 2228 dsec->_raw_size = sz; 2229 dsec->flags |= SEC_HAS_CONTENTS; 2230 } 2231 } 2232 #endif 2233 2234 #ifdef COFF_IMAGE_WITH_PE 2235 int page_size; 2236 if (coff_data (abfd)->link_info) 2237 { 2238 page_size = pe_data (abfd)->pe_opthdr.FileAlignment; 2239 } 2240 else 2241 page_size = PE_DEF_FILE_ALIGNMENT; 2242 #else 2243 #ifdef COFF_PAGE_SIZE 2244 int page_size = COFF_PAGE_SIZE; 2245 #endif 2246 #endif 2247 2248 if (bfd_get_start_address (abfd)) 2249 { 2250 /* A start address may have been added to the original file. In this 2251 case it will need an optional header to record it. */ 2252 abfd->flags |= EXEC_P; 2253 } 2254 2255 if (abfd->flags & EXEC_P) 2256 sofar += AOUTSZ; 2257 #ifdef RS6000COFF_C 2258 else if (xcoff_data (abfd)->full_aouthdr) 2259 sofar += AOUTSZ; 2260 else 2261 sofar += SMALL_AOUTSZ; 2262 #endif 2263 2264 sofar += abfd->section_count * SCNHSZ; 2265 2266 #ifdef RS6000COFF_C 2267 /* XCOFF handles overflows in the reloc and line number count fields 2268 by allocating a new section header to hold the correct counts. */ 2269 for (current = abfd->sections; current != NULL; current = current->next) 2270 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff) 2271 sofar += SCNHSZ; 2272 #endif 2273 2274 align_adjust = false; 2275 for (current = abfd->sections, count = 1; 2276 current != (asection *) NULL; 2277 current = current->next, ++count) 2278 { 2279 #ifdef COFF_IMAGE_WITH_PE 2280 /* The NT loader does not want empty section headers, so we omit 2281 them. We don't actually remove the section from the BFD, 2282 although we probably should. This matches code in 2283 coff_write_object_contents. */ 2284 if (current->_raw_size == 0) 2285 { 2286 current->target_index = -1; 2287 --count; 2288 continue; 2289 } 2290 #endif 2291 2292 current->target_index = count; 2293 2294 /* Only deal with sections which have contents */ 2295 if (!(current->flags & SEC_HAS_CONTENTS)) 2296 continue; 2297 2298 /* Align the sections in the file to the same boundary on 2299 which they are aligned in virtual memory. I960 doesn't 2300 do this (FIXME) so we can stay in sync with Intel. 960 2301 doesn't yet page from files... */ 2302 #ifdef ALIGN_SECTIONS_IN_FILE 2303 if ((abfd->flags & EXEC_P) != 0) 2304 { 2305 /* make sure this section is aligned on the right boundary - by 2306 padding the previous section up if necessary */ 2307 2308 old_sofar = sofar; 2309 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power); 2310 if (previous != (asection *) NULL) 2311 { 2312 previous->_raw_size += sofar - old_sofar; 2313 } 2314 } 2315 2316 #endif 2317 2318 /* In demand paged files the low order bits of the file offset 2319 must match the low order bits of the virtual address. */ 2320 #ifdef COFF_PAGE_SIZE 2321 if ((abfd->flags & D_PAGED) != 0 2322 && (current->flags & SEC_ALLOC) != 0) 2323 sofar += (current->vma - sofar) % page_size; 2324 #endif 2325 current->filepos = sofar; 2326 2327 #ifdef COFF_IMAGE_WITH_PE 2328 /* With PE we have to pad each section to be a multiple of its 2329 page size too, and remember both sizes. */ 2330 2331 if (coff_section_data (abfd, current) == NULL) 2332 { 2333 current->used_by_bfd = 2334 (PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata)); 2335 if (current->used_by_bfd == NULL) 2336 return false; 2337 } 2338 if (pei_section_data (abfd, current) == NULL) 2339 { 2340 coff_section_data (abfd, current)->tdata = 2341 (PTR) bfd_zalloc (abfd, sizeof (struct pei_section_tdata)); 2342 if (coff_section_data (abfd, current)->tdata == NULL) 2343 return false; 2344 } 2345 if (pei_section_data (abfd, current)->virt_size == 0) 2346 pei_section_data (abfd, current)->virt_size = current->_raw_size; 2347 2348 current->_raw_size = (current->_raw_size + page_size -1) & -page_size; 2349 #endif 2350 2351 sofar += current->_raw_size; 2352 2353 #ifdef ALIGN_SECTIONS_IN_FILE 2354 /* make sure that this section is of the right size too */ 2355 if ((abfd->flags & EXEC_P) == 0) 2356 { 2357 bfd_size_type old_size; 2358 2359 old_size = current->_raw_size; 2360 current->_raw_size = BFD_ALIGN (current->_raw_size, 2361 1 << current->alignment_power); 2362 align_adjust = current->_raw_size != old_size; 2363 sofar += current->_raw_size - old_size; 2364 } 2365 else 2366 { 2367 old_sofar = sofar; 2368 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power); 2369 align_adjust = sofar != old_sofar; 2370 current->_raw_size += sofar - old_sofar; 2371 } 2372 #endif 2373 2374 #ifdef COFF_IMAGE_WITH_PE 2375 /* For PE we need to make sure we pad out to the aligned 2376 _raw_size, in case the caller only writes out data to the 2377 unaligned _raw_size. */ 2378 if (pei_section_data (abfd, current)->virt_size < current->_raw_size) 2379 align_adjust = true; 2380 #endif 2381 2382 #ifdef _LIB 2383 /* Force .lib sections to start at zero. The vma is then 2384 incremented in coff_set_section_contents. This is right for 2385 SVR3.2. */ 2386 if (strcmp (current->name, _LIB) == 0) 2387 bfd_set_section_vma (abfd, current, 0); 2388 #endif 2389 2390 previous = current; 2391 } 2392 2393 /* It is now safe to write to the output file. If we needed an 2394 alignment adjustment for the last section, then make sure that 2395 there is a byte at offset sofar. If there are no symbols and no 2396 relocs, then nothing follows the last section. If we don't force 2397 the last byte out, then the file may appear to be truncated. */ 2398 if (align_adjust) 2399 { 2400 bfd_byte b; 2401 2402 b = 0; 2403 if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0 2404 || bfd_write (&b, 1, 1, abfd) != 1) 2405 return false; 2406 } 2407 2408 /* Make sure the relocations are aligned. We don't need to make 2409 sure that this byte exists, because it will only matter if there 2410 really are relocs. */ 2411 sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER); 2412 2413 obj_relocbase (abfd) = sofar; 2414 abfd->output_has_begun = true; 2415 2416 return true; 2417 } 2418 2419 #if 0 2420 2421 /* This can never work, because it is called too late--after the 2422 section positions have been set. I can't figure out what it is 2423 for, so I am going to disable it--Ian Taylor 20 March 1996. */ 2424 2425 /* If .file, .text, .data, .bss symbols are missing, add them. */ 2426 /* @@ Should we only be adding missing symbols, or overriding the aux 2427 values for existing section symbols? */ 2428 static boolean 2429 coff_add_missing_symbols (abfd) 2430 bfd *abfd; 2431 { 2432 unsigned int nsyms = bfd_get_symcount (abfd); 2433 asymbol **sympp = abfd->outsymbols; 2434 asymbol **sympp2; 2435 unsigned int i; 2436 int need_text = 1, need_data = 1, need_bss = 1, need_file = 1; 2437 2438 for (i = 0; i < nsyms; i++) 2439 { 2440 coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]); 2441 CONST char *name; 2442 if (csym) 2443 { 2444 /* only do this if there is a coff representation of the input 2445 symbol */ 2446 if (csym->native && csym->native->u.syment.n_sclass == C_FILE) 2447 { 2448 need_file = 0; 2449 continue; 2450 } 2451 name = csym->symbol.name; 2452 if (!name) 2453 continue; 2454 if (!strcmp (name, _TEXT)) 2455 need_text = 0; 2456 #ifdef APOLLO_M68 2457 else if (!strcmp (name, ".wtext")) 2458 need_text = 0; 2459 #endif 2460 else if (!strcmp (name, _DATA)) 2461 need_data = 0; 2462 else if (!strcmp (name, _BSS)) 2463 need_bss = 0; 2464 } 2465 } 2466 /* Now i == bfd_get_symcount (abfd). */ 2467 /* @@ For now, don't deal with .file symbol. */ 2468 need_file = 0; 2469 2470 if (!need_text && !need_data && !need_bss && !need_file) 2471 return true; 2472 nsyms += need_text + need_data + need_bss + need_file; 2473 sympp2 = (asymbol **) bfd_alloc (abfd, nsyms * sizeof (asymbol *)); 2474 if (!sympp2) 2475 return false; 2476 memcpy (sympp2, sympp, i * sizeof (asymbol *)); 2477 if (need_file) 2478 { 2479 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */ 2480 abort (); 2481 } 2482 if (need_text) 2483 sympp2[i++] = coff_section_symbol (abfd, _TEXT); 2484 if (need_data) 2485 sympp2[i++] = coff_section_symbol (abfd, _DATA); 2486 if (need_bss) 2487 sympp2[i++] = coff_section_symbol (abfd, _BSS); 2488 BFD_ASSERT (i == nsyms); 2489 bfd_set_symtab (abfd, sympp2, nsyms); 2490 return true; 2491 } 2492 2493 #endif /* 0 */ 2494 2495 /* SUPPRESS 558 */ 2496 /* SUPPRESS 529 */ 2497 static boolean 2498 coff_write_object_contents (abfd) 2499 bfd * abfd; 2500 { 2501 asection *current; 2502 boolean hasrelocs = false; 2503 boolean haslinno = false; 2504 file_ptr scn_base; 2505 file_ptr reloc_base; 2506 file_ptr lineno_base; 2507 file_ptr sym_base; 2508 unsigned long reloc_size = 0; 2509 unsigned long lnno_size = 0; 2510 boolean long_section_names; 2511 asection *text_sec = NULL; 2512 asection *data_sec = NULL; 2513 asection *bss_sec = NULL; 2514 struct internal_filehdr internal_f; 2515 struct internal_aouthdr internal_a; 2516 #ifdef COFF_LONG_SECTION_NAMES 2517 size_t string_size = STRING_SIZE_SIZE; 2518 #endif 2519 2520 bfd_set_error (bfd_error_system_call); 2521 2522 /* Make a pass through the symbol table to count line number entries and 2523 put them into the correct asections */ 2524 2525 lnno_size = coff_count_linenumbers (abfd) * LINESZ; 2526 2527 if (abfd->output_has_begun == false) 2528 { 2529 if (! coff_compute_section_file_positions (abfd)) 2530 return false; 2531 } 2532 2533 reloc_base = obj_relocbase (abfd); 2534 2535 /* Work out the size of the reloc and linno areas */ 2536 2537 for (current = abfd->sections; current != NULL; current = 2538 current->next) 2539 reloc_size += current->reloc_count * RELSZ; 2540 2541 lineno_base = reloc_base + reloc_size; 2542 sym_base = lineno_base + lnno_size; 2543 2544 /* Indicate in each section->line_filepos its actual file address */ 2545 for (current = abfd->sections; current != NULL; current = 2546 current->next) 2547 { 2548 if (current->lineno_count) 2549 { 2550 current->line_filepos = lineno_base; 2551 current->moving_line_filepos = lineno_base; 2552 lineno_base += current->lineno_count * LINESZ; 2553 } 2554 else 2555 { 2556 current->line_filepos = 0; 2557 } 2558 if (current->reloc_count) 2559 { 2560 current->rel_filepos = reloc_base; 2561 reloc_base += current->reloc_count * RELSZ; 2562 } 2563 else 2564 { 2565 current->rel_filepos = 0; 2566 } 2567 } 2568 2569 /* Write section headers to the file. */ 2570 internal_f.f_nscns = 0; 2571 2572 if ((abfd->flags & EXEC_P) != 0) 2573 scn_base = FILHSZ + AOUTSZ; 2574 else 2575 { 2576 scn_base = FILHSZ; 2577 #ifdef RS6000COFF_C 2578 if (xcoff_data (abfd)->full_aouthdr) 2579 scn_base += AOUTSZ; 2580 else 2581 scn_base += SMALL_AOUTSZ; 2582 #endif 2583 } 2584 2585 if (bfd_seek (abfd, scn_base, SEEK_SET) != 0) 2586 return false; 2587 2588 long_section_names = false; 2589 for (current = abfd->sections; 2590 current != NULL; 2591 current = current->next) 2592 { 2593 struct internal_scnhdr section; 2594 2595 #ifdef COFF_WITH_PE 2596 /* If we've got a .reloc section, remember. */ 2597 2598 #ifdef COFF_IMAGE_WITH_PE 2599 if (strcmp (current->name, ".reloc") == 0) 2600 { 2601 pe_data (abfd)->has_reloc_section = 1; 2602 } 2603 #endif 2604 2605 #endif 2606 internal_f.f_nscns++; 2607 2608 strncpy (section.s_name, current->name, SCNNMLEN); 2609 2610 #ifdef COFF_LONG_SECTION_NAMES 2611 /* Handle long section names as in PE. This must be compatible 2612 with the code in coff_write_symbols. */ 2613 { 2614 size_t len; 2615 2616 len = strlen (current->name); 2617 if (len > SCNNMLEN) 2618 { 2619 memset (section.s_name, 0, SCNNMLEN); 2620 sprintf (section.s_name, "/%lu", (unsigned long) string_size); 2621 string_size += len + 1; 2622 long_section_names = true; 2623 } 2624 } 2625 #endif 2626 2627 #ifdef _LIB 2628 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2 2629 Ian Taylor <[email protected]>. */ 2630 if (strcmp (current->name, _LIB) == 0) 2631 section.s_vaddr = 0; 2632 else 2633 #endif 2634 section.s_vaddr = current->vma; 2635 section.s_paddr = current->lma; 2636 section.s_size = current->_raw_size; 2637 2638 #ifdef COFF_WITH_PE 2639 section.s_paddr = 0; 2640 #endif 2641 #ifdef COFF_IMAGE_WITH_PE 2642 /* Reminder: s_paddr holds the virtual size of the section. */ 2643 if (coff_section_data (abfd, current) != NULL 2644 && pei_section_data (abfd, current) != NULL) 2645 section.s_paddr = pei_section_data (abfd, current)->virt_size; 2646 else 2647 section.s_paddr = 0; 2648 #endif 2649 2650 /* 2651 If this section has no size or is unloadable then the scnptr 2652 will be 0 too 2653 */ 2654 if (current->_raw_size == 0 || 2655 (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0) 2656 { 2657 section.s_scnptr = 0; 2658 } 2659 else 2660 { 2661 section.s_scnptr = current->filepos; 2662 } 2663 section.s_relptr = current->rel_filepos; 2664 section.s_lnnoptr = current->line_filepos; 2665 section.s_nreloc = current->reloc_count; 2666 section.s_nlnno = current->lineno_count; 2667 if (current->reloc_count != 0) 2668 hasrelocs = true; 2669 if (current->lineno_count != 0) 2670 haslinno = true; 2671 2672 #ifdef RS6000COFF_C 2673 /* Indicate the use of an XCOFF overflow section header. */ 2674 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff) 2675 { 2676 section.s_nreloc = 0xffff; 2677 section.s_nlnno = 0xffff; 2678 } 2679 #endif 2680 2681 section.s_flags = sec_to_styp_flags (current->name, current->flags); 2682 2683 if (!strcmp (current->name, _TEXT)) 2684 { 2685 text_sec = current; 2686 } 2687 else if (!strcmp (current->name, _DATA)) 2688 { 2689 data_sec = current; 2690 } 2691 else if (!strcmp (current->name, _BSS)) 2692 { 2693 bss_sec = current; 2694 } 2695 2696 #ifdef I960 2697 section.s_align = (current->alignment_power 2698 ? 1 << current->alignment_power 2699 : 0); 2700 #endif 2701 2702 #ifdef COFF_IMAGE_WITH_PE 2703 /* suppress output of the sections if they are null. ld includes 2704 the bss and data sections even if there is no size assigned 2705 to them. NT loader doesn't like it if these section headers are 2706 included if the sections themselves are not needed */ 2707 if (section.s_size == 0) 2708 internal_f.f_nscns--; 2709 else 2710 #endif 2711 { 2712 SCNHDR buff; 2713 if (coff_swap_scnhdr_out (abfd, §ion, &buff) == 0 2714 || bfd_write ((PTR) (&buff), 1, SCNHSZ, abfd) != SCNHSZ) 2715 return false; 2716 } 2717 2718 #ifdef COFF_WITH_PE 2719 /* PE stores COMDAT section information in the symbol table. If 2720 this section is supposed to have some COMDAT info, track down 2721 the symbol in the symbol table and modify it. */ 2722 if ((current->flags & SEC_LINK_ONCE) != 0) 2723 { 2724 unsigned int i, count; 2725 asymbol **psym; 2726 coff_symbol_type *csym = NULL; 2727 asymbol **psymsec; 2728 2729 psymsec = NULL; 2730 count = bfd_get_symcount (abfd); 2731 for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++) 2732 { 2733 if ((*psym)->section != current) 2734 continue; 2735 2736 /* Remember the location of the first symbol in this 2737 section. */ 2738 if (psymsec == NULL) 2739 psymsec = psym; 2740 2741 /* See if this is the section symbol. */ 2742 if (strcmp ((*psym)->name, current->name) == 0) 2743 { 2744 csym = coff_symbol_from (abfd, *psym); 2745 if (csym == NULL 2746 || csym->native == NULL 2747 || csym->native->u.syment.n_numaux < 1 2748 || csym->native->u.syment.n_sclass != C_STAT 2749 || csym->native->u.syment.n_type != T_NULL) 2750 continue; 2751 2752 /* Here *PSYM is the section symbol for CURRENT. */ 2753 2754 break; 2755 } 2756 } 2757 2758 /* Did we find it? 2759 Note that we might not if we're converting the file from 2760 some other object file format. */ 2761 if (i < count) 2762 { 2763 combined_entry_type *aux; 2764 2765 /* We don't touch the x_checksum field. The 2766 x_associated field is not currently supported. */ 2767 2768 aux = csym->native + 1; 2769 switch (current->flags & SEC_LINK_DUPLICATES) 2770 { 2771 case SEC_LINK_DUPLICATES_DISCARD: 2772 aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY; 2773 break; 2774 2775 case SEC_LINK_DUPLICATES_ONE_ONLY: 2776 aux->u.auxent.x_scn.x_comdat = 2777 IMAGE_COMDAT_SELECT_NODUPLICATES; 2778 break; 2779 2780 case SEC_LINK_DUPLICATES_SAME_SIZE: 2781 aux->u.auxent.x_scn.x_comdat = 2782 IMAGE_COMDAT_SELECT_SAME_SIZE; 2783 break; 2784 2785 case SEC_LINK_DUPLICATES_SAME_CONTENTS: 2786 aux->u.auxent.x_scn.x_comdat = 2787 IMAGE_COMDAT_SELECT_EXACT_MATCH; 2788 break; 2789 } 2790 2791 /* The COMDAT symbol must be the first symbol from this 2792 section in the symbol table. In order to make this 2793 work, we move the COMDAT symbol before the first 2794 symbol we found in the search above. It's OK to 2795 rearrange the symbol table at this point, because 2796 coff_renumber_symbols is going to rearrange it 2797 further and fix up all the aux entries. */ 2798 if (psym != psymsec) 2799 { 2800 asymbol *hold; 2801 asymbol **pcopy; 2802 2803 hold = *psym; 2804 for (pcopy = psym; pcopy > psymsec; pcopy--) 2805 pcopy[0] = pcopy[-1]; 2806 *psymsec = hold; 2807 } 2808 } 2809 } 2810 #endif /* COFF_WITH_PE */ 2811 } 2812 2813 #ifdef RS6000COFF_C 2814 /* XCOFF handles overflows in the reloc and line number count fields 2815 by creating a new section header to hold the correct values. */ 2816 for (current = abfd->sections; current != NULL; current = current->next) 2817 { 2818 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff) 2819 { 2820 struct internal_scnhdr scnhdr; 2821 SCNHDR buff; 2822 2823 internal_f.f_nscns++; 2824 strncpy (&(scnhdr.s_name[0]), current->name, 8); 2825 scnhdr.s_paddr = current->reloc_count; 2826 scnhdr.s_vaddr = current->lineno_count; 2827 scnhdr.s_size = 0; 2828 scnhdr.s_scnptr = 0; 2829 scnhdr.s_relptr = current->rel_filepos; 2830 scnhdr.s_lnnoptr = current->line_filepos; 2831 scnhdr.s_nreloc = current->target_index; 2832 scnhdr.s_nlnno = current->target_index; 2833 scnhdr.s_flags = STYP_OVRFLO; 2834 if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0 2835 || bfd_write ((PTR) &buff, 1, SCNHSZ, abfd) != SCNHSZ) 2836 return false; 2837 } 2838 } 2839 #endif 2840 2841 /* OK, now set up the filehdr... */ 2842 2843 /* Don't include the internal abs section in the section count */ 2844 2845 /* 2846 We will NOT put a fucking timestamp in the header here. Every time you 2847 put it back, I will come in and take it out again. I'm sorry. This 2848 field does not belong here. We fill it with a 0 so it compares the 2849 same but is not a reasonable time. -- [email protected] 2850 */ 2851 internal_f.f_timdat = 0; 2852 2853 internal_f.f_flags = 0; 2854 2855 if (abfd->flags & EXEC_P) 2856 internal_f.f_opthdr = AOUTSZ; 2857 else 2858 { 2859 internal_f.f_opthdr = 0; 2860 #ifdef RS6000COFF_C 2861 if (xcoff_data (abfd)->full_aouthdr) 2862 internal_f.f_opthdr = AOUTSZ; 2863 else 2864 internal_f.f_opthdr = SMALL_AOUTSZ; 2865 #endif 2866 } 2867 2868 if (!hasrelocs) 2869 internal_f.f_flags |= F_RELFLG; 2870 if (!haslinno) 2871 internal_f.f_flags |= F_LNNO; 2872 if (abfd->flags & EXEC_P) 2873 internal_f.f_flags |= F_EXEC; 2874 2875 /* FIXME: this is wrong for PPC_PE! */ 2876 if (bfd_little_endian (abfd)) 2877 internal_f.f_flags |= F_AR32WR; 2878 else 2879 internal_f.f_flags |= F_AR32W; 2880 2881 2882 /* 2883 FIXME, should do something about the other byte orders and 2884 architectures. 2885 */ 2886 2887 #ifdef RS6000COFF_C 2888 if ((abfd->flags & DYNAMIC) != 0) 2889 internal_f.f_flags |= F_SHROBJ; 2890 if (bfd_get_section_by_name (abfd, _LOADER) != NULL) 2891 internal_f.f_flags |= F_DYNLOAD; 2892 #endif 2893 2894 memset (&internal_a, 0, sizeof internal_a); 2895 2896 /* Set up architecture-dependent stuff */ 2897 2898 { 2899 unsigned int magic = 0; 2900 unsigned short flags = 0; 2901 coff_set_flags (abfd, &magic, &flags); 2902 internal_f.f_magic = magic; 2903 internal_f.f_flags |= flags; 2904 /* ...and the "opt"hdr... */ 2905 2906 #ifdef A29K 2907 #ifdef ULTRA3 /* NYU's machine */ 2908 /* FIXME: This is a bogus check. I really want to see if there 2909 * is a .shbss or a .shdata section, if so then set the magic 2910 * number to indicate a shared data executable. 2911 */ 2912 if (internal_f.f_nscns >= 7) 2913 internal_a.magic = SHMAGIC; /* Shared magic */ 2914 else 2915 #endif /* ULTRA3 */ 2916 internal_a.magic = NMAGIC; /* Assume separate i/d */ 2917 #define __A_MAGIC_SET__ 2918 #endif /* A29K */ 2919 #ifdef I860 2920 /* FIXME: What are the a.out magic numbers for the i860? */ 2921 internal_a.magic = 0; 2922 #define __A_MAGIC_SET__ 2923 #endif /* I860 */ 2924 #ifdef I960 2925 internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC); 2926 #define __A_MAGIC_SET__ 2927 #endif /* I960 */ 2928 #if M88 2929 #define __A_MAGIC_SET__ 2930 internal_a.magic = PAGEMAGICBCS; 2931 #endif /* M88 */ 2932 2933 #if APOLLO_M68 2934 #define __A_MAGIC_SET__ 2935 internal_a.magic = APOLLO_COFF_VERSION_NUMBER; 2936 #endif 2937 2938 #if defined(M68) || defined(WE32K) || defined(M68K) 2939 #define __A_MAGIC_SET__ 2940 #if defined(LYNXOS) 2941 internal_a.magic = LYNXCOFFMAGIC; 2942 #else 2943 #if defined(TARG_AUX) 2944 internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED : 2945 abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED : 2946 PAGEMAGICEXECSWAPPED); 2947 #else 2948 #if defined (PAGEMAGICPEXECPAGED) 2949 internal_a.magic = PAGEMAGICPEXECPAGED; 2950 #endif 2951 #endif /* TARG_AUX */ 2952 #endif /* LYNXOS */ 2953 #endif /* M68 || WE32K || M68K */ 2954 2955 #if defined(ARM) 2956 #define __A_MAGIC_SET__ 2957 internal_a.magic = ZMAGIC; 2958 #endif 2959 2960 #if defined(PPC_PE) 2961 #define __A_MAGIC_SET__ 2962 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC; 2963 #endif 2964 2965 #if defined(I386) 2966 #define __A_MAGIC_SET__ 2967 #if defined(LYNXOS) 2968 internal_a.magic = LYNXCOFFMAGIC; 2969 #else /* LYNXOS */ 2970 internal_a.magic = ZMAGIC; 2971 #endif /* LYNXOS */ 2972 #endif /* I386 */ 2973 2974 #if defined(SPARC) 2975 #define __A_MAGIC_SET__ 2976 #if defined(LYNXOS) 2977 internal_a.magic = LYNXCOFFMAGIC; 2978 #endif /* LYNXOS */ 2979 #endif /* SPARC */ 2980 2981 #ifdef RS6000COFF_C 2982 #define __A_MAGIC_SET__ 2983 internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC : 2984 (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC : 2985 RS6K_AOUTHDR_OMAGIC; 2986 #endif 2987 2988 #ifndef __A_MAGIC_SET__ 2989 #include "Your aouthdr magic number is not being set!" 2990 #else 2991 #undef __A_MAGIC_SET__ 2992 #endif 2993 } 2994 2995 /* FIXME: Does anybody ever set this to another value? */ 2996 internal_a.vstamp = 0; 2997 2998 /* Now should write relocs, strings, syms */ 2999 obj_sym_filepos (abfd) = sym_base; 3000 3001 if (bfd_get_symcount (abfd) != 0) 3002 { 3003 int firstundef; 3004 #if 0 3005 if (!coff_add_missing_symbols (abfd)) 3006 return false; 3007 #endif 3008 if (!coff_renumber_symbols (abfd, &firstundef)) 3009 return false; 3010 coff_mangle_symbols (abfd); 3011 if (! coff_write_symbols (abfd)) 3012 return false; 3013 if (! coff_write_linenumbers (abfd)) 3014 return false; 3015 if (! coff_write_relocs (abfd, firstundef)) 3016 return false; 3017 } 3018 #ifdef COFF_IMAGE_WITH_PE 3019 #ifdef PPC_PE 3020 else if ((abfd->flags & EXEC_P) != 0) 3021 { 3022 bfd_byte b; 3023 3024 /* PowerPC PE appears to require that all executable files be 3025 rounded up to the page size. */ 3026 b = 0; 3027 if (bfd_seek (abfd, 3028 BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1, 3029 SEEK_SET) != 0 3030 || bfd_write (&b, 1, 1, abfd) != 1) 3031 return false; 3032 } 3033 #endif 3034 #endif 3035 3036 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF 3037 backend linker, and obj_raw_syment_count is not valid until after 3038 coff_write_symbols is called. */ 3039 if (obj_raw_syment_count (abfd) != 0) 3040 { 3041 internal_f.f_symptr = sym_base; 3042 #ifdef RS6000COFF_C 3043 /* AIX appears to require that F_RELFLG not be set if there are 3044 local symbols but no relocations. */ 3045 internal_f.f_flags &=~ F_RELFLG; 3046 #endif 3047 } 3048 else 3049 { 3050 if (long_section_names) 3051 internal_f.f_symptr = sym_base; 3052 else 3053 internal_f.f_symptr = 0; 3054 internal_f.f_flags |= F_LSYMS; 3055 } 3056 3057 if (text_sec) 3058 { 3059 internal_a.tsize = bfd_get_section_size_before_reloc (text_sec); 3060 internal_a.text_start = internal_a.tsize ? text_sec->vma : 0; 3061 } 3062 if (data_sec) 3063 { 3064 internal_a.dsize = bfd_get_section_size_before_reloc (data_sec); 3065 internal_a.data_start = internal_a.dsize ? data_sec->vma : 0; 3066 } 3067 if (bss_sec) 3068 { 3069 internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec); 3070 if (internal_a.bsize && bss_sec->vma < internal_a.data_start) 3071 internal_a.data_start = bss_sec->vma; 3072 } 3073 3074 internal_a.entry = bfd_get_start_address (abfd); 3075 internal_f.f_nsyms = obj_raw_syment_count (abfd); 3076 3077 #ifdef RS6000COFF_C 3078 if (xcoff_data (abfd)->full_aouthdr) 3079 { 3080 bfd_vma toc; 3081 asection *loader_sec; 3082 3083 internal_a.vstamp = 1; 3084 3085 internal_a.o_snentry = xcoff_data (abfd)->snentry; 3086 if (internal_a.o_snentry == 0) 3087 internal_a.entry = (bfd_vma) -1; 3088 3089 if (text_sec != NULL) 3090 { 3091 internal_a.o_sntext = text_sec->target_index; 3092 internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec); 3093 } 3094 else 3095 { 3096 internal_a.o_sntext = 0; 3097 internal_a.o_algntext = 0; 3098 } 3099 if (data_sec != NULL) 3100 { 3101 internal_a.o_sndata = data_sec->target_index; 3102 internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec); 3103 } 3104 else 3105 { 3106 internal_a.o_sndata = 0; 3107 internal_a.o_algndata = 0; 3108 } 3109 loader_sec = bfd_get_section_by_name (abfd, ".loader"); 3110 if (loader_sec != NULL) 3111 internal_a.o_snloader = loader_sec->target_index; 3112 else 3113 internal_a.o_snloader = 0; 3114 if (bss_sec != NULL) 3115 internal_a.o_snbss = bss_sec->target_index; 3116 else 3117 internal_a.o_snbss = 0; 3118 3119 toc = xcoff_data (abfd)->toc; 3120 internal_a.o_toc = toc; 3121 internal_a.o_sntoc = xcoff_data (abfd)->sntoc; 3122 3123 internal_a.o_modtype = xcoff_data (abfd)->modtype; 3124 if (xcoff_data (abfd)->cputype != -1) 3125 internal_a.o_cputype = xcoff_data (abfd)->cputype; 3126 else 3127 { 3128 switch (bfd_get_arch (abfd)) 3129 { 3130 case bfd_arch_rs6000: 3131 internal_a.o_cputype = 4; 3132 break; 3133 case bfd_arch_powerpc: 3134 if (bfd_get_mach (abfd) == 0) 3135 internal_a.o_cputype = 3; 3136 else 3137 internal_a.o_cputype = 1; 3138 break; 3139 default: 3140 abort (); 3141 } 3142 } 3143 internal_a.o_maxstack = xcoff_data (abfd)->maxstack; 3144 internal_a.o_maxdata = xcoff_data (abfd)->maxdata; 3145 } 3146 #endif 3147 3148 /* now write them */ 3149 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) 3150 return false; 3151 { 3152 char buff[FILHSZ]; 3153 coff_swap_filehdr_out (abfd, (PTR) & internal_f, (PTR) buff); 3154 if (bfd_write ((PTR) buff, 1, FILHSZ, abfd) != FILHSZ) 3155 return false; 3156 } 3157 if (abfd->flags & EXEC_P) 3158 { 3159 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR. 3160 include/coff/pe.h sets AOUTSZ == sizeof(PEAOUTHDR)) */ 3161 char buff[AOUTSZ]; 3162 coff_swap_aouthdr_out (abfd, (PTR) & internal_a, (PTR) buff); 3163 if (bfd_write ((PTR) buff, 1, AOUTSZ, abfd) != AOUTSZ) 3164 return false; 3165 } 3166 #ifdef RS6000COFF_C 3167 else 3168 { 3169 AOUTHDR buff; 3170 size_t size; 3171 3172 /* XCOFF seems to always write at least a small a.out header. */ 3173 coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) &buff); 3174 if (xcoff_data (abfd)->full_aouthdr) 3175 size = AOUTSZ; 3176 else 3177 size = SMALL_AOUTSZ; 3178 if (bfd_write ((PTR) &buff, 1, size, abfd) != size) 3179 return false; 3180 } 3181 #endif 3182 3183 return true; 3184 } 3185 3186 static boolean 3187 coff_set_section_contents (abfd, section, location, offset, count) 3188 bfd * abfd; 3189 sec_ptr section; 3190 PTR location; 3191 file_ptr offset; 3192 bfd_size_type count; 3193 { 3194 if (abfd->output_has_begun == false) /* set by bfd.c handler */ 3195 { 3196 if (! coff_compute_section_file_positions (abfd)) 3197 return false; 3198 } 3199 3200 #if defined(_LIB) && !defined(TARG_AUX) 3201 3202 /* The physical address field of a .lib section is used to hold the 3203 number of shared libraries in the section. This code counts the 3204 number of sections being written, and increments the lma field 3205 with the number. 3206 3207 I have found no documentation on the contents of this section. 3208 Experimentation indicates that the section contains zero or more 3209 records, each of which has the following structure: 3210 3211 - a (four byte) word holding the length of this record, in words, 3212 - a word that always seems to be set to "2", 3213 - the path to a shared library, null-terminated and then padded 3214 to a whole word boundary. 3215 3216 bfd_assert calls have been added to alert if an attempt is made 3217 to write a section which doesn't follow these assumptions. The 3218 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe 3219 <[email protected]> (Thanks!). 3220 3221 Gvran Uddeborg <[email protected]> */ 3222 3223 if (strcmp (section->name, _LIB) == 0) 3224 { 3225 bfd_byte *rec, *recend; 3226 3227 rec = (bfd_byte *) location; 3228 recend = rec + count; 3229 while (rec < recend) 3230 { 3231 ++section->lma; 3232 rec += bfd_get_32 (abfd, rec) * 4; 3233 } 3234 3235 BFD_ASSERT (rec == recend); 3236 } 3237 3238 #endif 3239 3240 /* Don't write out bss sections - one way to do this is to 3241 see if the filepos has not been set. */ 3242 if (section->filepos == 0) 3243 return true; 3244 3245 if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0) 3246 return false; 3247 3248 if (count != 0) 3249 { 3250 return (bfd_write (location, 1, count, abfd) == count) ? true : false; 3251 } 3252 return true; 3253 } 3254 #if 0 3255 static boolean 3256 coff_close_and_cleanup (abfd) 3257 bfd *abfd; 3258 { 3259 if (!bfd_read_p (abfd)) 3260 switch (abfd->format) 3261 { 3262 case bfd_archive: 3263 if (!_bfd_write_archive_contents (abfd)) 3264 return false; 3265 break; 3266 case bfd_object: 3267 if (!coff_write_object_contents (abfd)) 3268 return false; 3269 break; 3270 default: 3271 bfd_set_error (bfd_error_invalid_operation); 3272 return false; 3273 } 3274 3275 /* We depend on bfd_close to free all the memory on the objalloc. */ 3276 return true; 3277 } 3278 3279 #endif 3280 3281 static PTR 3282 buy_and_read (abfd, where, seek_direction, size) 3283 bfd *abfd; 3284 file_ptr where; 3285 int seek_direction; 3286 size_t size; 3287 { 3288 PTR area = (PTR) bfd_alloc (abfd, size); 3289 if (!area) 3290 return (NULL); 3291 if (bfd_seek (abfd, where, seek_direction) != 0 3292 || bfd_read (area, 1, size, abfd) != size) 3293 return (NULL); 3294 return (area); 3295 } /* buy_and_read() */ 3296 3297 /* 3298 SUBSUBSECTION 3299 Reading linenumbers 3300 3301 Creating the linenumber table is done by reading in the entire 3302 coff linenumber table, and creating another table for internal use. 3303 3304 A coff linenumber table is structured so that each function 3305 is marked as having a line number of 0. Each line within the 3306 function is an offset from the first line in the function. The 3307 base of the line number information for the table is stored in 3308 the symbol associated with the function. 3309 3310 The information is copied from the external to the internal 3311 table, and each symbol which marks a function is marked by 3312 pointing its... 3313 3314 How does this work ? 3315 3316 */ 3317 3318 static boolean 3319 coff_slurp_line_table (abfd, asect) 3320 bfd *abfd; 3321 asection *asect; 3322 { 3323 LINENO *native_lineno; 3324 alent *lineno_cache; 3325 3326 BFD_ASSERT (asect->lineno == (alent *) NULL); 3327 3328 native_lineno = (LINENO *) buy_and_read (abfd, 3329 asect->line_filepos, 3330 SEEK_SET, 3331 (size_t) (LINESZ * 3332 asect->lineno_count)); 3333 lineno_cache = 3334 (alent *) bfd_alloc (abfd, (size_t) ((asect->lineno_count + 1) * sizeof (alent))); 3335 if (lineno_cache == NULL) 3336 return false; 3337 else 3338 { 3339 unsigned int counter = 0; 3340 alent *cache_ptr = lineno_cache; 3341 LINENO *src = native_lineno; 3342 3343 while (counter < asect->lineno_count) 3344 { 3345 struct internal_lineno dst; 3346 coff_swap_lineno_in (abfd, src, &dst); 3347 cache_ptr->line_number = dst.l_lnno; 3348 3349 if (cache_ptr->line_number == 0) 3350 { 3351 boolean warned; 3352 long symndx; 3353 coff_symbol_type *sym; 3354 3355 warned = false; 3356 symndx = dst.l_addr.l_symndx; 3357 if (symndx < 0 3358 || (unsigned long) symndx >= obj_raw_syment_count (abfd)) 3359 { 3360 (*_bfd_error_handler) 3361 ("%s: warning: illegal symbol index %ld in line numbers", 3362 bfd_get_filename (abfd), dst.l_addr.l_symndx); 3363 symndx = 0; 3364 warned = true; 3365 } 3366 /* FIXME: We should not be casting between ints and 3367 pointers like this. */ 3368 sym = ((coff_symbol_type *) 3369 ((symndx + obj_raw_syments (abfd)) 3370 ->u.syment._n._n_n._n_zeroes)); 3371 cache_ptr->u.sym = (asymbol *) sym; 3372 if (sym->lineno != NULL && ! warned) 3373 { 3374 (*_bfd_error_handler) 3375 ("%s: warning: duplicate line number information for `%s'", 3376 bfd_get_filename (abfd), 3377 bfd_asymbol_name (&sym->symbol)); 3378 } 3379 sym->lineno = cache_ptr; 3380 } 3381 else 3382 { 3383 cache_ptr->u.offset = dst.l_addr.l_paddr 3384 - bfd_section_vma (abfd, asect); 3385 } /* If no linenumber expect a symbol index */ 3386 3387 cache_ptr++; 3388 src++; 3389 counter++; 3390 } 3391 cache_ptr->line_number = 0; 3392 3393 } 3394 asect->lineno = lineno_cache; 3395 /* FIXME, free native_lineno here, or use alloca or something. */ 3396 return true; 3397 } 3398 3399 static boolean 3400 coff_slurp_symbol_table (abfd) 3401 bfd * abfd; 3402 { 3403 combined_entry_type *native_symbols; 3404 coff_symbol_type *cached_area; 3405 unsigned int *table_ptr; 3406 3407 unsigned int number_of_symbols = 0; 3408 3409 if (obj_symbols (abfd)) 3410 return true; 3411 3412 /* Read in the symbol table */ 3413 if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL) 3414 { 3415 return (false); 3416 } /* on error */ 3417 3418 /* Allocate enough room for all the symbols in cached form */ 3419 cached_area = ((coff_symbol_type *) 3420 bfd_alloc (abfd, 3421 (obj_raw_syment_count (abfd) 3422 * sizeof (coff_symbol_type)))); 3423 3424 if (cached_area == NULL) 3425 return false; 3426 table_ptr = ((unsigned int *) 3427 bfd_alloc (abfd, 3428 (obj_raw_syment_count (abfd) 3429 * sizeof (unsigned int)))); 3430 3431 if (table_ptr == NULL) 3432 return false; 3433 else 3434 { 3435 coff_symbol_type *dst = cached_area; 3436 unsigned int last_native_index = obj_raw_syment_count (abfd); 3437 unsigned int this_index = 0; 3438 while (this_index < last_native_index) 3439 { 3440 combined_entry_type *src = native_symbols + this_index; 3441 table_ptr[this_index] = number_of_symbols; 3442 dst->symbol.the_bfd = abfd; 3443 3444 dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset); 3445 /* We use the native name field to point to the cached field. */ 3446 src->u.syment._n._n_n._n_zeroes = (long) dst; 3447 dst->symbol.section = coff_section_from_bfd_index (abfd, 3448 src->u.syment.n_scnum); 3449 dst->symbol.flags = 0; 3450 dst->done_lineno = false; 3451 3452 switch (src->u.syment.n_sclass) 3453 { 3454 #ifdef I960 3455 case C_LEAFEXT: 3456 #if 0 3457 dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma; 3458 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL; 3459 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION; 3460 #endif 3461 /* Fall through to next case */ 3462 3463 #endif 3464 3465 case C_EXT: 3466 #if defined ARM 3467 case C_THUMBEXT: 3468 case C_THUMBEXTFUNC: 3469 #endif 3470 #ifdef RS6000COFF_C 3471 case C_HIDEXT: 3472 #endif 3473 #ifdef C_SYSTEM 3474 case C_SYSTEM: /* System Wide variable */ 3475 #endif 3476 #ifdef COFF_WITH_PE 3477 /* PE uses storage class 0x68 to denote a section symbol */ 3478 case C_SECTION: 3479 /* PE uses storage class 0x67 for a weak external symbol. */ 3480 case C_NT_WEAK: 3481 #endif 3482 if ((src->u.syment.n_scnum) == 0) 3483 { 3484 if ((src->u.syment.n_value) == 0) 3485 { 3486 dst->symbol.section = bfd_und_section_ptr; 3487 dst->symbol.value = 0; 3488 } 3489 else 3490 { 3491 dst->symbol.section = bfd_com_section_ptr; 3492 dst->symbol.value = (src->u.syment.n_value); 3493 } 3494 } 3495 else 3496 { 3497 /* Base the value as an index from the base of the 3498 section */ 3499 3500 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL; 3501 3502 #if defined COFF_WITH_PE 3503 /* PE sets the symbol to a value relative to the 3504 start of the section. */ 3505 dst->symbol.value = src->u.syment.n_value; 3506 #else 3507 dst->symbol.value = (src->u.syment.n_value 3508 - dst->symbol.section->vma); 3509 #endif 3510 3511 if (ISFCN ((src->u.syment.n_type))) 3512 { 3513 /* A function ext does not go at the end of a 3514 file. */ 3515 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION; 3516 } 3517 } 3518 3519 #ifdef RS6000COFF_C 3520 /* A C_HIDEXT symbol is not global. */ 3521 if (src->u.syment.n_sclass == C_HIDEXT) 3522 dst->symbol.flags = BSF_LOCAL; 3523 /* A symbol with a csect entry should not go at the end. */ 3524 if (src->u.syment.n_numaux > 0) 3525 dst->symbol.flags |= BSF_NOT_AT_END; 3526 #endif 3527 3528 #ifdef COFF_WITH_PE 3529 if (src->u.syment.n_sclass == C_NT_WEAK) 3530 dst->symbol.flags = BSF_WEAK; 3531 #endif 3532 3533 break; 3534 3535 case C_STAT: /* static */ 3536 #ifdef I960 3537 case C_LEAFSTAT: /* static leaf procedure */ 3538 #endif 3539 #if defined ARM 3540 case C_THUMBSTAT: /* Thumb static */ 3541 case C_THUMBLABEL: /* Thumb label */ 3542 case C_THUMBSTATFUNC:/* Thumb static function */ 3543 #endif 3544 case C_LABEL: /* label */ 3545 if (src->u.syment.n_scnum == -2) 3546 dst->symbol.flags = BSF_DEBUGGING; 3547 else 3548 dst->symbol.flags = BSF_LOCAL; 3549 3550 /* Base the value as an index from the base of the 3551 section, if there is one. */ 3552 if (dst->symbol.section) 3553 { 3554 #if defined COFF_WITH_PE 3555 /* PE sets the symbol to a value relative to the 3556 start of the section. */ 3557 dst->symbol.value = src->u.syment.n_value; 3558 #else 3559 dst->symbol.value = (src->u.syment.n_value 3560 - dst->symbol.section->vma); 3561 #endif 3562 } 3563 else 3564 dst->symbol.value = src->u.syment.n_value; 3565 break; 3566 3567 case C_MOS: /* member of structure */ 3568 case C_EOS: /* end of structure */ 3569 #ifdef NOTDEF /* C_AUTOARG has the same value */ 3570 #ifdef C_GLBLREG 3571 case C_GLBLREG: /* A29k-specific storage class */ 3572 #endif 3573 #endif 3574 case C_REGPARM: /* register parameter */ 3575 case C_REG: /* register variable */ 3576 #ifdef C_AUTOARG 3577 case C_AUTOARG: /* 960-specific storage class */ 3578 #endif 3579 case C_TPDEF: /* type definition */ 3580 case C_ARG: 3581 case C_AUTO: /* automatic variable */ 3582 case C_FIELD: /* bit field */ 3583 case C_ENTAG: /* enumeration tag */ 3584 case C_MOE: /* member of enumeration */ 3585 case C_MOU: /* member of union */ 3586 case C_UNTAG: /* union tag */ 3587 dst->symbol.flags = BSF_DEBUGGING; 3588 dst->symbol.value = (src->u.syment.n_value); 3589 break; 3590 3591 case C_FILE: /* file name */ 3592 case C_STRTAG: /* structure tag */ 3593 #ifdef RS6000COFF_C 3594 case C_GSYM: 3595 case C_LSYM: 3596 case C_PSYM: 3597 case C_RSYM: 3598 case C_RPSYM: 3599 case C_STSYM: 3600 case C_BCOMM: 3601 case C_ECOMM: 3602 case C_DECL: 3603 case C_ENTRY: 3604 case C_FUN: 3605 case C_ESTAT: 3606 #endif 3607 dst->symbol.flags = BSF_DEBUGGING; 3608 dst->symbol.value = (src->u.syment.n_value); 3609 break; 3610 3611 #ifdef RS6000COFF_C 3612 case C_BINCL: /* beginning of include file */ 3613 case C_EINCL: /* ending of include file */ 3614 /* The value is actually a pointer into the line numbers 3615 of the file. We locate the line number entry, and 3616 set the section to the section which contains it, and 3617 the value to the index in that section. */ 3618 { 3619 asection *sec; 3620 3621 dst->symbol.flags = BSF_DEBUGGING; 3622 for (sec = abfd->sections; sec != NULL; sec = sec->next) 3623 if (sec->line_filepos <= (file_ptr) src->u.syment.n_value 3624 && ((file_ptr) (sec->line_filepos 3625 + sec->lineno_count * LINESZ) 3626 > (file_ptr) src->u.syment.n_value)) 3627 break; 3628 if (sec == NULL) 3629 dst->symbol.value = 0; 3630 else 3631 { 3632 dst->symbol.section = sec; 3633 dst->symbol.value = ((src->u.syment.n_value 3634 - sec->line_filepos) 3635 / LINESZ); 3636 src->fix_line = 1; 3637 } 3638 } 3639 break; 3640 3641 case C_BSTAT: 3642 dst->symbol.flags = BSF_DEBUGGING; 3643 3644 /* The value is actually a symbol index. Save a pointer 3645 to the symbol instead of the index. FIXME: This 3646 should use a union. */ 3647 src->u.syment.n_value = 3648 (long) (native_symbols + src->u.syment.n_value); 3649 dst->symbol.value = src->u.syment.n_value; 3650 src->fix_value = 1; 3651 break; 3652 #endif 3653 3654 case C_BLOCK: /* ".bb" or ".eb" */ 3655 case C_FCN: /* ".bf" or ".ef" */ 3656 case C_EFCN: /* physical end of function */ 3657 dst->symbol.flags = BSF_LOCAL; 3658 #if defined COFF_WITH_PE 3659 /* PE sets the symbol to a value relative to the start 3660 of the section. */ 3661 dst->symbol.value = src->u.syment.n_value; 3662 #else 3663 /* Base the value as an index from the base of the 3664 section. */ 3665 dst->symbol.value = (src->u.syment.n_value 3666 - dst->symbol.section->vma); 3667 #endif 3668 break; 3669 3670 case C_NULL: 3671 case C_EXTDEF: /* external definition */ 3672 case C_ULABEL: /* undefined label */ 3673 case C_USTATIC: /* undefined static */ 3674 #ifndef COFF_WITH_PE 3675 /* C_LINE in regular coff is 0x68. NT has taken over this storage 3676 class to represent a section symbol */ 3677 case C_LINE: /* line # reformatted as symbol table entry */ 3678 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */ 3679 case C_ALIAS: /* duplicate tag */ 3680 #endif 3681 case C_HIDDEN: /* ext symbol in dmert public lib */ 3682 default: 3683 (*_bfd_error_handler) 3684 ("%s: Unrecognized storage class %d for %s symbol `%s'", 3685 bfd_get_filename (abfd), src->u.syment.n_sclass, 3686 dst->symbol.section->name, dst->symbol.name); 3687 dst->symbol.flags = BSF_DEBUGGING; 3688 dst->symbol.value = (src->u.syment.n_value); 3689 break; 3690 } 3691 3692 /* BFD_ASSERT(dst->symbol.flags != 0);*/ 3693 3694 dst->native = src; 3695 3696 dst->symbol.udata.i = 0; 3697 dst->lineno = (alent *) NULL; 3698 this_index += (src->u.syment.n_numaux) + 1; 3699 dst++; 3700 number_of_symbols++; 3701 } /* walk the native symtab */ 3702 } /* bfdize the native symtab */ 3703 3704 obj_symbols (abfd) = cached_area; 3705 obj_raw_syments (abfd) = native_symbols; 3706 3707 bfd_get_symcount (abfd) = number_of_symbols; 3708 obj_convert (abfd) = table_ptr; 3709 /* Slurp the line tables for each section too */ 3710 { 3711 asection *p; 3712 p = abfd->sections; 3713 while (p) 3714 { 3715 coff_slurp_line_table (abfd, p); 3716 p = p->next; 3717 } 3718 } 3719 return true; 3720 } /* coff_slurp_symbol_table() */ 3721 3722 /* Check whether a symbol is globally visible. This is used by the 3723 COFF backend linker code in cofflink.c, since a couple of targets 3724 have globally visible symbols which are not class C_EXT. This 3725 function need not handle the case of n_class == C_EXT. */ 3726 3727 #undef OTHER_GLOBAL_CLASS 3728 3729 #ifdef I960 3730 #define OTHER_GLOBAL_CLASS C_LEAFEXT 3731 #endif 3732 3733 #ifdef COFFARM 3734 #define OTHER_GLOBAL_CLASS C_THUMBEXT || syment->n_sclass == C_THUMBEXTFUNC 3735 #else 3736 #ifdef COFF_WITH_PE 3737 #define OTHER_GLOBAL_CLASS C_SECTION 3738 #endif 3739 #endif 3740 3741 #ifdef OTHER_GLOBAL_CLASS 3742 3743 static boolean coff_sym_is_global PARAMS ((bfd *, struct internal_syment *)); 3744 3745 static boolean 3746 coff_sym_is_global (abfd, syment) 3747 bfd * abfd; 3748 struct internal_syment * syment; 3749 { 3750 return (syment->n_sclass == OTHER_GLOBAL_CLASS); 3751 } 3752 3753 #undef OTHER_GLOBAL_CLASS 3754 3755 #else /* ! defined (OTHER_GLOBAL_CLASS) */ 3756 3757 /* sym_is_global should not be defined if it has nothing to do. */ 3758 3759 #define coff_sym_is_global 0 3760 3761 #endif /* ! defined (OTHER_GLOBAL_CLASS) */ 3762 3763 /* 3764 SUBSUBSECTION 3765 Reading relocations 3766 3767 Coff relocations are easily transformed into the internal BFD form 3768 (@code{arelent}). 3769 3770 Reading a coff relocation table is done in the following stages: 3771 3772 o Read the entire coff relocation table into memory. 3773 3774 o Process each relocation in turn; first swap it from the 3775 external to the internal form. 3776 3777 o Turn the symbol referenced in the relocation's symbol index 3778 into a pointer into the canonical symbol table. 3779 This table is the same as the one returned by a call to 3780 @code{bfd_canonicalize_symtab}. The back end will call that 3781 routine and save the result if a canonicalization hasn't been done. 3782 3783 o The reloc index is turned into a pointer to a howto 3784 structure, in a back end specific way. For instance, the 386 3785 and 960 use the @code{r_type} to directly produce an index 3786 into a howto table vector; the 88k subtracts a number from the 3787 @code{r_type} field and creates an addend field. 3788 3789 3790 */ 3791 3792 #ifndef CALC_ADDEND 3793 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \ 3794 { \ 3795 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \ 3796 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \ 3797 coffsym = (obj_symbols (abfd) \ 3798 + (cache_ptr->sym_ptr_ptr - symbols)); \ 3799 else if (ptr) \ 3800 coffsym = coff_symbol_from (abfd, ptr); \ 3801 if (coffsym != (coff_symbol_type *) NULL \ 3802 && coffsym->native->u.syment.n_scnum == 0) \ 3803 cache_ptr->addend = 0; \ 3804 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \ 3805 && ptr->section != (asection *) NULL) \ 3806 cache_ptr->addend = - (ptr->section->vma + ptr->value); \ 3807 else \ 3808 cache_ptr->addend = 0; \ 3809 } 3810 #endif 3811 3812 static boolean 3813 coff_slurp_reloc_table (abfd, asect, symbols) 3814 bfd * abfd; 3815 sec_ptr asect; 3816 asymbol ** symbols; 3817 { 3818 RELOC *native_relocs; 3819 arelent *reloc_cache; 3820 arelent *cache_ptr; 3821 3822 unsigned int idx; 3823 3824 if (asect->relocation) 3825 return true; 3826 if (asect->reloc_count == 0) 3827 return true; 3828 if (asect->flags & SEC_CONSTRUCTOR) 3829 return true; 3830 if (!coff_slurp_symbol_table (abfd)) 3831 return false; 3832 native_relocs = 3833 (RELOC *) buy_and_read (abfd, 3834 asect->rel_filepos, 3835 SEEK_SET, 3836 (size_t) (RELSZ * 3837 asect->reloc_count)); 3838 reloc_cache = (arelent *) 3839 bfd_alloc (abfd, (size_t) (asect->reloc_count * sizeof (arelent))); 3840 3841 if (reloc_cache == NULL) 3842 return false; 3843 3844 3845 for (idx = 0; idx < asect->reloc_count; idx++) 3846 { 3847 struct internal_reloc dst; 3848 struct external_reloc *src; 3849 #ifndef RELOC_PROCESSING 3850 asymbol *ptr; 3851 #endif 3852 3853 cache_ptr = reloc_cache + idx; 3854 src = native_relocs + idx; 3855 3856 coff_swap_reloc_in (abfd, src, &dst); 3857 3858 #ifdef RELOC_PROCESSING 3859 RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect); 3860 #else 3861 cache_ptr->address = dst.r_vaddr; 3862 3863 if (dst.r_symndx != -1) 3864 { 3865 if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd)) 3866 { 3867 (*_bfd_error_handler) 3868 ("%s: warning: illegal symbol index %ld in relocs", 3869 bfd_get_filename (abfd), dst.r_symndx); 3870 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; 3871 ptr = NULL; 3872 } 3873 else 3874 { 3875 cache_ptr->sym_ptr_ptr = (symbols 3876 + obj_convert (abfd)[dst.r_symndx]); 3877 ptr = *(cache_ptr->sym_ptr_ptr); 3878 } 3879 } 3880 else 3881 { 3882 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; 3883 ptr = NULL; 3884 } 3885 3886 /* The symbols definitions that we have read in have been 3887 relocated as if their sections started at 0. But the offsets 3888 refering to the symbols in the raw data have not been 3889 modified, so we have to have a negative addend to compensate. 3890 3891 Note that symbols which used to be common must be left alone */ 3892 3893 /* Calculate any reloc addend by looking at the symbol */ 3894 CALC_ADDEND (abfd, ptr, dst, cache_ptr); 3895 3896 cache_ptr->address -= asect->vma; 3897 /* !! cache_ptr->section = (asection *) NULL;*/ 3898 3899 /* Fill in the cache_ptr->howto field from dst.r_type */ 3900 RTYPE2HOWTO (cache_ptr, &dst); 3901 #endif /* RELOC_PROCESSING */ 3902 3903 if (cache_ptr->howto == NULL) 3904 { 3905 (*_bfd_error_handler) 3906 ("%s: illegal relocation type %d at address 0x%lx", 3907 bfd_get_filename (abfd), dst.r_type, (long) dst.r_vaddr); 3908 bfd_set_error (bfd_error_bad_value); 3909 return false; 3910 } 3911 } 3912 3913 asect->relocation = reloc_cache; 3914 return true; 3915 } 3916 3917 #ifndef coff_rtype_to_howto 3918 #ifdef RTYPE2HOWTO 3919 3920 /* Get the howto structure for a reloc. This is only used if the file 3921 including this one defines coff_relocate_section to be 3922 _bfd_coff_generic_relocate_section, so it is OK if it does not 3923 always work. It is the responsibility of the including file to 3924 make sure it is reasonable if it is needed. */ 3925 3926 static reloc_howto_type *coff_rtype_to_howto 3927 PARAMS ((bfd *, asection *, struct internal_reloc *, 3928 struct coff_link_hash_entry *, struct internal_syment *, 3929 bfd_vma *)); 3930 3931 /*ARGSUSED*/ 3932 static reloc_howto_type * 3933 coff_rtype_to_howto (abfd, sec, rel, h, sym, addendp) 3934 bfd *abfd; 3935 asection *sec; 3936 struct internal_reloc *rel; 3937 struct coff_link_hash_entry *h; 3938 struct internal_syment *sym; 3939 bfd_vma *addendp; 3940 { 3941 arelent genrel; 3942 3943 RTYPE2HOWTO (&genrel, rel); 3944 return genrel.howto; 3945 } 3946 3947 #else /* ! defined (RTYPE2HOWTO) */ 3948 3949 #define coff_rtype_to_howto NULL 3950 3951 #endif /* ! defined (RTYPE2HOWTO) */ 3952 #endif /* ! defined (coff_rtype_to_howto) */ 3953 3954 /* This is stupid. This function should be a boolean predicate. */ 3955 static long 3956 coff_canonicalize_reloc (abfd, section, relptr, symbols) 3957 bfd * abfd; 3958 sec_ptr section; 3959 arelent ** relptr; 3960 asymbol ** symbols; 3961 { 3962 arelent *tblptr = section->relocation; 3963 unsigned int count = 0; 3964 3965 3966 if (section->flags & SEC_CONSTRUCTOR) 3967 { 3968 /* this section has relocs made up by us, they are not in the 3969 file, so take them out of their chain and place them into 3970 the data area provided */ 3971 arelent_chain *chain = section->constructor_chain; 3972 for (count = 0; count < section->reloc_count; count++) 3973 { 3974 *relptr++ = &chain->relent; 3975 chain = chain->next; 3976 } 3977 3978 } 3979 else 3980 { 3981 if (! coff_slurp_reloc_table (abfd, section, symbols)) 3982 return -1; 3983 3984 tblptr = section->relocation; 3985 3986 for (; count++ < section->reloc_count;) 3987 *relptr++ = tblptr++; 3988 3989 3990 } 3991 *relptr = 0; 3992 return section->reloc_count; 3993 } 3994 3995 #ifdef GNU960 3996 file_ptr 3997 coff_sym_filepos (abfd) 3998 bfd *abfd; 3999 { 4000 return obj_sym_filepos (abfd); 4001 } 4002 #endif 4003 4004 #ifndef coff_reloc16_estimate 4005 #define coff_reloc16_estimate dummy_reloc16_estimate 4006 4007 static int dummy_reloc16_estimate 4008 PARAMS ((bfd *, asection *, arelent *, unsigned int, 4009 struct bfd_link_info *)); 4010 4011 static int 4012 dummy_reloc16_estimate (abfd, input_section, reloc, shrink, link_info) 4013 bfd *abfd; 4014 asection *input_section; 4015 arelent *reloc; 4016 unsigned int shrink; 4017 struct bfd_link_info *link_info; 4018 { 4019 abort (); 4020 } 4021 4022 #endif 4023 4024 #ifndef coff_reloc16_extra_cases 4025 4026 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases 4027 4028 /* This works even if abort is not declared in any header file. */ 4029 4030 static void dummy_reloc16_extra_cases 4031 PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *, 4032 bfd_byte *, unsigned int *, unsigned int *)); 4033 4034 static void 4035 dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr, 4036 dst_ptr) 4037 bfd *abfd; 4038 struct bfd_link_info *link_info; 4039 struct bfd_link_order *link_order; 4040 arelent *reloc; 4041 bfd_byte *data; 4042 unsigned int *src_ptr; 4043 unsigned int *dst_ptr; 4044 { 4045 abort (); 4046 } 4047 #endif 4048 4049 /* If coff_relocate_section is defined, we can use the optimized COFF 4050 backend linker. Otherwise we must continue to use the old linker. */ 4051 #ifdef coff_relocate_section 4052 #ifndef coff_bfd_link_hash_table_create 4053 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create 4054 #endif 4055 #ifndef coff_bfd_link_add_symbols 4056 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols 4057 #endif 4058 #ifndef coff_bfd_final_link 4059 #define coff_bfd_final_link _bfd_coff_final_link 4060 #endif 4061 #else /* ! defined (coff_relocate_section) */ 4062 #define coff_relocate_section NULL 4063 #ifndef coff_bfd_link_hash_table_create 4064 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create 4065 #endif 4066 #ifndef coff_bfd_link_add_symbols 4067 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols 4068 #endif 4069 #define coff_bfd_final_link _bfd_generic_final_link 4070 #endif /* ! defined (coff_relocate_section) */ 4071 4072 #define coff_bfd_link_split_section _bfd_generic_link_split_section 4073 4074 #ifndef coff_start_final_link 4075 #define coff_start_final_link NULL 4076 #endif 4077 4078 #ifndef coff_adjust_symndx 4079 #define coff_adjust_symndx NULL 4080 #endif 4081 4082 #ifndef coff_link_add_one_symbol 4083 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol 4084 #endif 4085 4086 #ifndef coff_link_output_has_begun 4087 #define coff_link_output_has_begun _coff_link_output_has_begun 4088 static boolean 4089 _coff_link_output_has_begun (abfd) 4090 bfd * abfd; 4091 { 4092 return abfd->output_has_begun; 4093 } 4094 #endif 4095 4096 #ifndef coff_final_link_postscript 4097 #define coff_final_link_postscript _coff_final_link_postscript 4098 static boolean 4099 _coff_final_link_postscript (abfd, pfinfo) 4100 bfd * abfd; 4101 struct coff_final_link_info * pfinfo; 4102 { 4103 return true; 4104 } 4105 #endif 4106 4107 #ifndef coff_SWAP_aux_in 4108 #define coff_SWAP_aux_in coff_swap_aux_in 4109 #endif 4110 #ifndef coff_SWAP_sym_in 4111 #define coff_SWAP_sym_in coff_swap_sym_in 4112 #endif 4113 #ifndef coff_SWAP_lineno_in 4114 #define coff_SWAP_lineno_in coff_swap_lineno_in 4115 #endif 4116 #ifndef coff_SWAP_aux_out 4117 #define coff_SWAP_aux_out coff_swap_aux_out 4118 #endif 4119 #ifndef coff_SWAP_sym_out 4120 #define coff_SWAP_sym_out coff_swap_sym_out 4121 #endif 4122 #ifndef coff_SWAP_lineno_out 4123 #define coff_SWAP_lineno_out coff_swap_lineno_out 4124 #endif 4125 #ifndef coff_SWAP_reloc_out 4126 #define coff_SWAP_reloc_out coff_swap_reloc_out 4127 #endif 4128 #ifndef coff_SWAP_filehdr_out 4129 #define coff_SWAP_filehdr_out coff_swap_filehdr_out 4130 #endif 4131 #ifndef coff_SWAP_aouthdr_out 4132 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out 4133 #endif 4134 #ifndef coff_SWAP_scnhdr_out 4135 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out 4136 #endif 4137 #ifndef coff_SWAP_reloc_in 4138 #define coff_SWAP_reloc_in coff_swap_reloc_in 4139 #endif 4140 #ifndef coff_SWAP_filehdr_in 4141 #define coff_SWAP_filehdr_in coff_swap_filehdr_in 4142 #endif 4143 #ifndef coff_SWAP_aouthdr_in 4144 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in 4145 #endif 4146 #ifndef coff_SWAP_scnhdr_in 4147 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in 4148 #endif 4149 4150 4151 4152 static CONST bfd_coff_backend_data bfd_coff_std_swap_table = 4153 { 4154 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in, 4155 coff_SWAP_aux_out, coff_SWAP_sym_out, 4156 coff_SWAP_lineno_out, coff_SWAP_reloc_out, 4157 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out, 4158 coff_SWAP_scnhdr_out, 4159 FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, 4160 #ifdef COFF_LONG_FILENAMES 4161 true, 4162 #else 4163 false, 4164 #endif 4165 #ifdef COFF_LONG_SECTION_NAMES 4166 true, 4167 #else 4168 false, 4169 #endif 4170 COFF_DEFAULT_SECTION_ALIGNMENT_POWER, 4171 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in, 4172 coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook, 4173 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook, 4174 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook, 4175 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate, 4176 coff_sym_is_global, coff_compute_section_file_positions, 4177 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto, 4178 coff_adjust_symndx, coff_link_add_one_symbol, 4179 coff_link_output_has_begun, coff_final_link_postscript 4180 }; 4181 4182 #ifndef coff_close_and_cleanup 4183 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup 4184 #endif 4185 4186 #ifndef coff_bfd_free_cached_info 4187 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info 4188 #endif 4189 4190 #ifndef coff_get_section_contents 4191 #define coff_get_section_contents _bfd_generic_get_section_contents 4192 #endif 4193 4194 #ifndef coff_bfd_copy_private_symbol_data 4195 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data 4196 #endif 4197 4198 #ifndef coff_bfd_copy_private_section_data 4199 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data 4200 #endif 4201 4202 #ifndef coff_bfd_copy_private_bfd_data 4203 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data 4204 #endif 4205 4206 #ifndef coff_bfd_merge_private_bfd_data 4207 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data 4208 #endif 4209 4210 #ifndef coff_bfd_set_private_flags 4211 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags 4212 #endif 4213 4214 #ifndef coff_bfd_print_private_bfd_data 4215 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data 4216 #endif 4217 4218 #ifndef coff_bfd_is_local_label_name 4219 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name 4220 #endif 4221 4222 #ifndef coff_read_minisymbols 4223 #define coff_read_minisymbols _bfd_generic_read_minisymbols 4224 #endif 4225 4226 #ifndef coff_minisymbol_to_symbol 4227 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol 4228 #endif 4229 4230 /* The reloc lookup routine must be supplied by each individual COFF 4231 backend. */ 4232 #ifndef coff_bfd_reloc_type_lookup 4233 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup 4234 #endif 4235 4236 #ifndef coff_bfd_get_relocated_section_contents 4237 #define coff_bfd_get_relocated_section_contents \ 4238 bfd_generic_get_relocated_section_contents 4239 #endif 4240 4241 #ifndef coff_bfd_relax_section 4242 #define coff_bfd_relax_section bfd_generic_relax_section 4243 #endif 4244