1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 Free Software Foundation, Inc.
5 Written by Cygnus Support.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
24 Most of this hacked by Steve Chamberlain,
32 BFD supports a number of different flavours of coff format.
33 The major differences between formats are the sizes and
34 alignments of fields in structures on disk, and the occasional
37 Coff in all its varieties is implemented with a few common
38 files and a number of implementation specific files. For
39 example, The 88k bcs coff format is implemented in the file
40 @file{coff-m88k.c}. This file @code{#include}s
41 @file{coff/m88k.h} which defines the external structure of the
42 coff format for the 88k, and @file{coff/internal.h} which
43 defines the internal structure. @file{coff-m88k.c} also
44 defines the relocations used by the 88k format
47 The Intel i960 processor version of coff is implemented in
48 @file{coff-i960.c}. This file has the same structure as
49 @file{coff-m88k.c}, except that it includes @file{coff/i960.h}
50 rather than @file{coff-m88k.h}.
53 Porting to a new version of coff
55 The recommended method is to select from the existing
56 implementations the version of coff which is most like the one
57 you want to use. For example, we'll say that i386 coff is
58 the one you select, and that your coff flavour is called foo.
59 Copy @file{i386coff.c} to @file{foocoff.c}, copy
60 @file{../include/coff/i386.h} to @file{../include/coff/foo.h},
61 and add the lines to @file{targets.c} and @file{Makefile.in}
62 so that your new back end is used. Alter the shapes of the
63 structures in @file{../include/coff/foo.h} so that they match
64 what you need. You will probably also have to add
65 @code{#ifdef}s to the code in @file{coff/internal.h} and
66 @file{coffcode.h} if your version of coff is too wild.
68 You can verify that your new BFD backend works quite simply by
69 building @file{objdump} from the @file{binutils} directory,
70 and making sure that its version of what's going on and your
71 host system's idea (assuming it has the pretty standard coff
72 dump utility, usually called @code{att-dump} or just
73 @code{dump}) are the same. Then clean up your code, and send
74 what you've done to Cygnus. Then your stuff will be in the
75 next release, and you won't have to keep integrating it.
78 How the coff backend works
83 The Coff backend is split into generic routines that are
84 applicable to any Coff target and routines that are specific
85 to a particular target. The target-specific routines are
86 further split into ones which are basically the same for all
87 Coff targets except that they use the external symbol format
88 or use different values for certain constants.
90 The generic routines are in @file{coffgen.c}. These routines
91 work for any Coff target. They use some hooks into the target
92 specific code; the hooks are in a @code{bfd_coff_backend_data}
93 structure, one of which exists for each target.
95 The essentially similar target-specific routines are in
96 @file{coffcode.h}. This header file includes executable C code.
97 The various Coff targets first include the appropriate Coff
98 header file, make any special defines that are needed, and
99 then include @file{coffcode.h}.
101 Some of the Coff targets then also have additional routines in
102 the target source file itself.
104 For example, @file{coff-i960.c} includes
105 @file{coff/internal.h} and @file{coff/i960.h}. It then
106 defines a few constants, such as @code{I960}, and includes
107 @file{coffcode.h}. Since the i960 has complex relocation
108 types, @file{coff-i960.c} also includes some code to
109 manipulate the i960 relocs. This code is not in
110 @file{coffcode.h} because it would not be used by any other
116 Each flavour of coff supported in BFD has its own header file
117 describing the external layout of the structures. There is also
118 an internal description of the coff layout, in
119 @file{coff/internal.h}. A major function of the
120 coff backend is swapping the bytes and twiddling the bits to
121 translate the external form of the structures into the normal
122 internal form. This is all performed in the
123 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
124 elements are different sizes between different versions of
125 coff; it is the duty of the coff version specific include file
126 to override the definitions of various packing routines in
127 @file{coffcode.h}. E.g., the size of line number entry in coff is
128 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
129 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
130 correct one. No doubt, some day someone will find a version of
131 coff which has a varying field size not catered to at the
132 moment. To port BFD, that person will have to add more @code{#defines}.
133 Three of the bit twiddling routines are exported to
134 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
135 and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol
136 table on its own, but uses BFD to fix things up. More of the
137 bit twiddlers are exported for @code{gas};
138 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
139 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
140 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
141 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
142 of all the symbol table and reloc drudgery itself, thereby
143 saving the internal BFD overhead, but uses BFD to swap things
144 on the way out, making cross ports much safer. Doing so also
145 allows BFD (and thus the linker) to use the same header files
146 as @code{gas}, which makes one avenue to disaster disappear.
151 The simple canonical form for symbols used by BFD is not rich
152 enough to keep all the information available in a coff symbol
153 table. The back end gets around this problem by keeping the original
154 symbol table around, "behind the scenes".
156 When a symbol table is requested (through a call to
157 @code{bfd_canonicalize_symtab}), a request gets through to
158 @code{coff_get_normalized_symtab}. This reads the symbol table from
159 the coff file and swaps all the structures inside into the
160 internal form. It also fixes up all the pointers in the table
161 (represented in the file by offsets from the first symbol in
162 the table) into physical pointers to elements in the new
163 internal table. This involves some work since the meanings of
164 fields change depending upon context: a field that is a
165 pointer to another structure in the symbol table at one moment
166 may be the size in bytes of a structure at the next. Another
167 pass is made over the table. All symbols which mark file names
168 (<<C_FILE>> symbols) are modified so that the internal
169 string points to the value in the auxent (the real filename)
170 rather than the normal text associated with the symbol
173 At this time the symbol names are moved around. Coff stores
174 all symbols less than nine characters long physically
175 within the symbol table; longer strings are kept at the end of
176 the file in the string table. This pass moves all strings
177 into memory and replaces them with pointers to the strings.
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.
186 Any linenumbers are read from the coff file too, and attached
187 to the symbols which own the functions the linenumbers belong to.
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.
198 When the symbols have come from a coff file then all the
199 debugging information is preserved.
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.
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.
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}.
223 o <<coff_mangle_symbols>>
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.
231 o <<coff_write_symbols>>
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.
244 The hidden information for an <<asymbol>> is described in a
245 <<combined_entry_type>>:
249 .typedef struct coff_ptr_struct
251 . {* Remembers the offset from the first symbol in the file for
252 . this symbol. Generated by coff_renumber_symbols. *}
253 . unsigned int offset;
255 . {* Should the value of this symbol be renumbered. Used for
256 . XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
257 . unsigned int fix_value : 1;
259 . {* Should the tag field of this symbol be renumbered.
260 . Created by coff_pointerize_aux. *}
261 . unsigned int fix_tag : 1;
263 . {* Should the endidx field of this symbol be renumbered.
264 . Created by coff_pointerize_aux. *}
265 . unsigned int fix_end : 1;
267 . {* Should the x_csect.x_scnlen field be renumbered.
268 . Created by coff_pointerize_aux. *}
269 . unsigned int fix_scnlen : 1;
271 . {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
272 . index into the line number entries. Set by coff_slurp_symbol_table. *}
273 . unsigned int fix_line : 1;
275 . {* The container for the symbol structure as read and translated
279 . union internal_auxent auxent;
280 . struct internal_syment syment;
282 .} combined_entry_type;
285 .{* Each canonical asymbol really looks like this: *}
287 .typedef struct coff_symbol_struct
289 . {* The actual symbol which the rest of BFD works with *}
292 . {* A pointer to the hidden information for this symbol *}
293 . combined_entry_type *native;
295 . {* A pointer to the linenumber information for this symbol *}
296 . struct lineno_cache_entry *lineno;
298 . {* Have the line numbers been relocated yet ? *}
299 . boolean done_lineno;
307 #include "coffswap.h"
310 #define STRING_SIZE_SIZE (4)
312 static long sec_to_styp_flags PARAMS ((const char *, flagword));
313 static boolean styp_to_sec_flags
314 PARAMS ((bfd *, PTR, const char *, asection *, flagword *));
315 static boolean coff_bad_format_hook PARAMS ((bfd *, PTR));
316 static void coff_set_custom_section_alignment
317 PARAMS ((bfd *, asection *, const struct coff_section_alignment_entry *,
318 const unsigned int));
319 static boolean coff_new_section_hook PARAMS ((bfd *, asection *));
320 static boolean coff_set_arch_mach_hook PARAMS ((bfd *, PTR));
321 static boolean coff_write_relocs PARAMS ((bfd *, int));
322 static boolean coff_set_flags
323 PARAMS ((bfd *, unsigned int *, unsigned short *));
324 static boolean coff_set_arch_mach
325 PARAMS ((bfd *, enum bfd_architecture, unsigned long)) ATTRIBUTE_UNUSED;
326 static boolean coff_compute_section_file_positions PARAMS ((bfd *));
327 static boolean coff_write_object_contents PARAMS ((bfd *)) ATTRIBUTE_UNUSED;
328 static boolean coff_set_section_contents
329 PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
330 static PTR buy_and_read PARAMS ((bfd *, file_ptr, bfd_size_type));
331 static boolean coff_slurp_line_table PARAMS ((bfd *, asection *));
332 static boolean coff_slurp_symbol_table PARAMS ((bfd *));
333 static enum coff_symbol_classification coff_classify_symbol
334 PARAMS ((bfd *, struct internal_syment *));
335 static boolean coff_slurp_reloc_table PARAMS ((bfd *, asection *, asymbol **));
336 static long coff_canonicalize_reloc
337 PARAMS ((bfd *, asection *, arelent **, asymbol **));
338 #ifndef coff_mkobject_hook
339 static PTR coff_mkobject_hook PARAMS ((bfd *, PTR, PTR));
342 static flagword handle_COMDAT PARAMS ((bfd *, flagword, PTR, const char *, asection *));
344 #ifdef COFF_IMAGE_WITH_PE
345 static boolean coff_read_word PARAMS ((bfd *, unsigned int *));
346 static unsigned int coff_compute_checksum PARAMS ((bfd *));
347 static boolean coff_apply_checksum PARAMS ((bfd *));
350 /* void warning(); */
352 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
353 the incoming SEC_* flags. The inverse of this function is
354 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
355 should probably mirror the changes in styp_to_sec_flags(). */
359 /* Macros for setting debugging flags. */
361 #define STYP_XCOFF_DEBUG STYP_DEBUG
363 #define STYP_XCOFF_DEBUG STYP_INFO
366 #ifdef COFF_ALIGN_IN_S_FLAGS
367 #define STYP_DEBUG_INFO STYP_DSECT
369 #define STYP_DEBUG_INFO STYP_INFO
373 sec_to_styp_flags (sec_name, sec_flags)
374 const char *sec_name;
379 if (!strcmp (sec_name, _TEXT))
381 styp_flags = STYP_TEXT;
383 else if (!strcmp (sec_name, _DATA))
385 styp_flags = STYP_DATA;
387 else if (!strcmp (sec_name, _BSS))
389 styp_flags = STYP_BSS;
392 else if (!strcmp (sec_name, _COMMENT))
394 styp_flags = STYP_INFO;
395 #endif /* _COMMENT */
398 else if (!strcmp (sec_name, _LIB))
400 styp_flags = STYP_LIB;
404 else if (!strcmp (sec_name, _LIT))
406 styp_flags = STYP_LIT;
409 else if (!strncmp (sec_name, ".debug", 6))
411 /* Handle the XCOFF debug section and DWARF2 debug sections. */
413 styp_flags = STYP_XCOFF_DEBUG;
415 styp_flags = STYP_DEBUG_INFO;
417 else if (!strncmp (sec_name, ".stab", 5))
419 styp_flags = STYP_DEBUG_INFO;
421 #ifdef COFF_LONG_SECTION_NAMES
422 else if (!strncmp (sec_name, ".gnu.linkonce.wi.", 17))
424 styp_flags = STYP_DEBUG_INFO;
428 else if (!strcmp (sec_name, _PAD))
430 styp_flags = STYP_PAD;
432 else if (!strcmp (sec_name, _LOADER))
434 styp_flags = STYP_LOADER;
436 else if (!strcmp (sec_name, _EXCEPT))
438 styp_flags = STYP_EXCEPT;
440 else if (!strcmp (sec_name, _TYPCHK))
442 styp_flags = STYP_TYPCHK;
445 /* Try and figure out what it should be */
446 else if (sec_flags & SEC_CODE)
448 styp_flags = STYP_TEXT;
450 else if (sec_flags & SEC_DATA)
452 styp_flags = STYP_DATA;
454 else if (sec_flags & SEC_READONLY)
456 #ifdef STYP_LIT /* 29k readonly text/data section */
457 styp_flags = STYP_LIT;
459 styp_flags = STYP_TEXT;
460 #endif /* STYP_LIT */
462 else if (sec_flags & SEC_LOAD)
464 styp_flags = STYP_TEXT;
466 else if (sec_flags & SEC_ALLOC)
468 styp_flags = STYP_BSS;
472 if (sec_flags & SEC_CLINK)
473 styp_flags |= STYP_CLINK;
477 if (sec_flags & SEC_BLOCK)
478 styp_flags |= STYP_BLOCK;
482 if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
483 styp_flags |= STYP_NOLOAD;
489 #else /* COFF_WITH_PE */
491 /* The PE version; see above for the general comments. The non-PE
492 case seems to be more guessing, and breaks PE format; specifically,
493 .rdata is readonly, but it sure ain't text. Really, all this
494 should be set up properly in gas (or whatever assembler is in use),
495 and honor whatever objcopy/strip, etc. sent us as input. */
498 sec_to_styp_flags (sec_name, sec_flags)
499 const char *sec_name ATTRIBUTE_UNUSED;
504 /* caution: there are at least three groups of symbols that have
505 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
506 SEC_* are the BFD internal flags, used for generic BFD
507 information. STYP_* are the COFF section flags which appear in
508 COFF files. IMAGE_SCN_* are the PE section flags which appear in
509 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
510 but there are more IMAGE_SCN_* flags. */
515 if ((sec_flags & SEC_CODE) != 0)
516 styp_flags |= IMAGE_SCN_CNT_CODE;
517 if ((sec_flags & SEC_DATA) != 0)
518 styp_flags |= IMAGE_SCN_CNT_INITIALIZED_DATA;
519 if ((sec_flags & SEC_ALLOC) != 0 && (sec_flags & SEC_LOAD) == 0)
520 styp_flags |= IMAGE_SCN_CNT_UNINITIALIZED_DATA; /* ==STYP_BSS */
522 /* skip constRUCTOR */
525 if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
526 styp_flags |= STYP_NOLOAD;
528 if ((sec_flags & SEC_IS_COMMON) != 0)
529 styp_flags |= IMAGE_SCN_LNK_COMDAT;
530 if ((sec_flags & SEC_DEBUGGING) != 0)
531 styp_flags |= IMAGE_SCN_MEM_DISCARDABLE;
532 if ((sec_flags & SEC_EXCLUDE) != 0)
533 styp_flags |= IMAGE_SCN_LNK_REMOVE;
534 if ((sec_flags & SEC_NEVER_LOAD) != 0)
535 styp_flags |= IMAGE_SCN_LNK_REMOVE;
538 if (sec_flags & SEC_LINK_ONCE)
539 styp_flags |= IMAGE_SCN_LNK_COMDAT;
540 /* skip LINK_DUPLICATES */
541 /* skip LINKER_CREATED */
543 /* For now, the read/write bits are mapped onto SEC_READONLY, even
544 though the semantics don't quite match. The bits from the input
545 are retained in pei_section_data(abfd, section)->pe_flags */
547 styp_flags |= IMAGE_SCN_MEM_READ; /* always readable. */
548 if ((sec_flags & SEC_READONLY) == 0)
549 styp_flags |= IMAGE_SCN_MEM_WRITE; /* Invert READONLY for write */
550 if (sec_flags & SEC_CODE)
551 styp_flags |= IMAGE_SCN_MEM_EXECUTE; /* CODE->EXECUTE */
552 if (sec_flags & SEC_SHARED)
553 styp_flags |= IMAGE_SCN_MEM_SHARED; /* Shared remains meaningful */
558 #endif /* COFF_WITH_PE */
560 /* Return a word with SEC_* flags set to represent the incoming STYP_*
561 flags (from scnhdr.s_flags). The inverse of this function is
562 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
563 should probably mirror the changes in sec_to_styp_flags(). */
568 styp_to_sec_flags (abfd, hdr, name, section, flags_ptr)
569 bfd *abfd ATTRIBUTE_UNUSED;
572 asection *section ATTRIBUTE_UNUSED;
575 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
576 long styp_flags = internal_s->s_flags;
577 flagword sec_flags = 0;
580 if (styp_flags & STYP_BLOCK)
581 sec_flags |= SEC_BLOCK;
585 if (styp_flags & STYP_CLINK)
586 sec_flags |= SEC_CLINK;
590 if (styp_flags & STYP_NOLOAD)
591 sec_flags |= SEC_NEVER_LOAD;
592 #endif /* STYP_NOLOAD */
594 /* For 386 COFF, at least, an unloadable text or data section is
595 actually a shared library section. */
596 if (styp_flags & STYP_TEXT)
598 if (sec_flags & SEC_NEVER_LOAD)
599 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
601 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
603 else if (styp_flags & STYP_DATA)
605 if (sec_flags & SEC_NEVER_LOAD)
606 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
608 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
610 else if (styp_flags & STYP_BSS)
612 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
613 if (sec_flags & SEC_NEVER_LOAD)
614 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
617 sec_flags |= SEC_ALLOC;
619 else if (styp_flags & STYP_INFO)
621 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
622 defined. coff_compute_section_file_positions uses
623 COFF_PAGE_SIZE to ensure that the low order bits of the
624 section VMA and the file offset match. If we don't know
625 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
626 and demand page loading of the file will fail. */
627 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
628 sec_flags |= SEC_DEBUGGING;
631 else if (styp_flags & STYP_PAD)
633 else if (strcmp (name, _TEXT) == 0)
635 if (sec_flags & SEC_NEVER_LOAD)
636 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
638 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
640 else if (strcmp (name, _DATA) == 0)
642 if (sec_flags & SEC_NEVER_LOAD)
643 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
645 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
647 else if (strcmp (name, _BSS) == 0)
649 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
650 if (sec_flags & SEC_NEVER_LOAD)
651 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
654 sec_flags |= SEC_ALLOC;
656 else if (strncmp (name, ".debug", 6) == 0
658 || strcmp (name, _COMMENT) == 0
660 #ifdef COFF_LONG_SECTION_NAMES
661 || strncmp (name, ".gnu.linkonce.wi.", 17) == 0
663 || strncmp (name, ".stab", 5) == 0)
665 #ifdef COFF_PAGE_SIZE
666 sec_flags |= SEC_DEBUGGING;
670 else if (strcmp (name, _LIB) == 0)
674 else if (strcmp (name, _LIT) == 0)
675 sec_flags = SEC_LOAD | SEC_ALLOC | SEC_READONLY;
678 sec_flags |= SEC_ALLOC | SEC_LOAD;
680 #ifdef STYP_LIT /* A29k readonly text/data section type */
681 if ((styp_flags & STYP_LIT) == STYP_LIT)
682 sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
683 #endif /* STYP_LIT */
685 #ifdef STYP_OTHER_LOAD /* Other loaded sections */
686 if (styp_flags & STYP_OTHER_LOAD)
687 sec_flags = (SEC_LOAD | SEC_ALLOC);
688 #endif /* STYP_SDATA */
690 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
691 /* As a GNU extension, if the name begins with .gnu.linkonce, we
692 only link a single copy of the section. This is used to support
693 g++. g++ will emit each template expansion in its own section.
694 The symbols will be defined as weak, so that multiple definitions
695 are permitted. The GNU linker extension is to actually discard
696 all but one of the sections. */
697 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
698 sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
701 if (flags_ptr == NULL)
704 * flags_ptr = sec_flags;
708 #else /* COFF_WITH_PE */
711 handle_COMDAT (abfd, sec_flags, hdr, name, section)
718 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
719 bfd_byte *esymstart, *esym, *esymend;
721 char *target_name = NULL;
723 sec_flags |= SEC_LINK_ONCE;
725 /* Unfortunately, the PE format stores essential information in
726 the symbol table, of all places. We need to extract that
727 information now, so that objdump and the linker will know how
728 to handle the section without worrying about the symbols. We
729 can't call slurp_symtab, because the linker doesn't want the
732 /* COMDAT sections are special. The first symbol is the section
733 symbol, which tells what kind of COMDAT section it is. The
734 second symbol is the "comdat symbol" - the one with the
735 unique name. GNU uses the section symbol for the unique
736 name; MS uses ".text" for every comdat section. Sigh. - DJ */
738 /* This is not mirrored in sec_to_styp_flags(), but there
739 doesn't seem to be a need to, either, and it would at best be
742 if (! _bfd_coff_get_external_symbols (abfd))
745 esymstart = esym = (bfd_byte *) obj_coff_external_syms (abfd);
746 esymend = esym + obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd);
748 while (esym < esymend)
750 struct internal_syment isym;
751 char buf[SYMNMLEN + 1];
754 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &isym);
756 if (sizeof (internal_s->s_name) > SYMNMLEN)
758 /* This case implies that the matching
759 symbol name will be in the string table. */
763 if (isym.n_scnum == section->target_index)
765 /* According to the MSVC documentation, the first
766 TWO entries with the section # are both of
767 interest to us. The first one is the "section
768 symbol" (section name). The second is the comdat
769 symbol name. Here, we've found the first
770 qualifying entry; we distinguish it from the
771 second with a state flag.
773 In the case of gas-generated (at least until that
774 is fixed) .o files, it isn't necessarily the
775 second one. It may be some other later symbol.
777 Since gas also doesn't follow MS conventions and
778 emits the section similar to .text$<name>, where
779 <something> is the name we're looking for, we
780 distinguish the two as follows:
782 If the section name is simply a section name (no
783 $) we presume it's MS-generated, and look at
784 precisely the second symbol for the comdat name.
785 If the section name has a $, we assume it's
786 gas-generated, and look for <something> (whatever
787 follows the $) as the comdat symbol. */
789 /* All 3 branches use this */
790 symname = _bfd_coff_internal_syment_name (abfd, &isym, buf);
799 /* The first time we've seen the symbol. */
800 union internal_auxent aux;
804 /* If it isn't the stuff we're expecting, die;
805 The MS documentation is vague, but it
806 appears that the second entry serves BOTH
807 as the comdat symbol and the defining
808 symbol record (either C_STAT or C_EXT,
809 possibly with an aux entry with debug
810 information if it's a function.) It
811 appears the only way to find the second one
812 is to count. (On Intel, they appear to be
813 adjacent, but on Alpha, they have been
816 Here, we think we've found the first one,
817 but there's some checking we can do to be
820 if (! (isym.n_sclass == C_STAT
821 && isym.n_type == T_NULL
822 && isym.n_value == 0))
825 /* FIXME LATER: MSVC generates section names
826 like .text for comdats. Gas generates
827 names like .text$foo__Fv (in the case of a
828 function). See comment above for more. */
830 if (strcmp (name, symname) != 0)
833 /* This is the section symbol. */
834 bfd_coff_swap_aux_in (abfd, (PTR) (esym + bfd_coff_symesz (abfd)),
835 isym.n_type, isym.n_sclass,
836 0, isym.n_numaux, (PTR) &aux);
838 target_name = strchr (name, '$');
839 if (target_name != NULL)
847 /* FIXME: Microsoft uses NODUPLICATES and
848 ASSOCIATIVE, but gnu uses ANY and
849 SAME_SIZE. Unfortunately, gnu doesn't do
850 the comdat symbols right. So, until we can
851 fix it to do the right thing, we are
852 temporarily disabling comdats for the MS
853 types (they're used in DLLs and C++, but we
854 don't support *their* C++ libraries anyway
857 /* Cygwin does not follow the MS style, and
858 uses ANY and SAME_SIZE where NODUPLICATES
859 and ASSOCIATIVE should be used. For
860 Interix, we just do the right thing up
863 switch (aux.x_scn.x_comdat)
865 case IMAGE_COMDAT_SELECT_NODUPLICATES:
866 #ifdef STRICT_PE_FORMAT
867 sec_flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
869 sec_flags &= ~SEC_LINK_ONCE;
873 case IMAGE_COMDAT_SELECT_ANY:
874 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
877 case IMAGE_COMDAT_SELECT_SAME_SIZE:
878 sec_flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
881 case IMAGE_COMDAT_SELECT_EXACT_MATCH:
882 /* Not yet fully implemented ??? */
883 sec_flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
886 /* debug$S gets this case; other
889 /* There may be no symbol... we'll search
890 the whole table... Is this the right
891 place to play this game? Or should we do
892 it when reading it in. */
893 case IMAGE_COMDAT_SELECT_ASSOCIATIVE:
894 #ifdef STRICT_PE_FORMAT
895 /* FIXME: This is not currently implemented. */
896 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
898 sec_flags &= ~SEC_LINK_ONCE;
902 default: /* 0 means "no symbol" */
903 /* debug$F gets this case; other
905 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
912 /* Gas mode: the first matching on partial name. */
914 #ifndef TARGET_UNDERSCORE
915 #define TARGET_UNDERSCORE 0
917 /* Is this the name we're looking for? */
918 if (strcmp (target_name,
919 symname + (TARGET_UNDERSCORE ? 1 : 0)) != 0)
921 /* Not the name we're looking for */
922 esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd);
927 /* MSVC mode: the lexically second symbol (or
928 drop through from the above). */
933 /* This must the second symbol with the
934 section #. It is the actual symbol name.
935 Intel puts the two adjacent, but Alpha (at
936 least) spreads them out. */
938 amt = sizeof (struct bfd_comdat_info);
939 section->comdat = bfd_alloc (abfd, amt);
940 if (section->comdat == NULL)
943 section->comdat->symbol =
944 (esym - esymstart) / bfd_coff_symesz (abfd);
946 amt = strlen (symname) + 1;
947 newname = bfd_alloc (abfd, amt);
951 strcpy (newname, symname);
952 section->comdat->name = newname;
959 esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd);
967 /* The PE version; see above for the general comments.
969 Since to set the SEC_LINK_ONCE and associated flags, we have to
970 look at the symbol table anyway, we return the symbol table index
971 of the symbol being used as the COMDAT symbol. This is admittedly
972 ugly, but there's really nowhere else that we have access to the
973 required information. FIXME: Is the COMDAT symbol index used for
974 any purpose other than objdump? */
977 styp_to_sec_flags (abfd, hdr, name, section, flags_ptr)
984 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
985 long styp_flags = internal_s->s_flags;
987 boolean result = true;
989 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
990 sec_flags = SEC_READONLY;
992 /* Process each flag bit in styp_flags in turn. */
995 long flag = styp_flags & - styp_flags;
996 char * unhandled = NULL;
998 styp_flags &= ~ flag;
1000 /* We infer from the distinct read/write/execute bits the settings
1001 of some of the bfd flags; the actual values, should we need them,
1002 are also in pei_section_data (abfd, section)->pe_flags. */
1007 unhandled = "STYP_DSECT";
1010 unhandled = "STYP_GROUP";
1013 unhandled = "STYP_COPY";
1016 unhandled = "STYP_OVER";
1018 #ifdef SEC_NEVER_LOAD
1020 sec_flags |= SEC_NEVER_LOAD;
1023 case IMAGE_SCN_MEM_READ:
1024 /* Ignored, assume it always to be true. */
1026 case IMAGE_SCN_TYPE_NO_PAD:
1029 case IMAGE_SCN_LNK_OTHER:
1030 unhandled = "IMAGE_SCN_LNK_OTHER";
1032 case IMAGE_SCN_MEM_NOT_CACHED:
1033 unhandled = "IMAGE_SCN_MEM_NOT_CACHED";
1035 case IMAGE_SCN_MEM_NOT_PAGED:
1036 unhandled = "IMAGE_SCN_MEM_NOT_PAGED";
1038 case IMAGE_SCN_MEM_EXECUTE:
1039 sec_flags |= SEC_CODE;
1041 case IMAGE_SCN_MEM_WRITE:
1042 sec_flags &= ~ SEC_READONLY;
1044 case IMAGE_SCN_MEM_DISCARDABLE:
1045 sec_flags |= SEC_DEBUGGING;
1047 case IMAGE_SCN_MEM_SHARED:
1048 sec_flags |= SEC_SHARED;
1050 case IMAGE_SCN_LNK_REMOVE:
1051 sec_flags |= SEC_EXCLUDE;
1053 case IMAGE_SCN_CNT_CODE:
1054 sec_flags |= SEC_CODE | SEC_ALLOC | SEC_LOAD;
1056 case IMAGE_SCN_CNT_INITIALIZED_DATA:
1057 sec_flags |= SEC_DATA | SEC_ALLOC | SEC_LOAD;
1059 case IMAGE_SCN_CNT_UNINITIALIZED_DATA:
1060 sec_flags |= SEC_ALLOC;
1062 case IMAGE_SCN_LNK_INFO:
1063 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1064 defined. coff_compute_section_file_positions uses
1065 COFF_PAGE_SIZE to ensure that the low order bits of the
1066 section VMA and the file offset match. If we don't know
1067 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1068 and demand page loading of the file will fail. */
1069 #ifdef COFF_PAGE_SIZE
1070 sec_flags |= SEC_DEBUGGING;
1073 case IMAGE_SCN_LNK_COMDAT:
1074 /* COMDAT gets very special treatment. */
1075 sec_flags = handle_COMDAT (abfd, sec_flags, hdr, name, section);
1078 /* Silently ignore for now. */
1082 /* If the section flag was not handled, report it here. */
1083 if (unhandled != NULL)
1085 (*_bfd_error_handler)
1086 (_("%s (%s): Section flag %s (0x%x) ignored"),
1087 bfd_archive_filename (abfd), name, unhandled, flag);
1092 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1093 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1094 only link a single copy of the section. This is used to support
1095 g++. g++ will emit each template expansion in its own section.
1096 The symbols will be defined as weak, so that multiple definitions
1097 are permitted. The GNU linker extension is to actually discard
1098 all but one of the sections. */
1099 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
1100 sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1104 * flags_ptr = sec_flags;
1109 #endif /* COFF_WITH_PE */
1111 #define get_index(symbol) ((symbol)->udata.i)
1115 bfd_coff_backend_data
1119 .{* COFF symbol classifications. *}
1121 .enum coff_symbol_classification
1123 . {* Global symbol. *}
1124 . COFF_SYMBOL_GLOBAL,
1125 . {* Common symbol. *}
1126 . COFF_SYMBOL_COMMON,
1127 . {* Undefined symbol. *}
1128 . COFF_SYMBOL_UNDEFINED,
1129 . {* Local symbol. *}
1130 . COFF_SYMBOL_LOCAL,
1131 . {* PE section symbol. *}
1132 . COFF_SYMBOL_PE_SECTION
1135 Special entry points for gdb to swap in coff symbol table parts:
1138 . void (*_bfd_coff_swap_aux_in)
1139 . PARAMS ((bfd *, PTR, int, int, int, int, PTR));
1141 . void (*_bfd_coff_swap_sym_in)
1142 . PARAMS ((bfd *, PTR, PTR));
1144 . void (*_bfd_coff_swap_lineno_in)
1145 . PARAMS ((bfd *, PTR, PTR));
1147 . unsigned int (*_bfd_coff_swap_aux_out)
1148 . PARAMS ((bfd *, PTR, int, int, int, int, PTR));
1150 . unsigned int (*_bfd_coff_swap_sym_out)
1151 . PARAMS ((bfd *, PTR, PTR));
1153 . unsigned int (*_bfd_coff_swap_lineno_out)
1154 . PARAMS ((bfd *, PTR, PTR));
1156 . unsigned int (*_bfd_coff_swap_reloc_out)
1157 . PARAMS ((bfd *, PTR, PTR));
1159 . unsigned int (*_bfd_coff_swap_filehdr_out)
1160 . PARAMS ((bfd *, PTR, PTR));
1162 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1163 . PARAMS ((bfd *, PTR, PTR));
1165 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1166 . PARAMS ((bfd *, PTR, PTR));
1168 . unsigned int _bfd_filhsz;
1169 . unsigned int _bfd_aoutsz;
1170 . unsigned int _bfd_scnhsz;
1171 . unsigned int _bfd_symesz;
1172 . unsigned int _bfd_auxesz;
1173 . unsigned int _bfd_relsz;
1174 . unsigned int _bfd_linesz;
1175 . unsigned int _bfd_filnmlen;
1176 . boolean _bfd_coff_long_filenames;
1177 . boolean _bfd_coff_long_section_names;
1178 . unsigned int _bfd_coff_default_section_alignment_power;
1179 . boolean _bfd_coff_force_symnames_in_strings;
1180 . unsigned int _bfd_coff_debug_string_prefix_length;
1182 . void (*_bfd_coff_swap_filehdr_in)
1183 . PARAMS ((bfd *, PTR, PTR));
1185 . void (*_bfd_coff_swap_aouthdr_in)
1186 . PARAMS ((bfd *, PTR, PTR));
1188 . void (*_bfd_coff_swap_scnhdr_in)
1189 . PARAMS ((bfd *, PTR, PTR));
1191 . void (*_bfd_coff_swap_reloc_in)
1192 . PARAMS ((bfd *abfd, PTR, PTR));
1194 . boolean (*_bfd_coff_bad_format_hook)
1195 . PARAMS ((bfd *, PTR));
1197 . boolean (*_bfd_coff_set_arch_mach_hook)
1198 . PARAMS ((bfd *, PTR));
1200 . PTR (*_bfd_coff_mkobject_hook)
1201 . PARAMS ((bfd *, PTR, PTR));
1203 . boolean (*_bfd_styp_to_sec_flags_hook)
1204 . PARAMS ((bfd *, PTR, const char *, asection *, flagword *));
1206 . void (*_bfd_set_alignment_hook)
1207 . PARAMS ((bfd *, asection *, PTR));
1209 . boolean (*_bfd_coff_slurp_symbol_table)
1212 . boolean (*_bfd_coff_symname_in_debug)
1213 . PARAMS ((bfd *, struct internal_syment *));
1215 . boolean (*_bfd_coff_pointerize_aux_hook)
1216 . PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
1217 . unsigned int, combined_entry_type *));
1219 . boolean (*_bfd_coff_print_aux)
1220 . PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1221 . combined_entry_type *, unsigned int));
1223 . void (*_bfd_coff_reloc16_extra_cases)
1224 . PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1225 . bfd_byte *, unsigned int *, unsigned int *));
1227 . int (*_bfd_coff_reloc16_estimate)
1228 . PARAMS ((bfd *, asection *, arelent *, unsigned int,
1229 . struct bfd_link_info *));
1231 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1232 . PARAMS ((bfd *, struct internal_syment *));
1234 . boolean (*_bfd_coff_compute_section_file_positions)
1237 . boolean (*_bfd_coff_start_final_link)
1238 . PARAMS ((bfd *, struct bfd_link_info *));
1240 . boolean (*_bfd_coff_relocate_section)
1241 . PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1242 . struct internal_reloc *, struct internal_syment *, asection **));
1244 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1245 . PARAMS ((bfd *, asection *, struct internal_reloc *,
1246 . struct coff_link_hash_entry *, struct internal_syment *,
1249 . boolean (*_bfd_coff_adjust_symndx)\
1250 . PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
1251 . struct internal_reloc *, boolean *));
1253 . boolean (*_bfd_coff_link_add_one_symbol)
1254 . PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword,
1255 . asection *, bfd_vma, const char *, boolean, boolean,
1256 . struct bfd_link_hash_entry **));
1258 . boolean (*_bfd_coff_link_output_has_begun)
1259 . PARAMS ((bfd *, struct coff_final_link_info *));
1261 . boolean (*_bfd_coff_final_link_postscript)
1262 . PARAMS ((bfd *, struct coff_final_link_info *));
1264 .} bfd_coff_backend_data;
1266 .#define coff_backend_info(abfd) \
1267 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1269 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1270 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1272 .#define bfd_coff_swap_sym_in(a,e,i) \
1273 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1275 .#define bfd_coff_swap_lineno_in(a,e,i) \
1276 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1278 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1279 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1281 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1282 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1284 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1285 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1287 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1288 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1290 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1291 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1293 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1294 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1296 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1297 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1299 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1300 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1301 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1302 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1303 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1304 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1305 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1306 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1307 .#define bfd_coff_long_filenames(abfd) \
1308 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1309 .#define bfd_coff_long_section_names(abfd) \
1310 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1311 .#define bfd_coff_default_section_alignment_power(abfd) \
1312 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1313 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1314 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1316 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1317 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1319 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1320 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1322 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1323 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1325 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1326 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1328 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1329 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1330 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1331 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
1333 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1334 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1335 . (abfd, scnhdr, name, section, flags_ptr))
1337 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1338 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1340 .#define bfd_coff_slurp_symbol_table(abfd)\
1341 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1343 .#define bfd_coff_symname_in_debug(abfd, sym)\
1344 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1346 .#define bfd_coff_force_symnames_in_strings(abfd)\
1347 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1349 .#define bfd_coff_debug_string_prefix_length(abfd)\
1350 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1352 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1353 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1354 . (abfd, file, base, symbol, aux, indaux))
1356 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
1357 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1358 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1360 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1361 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1362 . (abfd, section, reloc, shrink, link_info))
1364 .#define bfd_coff_classify_symbol(abfd, sym)\
1365 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1368 .#define bfd_coff_compute_section_file_positions(abfd)\
1369 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1372 .#define bfd_coff_start_final_link(obfd, info)\
1373 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1375 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1376 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1377 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1378 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1379 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1380 . (abfd, sec, rel, h, sym, addendp))
1381 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1382 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1383 . (obfd, info, ibfd, sec, rel, adjustedp))
1384 .#define bfd_coff_link_add_one_symbol(info,abfd,name,flags,section,value,string,cp,coll,hashp)\
1385 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1386 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1388 .#define bfd_coff_link_output_has_begun(a,p) \
1389 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p))
1390 .#define bfd_coff_final_link_postscript(a,p) \
1391 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
1395 /* See whether the magic number matches. */
1398 coff_bad_format_hook (abfd, filehdr)
1399 bfd * abfd ATTRIBUTE_UNUSED;
1402 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1404 if (BADMAG (*internal_f))
1407 /* if the optional header is NULL or not the correct size then
1408 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1409 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1410 optional header is of a different size.
1412 But the mips keeps extra stuff in it's opthdr, so dont check
1416 #if defined(M88) || defined(I960)
1417 if (internal_f->f_opthdr != 0 && bfd_coff_aoutsz (abfd) != internal_f->f_opthdr)
1424 /* Check whether this section uses an alignment other than the
1428 coff_set_custom_section_alignment (abfd, section, alignment_table, table_size)
1429 bfd *abfd ATTRIBUTE_UNUSED;
1431 const struct coff_section_alignment_entry *alignment_table;
1432 const unsigned int table_size;
1434 const unsigned int default_alignment = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1437 for (i = 0; i < table_size; ++i)
1439 const char *secname = bfd_get_section_name (abfd, section);
1440 if (alignment_table[i].comparison_length == (unsigned int) -1
1441 ? strcmp (alignment_table[i].name, secname) == 0
1442 : strncmp (alignment_table[i].name, secname,
1443 alignment_table[i].comparison_length) == 0)
1446 if (i >= table_size)
1449 if (alignment_table[i].default_alignment_min != COFF_ALIGNMENT_FIELD_EMPTY
1450 && default_alignment < alignment_table[i].default_alignment_min)
1453 if (alignment_table[i].default_alignment_max != COFF_ALIGNMENT_FIELD_EMPTY
1454 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1455 && default_alignment > alignment_table[i].default_alignment_max
1460 section->alignment_power = alignment_table[i].alignment_power;
1463 /* Custom section alignment records. */
1465 static const struct coff_section_alignment_entry
1466 coff_section_alignment_table[] =
1468 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1469 COFF_SECTION_ALIGNMENT_ENTRIES,
1471 /* There must not be any gaps between .stabstr sections. */
1472 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1473 1, COFF_ALIGNMENT_FIELD_EMPTY, 0 },
1474 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1475 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1476 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1477 /* Similarly for the .ctors and .dtors sections. */
1478 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1479 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1480 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1481 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 }
1484 static const unsigned int coff_section_alignment_table_size =
1485 sizeof coff_section_alignment_table / sizeof coff_section_alignment_table[0];
1487 /* Initialize a section structure with information peculiar to this
1488 particular implementation of COFF. */
1491 coff_new_section_hook (abfd, section)
1495 combined_entry_type *native;
1498 section->alignment_power = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1501 if (bfd_xcoff_text_align_power (abfd) != 0
1502 && strcmp (bfd_get_section_name (abfd, section), ".text") == 0)
1503 section->alignment_power = bfd_xcoff_text_align_power (abfd);
1504 if (bfd_xcoff_data_align_power (abfd) != 0
1505 && strcmp (bfd_get_section_name (abfd, section), ".data") == 0)
1506 section->alignment_power = bfd_xcoff_data_align_power (abfd);
1509 /* Allocate aux records for section symbols, to store size and
1512 @@ The 10 is a guess at a plausible maximum number of aux entries
1513 (but shouldn't be a constant). */
1514 amt = sizeof (combined_entry_type) * 10;
1515 native = (combined_entry_type *) bfd_zalloc (abfd, amt);
1519 /* We don't need to set up n_name, n_value, or n_scnum in the native
1520 symbol information, since they'll be overriden by the BFD symbol
1521 anyhow. However, we do need to set the type and storage class,
1522 in case this symbol winds up getting written out. The value 0
1523 for n_numaux is already correct. */
1525 native->u.syment.n_type = T_NULL;
1526 native->u.syment.n_sclass = C_STAT;
1528 coffsymbol (section->symbol)->native = native;
1530 coff_set_custom_section_alignment (abfd, section,
1531 coff_section_alignment_table,
1532 coff_section_alignment_table_size);
1537 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1539 /* Set the alignment of a BFD section. */
1541 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1544 coff_set_alignment_hook (abfd, section, scnhdr)
1545 bfd * abfd ATTRIBUTE_UNUSED;
1549 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1553 /* Extract ALIGN from 2**ALIGN stored in section header */
1554 for (i = 0; i < 32; i++)
1555 if ((1 << i) >= hdr->s_align)
1559 /* TI tools puts the alignment power in bits 8-11 */
1560 i = (hdr->s_flags >> 8) & 0xF ;
1562 #ifdef COFF_DECODE_ALIGNMENT
1563 i = COFF_DECODE_ALIGNMENT(hdr->s_flags);
1565 section->alignment_power = i;
1567 #ifdef coff_set_section_load_page
1568 coff_set_section_load_page (section, hdr->s_page);
1572 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1575 /* a couple of macros to help setting the alignment power field */
1576 #define ALIGN_SET(field,x,y) \
1577 if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1579 section->alignment_power = y;\
1582 #define ELIFALIGN_SET(field,x,y) \
1583 else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1585 section->alignment_power = y;\
1588 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1591 coff_set_alignment_hook (abfd, section, scnhdr)
1592 bfd * abfd ATTRIBUTE_UNUSED;
1596 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1599 ALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_64BYTES, 6)
1600 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_32BYTES, 5)
1601 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_16BYTES, 4)
1602 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_8BYTES, 3)
1603 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_4BYTES, 2)
1604 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_2BYTES, 1)
1605 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_1BYTES, 0)
1607 /* In a PE image file, the s_paddr field holds the virtual size of a
1608 section, while the s_size field holds the raw size. We also keep
1609 the original section flag value, since not every bit can be
1610 mapped onto a generic BFD section bit. */
1611 if (coff_section_data (abfd, section) == NULL)
1613 amt = sizeof (struct coff_section_tdata);
1614 section->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
1615 if (section->used_by_bfd == NULL)
1617 /* FIXME: Return error. */
1621 if (pei_section_data (abfd, section) == NULL)
1623 amt = sizeof (struct pei_section_tdata);
1624 coff_section_data (abfd, section)->tdata = (PTR) bfd_zalloc (abfd, amt);
1625 if (coff_section_data (abfd, section)->tdata == NULL)
1627 /* FIXME: Return error. */
1631 pei_section_data (abfd, section)->virt_size = hdr->s_paddr;
1632 pei_section_data (abfd, section)->pe_flags = hdr->s_flags;
1634 section->lma = hdr->s_vaddr;
1636 /* check for extended relocs */
1637 if (hdr->s_flags & IMAGE_SCN_LNK_NRELOC_OVFL)
1639 struct external_reloc dst;
1640 struct internal_reloc n;
1641 file_ptr oldpos = bfd_tell (abfd);
1642 bfd_seek (abfd, (file_ptr) hdr->s_relptr, 0);
1643 if (bfd_bread ((PTR) &dst, (bfd_size_type) bfd_coff_relsz (abfd), abfd)
1644 != bfd_coff_relsz (abfd))
1647 coff_swap_reloc_in (abfd, &dst, &n);
1648 bfd_seek (abfd, oldpos, 0);
1649 section->reloc_count = hdr->s_nreloc = n.r_vaddr;
1653 #undef ELIFALIGN_SET
1655 #else /* ! COFF_WITH_PE */
1658 /* We grossly abuse this function to handle XCOFF overflow headers.
1659 When we see one, we correct the reloc and line number counts in the
1660 real header, and remove the section we just created. */
1662 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1665 coff_set_alignment_hook (abfd, section, scnhdr)
1670 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1674 if ((hdr->s_flags & STYP_OVRFLO) == 0)
1677 real_sec = coff_section_from_bfd_index (abfd, (int) hdr->s_nreloc);
1678 if (real_sec == NULL)
1681 real_sec->reloc_count = hdr->s_paddr;
1682 real_sec->lineno_count = hdr->s_vaddr;
1684 for (ps = &abfd->sections; *ps != NULL; ps = &(*ps)->next)
1688 bfd_section_list_remove (abfd, ps);
1689 --abfd->section_count;
1695 #else /* ! RS6000COFF_C */
1697 #define coff_set_alignment_hook \
1698 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1700 #endif /* ! RS6000COFF_C */
1701 #endif /* ! COFF_WITH_PE */
1702 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1704 #ifndef coff_mkobject
1706 static boolean coff_mkobject PARAMS ((bfd *));
1709 coff_mkobject (abfd)
1712 coff_data_type *coff;
1713 bfd_size_type amt = sizeof (coff_data_type);
1715 abfd->tdata.coff_obj_data = (struct coff_tdata *) bfd_zalloc (abfd, amt);
1716 if (abfd->tdata.coff_obj_data == 0)
1718 coff = coff_data (abfd);
1719 coff->symbols = (coff_symbol_type *) NULL;
1720 coff->conversion_table = (unsigned int *) NULL;
1721 coff->raw_syments = (struct coff_ptr_struct *) NULL;
1722 coff->relocbase = 0;
1723 coff->local_toc_sym_map = 0;
1725 /* make_abs_section(abfd);*/
1731 /* Create the COFF backend specific information. */
1732 #ifndef coff_mkobject_hook
1734 coff_mkobject_hook (abfd, filehdr, aouthdr)
1737 PTR aouthdr ATTRIBUTE_UNUSED;
1739 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1740 coff_data_type *coff;
1742 if (coff_mkobject (abfd) == false)
1745 coff = coff_data (abfd);
1747 coff->sym_filepos = internal_f->f_symptr;
1749 /* These members communicate important constants about the symbol
1750 table to GDB's symbol-reading code. These `constants'
1751 unfortunately vary among coff implementations... */
1752 coff->local_n_btmask = N_BTMASK;
1753 coff->local_n_btshft = N_BTSHFT;
1754 coff->local_n_tmask = N_TMASK;
1755 coff->local_n_tshift = N_TSHIFT;
1756 coff->local_symesz = bfd_coff_symesz (abfd);
1757 coff->local_auxesz = bfd_coff_auxesz (abfd);
1758 coff->local_linesz = bfd_coff_linesz (abfd);
1760 coff->timestamp = internal_f->f_timdat;
1762 obj_raw_syment_count (abfd) =
1763 obj_conv_table_size (abfd) =
1764 internal_f->f_nsyms;
1767 if ((internal_f->f_flags & F_SHROBJ) != 0)
1768 abfd->flags |= DYNAMIC;
1769 if (aouthdr != NULL && internal_f->f_opthdr >= bfd_coff_aoutsz (abfd))
1771 struct internal_aouthdr *internal_a =
1772 (struct internal_aouthdr *) aouthdr;
1773 struct xcoff_tdata *xcoff;
1775 xcoff = xcoff_data (abfd);
1776 # ifdef U803XTOCMAGIC
1777 xcoff->xcoff64 = internal_f->f_magic == U803XTOCMAGIC;
1781 xcoff->full_aouthdr = true;
1782 xcoff->toc = internal_a->o_toc;
1783 xcoff->sntoc = internal_a->o_sntoc;
1784 xcoff->snentry = internal_a->o_snentry;
1785 bfd_xcoff_text_align_power (abfd) = internal_a->o_algntext;
1786 bfd_xcoff_data_align_power (abfd) = internal_a->o_algndata;
1787 xcoff->modtype = internal_a->o_modtype;
1788 xcoff->cputype = internal_a->o_cputype;
1789 xcoff->maxdata = internal_a->o_maxdata;
1790 xcoff->maxstack = internal_a->o_maxstack;
1795 /* Set the flags field from the COFF header read in. */
1796 if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags))
1801 /* FIXME: I'm not sure this is ever executed, since peicode.h
1802 defines coff_mkobject_hook. */
1803 if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0)
1804 abfd->flags |= HAS_DEBUG;
1811 /* Determine the machine architecture and type. FIXME: This is target
1812 dependent because the magic numbers are defined in the target
1813 dependent header files. But there is no particular need for this.
1814 If the magic numbers were moved to a separate file, this function
1815 would be target independent and would also be much more successful
1816 at linking together COFF files for different architectures. */
1819 coff_set_arch_mach_hook (abfd, filehdr)
1823 unsigned long machine;
1824 enum bfd_architecture arch;
1825 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1828 switch (internal_f->f_magic)
1830 #ifdef OR32_MAGIC_BIG
1831 case OR32_MAGIC_BIG:
1832 case OR32_MAGIC_LITTLE:
1833 arch = bfd_arch_or32;
1839 arch = bfd_arch_powerpc;
1840 machine = 0; /* what does this mean? (krk) */
1846 case I386AIXMAGIC: /* Danbury PS/2 AIX C Compiler */
1847 case LYNXCOFFMAGIC: /* shadows the m68k Lynx number below, sigh */
1848 arch = bfd_arch_i386;
1854 arch = bfd_arch_ia64;
1858 #ifdef A29K_MAGIC_BIG
1859 case A29K_MAGIC_BIG:
1860 case A29K_MAGIC_LITTLE:
1861 arch = bfd_arch_a29k;
1869 arch = bfd_arch_arm;
1870 switch (internal_f->f_flags & F_ARM_ARCHITECTURE_MASK)
1872 case F_ARM_2: machine = bfd_mach_arm_2; break;
1873 case F_ARM_2a: machine = bfd_mach_arm_2a; break;
1874 case F_ARM_3: machine = bfd_mach_arm_3; break;
1876 case F_ARM_3M: machine = bfd_mach_arm_3M; break;
1877 case F_ARM_4: machine = bfd_mach_arm_4; break;
1878 case F_ARM_4T: machine = bfd_mach_arm_4T; break;
1879 /* The COFF header does not have enough bits available
1880 to cover all the different ARM architectures. So
1881 we interpret F_ARM_5, the highest flag value to mean
1882 "the highest ARM architecture known to BFD" which is
1883 currently the XScale. */
1884 case F_ARM_5: machine = bfd_mach_arm_XScale; break;
1891 #ifdef MC68KBCSMAGIC
1894 #ifdef APOLLOM68KMAGIC
1895 case APOLLOM68KMAGIC:
1897 #ifdef LYNXCOFFMAGIC
1900 arch = bfd_arch_m68k;
1901 machine = bfd_mach_m68020;
1908 arch = bfd_arch_m88k;
1914 arch = bfd_arch_z8k;
1915 switch (internal_f->f_flags & F_MACHMASK)
1918 machine = bfd_mach_z8001;
1921 machine = bfd_mach_z8002;
1930 arch = bfd_arch_i860;
1937 arch = bfd_arch_i960;
1938 switch (F_I960TYPE & internal_f->f_flags)
1942 machine = bfd_mach_i960_core;
1945 machine = bfd_mach_i960_kb_sb;
1948 machine = bfd_mach_i960_mc;
1951 machine = bfd_mach_i960_xa;
1954 machine = bfd_mach_i960_ca;
1957 machine = bfd_mach_i960_ka_sa;
1960 machine = bfd_mach_i960_jx;
1963 machine = bfd_mach_i960_hx;
1982 if (xcoff_data (abfd)->cputype != -1)
1983 cputype = xcoff_data (abfd)->cputype & 0xff;
1986 /* We did not get a value from the a.out header. If the
1987 file has not been stripped, we may be able to get the
1988 architecture information from the first symbol, if it
1989 is a .file symbol. */
1990 if (obj_raw_syment_count (abfd) == 0)
1995 struct internal_syment sym;
1996 bfd_size_type amt = bfd_coff_symesz (abfd);
1998 buf = (bfd_byte *) bfd_malloc (amt);
1999 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
2000 || bfd_bread (buf, amt, abfd) != amt)
2005 bfd_coff_swap_sym_in (abfd, (PTR) buf, (PTR) &sym);
2006 if (sym.n_sclass == C_FILE)
2007 cputype = sym.n_type & 0xff;
2014 /* FIXME: We don't handle all cases here. */
2019 arch = bfd_xcoff_architecture (abfd);
2020 machine = bfd_xcoff_machine (abfd);
2024 arch = bfd_arch_powerpc;
2025 machine = bfd_mach_ppc_601;
2027 case 2: /* 64 bit PowerPC */
2028 arch = bfd_arch_powerpc;
2029 machine = bfd_mach_ppc_620;
2032 arch = bfd_arch_powerpc;
2033 machine = bfd_mach_ppc;
2036 arch = bfd_arch_rs6000;
2037 machine = bfd_mach_rs6k;
2046 arch = bfd_arch_we32k;
2053 arch = bfd_arch_h8300;
2054 machine = bfd_mach_h8300;
2055 /* !! FIXME this probably isn't the right place for this */
2056 abfd->flags |= BFD_IS_RELAXABLE;
2062 arch = bfd_arch_h8300;
2063 machine = bfd_mach_h8300h;
2064 /* !! FIXME this probably isn't the right place for this */
2065 abfd->flags |= BFD_IS_RELAXABLE;
2071 arch = bfd_arch_h8300;
2072 machine = bfd_mach_h8300s;
2073 /* !! FIXME this probably isn't the right place for this */
2074 abfd->flags |= BFD_IS_RELAXABLE;
2078 #ifdef SH_ARCH_MAGIC_BIG
2079 case SH_ARCH_MAGIC_BIG:
2080 case SH_ARCH_MAGIC_LITTLE:
2082 case SH_ARCH_MAGIC_WINCE:
2089 #ifdef MIPS_ARCH_MAGIC_WINCE
2090 case MIPS_ARCH_MAGIC_WINCE:
2091 arch = bfd_arch_mips;
2098 arch = bfd_arch_h8500;
2105 #ifdef LYNXCOFFMAGIC
2108 arch = bfd_arch_sparc;
2115 arch = bfd_arch_tic30;
2120 #ifdef TICOFF_TARGET_ARCH
2121 /* this TI COFF section should be used by all new TI COFF v0 targets */
2123 arch = TICOFF_TARGET_ARCH;
2129 /* this TI COFF section should be used by all new TI COFF v1/2 targets */
2130 /* TI COFF1 and COFF2 use the target_id field to specify which arch */
2133 switch (internal_f->f_target_id)
2137 arch = TICOFF_TARGET_ARCH;
2141 arch = bfd_arch_obscure;
2142 (*_bfd_error_handler)
2143 (_("Unrecognized TI COFF target id '0x%x'"),
2144 internal_f->f_target_id);
2150 #ifdef TIC80_ARCH_MAGIC
2151 case TIC80_ARCH_MAGIC:
2152 arch = bfd_arch_tic80;
2158 arch = bfd_arch_mcore;
2161 default: /* Unreadable input file type */
2162 arch = bfd_arch_obscure;
2166 bfd_default_set_arch_mach (abfd, arch, machine);
2170 #ifdef SYMNAME_IN_DEBUG
2172 static boolean symname_in_debug_hook
2173 PARAMS ((bfd *, struct internal_syment *));
2176 symname_in_debug_hook (abfd, sym)
2177 bfd * abfd ATTRIBUTE_UNUSED;
2178 struct internal_syment *sym;
2180 return SYMNAME_IN_DEBUG (sym) ? true : false;
2185 #define symname_in_debug_hook \
2186 (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
2193 #define FORCE_SYMNAMES_IN_STRINGS
2196 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
2198 static boolean coff_pointerize_aux_hook
2199 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
2200 unsigned int, combined_entry_type *));
2204 coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
2205 bfd *abfd ATTRIBUTE_UNUSED;
2206 combined_entry_type *table_base;
2207 combined_entry_type *symbol;
2208 unsigned int indaux;
2209 combined_entry_type *aux;
2211 int class = symbol->u.syment.n_sclass;
2213 if ((class == C_EXT || class == C_HIDEXT)
2214 && indaux + 1 == symbol->u.syment.n_numaux)
2216 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
2218 aux->u.auxent.x_csect.x_scnlen.p =
2219 table_base + aux->u.auxent.x_csect.x_scnlen.l;
2220 aux->fix_scnlen = 1;
2223 /* Return true to indicate that the caller should not do any
2224 further work on this auxent. */
2228 /* Return false to indicate that this auxent should be handled by
2236 /* We don't want to pointerize bal entries. */
2238 static boolean coff_pointerize_aux_hook
2239 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
2240 unsigned int, combined_entry_type *));
2244 coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
2245 bfd *abfd ATTRIBUTE_UNUSED;
2246 combined_entry_type *table_base ATTRIBUTE_UNUSED;
2247 combined_entry_type *symbol;
2248 unsigned int indaux;
2249 combined_entry_type *aux ATTRIBUTE_UNUSED;
2251 /* Return true if we don't want to pointerize this aux entry, which
2252 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2254 && (symbol->u.syment.n_sclass == C_LEAFPROC
2255 || symbol->u.syment.n_sclass == C_LEAFSTAT
2256 || symbol->u.syment.n_sclass == C_LEAFEXT));
2261 #define coff_pointerize_aux_hook 0
2264 #endif /* ! RS6000COFF_C */
2266 /* Print an aux entry. This returns true if it has printed it. */
2268 static boolean coff_print_aux
2269 PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
2270 combined_entry_type *, unsigned int));
2273 coff_print_aux (abfd, file, table_base, symbol, aux, indaux)
2274 bfd *abfd ATTRIBUTE_UNUSED;
2275 FILE *file ATTRIBUTE_UNUSED;
2276 combined_entry_type *table_base ATTRIBUTE_UNUSED;
2277 combined_entry_type *symbol ATTRIBUTE_UNUSED;
2278 combined_entry_type *aux ATTRIBUTE_UNUSED;
2279 unsigned int indaux ATTRIBUTE_UNUSED;
2282 if ((symbol->u.syment.n_sclass == C_EXT
2283 || symbol->u.syment.n_sclass == C_HIDEXT)
2284 && indaux + 1 == symbol->u.syment.n_numaux)
2286 /* This is a csect entry. */
2287 fprintf (file, "AUX ");
2288 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
2290 BFD_ASSERT (! aux->fix_scnlen);
2292 fprintf (file, "val %5lld", aux->u.auxent.x_csect.x_scnlen.l);
2294 fprintf (file, "val %5ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
2299 fprintf (file, "indx ");
2300 if (! aux->fix_scnlen)
2302 fprintf (file, "%4lld", aux->u.auxent.x_csect.x_scnlen.l);
2304 fprintf (file, "%4ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
2307 fprintf (file, "%4ld",
2308 (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base));
2311 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2312 aux->u.auxent.x_csect.x_parmhash,
2313 (unsigned int) aux->u.auxent.x_csect.x_snhash,
2314 SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp),
2315 SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp),
2316 (unsigned int) aux->u.auxent.x_csect.x_smclas,
2317 aux->u.auxent.x_csect.x_stab,
2318 (unsigned int) aux->u.auxent.x_csect.x_snstab);
2323 /* Return false to indicate that no special action was taken. */
2331 To write relocations, the back end steps though the
2332 canonical relocation table and create an
2333 @code{internal_reloc}. The symbol index to use is removed from
2334 the @code{offset} field in the symbol table supplied. The
2335 address comes directly from the sum of the section base
2336 address and the relocation offset; the type is dug directly
2337 from the howto field. Then the @code{internal_reloc} is
2338 swapped into the shape of an @code{external_reloc} and written
2345 static int compare_arelent_ptr PARAMS ((const PTR, const PTR));
2347 /* AUX's ld wants relocations to be sorted */
2349 compare_arelent_ptr (x, y)
2353 const arelent **a = (const arelent **) x;
2354 const arelent **b = (const arelent **) y;
2355 bfd_size_type aadr = (*a)->address;
2356 bfd_size_type badr = (*b)->address;
2358 return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
2361 #endif /* TARG_AUX */
2364 coff_write_relocs (abfd, first_undef)
2370 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
2373 struct external_reloc dst;
2380 /* sort relocations before we write them out */
2383 amt = s->reloc_count;
2384 amt *= sizeof (arelent *);
2385 p = (arelent **) bfd_malloc (amt);
2386 if (p == NULL && s->reloc_count > 0)
2388 memcpy (p, s->orelocation, (size_t) amt);
2389 qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr);
2393 if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
2397 if (s->reloc_count > 0xffff)
2399 /* encode real count here as first reloc */
2400 struct internal_reloc n;
2401 memset ((PTR) & n, 0, sizeof (n));
2402 /* add one to count *this* reloc (grr) */
2403 n.r_vaddr = s->reloc_count + 1;
2404 coff_swap_reloc_out (abfd, &n, &dst);
2405 if (bfd_bwrite ((PTR) & dst, (bfd_size_type) bfd_coff_relsz (abfd),
2406 abfd) != bfd_coff_relsz (abfd))
2411 for (i = 0; i < s->reloc_count; i++)
2413 struct internal_reloc n;
2415 memset ((PTR) & n, 0, sizeof (n));
2417 /* Now we've renumbered the symbols we know where the
2418 undefined symbols live in the table. Check the reloc
2419 entries for symbols who's output bfd isn't the right one.
2420 This is because the symbol was undefined (which means
2421 that all the pointers are never made to point to the same
2422 place). This is a bad thing,'cause the symbols attached
2423 to the output bfd are indexed, so that the relocation
2424 entries know which symbol index they point to. So we
2425 have to look up the output symbol here. */
2427 if (q->sym_ptr_ptr[0]->the_bfd != abfd)
2430 const char *sname = q->sym_ptr_ptr[0]->name;
2431 asymbol **outsyms = abfd->outsymbols;
2432 for (j = first_undef; outsyms[j]; j++)
2434 const char *intable = outsyms[j]->name;
2435 if (strcmp (intable, sname) == 0) {
2436 /* got a hit, so repoint the reloc */
2437 q->sym_ptr_ptr = outsyms + j;
2443 n.r_vaddr = q->address + s->vma;
2446 /* The 29k const/consth reloc pair is a real kludge. The consth
2447 part doesn't have a symbol; it has an offset. So rebuilt
2449 if (q->howto->type == R_IHCONST)
2450 n.r_symndx = q->addend;
2455 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2456 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q,s))
2458 if (q->sym_ptr_ptr == bfd_abs_section_ptr->symbol_ptr_ptr)
2460 /* This is a relocation relative to the absolute symbol. */
2464 n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
2465 /* Take notice if the symbol reloc points to a symbol
2466 we don't have in our symbol table. What should we
2468 if (n.r_symndx > obj_conv_table_size (abfd))
2473 #ifdef SWAP_OUT_RELOC_OFFSET
2474 n.r_offset = q->addend;
2478 /* Work out reloc type from what is required */
2479 SELECT_RELOC (n, q->howto);
2481 n.r_type = q->howto->type;
2483 coff_swap_reloc_out (abfd, &n, &dst);
2484 if (bfd_bwrite ((PTR) & dst, (bfd_size_type) bfd_coff_relsz (abfd),
2485 abfd) != bfd_coff_relsz (abfd))
2498 /* Set flags and magic number of a coff file from architecture and machine
2499 type. Result is true if we can represent the arch&type, false if not. */
2502 coff_set_flags (abfd, magicp, flagsp)
2504 unsigned int *magicp ATTRIBUTE_UNUSED;
2505 unsigned short *flagsp ATTRIBUTE_UNUSED;
2507 switch (bfd_get_arch (abfd))
2512 switch (bfd_get_mach (abfd))
2514 case bfd_mach_z8001:
2517 case bfd_mach_z8002:
2531 *magicp = I960ROMAGIC;
2533 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2534 I960RWMAGIC); FIXME???
2536 switch (bfd_get_mach (abfd))
2538 case bfd_mach_i960_core:
2541 case bfd_mach_i960_kb_sb:
2544 case bfd_mach_i960_mc:
2547 case bfd_mach_i960_xa:
2550 case bfd_mach_i960_ca:
2553 case bfd_mach_i960_ka_sa:
2556 case bfd_mach_i960_jx:
2559 case bfd_mach_i960_hx:
2572 case bfd_arch_tic30:
2573 *magicp = TIC30MAGIC;
2577 #ifdef TICOFF_DEFAULT_MAGIC
2578 case TICOFF_TARGET_ARCH:
2579 /* if there's no indication of which version we want, use the default */
2581 *magicp = TICOFF_DEFAULT_MAGIC;
2584 /* we may want to output in a different COFF version */
2585 switch (abfd->xvec->name[4])
2588 *magicp = TICOFF0MAGIC;
2591 *magicp = TICOFF1MAGIC;
2594 *magicp = TICOFF2MAGIC;
2603 #ifdef TIC80_ARCH_MAGIC
2604 case bfd_arch_tic80:
2605 *magicp = TIC80_ARCH_MAGIC;
2611 * magicp = ARMPEMAGIC;
2613 * magicp = ARMMAGIC;
2616 if (APCS_SET (abfd))
2618 if (APCS_26_FLAG (abfd))
2619 * flagsp |= F_APCS26;
2621 if (APCS_FLOAT_FLAG (abfd))
2622 * flagsp |= F_APCS_FLOAT;
2624 if (PIC_FLAG (abfd))
2627 if (INTERWORK_SET (abfd) && INTERWORK_FLAG (abfd))
2628 * flagsp |= F_INTERWORK;
2629 switch (bfd_get_mach (abfd))
2631 case bfd_mach_arm_2: * flagsp |= F_ARM_2; break;
2632 case bfd_mach_arm_2a: * flagsp |= F_ARM_2a; break;
2633 case bfd_mach_arm_3: * flagsp |= F_ARM_3; break;
2634 case bfd_mach_arm_3M: * flagsp |= F_ARM_3M; break;
2635 case bfd_mach_arm_4: * flagsp |= F_ARM_4; break;
2636 case bfd_mach_arm_4T: * flagsp |= F_ARM_4T; break;
2637 case bfd_mach_arm_5: * flagsp |= F_ARM_5; break;
2638 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2639 See also the comment in coff_set_arch_mach_hook(). */
2640 case bfd_mach_arm_5T: * flagsp |= F_ARM_5; break;
2641 case bfd_mach_arm_5TE: * flagsp |= F_ARM_5; break;
2642 case bfd_mach_arm_XScale: * flagsp |= F_ARM_5; break;
2647 case bfd_arch_powerpc:
2654 *magicp = I386MAGIC;
2656 /* Just overwrite the usual value if we're doing Lynx. */
2657 *magicp = LYNXCOFFMAGIC;
2664 *magicp = I860MAGIC;
2670 *magicp = IA64MAGIC;
2676 #ifdef APOLLOM68KMAGIC
2677 *magicp = APOLLO_COFF_VERSION_NUMBER;
2679 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2680 #ifdef NAMES_HAVE_UNDERSCORE
2681 *magicp = MC68KBCSMAGIC;
2683 *magicp = MC68MAGIC;
2687 /* Just overwrite the usual value if we're doing Lynx. */
2688 *magicp = LYNXCOFFMAGIC;
2696 *magicp = MC88OMAGIC;
2701 case bfd_arch_h8300:
2702 switch (bfd_get_mach (abfd))
2704 case bfd_mach_h8300:
2705 *magicp = H8300MAGIC;
2707 case bfd_mach_h8300h:
2708 *magicp = H8300HMAGIC;
2710 case bfd_mach_h8300s:
2711 *magicp = H8300SMAGIC;
2717 #ifdef SH_ARCH_MAGIC_BIG
2719 #ifdef COFF_IMAGE_WITH_PE
2720 *magicp = SH_ARCH_MAGIC_WINCE;
2722 if (bfd_big_endian (abfd))
2723 *magicp = SH_ARCH_MAGIC_BIG;
2725 *magicp = SH_ARCH_MAGIC_LITTLE;
2731 #ifdef MIPS_ARCH_MAGIC_WINCE
2733 *magicp = MIPS_ARCH_MAGIC_WINCE;
2739 case bfd_arch_sparc:
2740 *magicp = SPARCMAGIC;
2742 /* Just overwrite the usual value if we're doing Lynx. */
2743 *magicp = LYNXCOFFMAGIC;
2750 case bfd_arch_h8500:
2751 *magicp = H8500MAGIC;
2755 #ifdef A29K_MAGIC_BIG
2757 if (bfd_big_endian (abfd))
2758 *magicp = A29K_MAGIC_BIG;
2760 *magicp = A29K_MAGIC_LITTLE;
2766 case bfd_arch_we32k:
2767 *magicp = WE32KMAGIC;
2773 case bfd_arch_rs6000:
2775 case bfd_arch_powerpc:
2777 BFD_ASSERT (bfd_get_flavour (abfd) == bfd_target_xcoff_flavour);
2778 *magicp = bfd_xcoff_magic_number (abfd);
2784 case bfd_arch_mcore:
2785 * magicp = MCOREMAGIC;
2795 #ifdef OR32_MAGIC_BIG
2797 if (bfd_big_endian (abfd))
2798 * magicp = OR32_MAGIC_BIG;
2800 * magicp = OR32_MAGIC_LITTLE;
2804 default: /* Unknown architecture. */
2805 /* Fall through to "return false" below, to avoid
2806 "statement never reached" errors on the one below. */
2814 coff_set_arch_mach (abfd, arch, machine)
2816 enum bfd_architecture arch;
2817 unsigned long machine;
2820 unsigned short dummy2;
2822 if (! bfd_default_set_arch_mach (abfd, arch, machine))
2825 if (arch != bfd_arch_unknown &&
2826 coff_set_flags (abfd, &dummy1, &dummy2) != true)
2827 return false; /* We can't represent this type */
2829 return true; /* We're easy ... */
2832 #ifdef COFF_IMAGE_WITH_PE
2834 /* This is used to sort sections by VMA, as required by PE image
2837 static int sort_by_secaddr PARAMS ((const PTR, const PTR));
2840 sort_by_secaddr (arg1, arg2)
2844 const asection *a = *(const asection **) arg1;
2845 const asection *b = *(const asection **) arg2;
2847 if (a->vma < b->vma)
2849 else if (a->vma > b->vma)
2855 #endif /* COFF_IMAGE_WITH_PE */
2857 /* Calculate the file position for each section. */
2860 #define ALIGN_SECTIONS_IN_FILE
2862 #if defined(TIC80COFF) || defined(TICOFF)
2863 #undef ALIGN_SECTIONS_IN_FILE
2867 coff_compute_section_file_positions (abfd)
2871 asection *previous = (asection *) NULL;
2872 file_ptr sofar = bfd_coff_filhsz (abfd);
2873 boolean align_adjust;
2874 #ifdef ALIGN_SECTIONS_IN_FILE
2879 /* On XCOFF, if we have symbols, set up the .debug section. */
2880 if (bfd_get_symcount (abfd) > 0)
2883 bfd_size_type i, symcount;
2887 symcount = bfd_get_symcount (abfd);
2888 for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++)
2890 coff_symbol_type *cf;
2892 cf = coff_symbol_from (abfd, *symp);
2894 && cf->native != NULL
2895 && SYMNAME_IN_DEBUG (&cf->native->u.syment))
2899 len = strlen (bfd_asymbol_name (*symp));
2900 if (len > SYMNMLEN || bfd_coff_force_symnames_in_strings (abfd))
2901 sz += len + 1 + bfd_coff_debug_string_prefix_length (abfd);
2908 dsec = bfd_make_section_old_way (abfd, ".debug");
2911 dsec->_raw_size = sz;
2912 dsec->flags |= SEC_HAS_CONTENTS;
2917 #ifdef COFF_IMAGE_WITH_PE
2919 if (coff_data (abfd)->link_info)
2921 page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
2924 page_size = PE_DEF_FILE_ALIGNMENT;
2926 #ifdef COFF_PAGE_SIZE
2927 int page_size = COFF_PAGE_SIZE;
2931 if (bfd_get_start_address (abfd))
2933 /* A start address may have been added to the original file. In this
2934 case it will need an optional header to record it. */
2935 abfd->flags |= EXEC_P;
2938 if (abfd->flags & EXEC_P)
2939 sofar += bfd_coff_aoutsz (abfd);
2941 else if (xcoff_data (abfd)->full_aouthdr)
2942 sofar += bfd_coff_aoutsz (abfd);
2944 sofar += SMALL_AOUTSZ;
2947 sofar += abfd->section_count * bfd_coff_scnhsz (abfd);
2950 /* XCOFF handles overflows in the reloc and line number count fields
2951 by allocating a new section header to hold the correct counts. */
2952 for (current = abfd->sections; current != NULL; current = current->next)
2953 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
2954 sofar += bfd_coff_scnhsz (abfd);
2957 #ifdef COFF_IMAGE_WITH_PE
2959 /* PE requires the sections to be in memory order when listed in
2960 the section headers. It also does not like empty loadable
2961 sections. The sections apparently do not have to be in the
2962 right order in the image file itself, but we do need to get the
2963 target_index values right. */
2966 asection **section_list;
2972 for (current = abfd->sections; current != NULL; current = current->next)
2975 /* We allocate an extra cell to simplify the final loop. */
2976 amt = sizeof (struct asection *) * (count + 1);
2977 section_list = bfd_malloc (amt);
2978 if (section_list == NULL)
2982 for (current = abfd->sections; current != NULL; current = current->next)
2984 section_list[i] = current;
2987 section_list[i] = NULL;
2989 qsort (section_list, count, sizeof (asection *), sort_by_secaddr);
2991 /* Rethread the linked list into sorted order; at the same time,
2992 assign target_index values. */
2994 abfd->sections = section_list[0];
2995 for (i = 0; i < count; i++)
2997 current = section_list[i];
2998 current->next = section_list[i + 1];
3000 /* Later, if the section has zero size, we'll be throwing it
3001 away, so we don't want to number it now. Note that having
3002 a zero size and having real contents are different
3003 concepts: .bss has no contents, but (usually) non-zero
3005 if (current->_raw_size == 0)
3007 /* Discard. However, it still might have (valid) symbols
3008 in it, so arbitrarily set it to section 1 (indexing is
3009 1-based here; usually .text). __end__ and other
3010 contents of .endsection really have this happen.
3011 FIXME: This seems somewhat dubious. */
3012 current->target_index = 1;
3015 current->target_index = target_index++;
3017 abfd->section_tail = ¤t->next;
3019 free (section_list);
3021 #else /* ! COFF_IMAGE_WITH_PE */
3023 /* Set the target_index field. */
3027 for (current = abfd->sections; current != NULL; current = current->next)
3028 current->target_index = target_index++;
3030 #endif /* ! COFF_IMAGE_WITH_PE */
3032 align_adjust = false;
3033 for (current = abfd->sections;
3034 current != (asection *) NULL;
3035 current = current->next)
3037 #ifdef COFF_IMAGE_WITH_PE
3038 /* With PE we have to pad each section to be a multiple of its
3039 page size too, and remember both sizes. */
3040 if (coff_section_data (abfd, current) == NULL)
3042 bfd_size_type amt = sizeof (struct coff_section_tdata);
3043 current->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
3044 if (current->used_by_bfd == NULL)
3047 if (pei_section_data (abfd, current) == NULL)
3049 bfd_size_type amt = sizeof (struct pei_section_tdata);
3050 coff_section_data (abfd, current)->tdata
3051 = (PTR) bfd_zalloc (abfd, amt);
3052 if (coff_section_data (abfd, current)->tdata == NULL)
3055 if (pei_section_data (abfd, current)->virt_size == 0)
3056 pei_section_data (abfd, current)->virt_size = current->_raw_size;
3059 /* Only deal with sections which have contents. */
3060 if (!(current->flags & SEC_HAS_CONTENTS))
3063 #ifdef COFF_IMAGE_WITH_PE
3064 /* Make sure we skip empty sections in a PE image. */
3065 if (current->_raw_size == 0)
3069 /* Align the sections in the file to the same boundary on
3070 which they are aligned in virtual memory. I960 doesn't
3071 do this (FIXME) so we can stay in sync with Intel. 960
3072 doesn't yet page from files... */
3073 #ifdef ALIGN_SECTIONS_IN_FILE
3074 if ((abfd->flags & EXEC_P) != 0)
3076 /* make sure this section is aligned on the right boundary - by
3077 padding the previous section up if necessary */
3081 /* AIX loader checks the text section alignment of (vma - filepos)
3082 So even though the filepos may be aligned wrt the o_algntext, for
3083 AIX executables, this check fails. This shows up when an native
3084 AIX executable is stripped with gnu strip because the default vma
3085 of native is 0x10000150 but default for gnu is 0x10000140. Gnu
3086 stripped gnu excutable passes this check because the filepos is
3087 0x0140. This problem also show up with 64 bit shared objects. The
3088 data section must also be aligned. */
3089 if (!strcmp (current->name, _TEXT)
3090 || !strcmp (current->name, _DATA))
3095 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3097 align = 1 << current->alignment_power;
3098 pad = abs (current->vma - sofar) % align;
3109 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3112 if (previous != (asection *) NULL)
3114 previous->_raw_size += sofar - old_sofar;
3120 /* In demand paged files the low order bits of the file offset
3121 must match the low order bits of the virtual address. */
3122 #ifdef COFF_PAGE_SIZE
3123 if ((abfd->flags & D_PAGED) != 0
3124 && (current->flags & SEC_ALLOC) != 0)
3125 sofar += (current->vma - sofar) % page_size;
3127 current->filepos = sofar;
3129 #ifdef COFF_IMAGE_WITH_PE
3130 /* Set the padded size. */
3131 current->_raw_size = (current->_raw_size + page_size -1) & -page_size;
3134 sofar += current->_raw_size;
3136 #ifdef ALIGN_SECTIONS_IN_FILE
3137 /* make sure that this section is of the right size too */
3138 if ((abfd->flags & EXEC_P) == 0)
3140 bfd_size_type old_size;
3142 old_size = current->_raw_size;
3143 current->_raw_size = BFD_ALIGN (current->_raw_size,
3144 1 << current->alignment_power);
3145 align_adjust = current->_raw_size != old_size;
3146 sofar += current->_raw_size - old_size;
3151 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3152 align_adjust = sofar != old_sofar;
3153 current->_raw_size += sofar - old_sofar;
3157 #ifdef COFF_IMAGE_WITH_PE
3158 /* For PE we need to make sure we pad out to the aligned
3159 _raw_size, in case the caller only writes out data to the
3160 unaligned _raw_size. */
3161 if (pei_section_data (abfd, current)->virt_size < current->_raw_size)
3162 align_adjust = true;
3166 /* Force .lib sections to start at zero. The vma is then
3167 incremented in coff_set_section_contents. This is right for
3169 if (strcmp (current->name, _LIB) == 0)
3170 bfd_set_section_vma (abfd, current, 0);
3176 /* It is now safe to write to the output file. If we needed an
3177 alignment adjustment for the last section, then make sure that
3178 there is a byte at offset sofar. If there are no symbols and no
3179 relocs, then nothing follows the last section. If we don't force
3180 the last byte out, then the file may appear to be truncated. */
3186 if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0
3187 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
3191 /* Make sure the relocations are aligned. We don't need to make
3192 sure that this byte exists, because it will only matter if there
3193 really are relocs. */
3194 sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER);
3196 obj_relocbase (abfd) = sofar;
3197 abfd->output_has_begun = true;
3204 /* This can never work, because it is called too late--after the
3205 section positions have been set. I can't figure out what it is
3206 for, so I am going to disable it--Ian Taylor 20 March 1996. */
3208 /* If .file, .text, .data, .bss symbols are missing, add them. */
3209 /* @@ Should we only be adding missing symbols, or overriding the aux
3210 values for existing section symbols? */
3212 coff_add_missing_symbols (abfd)
3215 unsigned int nsyms = bfd_get_symcount (abfd);
3216 asymbol **sympp = abfd->outsymbols;
3219 int need_text = 1, need_data = 1, need_bss = 1, need_file = 1;
3222 for (i = 0; i < nsyms; i++)
3224 coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
3228 /* only do this if there is a coff representation of the input
3230 if (csym->native && csym->native->u.syment.n_sclass == C_FILE)
3235 name = csym->symbol.name;
3238 if (!strcmp (name, _TEXT))
3241 else if (!strcmp (name, ".wtext"))
3244 else if (!strcmp (name, _DATA))
3246 else if (!strcmp (name, _BSS))
3250 /* Now i == bfd_get_symcount (abfd). */
3251 /* @@ For now, don't deal with .file symbol. */
3254 if (!need_text && !need_data && !need_bss && !need_file)
3256 nsyms += need_text + need_data + need_bss + need_file;
3258 amt *= sizeof (asymbol *);
3259 sympp2 = (asymbol **) bfd_alloc (abfd, amt);
3262 memcpy (sympp2, sympp, i * sizeof (asymbol *));
3265 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
3269 sympp2[i++] = coff_section_symbol (abfd, _TEXT);
3271 sympp2[i++] = coff_section_symbol (abfd, _DATA);
3273 sympp2[i++] = coff_section_symbol (abfd, _BSS);
3274 BFD_ASSERT (i == nsyms);
3275 bfd_set_symtab (abfd, sympp2, nsyms);
3281 #ifdef COFF_IMAGE_WITH_PE
3283 static unsigned int pelength;
3284 static unsigned int peheader;
3287 coff_read_word (abfd, value)
3289 unsigned int *value;
3294 status = bfd_bread (b, (bfd_size_type) 2, abfd);
3302 *value = (unsigned int) b[0];
3304 *value = (unsigned int) (b[0] + (b[1] << 8));
3306 pelength += (unsigned int) status;
3312 coff_compute_checksum (abfd)
3322 filepos = (file_ptr) 0;
3326 if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
3329 more_data = coff_read_word (abfd, &value);
3331 total = 0xffff & (total + (total >> 0x10));
3336 return (0xffff & (total + (total >> 0x10)));
3340 coff_apply_checksum (abfd)
3343 unsigned int computed;
3344 unsigned int checksum = 0;
3346 if (bfd_seek (abfd, 0x3c, SEEK_SET) != 0)
3349 if (!coff_read_word (abfd, &peheader))
3352 if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
3356 bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
3358 if (bfd_seek (abfd, peheader, SEEK_SET) != 0)
3361 computed = coff_compute_checksum (abfd);
3363 checksum = computed + pelength;
3365 if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
3368 bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
3373 #endif /* COFF_IMAGE_WITH_PE */
3378 coff_write_object_contents (abfd)
3382 boolean hasrelocs = false;
3383 boolean haslinno = false;
3384 boolean hasdebug = false;
3386 file_ptr reloc_base;
3387 file_ptr lineno_base;
3389 unsigned long reloc_size = 0, reloc_count = 0;
3390 unsigned long lnno_size = 0;
3391 boolean long_section_names;
3392 asection *text_sec = NULL;
3393 asection *data_sec = NULL;
3394 asection *bss_sec = NULL;
3395 struct internal_filehdr internal_f;
3396 struct internal_aouthdr internal_a;
3397 #ifdef COFF_LONG_SECTION_NAMES
3398 size_t string_size = STRING_SIZE_SIZE;
3401 bfd_set_error (bfd_error_system_call);
3403 /* Make a pass through the symbol table to count line number entries and
3404 put them into the correct asections */
3406 lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd);
3408 if (abfd->output_has_begun == false)
3410 if (! coff_compute_section_file_positions (abfd))
3414 reloc_base = obj_relocbase (abfd);
3416 /* Work out the size of the reloc and linno areas */
3418 for (current = abfd->sections; current != NULL; current =
3422 /* we store the actual reloc count in the first reloc's addr */
3423 if (current->reloc_count > 0xffff)
3426 reloc_count += current->reloc_count;
3429 reloc_size = reloc_count * bfd_coff_relsz (abfd);
3431 lineno_base = reloc_base + reloc_size;
3432 sym_base = lineno_base + lnno_size;
3434 /* Indicate in each section->line_filepos its actual file address */
3435 for (current = abfd->sections; current != NULL; current =
3438 if (current->lineno_count)
3440 current->line_filepos = lineno_base;
3441 current->moving_line_filepos = lineno_base;
3442 lineno_base += current->lineno_count * bfd_coff_linesz (abfd);
3446 current->line_filepos = 0;
3448 if (current->reloc_count)
3450 current->rel_filepos = reloc_base;
3451 reloc_base += current->reloc_count * bfd_coff_relsz (abfd);
3453 /* extra reloc to hold real count */
3454 if (current->reloc_count > 0xffff)
3455 reloc_base += bfd_coff_relsz (abfd);
3460 current->rel_filepos = 0;
3464 /* Write section headers to the file. */
3465 internal_f.f_nscns = 0;
3467 if ((abfd->flags & EXEC_P) != 0)
3468 scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
3471 scn_base = bfd_coff_filhsz (abfd);
3474 if (xcoff_data (abfd)->full_aouthdr)
3475 scn_base += bfd_coff_aoutsz (abfd);
3477 scn_base += SMALL_AOUTSZ;
3482 if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
3485 long_section_names = false;
3486 for (current = abfd->sections;
3488 current = current->next)
3490 struct internal_scnhdr section;
3491 boolean is_reloc_section = false;
3493 #ifdef COFF_IMAGE_WITH_PE
3494 if (strcmp (current->name, ".reloc") == 0)
3496 is_reloc_section = true;
3498 pe_data (abfd)->has_reloc_section = 1;
3502 internal_f.f_nscns++;
3504 strncpy (section.s_name, current->name, SCNNMLEN);
3506 #ifdef COFF_LONG_SECTION_NAMES
3507 /* Handle long section names as in PE. This must be compatible
3508 with the code in coff_write_symbols and _bfd_coff_final_link. */
3512 len = strlen (current->name);
3515 memset (section.s_name, 0, SCNNMLEN);
3516 sprintf (section.s_name, "/%lu", (unsigned long) string_size);
3517 string_size += len + 1;
3518 long_section_names = true;
3524 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3525 Ian Taylor <ian@cygnus.com>. */
3526 if (strcmp (current->name, _LIB) == 0)
3527 section.s_vaddr = 0;
3530 section.s_vaddr = current->vma;
3531 section.s_paddr = current->lma;
3532 section.s_size = current->_raw_size;
3533 #ifdef coff_get_section_load_page
3534 section.s_page = coff_get_section_load_page (current);
3538 section.s_paddr = 0;
3540 #ifdef COFF_IMAGE_WITH_PE
3541 /* Reminder: s_paddr holds the virtual size of the section. */
3542 if (coff_section_data (abfd, current) != NULL
3543 && pei_section_data (abfd, current) != NULL)
3544 section.s_paddr = pei_section_data (abfd, current)->virt_size;
3546 section.s_paddr = 0;
3550 If this section has no size or is unloadable then the scnptr
3553 if (current->_raw_size == 0 ||
3554 (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
3556 section.s_scnptr = 0;
3560 section.s_scnptr = current->filepos;
3562 section.s_relptr = current->rel_filepos;
3563 section.s_lnnoptr = current->line_filepos;
3564 section.s_nreloc = current->reloc_count;
3565 section.s_nlnno = current->lineno_count;
3566 #ifndef COFF_IMAGE_WITH_PE
3567 /* In PEI, relocs come in the .reloc section. */
3568 if (current->reloc_count != 0)
3571 if (current->lineno_count != 0)
3573 if ((current->flags & SEC_DEBUGGING) != 0
3574 && ! is_reloc_section)
3579 /* Indicate the use of an XCOFF overflow section header. */
3580 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3582 section.s_nreloc = 0xffff;
3583 section.s_nlnno = 0xffff;
3588 section.s_flags = sec_to_styp_flags (current->name, current->flags);
3590 if (!strcmp (current->name, _TEXT))
3594 else if (!strcmp (current->name, _DATA))
3598 else if (!strcmp (current->name, _BSS))
3604 section.s_align = (current->alignment_power
3605 ? 1 << current->alignment_power
3609 /* TI COFF puts the alignment power in bits 8-11 of the flags */
3610 section.s_flags |= (current->alignment_power & 0xF) << 8;
3612 #ifdef COFF_ENCODE_ALIGNMENT
3613 COFF_ENCODE_ALIGNMENT(section, current->alignment_power);
3616 #ifdef COFF_IMAGE_WITH_PE
3617 /* Suppress output of the sections if they are null. ld
3618 includes the bss and data sections even if there is no size
3619 assigned to them. NT loader doesn't like it if these section
3620 headers are included if the sections themselves are not
3621 needed. See also coff_compute_section_file_positions. */
3622 if (section.s_size == 0)
3623 internal_f.f_nscns--;
3628 bfd_size_type amt = bfd_coff_scnhsz (abfd);
3630 if (coff_swap_scnhdr_out (abfd, §ion, &buff) == 0
3631 || bfd_bwrite ((PTR) &buff, amt, abfd) != amt)
3636 /* PE stores COMDAT section information in the symbol table. If
3637 this section is supposed to have some COMDAT info, track down
3638 the symbol in the symbol table and modify it. */
3639 if ((current->flags & SEC_LINK_ONCE) != 0)
3641 unsigned int i, count;
3643 coff_symbol_type *csym = NULL;
3647 count = bfd_get_symcount (abfd);
3648 for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++)
3650 if ((*psym)->section != current)
3653 /* Remember the location of the first symbol in this
3655 if (psymsec == NULL)
3658 /* See if this is the section symbol. */
3659 if (strcmp ((*psym)->name, current->name) == 0)
3661 csym = coff_symbol_from (abfd, *psym);
3663 || csym->native == NULL
3664 || csym->native->u.syment.n_numaux < 1
3665 || csym->native->u.syment.n_sclass != C_STAT
3666 || csym->native->u.syment.n_type != T_NULL)
3669 /* Here *PSYM is the section symbol for CURRENT. */
3676 Note that we might not if we're converting the file from
3677 some other object file format. */
3680 combined_entry_type *aux;
3682 /* We don't touch the x_checksum field. The
3683 x_associated field is not currently supported. */
3685 aux = csym->native + 1;
3686 switch (current->flags & SEC_LINK_DUPLICATES)
3688 case SEC_LINK_DUPLICATES_DISCARD:
3689 aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY;
3692 case SEC_LINK_DUPLICATES_ONE_ONLY:
3693 aux->u.auxent.x_scn.x_comdat =
3694 IMAGE_COMDAT_SELECT_NODUPLICATES;
3697 case SEC_LINK_DUPLICATES_SAME_SIZE:
3698 aux->u.auxent.x_scn.x_comdat =
3699 IMAGE_COMDAT_SELECT_SAME_SIZE;
3702 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
3703 aux->u.auxent.x_scn.x_comdat =
3704 IMAGE_COMDAT_SELECT_EXACT_MATCH;
3708 /* The COMDAT symbol must be the first symbol from this
3709 section in the symbol table. In order to make this
3710 work, we move the COMDAT symbol before the first
3711 symbol we found in the search above. It's OK to
3712 rearrange the symbol table at this point, because
3713 coff_renumber_symbols is going to rearrange it
3714 further and fix up all the aux entries. */
3715 if (psym != psymsec)
3721 for (pcopy = psym; pcopy > psymsec; pcopy--)
3722 pcopy[0] = pcopy[-1];
3727 #endif /* COFF_WITH_PE */
3732 /* XCOFF handles overflows in the reloc and line number count fields
3733 by creating a new section header to hold the correct values. */
3734 for (current = abfd->sections; current != NULL; current = current->next)
3736 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3738 struct internal_scnhdr scnhdr;
3742 internal_f.f_nscns++;
3743 strncpy (&(scnhdr.s_name[0]), current->name, 8);
3744 scnhdr.s_paddr = current->reloc_count;
3745 scnhdr.s_vaddr = current->lineno_count;
3747 scnhdr.s_scnptr = 0;
3748 scnhdr.s_relptr = current->rel_filepos;
3749 scnhdr.s_lnnoptr = current->line_filepos;
3750 scnhdr.s_nreloc = current->target_index;
3751 scnhdr.s_nlnno = current->target_index;
3752 scnhdr.s_flags = STYP_OVRFLO;
3753 amt = bfd_coff_scnhsz (abfd);
3754 if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
3755 || bfd_bwrite ((PTR) &buff, amt, abfd) != amt)
3762 /* OK, now set up the filehdr... */
3764 /* Don't include the internal abs section in the section count */
3767 We will NOT put a fucking timestamp in the header here. Every time you
3768 put it back, I will come in and take it out again. I'm sorry. This
3769 field does not belong here. We fill it with a 0 so it compares the
3770 same but is not a reasonable time. -- gnu@cygnus.com
3772 internal_f.f_timdat = 0;
3774 internal_f.f_flags = 0;
3776 if (abfd->flags & EXEC_P)
3777 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3780 internal_f.f_opthdr = 0;
3783 if (xcoff_data (abfd)->full_aouthdr)
3784 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3786 internal_f.f_opthdr = SMALL_AOUTSZ;
3792 internal_f.f_flags |= F_RELFLG;
3794 internal_f.f_flags |= F_LNNO;
3795 if (abfd->flags & EXEC_P)
3796 internal_f.f_flags |= F_EXEC;
3797 #ifdef COFF_IMAGE_WITH_PE
3799 internal_f.f_flags |= IMAGE_FILE_DEBUG_STRIPPED;
3802 #ifndef COFF_WITH_PE
3803 if (bfd_little_endian (abfd))
3804 internal_f.f_flags |= F_AR32WR;
3806 internal_f.f_flags |= F_AR32W;
3810 /* target id is used in TI COFF v1 and later; COFF0 won't use this field,
3811 but it doesn't hurt to set it internally */
3812 internal_f.f_target_id = TI_TARGET_ID;
3814 #ifdef TIC80_TARGET_ID
3815 internal_f.f_target_id = TIC80_TARGET_ID;
3819 FIXME, should do something about the other byte orders and
3824 if ((abfd->flags & DYNAMIC) != 0)
3825 internal_f.f_flags |= F_SHROBJ;
3826 if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
3827 internal_f.f_flags |= F_DYNLOAD;
3830 memset (&internal_a, 0, sizeof internal_a);
3832 /* Set up architecture-dependent stuff */
3835 unsigned int magic = 0;
3836 unsigned short flags = 0;
3837 coff_set_flags (abfd, &magic, &flags);
3838 internal_f.f_magic = magic;
3839 internal_f.f_flags |= flags;
3840 /* ...and the "opt"hdr... */
3843 #ifdef ULTRA3 /* NYU's machine */
3844 /* FIXME: This is a bogus check. I really want to see if there
3845 * is a .shbss or a .shdata section, if so then set the magic
3846 * number to indicate a shared data executable.
3848 if (internal_f.f_nscns >= 7)
3849 internal_a.magic = SHMAGIC; /* Shared magic */
3852 internal_a.magic = NMAGIC; /* Assume separate i/d */
3853 #define __A_MAGIC_SET__
3855 #ifdef TICOFF_AOUT_MAGIC
3856 internal_a.magic = TICOFF_AOUT_MAGIC;
3857 #define __A_MAGIC_SET__
3860 internal_a.magic = TIC80_ARCH_MAGIC;
3861 #define __A_MAGIC_SET__
3864 /* FIXME: What are the a.out magic numbers for the i860? */
3865 internal_a.magic = 0;
3866 #define __A_MAGIC_SET__
3869 internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
3870 #define __A_MAGIC_SET__
3873 #define __A_MAGIC_SET__
3874 internal_a.magic = PAGEMAGICBCS;
3878 #define __A_MAGIC_SET__
3879 internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
3882 #if defined(M68) || defined(WE32K) || defined(M68K)
3883 #define __A_MAGIC_SET__
3885 internal_a.magic = LYNXCOFFMAGIC;
3887 #if defined(TARG_AUX)
3888 internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED :
3889 abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED :
3890 PAGEMAGICEXECSWAPPED);
3892 #if defined (PAGEMAGICPEXECPAGED)
3893 internal_a.magic = PAGEMAGICPEXECPAGED;
3895 #endif /* TARG_AUX */
3897 #endif /* M68 || WE32K || M68K */
3900 #define __A_MAGIC_SET__
3901 internal_a.magic = ZMAGIC;
3905 #define __A_MAGIC_SET__
3906 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3909 #if defined MCORE_PE
3910 #define __A_MAGIC_SET__
3911 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3915 #define __A_MAGIC_SET__
3917 internal_a.magic = LYNXCOFFMAGIC;
3919 internal_a.magic = ZMAGIC;
3924 #define __A_MAGIC_SET__
3925 internal_a.magic = ZMAGIC;
3929 #define __A_MAGIC_SET__
3931 internal_a.magic = LYNXCOFFMAGIC;
3936 #define __A_MAGIC_SET__
3937 internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
3938 (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
3939 RS6K_AOUTHDR_OMAGIC;
3942 #if defined(SH) && defined(COFF_WITH_PE)
3943 #define __A_MAGIC_SET__
3944 internal_a.magic = SH_PE_MAGIC;
3947 #if defined(MIPS) && defined(COFF_WITH_PE)
3948 #define __A_MAGIC_SET__
3949 internal_a.magic = MIPS_PE_MAGIC;
3953 #define __A_MAGIC_SET__
3954 internal_a.magic = NMAGIC; /* Assume separate i/d. */
3957 #ifndef __A_MAGIC_SET__
3958 #include "Your aouthdr magic number is not being set!"
3960 #undef __A_MAGIC_SET__
3964 /* FIXME: Does anybody ever set this to another value? */
3965 internal_a.vstamp = 0;
3967 /* Now should write relocs, strings, syms */
3968 obj_sym_filepos (abfd) = sym_base;
3970 if (bfd_get_symcount (abfd) != 0)
3974 if (!coff_add_missing_symbols (abfd))
3977 if (!coff_renumber_symbols (abfd, &firstundef))
3979 coff_mangle_symbols (abfd);
3980 if (! coff_write_symbols (abfd))
3982 if (! coff_write_linenumbers (abfd))
3984 if (! coff_write_relocs (abfd, firstundef))
3987 #ifdef COFF_LONG_SECTION_NAMES
3988 else if (long_section_names && ! obj_coff_strings_written (abfd))
3990 /* If we have long section names we have to write out the string
3991 table even if there are no symbols. */
3992 if (! coff_write_symbols (abfd))
3996 #ifdef COFF_IMAGE_WITH_PE
3998 else if ((abfd->flags & EXEC_P) != 0)
4002 /* PowerPC PE appears to require that all executable files be
4003 rounded up to the page size. */
4006 (file_ptr) BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1,
4008 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
4014 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
4015 backend linker, and obj_raw_syment_count is not valid until after
4016 coff_write_symbols is called. */
4017 if (obj_raw_syment_count (abfd) != 0)
4019 internal_f.f_symptr = sym_base;
4021 /* AIX appears to require that F_RELFLG not be set if there are
4022 local symbols but no relocations. */
4023 internal_f.f_flags &=~ F_RELFLG;
4028 if (long_section_names)
4029 internal_f.f_symptr = sym_base;
4031 internal_f.f_symptr = 0;
4032 internal_f.f_flags |= F_LSYMS;
4037 internal_a.tsize = bfd_get_section_size_before_reloc (text_sec);
4038 internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
4042 internal_a.dsize = bfd_get_section_size_before_reloc (data_sec);
4043 internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
4047 internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec);
4048 if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
4049 internal_a.data_start = bss_sec->vma;
4052 internal_a.entry = bfd_get_start_address (abfd);
4053 internal_f.f_nsyms = obj_raw_syment_count (abfd);
4056 if (xcoff_data (abfd)->full_aouthdr)
4059 asection *loader_sec;
4061 internal_a.vstamp = 1;
4063 internal_a.o_snentry = xcoff_data (abfd)->snentry;
4064 if (internal_a.o_snentry == 0)
4065 internal_a.entry = (bfd_vma) -1;
4067 if (text_sec != NULL)
4069 internal_a.o_sntext = text_sec->target_index;
4070 internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
4074 internal_a.o_sntext = 0;
4075 internal_a.o_algntext = 0;
4077 if (data_sec != NULL)
4079 internal_a.o_sndata = data_sec->target_index;
4080 internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
4084 internal_a.o_sndata = 0;
4085 internal_a.o_algndata = 0;
4087 loader_sec = bfd_get_section_by_name (abfd, ".loader");
4088 if (loader_sec != NULL)
4089 internal_a.o_snloader = loader_sec->target_index;
4091 internal_a.o_snloader = 0;
4092 if (bss_sec != NULL)
4093 internal_a.o_snbss = bss_sec->target_index;
4095 internal_a.o_snbss = 0;
4097 toc = xcoff_data (abfd)->toc;
4098 internal_a.o_toc = toc;
4099 internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
4101 internal_a.o_modtype = xcoff_data (abfd)->modtype;
4102 if (xcoff_data (abfd)->cputype != -1)
4103 internal_a.o_cputype = xcoff_data (abfd)->cputype;
4106 switch (bfd_get_arch (abfd))
4108 case bfd_arch_rs6000:
4109 internal_a.o_cputype = 4;
4111 case bfd_arch_powerpc:
4112 if (bfd_get_mach (abfd) == 0)
4113 internal_a.o_cputype = 3;
4115 internal_a.o_cputype = 1;
4121 internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
4122 internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
4126 /* now write them */
4127 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
4132 bfd_size_type amount = bfd_coff_filhsz (abfd);
4134 buff = bfd_malloc (amount);
4138 bfd_coff_swap_filehdr_out (abfd, (PTR) &internal_f, (PTR) buff);
4139 amount = bfd_bwrite ((PTR) buff, amount, abfd);
4143 if (amount != bfd_coff_filhsz (abfd))
4147 if (abfd->flags & EXEC_P)
4149 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4150 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)) */
4152 bfd_size_type amount = bfd_coff_aoutsz (abfd);
4154 buff = bfd_malloc (amount);
4158 coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) buff);
4159 amount = bfd_bwrite ((PTR) buff, amount, abfd);
4163 if (amount != bfd_coff_aoutsz (abfd))
4166 #ifdef COFF_IMAGE_WITH_PE
4167 if (! coff_apply_checksum (abfd))
4177 /* XCOFF seems to always write at least a small a.out header. */
4178 coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) &buff);
4179 if (xcoff_data (abfd)->full_aouthdr)
4180 size = bfd_coff_aoutsz (abfd);
4182 size = SMALL_AOUTSZ;
4183 if (bfd_bwrite ((PTR) &buff, (bfd_size_type) size, abfd) != size)
4192 coff_set_section_contents (abfd, section, location, offset, count)
4197 bfd_size_type count;
4199 if (abfd->output_has_begun == false) /* set by bfd.c handler */
4201 if (! coff_compute_section_file_positions (abfd))
4205 #if defined(_LIB) && !defined(TARG_AUX)
4207 /* The physical address field of a .lib section is used to hold the
4208 number of shared libraries in the section. This code counts the
4209 number of sections being written, and increments the lma field
4212 I have found no documentation on the contents of this section.
4213 Experimentation indicates that the section contains zero or more
4214 records, each of which has the following structure:
4216 - a (four byte) word holding the length of this record, in words,
4217 - a word that always seems to be set to "2",
4218 - the path to a shared library, null-terminated and then padded
4219 to a whole word boundary.
4221 bfd_assert calls have been added to alert if an attempt is made
4222 to write a section which doesn't follow these assumptions. The
4223 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4224 <robertl@arnet.com> (Thanks!).
4226 Gvran Uddeborg <gvran@uddeborg.pp.se> */
4228 if (strcmp (section->name, _LIB) == 0)
4230 bfd_byte *rec, *recend;
4232 rec = (bfd_byte *) location;
4233 recend = rec + count;
4234 while (rec < recend)
4237 rec += bfd_get_32 (abfd, rec) * 4;
4240 BFD_ASSERT (rec == recend);
4245 /* Don't write out bss sections - one way to do this is to
4246 see if the filepos has not been set. */
4247 if (section->filepos == 0)
4250 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
4256 return bfd_bwrite (location, count, abfd) == count;
4260 coff_close_and_cleanup (abfd)
4263 if (!bfd_read_p (abfd))
4264 switch (abfd->format)
4267 if (!_bfd_write_archive_contents (abfd))
4271 if (!coff_write_object_contents (abfd))
4275 bfd_set_error (bfd_error_invalid_operation);
4279 /* We depend on bfd_close to free all the memory on the objalloc. */
4286 buy_and_read (abfd, where, size)
4291 PTR area = (PTR) bfd_alloc (abfd, size);
4294 if (bfd_seek (abfd, where, SEEK_SET) != 0
4295 || bfd_bread (area, size, abfd) != size)
4298 } /* buy_and_read() */
4304 Creating the linenumber table is done by reading in the entire
4305 coff linenumber table, and creating another table for internal use.
4307 A coff linenumber table is structured so that each function
4308 is marked as having a line number of 0. Each line within the
4309 function is an offset from the first line in the function. The
4310 base of the line number information for the table is stored in
4311 the symbol associated with the function.
4313 Note: The PE format uses line number 0 for a flag indicating a
4316 The information is copied from the external to the internal
4317 table, and each symbol which marks a function is marked by
4320 How does this work ?
4325 coff_slurp_line_table (abfd, asect)
4329 LINENO *native_lineno;
4330 alent *lineno_cache;
4333 BFD_ASSERT (asect->lineno == (alent *) NULL);
4335 amt = (bfd_size_type) bfd_coff_linesz (abfd) * asect->lineno_count;
4336 native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos, amt);
4337 amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
4338 lineno_cache = (alent *) bfd_alloc (abfd, amt);
4339 if (lineno_cache == NULL)
4343 unsigned int counter = 0;
4344 alent *cache_ptr = lineno_cache;
4345 LINENO *src = native_lineno;
4347 while (counter < asect->lineno_count)
4349 struct internal_lineno dst;
4350 bfd_coff_swap_lineno_in (abfd, src, &dst);
4351 cache_ptr->line_number = dst.l_lnno;
4353 if (cache_ptr->line_number == 0)
4356 bfd_signed_vma symndx;
4357 coff_symbol_type *sym;
4360 symndx = dst.l_addr.l_symndx;
4362 || (bfd_vma) symndx >= obj_raw_syment_count (abfd))
4364 (*_bfd_error_handler)
4365 (_("%s: warning: illegal symbol index %ld in line numbers"),
4366 bfd_archive_filename (abfd), dst.l_addr.l_symndx);
4370 /* FIXME: We should not be casting between ints and
4371 pointers like this. */
4372 sym = ((coff_symbol_type *)
4373 ((symndx + obj_raw_syments (abfd))
4374 ->u.syment._n._n_n._n_zeroes));
4375 cache_ptr->u.sym = (asymbol *) sym;
4376 if (sym->lineno != NULL && ! warned)
4378 (*_bfd_error_handler)
4379 (_("%s: warning: duplicate line number information for `%s'"),
4380 bfd_archive_filename (abfd),
4381 bfd_asymbol_name (&sym->symbol));
4383 sym->lineno = cache_ptr;
4387 cache_ptr->u.offset = dst.l_addr.l_paddr
4388 - bfd_section_vma (abfd, asect);
4389 } /* If no linenumber expect a symbol index */
4395 cache_ptr->line_number = 0;
4398 asect->lineno = lineno_cache;
4399 /* FIXME, free native_lineno here, or use alloca or something. */
4403 /* Slurp in the symbol table, converting it to generic form. Note
4404 that if coff_relocate_section is defined, the linker will read
4405 symbols via coff_link_add_symbols, rather than via this routine. */
4408 coff_slurp_symbol_table (abfd)
4411 combined_entry_type *native_symbols;
4412 coff_symbol_type *cached_area;
4413 unsigned int *table_ptr;
4416 unsigned int number_of_symbols = 0;
4418 if (obj_symbols (abfd))
4421 /* Read in the symbol table */
4422 if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
4427 /* Allocate enough room for all the symbols in cached form */
4428 amt = obj_raw_syment_count (abfd);
4429 amt *= sizeof (coff_symbol_type);
4430 cached_area = (coff_symbol_type *) bfd_alloc (abfd, amt);
4431 if (cached_area == NULL)
4434 amt = obj_raw_syment_count (abfd);
4435 amt *= sizeof (unsigned int);
4436 table_ptr = (unsigned int *) bfd_alloc (abfd, amt);
4438 if (table_ptr == NULL)
4442 coff_symbol_type *dst = cached_area;
4443 unsigned int last_native_index = obj_raw_syment_count (abfd);
4444 unsigned int this_index = 0;
4445 while (this_index < last_native_index)
4447 combined_entry_type *src = native_symbols + this_index;
4448 table_ptr[this_index] = number_of_symbols;
4449 dst->symbol.the_bfd = abfd;
4451 dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
4452 /* We use the native name field to point to the cached field. */
4453 src->u.syment._n._n_n._n_zeroes = (long) dst;
4454 dst->symbol.section = coff_section_from_bfd_index (abfd,
4455 src->u.syment.n_scnum);
4456 dst->symbol.flags = 0;
4457 dst->done_lineno = false;
4459 switch (src->u.syment.n_sclass)
4464 dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
4465 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
4466 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4468 /* Fall through to next case */
4476 case C_THUMBEXTFUNC:
4482 case C_SYSTEM: /* System Wide variable */
4485 /* In PE, 0x68 (104) denotes a section symbol */
4487 /* In PE, 0x69 (105) denotes a weak external symbol. */
4490 switch (coff_classify_symbol (abfd, &src->u.syment))
4492 case COFF_SYMBOL_GLOBAL:
4493 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
4494 #if defined COFF_WITH_PE
4495 /* PE sets the symbol to a value relative to the
4496 start of the section. */
4497 dst->symbol.value = src->u.syment.n_value;
4499 dst->symbol.value = (src->u.syment.n_value
4500 - dst->symbol.section->vma);
4502 if (ISFCN ((src->u.syment.n_type)))
4504 /* A function ext does not go at the end of a
4506 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4510 case COFF_SYMBOL_COMMON:
4511 dst->symbol.section = bfd_com_section_ptr;
4512 dst->symbol.value = src->u.syment.n_value;
4515 case COFF_SYMBOL_UNDEFINED:
4516 dst->symbol.section = bfd_und_section_ptr;
4517 dst->symbol.value = 0;
4520 case COFF_SYMBOL_PE_SECTION:
4521 dst->symbol.flags |= BSF_EXPORT | BSF_SECTION_SYM;
4522 dst->symbol.value = 0;
4525 case COFF_SYMBOL_LOCAL:
4526 dst->symbol.flags = BSF_LOCAL;
4527 #if defined COFF_WITH_PE
4528 /* PE sets the symbol to a value relative to the
4529 start of the section. */
4530 dst->symbol.value = src->u.syment.n_value;
4532 dst->symbol.value = (src->u.syment.n_value
4533 - dst->symbol.section->vma);
4535 if (ISFCN ((src->u.syment.n_type)))
4536 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4541 /* A symbol with a csect entry should not go at the end. */
4542 if (src->u.syment.n_numaux > 0)
4543 dst->symbol.flags |= BSF_NOT_AT_END;
4547 if (src->u.syment.n_sclass == C_NT_WEAK)
4548 dst->symbol.flags |= BSF_WEAK;
4550 if (src->u.syment.n_sclass == C_SECTION
4551 && src->u.syment.n_scnum > 0)
4552 dst->symbol.flags = BSF_LOCAL;
4554 if (src->u.syment.n_sclass == C_WEAKEXT)
4555 dst->symbol.flags |= BSF_WEAK;
4559 case C_STAT: /* static */
4561 case C_LEAFSTAT: /* static leaf procedure */
4564 case C_THUMBSTAT: /* Thumb static */
4565 case C_THUMBLABEL: /* Thumb label */
4566 case C_THUMBSTATFUNC:/* Thumb static function */
4568 case C_LABEL: /* label */
4569 if (src->u.syment.n_scnum == N_DEBUG)
4570 dst->symbol.flags = BSF_DEBUGGING;
4572 dst->symbol.flags = BSF_LOCAL;
4574 /* Base the value as an index from the base of the
4575 section, if there is one. */
4576 if (dst->symbol.section)
4578 #if defined COFF_WITH_PE
4579 /* PE sets the symbol to a value relative to the
4580 start of the section. */
4581 dst->symbol.value = src->u.syment.n_value;
4583 dst->symbol.value = (src->u.syment.n_value
4584 - dst->symbol.section->vma);
4588 dst->symbol.value = src->u.syment.n_value;
4591 case C_MOS: /* member of structure */
4592 case C_EOS: /* end of structure */
4593 #ifdef NOTDEF /* C_AUTOARG has the same value */
4595 case C_GLBLREG: /* A29k-specific storage class */
4598 case C_REGPARM: /* register parameter */
4599 case C_REG: /* register variable */
4600 /* C_AUTOARG conflictes with TI COFF C_UEXT */
4601 #if !defined (TIC80COFF) && !defined (TICOFF)
4603 case C_AUTOARG: /* 960-specific storage class */
4606 case C_TPDEF: /* type definition */
4608 case C_AUTO: /* automatic variable */
4609 case C_FIELD: /* bit field */
4610 case C_ENTAG: /* enumeration tag */
4611 case C_MOE: /* member of enumeration */
4612 case C_MOU: /* member of union */
4613 case C_UNTAG: /* union tag */
4614 dst->symbol.flags = BSF_DEBUGGING;
4615 dst->symbol.value = (src->u.syment.n_value);
4618 case C_FILE: /* file name */
4619 case C_STRTAG: /* structure tag */
4634 dst->symbol.flags = BSF_DEBUGGING;
4635 dst->symbol.value = (src->u.syment.n_value);
4639 case C_BINCL: /* beginning of include file */
4640 case C_EINCL: /* ending of include file */
4641 /* The value is actually a pointer into the line numbers
4642 of the file. We locate the line number entry, and
4643 set the section to the section which contains it, and
4644 the value to the index in that section. */
4648 dst->symbol.flags = BSF_DEBUGGING;
4649 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4650 if (sec->line_filepos <= (file_ptr) src->u.syment.n_value
4651 && ((file_ptr) (sec->line_filepos
4652 + sec->lineno_count * bfd_coff_linesz (abfd))
4653 > (file_ptr) src->u.syment.n_value))
4656 dst->symbol.value = 0;
4659 dst->symbol.section = sec;
4660 dst->symbol.value = ((src->u.syment.n_value
4661 - sec->line_filepos)
4662 / bfd_coff_linesz (abfd));
4669 dst->symbol.flags = BSF_DEBUGGING;
4671 /* The value is actually a symbol index. Save a pointer
4672 to the symbol instead of the index. FIXME: This
4673 should use a union. */
4674 src->u.syment.n_value =
4675 (long) (native_symbols + src->u.syment.n_value);
4676 dst->symbol.value = src->u.syment.n_value;
4681 case C_BLOCK: /* ".bb" or ".eb" */
4682 case C_FCN: /* ".bf" or ".ef" (or PE ".lf") */
4683 case C_EFCN: /* physical end of function */
4684 #if defined COFF_WITH_PE
4685 /* PE sets the symbol to a value relative to the start
4687 dst->symbol.value = src->u.syment.n_value;
4688 if (strcmp (dst->symbol.name, ".bf") != 0)
4690 /* PE uses funny values for .ef and .lf; don't
4692 dst->symbol.flags = BSF_DEBUGGING;
4695 dst->symbol.flags = BSF_DEBUGGING | BSF_DEBUGGING_RELOC;
4697 /* Base the value as an index from the base of the
4699 dst->symbol.flags = BSF_LOCAL;
4700 dst->symbol.value = (src->u.syment.n_value
4701 - dst->symbol.section->vma);
4705 case C_STATLAB: /* Static load time label */
4706 dst->symbol.value = src->u.syment.n_value;
4707 dst->symbol.flags = BSF_GLOBAL;
4711 /* PE DLLs sometimes have zeroed out symbols for some
4712 reason. Just ignore them without a warning. */
4713 if (src->u.syment.n_type == 0
4714 && src->u.syment.n_value == 0
4715 && src->u.syment.n_scnum == 0)
4718 case C_EXTDEF: /* external definition */
4719 case C_ULABEL: /* undefined label */
4720 case C_USTATIC: /* undefined static */
4721 #ifndef COFF_WITH_PE
4722 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4723 class to represent a section symbol */
4724 case C_LINE: /* line # reformatted as symbol table entry */
4725 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4726 case C_ALIAS: /* duplicate tag */
4728 /* New storage classes for TI COFF */
4729 #if defined(TIC80COFF) || defined(TICOFF)
4730 case C_UEXT: /* Tentative external definition */
4732 case C_EXTLAB: /* External load time label */
4733 case C_HIDDEN: /* ext symbol in dmert public lib */
4735 (*_bfd_error_handler)
4736 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
4737 bfd_archive_filename (abfd), src->u.syment.n_sclass,
4738 dst->symbol.section->name, dst->symbol.name);
4739 dst->symbol.flags = BSF_DEBUGGING;
4740 dst->symbol.value = (src->u.syment.n_value);
4744 /* BFD_ASSERT(dst->symbol.flags != 0);*/
4748 dst->symbol.udata.i = 0;
4749 dst->lineno = (alent *) NULL;
4750 this_index += (src->u.syment.n_numaux) + 1;
4752 number_of_symbols++;
4753 } /* walk the native symtab */
4754 } /* bfdize the native symtab */
4756 obj_symbols (abfd) = cached_area;
4757 obj_raw_syments (abfd) = native_symbols;
4759 bfd_get_symcount (abfd) = number_of_symbols;
4760 obj_convert (abfd) = table_ptr;
4761 /* Slurp the line tables for each section too */
4767 coff_slurp_line_table (abfd, p);
4772 } /* coff_slurp_symbol_table() */
4774 /* Classify a COFF symbol. A couple of targets have globally visible
4775 symbols which are not class C_EXT, and this handles those. It also
4776 recognizes some special PE cases. */
4778 static enum coff_symbol_classification
4779 coff_classify_symbol (abfd, syment)
4781 struct internal_syment *syment;
4783 /* FIXME: This partially duplicates the switch in
4784 coff_slurp_symbol_table. */
4785 switch (syment->n_sclass)
4794 case C_THUMBEXTFUNC:
4802 if (syment->n_scnum == 0)
4804 if (syment->n_value == 0)
4805 return COFF_SYMBOL_UNDEFINED;
4807 return COFF_SYMBOL_COMMON;
4809 return COFF_SYMBOL_GLOBAL;
4816 if (syment->n_sclass == C_STAT)
4818 if (syment->n_scnum == 0)
4820 /* The Microsoft compiler sometimes generates these if a
4821 small static function is inlined every time it is used.
4822 The function is discarded, but the symbol table entry
4824 return COFF_SYMBOL_LOCAL;
4827 #ifdef STRICT_PE_FORMAT
4828 /* This is correct for Microsoft generated objects, but it
4829 breaks gas generated objects. */
4831 if (syment->n_value == 0)
4834 char buf[SYMNMLEN + 1];
4836 sec = coff_section_from_bfd_index (abfd, syment->n_scnum);
4838 && (strcmp (bfd_get_section_name (abfd, sec),
4839 _bfd_coff_internal_syment_name (abfd, syment, buf))
4841 return COFF_SYMBOL_PE_SECTION;
4845 return COFF_SYMBOL_LOCAL;
4848 if (syment->n_sclass == C_SECTION)
4850 /* In some cases in a DLL generated by the Microsoft linker, the
4851 n_value field will contain garbage. FIXME: This should
4852 probably be handled by the swapping function instead. */
4853 syment->n_value = 0;
4854 if (syment->n_scnum == 0)
4855 return COFF_SYMBOL_UNDEFINED;
4856 return COFF_SYMBOL_PE_SECTION;
4858 #endif /* COFF_WITH_PE */
4860 /* If it is not a global symbol, we presume it is a local symbol. */
4862 if (syment->n_scnum == 0)
4864 char buf[SYMNMLEN + 1];
4866 (*_bfd_error_handler)
4867 (_("warning: %s: local symbol `%s' has no section"),
4868 bfd_archive_filename (abfd),
4869 _bfd_coff_internal_syment_name (abfd, syment, buf));
4872 return COFF_SYMBOL_LOCAL;
4879 Coff relocations are easily transformed into the internal BFD form
4882 Reading a coff relocation table is done in the following stages:
4884 o Read the entire coff relocation table into memory.
4886 o Process each relocation in turn; first swap it from the
4887 external to the internal form.
4889 o Turn the symbol referenced in the relocation's symbol index
4890 into a pointer into the canonical symbol table.
4891 This table is the same as the one returned by a call to
4892 @code{bfd_canonicalize_symtab}. The back end will call that
4893 routine and save the result if a canonicalization hasn't been done.
4895 o The reloc index is turned into a pointer to a howto
4896 structure, in a back end specific way. For instance, the 386
4897 and 960 use the @code{r_type} to directly produce an index
4898 into a howto table vector; the 88k subtracts a number from the
4899 @code{r_type} field and creates an addend field.
4904 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
4906 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
4907 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
4908 coffsym = (obj_symbols (abfd) \
4909 + (cache_ptr->sym_ptr_ptr - symbols)); \
4911 coffsym = coff_symbol_from (abfd, ptr); \
4912 if (coffsym != (coff_symbol_type *) NULL \
4913 && coffsym->native->u.syment.n_scnum == 0) \
4914 cache_ptr->addend = 0; \
4915 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
4916 && ptr->section != (asection *) NULL) \
4917 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
4919 cache_ptr->addend = 0; \
4924 coff_slurp_reloc_table (abfd, asect, symbols)
4929 RELOC *native_relocs;
4930 arelent *reloc_cache;
4935 if (asect->relocation)
4937 if (asect->reloc_count == 0)
4939 if (asect->flags & SEC_CONSTRUCTOR)
4941 if (!coff_slurp_symbol_table (abfd))
4943 amt = (bfd_size_type) bfd_coff_relsz (abfd) * asect->reloc_count;
4944 native_relocs = (RELOC *) buy_and_read (abfd, asect->rel_filepos, amt);
4945 amt = (bfd_size_type) asect->reloc_count * sizeof (arelent);
4946 reloc_cache = (arelent *) bfd_alloc (abfd, amt);
4948 if (reloc_cache == NULL)
4951 for (idx = 0; idx < asect->reloc_count; idx++)
4953 struct internal_reloc dst;
4954 struct external_reloc *src;
4955 #ifndef RELOC_PROCESSING
4959 cache_ptr = reloc_cache + idx;
4960 src = native_relocs + idx;
4962 coff_swap_reloc_in (abfd, src, &dst);
4964 #ifdef RELOC_PROCESSING
4965 RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
4967 cache_ptr->address = dst.r_vaddr;
4969 if (dst.r_symndx != -1)
4971 if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd))
4973 (*_bfd_error_handler)
4974 (_("%s: warning: illegal symbol index %ld in relocs"),
4975 bfd_archive_filename (abfd), dst.r_symndx);
4976 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4981 cache_ptr->sym_ptr_ptr = (symbols
4982 + obj_convert (abfd)[dst.r_symndx]);
4983 ptr = *(cache_ptr->sym_ptr_ptr);
4988 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4992 /* The symbols definitions that we have read in have been
4993 relocated as if their sections started at 0. But the offsets
4994 refering to the symbols in the raw data have not been
4995 modified, so we have to have a negative addend to compensate.
4997 Note that symbols which used to be common must be left alone */
4999 /* Calculate any reloc addend by looking at the symbol */
5000 CALC_ADDEND (abfd, ptr, dst, cache_ptr);
5002 cache_ptr->address -= asect->vma;
5003 /* !! cache_ptr->section = (asection *) NULL;*/
5005 /* Fill in the cache_ptr->howto field from dst.r_type */
5006 RTYPE2HOWTO (cache_ptr, &dst);
5007 #endif /* RELOC_PROCESSING */
5009 if (cache_ptr->howto == NULL)
5011 (*_bfd_error_handler)
5012 (_("%s: illegal relocation type %d at address 0x%lx"),
5013 bfd_archive_filename (abfd), dst.r_type, (long) dst.r_vaddr);
5014 bfd_set_error (bfd_error_bad_value);
5019 asect->relocation = reloc_cache;
5023 #ifndef coff_rtype_to_howto
5026 /* Get the howto structure for a reloc. This is only used if the file
5027 including this one defines coff_relocate_section to be
5028 _bfd_coff_generic_relocate_section, so it is OK if it does not
5029 always work. It is the responsibility of the including file to
5030 make sure it is reasonable if it is needed. */
5032 static reloc_howto_type *coff_rtype_to_howto
5033 PARAMS ((bfd *, asection *, struct internal_reloc *,
5034 struct coff_link_hash_entry *, struct internal_syment *,
5038 static reloc_howto_type *
5039 coff_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
5040 bfd *abfd ATTRIBUTE_UNUSED;
5041 asection *sec ATTRIBUTE_UNUSED;
5042 struct internal_reloc *rel;
5043 struct coff_link_hash_entry *h ATTRIBUTE_UNUSED;
5044 struct internal_syment *sym ATTRIBUTE_UNUSED;
5045 bfd_vma *addendp ATTRIBUTE_UNUSED;
5049 RTYPE2HOWTO (&genrel, rel);
5050 return genrel.howto;
5053 #else /* ! defined (RTYPE2HOWTO) */
5055 #define coff_rtype_to_howto NULL
5057 #endif /* ! defined (RTYPE2HOWTO) */
5058 #endif /* ! defined (coff_rtype_to_howto) */
5060 /* This is stupid. This function should be a boolean predicate. */
5062 coff_canonicalize_reloc (abfd, section, relptr, symbols)
5068 arelent *tblptr = section->relocation;
5069 unsigned int count = 0;
5071 if (section->flags & SEC_CONSTRUCTOR)
5073 /* this section has relocs made up by us, they are not in the
5074 file, so take them out of their chain and place them into
5075 the data area provided */
5076 arelent_chain *chain = section->constructor_chain;
5077 for (count = 0; count < section->reloc_count; count++)
5079 *relptr++ = &chain->relent;
5080 chain = chain->next;
5086 if (! coff_slurp_reloc_table (abfd, section, symbols))
5089 tblptr = section->relocation;
5091 for (; count++ < section->reloc_count;)
5092 *relptr++ = tblptr++;
5095 return section->reloc_count;
5100 coff_sym_filepos (abfd)
5103 return obj_sym_filepos (abfd);
5107 #ifndef coff_reloc16_estimate
5108 #define coff_reloc16_estimate dummy_reloc16_estimate
5110 static int dummy_reloc16_estimate
5111 PARAMS ((bfd *, asection *, arelent *, unsigned int,
5112 struct bfd_link_info *));
5115 dummy_reloc16_estimate (abfd, input_section, reloc, shrink, link_info)
5116 bfd *abfd ATTRIBUTE_UNUSED;
5117 asection *input_section ATTRIBUTE_UNUSED;
5118 arelent *reloc ATTRIBUTE_UNUSED;
5119 unsigned int shrink ATTRIBUTE_UNUSED;
5120 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
5128 #ifndef coff_reloc16_extra_cases
5130 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5132 /* This works even if abort is not declared in any header file. */
5134 static void dummy_reloc16_extra_cases
5135 PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
5136 bfd_byte *, unsigned int *, unsigned int *));
5139 dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
5141 bfd *abfd ATTRIBUTE_UNUSED;
5142 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
5143 struct bfd_link_order *link_order ATTRIBUTE_UNUSED;
5144 arelent *reloc ATTRIBUTE_UNUSED;
5145 bfd_byte *data ATTRIBUTE_UNUSED;
5146 unsigned int *src_ptr ATTRIBUTE_UNUSED;
5147 unsigned int *dst_ptr ATTRIBUTE_UNUSED;
5153 #ifndef coff_bfd_link_hash_table_free
5154 #define coff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
5157 /* If coff_relocate_section is defined, we can use the optimized COFF
5158 backend linker. Otherwise we must continue to use the old linker. */
5159 #ifdef coff_relocate_section
5160 #ifndef coff_bfd_link_hash_table_create
5161 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5163 #ifndef coff_bfd_link_add_symbols
5164 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5166 #ifndef coff_bfd_final_link
5167 #define coff_bfd_final_link _bfd_coff_final_link
5169 #else /* ! defined (coff_relocate_section) */
5170 #define coff_relocate_section NULL
5171 #ifndef coff_bfd_link_hash_table_create
5172 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5174 #ifndef coff_bfd_link_add_symbols
5175 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5177 #define coff_bfd_final_link _bfd_generic_final_link
5178 #endif /* ! defined (coff_relocate_section) */
5180 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5181 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5183 #ifndef coff_start_final_link
5184 #define coff_start_final_link NULL
5187 #ifndef coff_adjust_symndx
5188 #define coff_adjust_symndx NULL
5191 #ifndef coff_link_add_one_symbol
5192 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5195 #ifndef coff_link_output_has_begun
5197 static boolean coff_link_output_has_begun
5198 PARAMS ((bfd *, struct coff_final_link_info *));
5201 coff_link_output_has_begun (abfd, info)
5203 struct coff_final_link_info * info ATTRIBUTE_UNUSED;
5205 return abfd->output_has_begun;
5209 #ifndef coff_final_link_postscript
5211 static boolean coff_final_link_postscript
5212 PARAMS ((bfd *, struct coff_final_link_info *));
5215 coff_final_link_postscript (abfd, pfinfo)
5216 bfd * abfd ATTRIBUTE_UNUSED;
5217 struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED;
5223 #ifndef coff_SWAP_aux_in
5224 #define coff_SWAP_aux_in coff_swap_aux_in
5226 #ifndef coff_SWAP_sym_in
5227 #define coff_SWAP_sym_in coff_swap_sym_in
5229 #ifndef coff_SWAP_lineno_in
5230 #define coff_SWAP_lineno_in coff_swap_lineno_in
5232 #ifndef coff_SWAP_aux_out
5233 #define coff_SWAP_aux_out coff_swap_aux_out
5235 #ifndef coff_SWAP_sym_out
5236 #define coff_SWAP_sym_out coff_swap_sym_out
5238 #ifndef coff_SWAP_lineno_out
5239 #define coff_SWAP_lineno_out coff_swap_lineno_out
5241 #ifndef coff_SWAP_reloc_out
5242 #define coff_SWAP_reloc_out coff_swap_reloc_out
5244 #ifndef coff_SWAP_filehdr_out
5245 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5247 #ifndef coff_SWAP_aouthdr_out
5248 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5250 #ifndef coff_SWAP_scnhdr_out
5251 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5253 #ifndef coff_SWAP_reloc_in
5254 #define coff_SWAP_reloc_in coff_swap_reloc_in
5256 #ifndef coff_SWAP_filehdr_in
5257 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5259 #ifndef coff_SWAP_aouthdr_in
5260 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5262 #ifndef coff_SWAP_scnhdr_in
5263 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5266 static const bfd_coff_backend_data bfd_coff_std_swap_table =
5268 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5269 coff_SWAP_aux_out, coff_SWAP_sym_out,
5270 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5271 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5272 coff_SWAP_scnhdr_out,
5273 FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
5274 #ifdef COFF_LONG_FILENAMES
5279 #ifdef COFF_LONG_SECTION_NAMES
5284 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5285 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5290 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5295 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5296 coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
5297 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5298 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5299 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5300 coff_classify_symbol, coff_compute_section_file_positions,
5301 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5302 coff_adjust_symndx, coff_link_add_one_symbol,
5303 coff_link_output_has_begun, coff_final_link_postscript
5306 #ifndef coff_close_and_cleanup
5307 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5310 #ifndef coff_bfd_free_cached_info
5311 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5314 #ifndef coff_get_section_contents
5315 #define coff_get_section_contents _bfd_generic_get_section_contents
5318 #ifndef coff_bfd_copy_private_symbol_data
5319 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5322 #ifndef coff_bfd_copy_private_section_data
5323 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5326 #ifndef coff_bfd_copy_private_bfd_data
5327 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5330 #ifndef coff_bfd_merge_private_bfd_data
5331 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5334 #ifndef coff_bfd_set_private_flags
5335 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5338 #ifndef coff_bfd_print_private_bfd_data
5339 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5342 #ifndef coff_bfd_is_local_label_name
5343 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5346 #ifndef coff_read_minisymbols
5347 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5350 #ifndef coff_minisymbol_to_symbol
5351 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5354 /* The reloc lookup routine must be supplied by each individual COFF
5356 #ifndef coff_bfd_reloc_type_lookup
5357 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5360 #ifndef coff_bfd_get_relocated_section_contents
5361 #define coff_bfd_get_relocated_section_contents \
5362 bfd_generic_get_relocated_section_contents
5365 #ifndef coff_bfd_relax_section
5366 #define coff_bfd_relax_section bfd_generic_relax_section
5369 #ifndef coff_bfd_gc_sections
5370 #define coff_bfd_gc_sections bfd_generic_gc_sections
5373 #ifndef coff_bfd_merge_sections
5374 #define coff_bfd_merge_sections bfd_generic_merge_sections
5377 #ifndef coff_bfd_discard_group
5378 #define coff_bfd_discard_group bfd_generic_discard_group
5381 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
5382 const bfd_target VAR = \
5385 bfd_target_coff_flavour, \
5386 BFD_ENDIAN_BIG, /* data byte order is big */ \
5387 BFD_ENDIAN_BIG, /* header byte order is big */ \
5388 /* object flags */ \
5389 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5390 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5391 /* section flags */ \
5392 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5393 UNDER, /* leading symbol underscore */ \
5394 '/', /* ar_pad_char */ \
5395 15, /* ar_max_namelen */ \
5397 /* Data conversion functions. */ \
5398 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5399 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5400 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5402 /* Header conversion functions. */ \
5403 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5404 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5405 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5407 /* bfd_check_format */ \
5408 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5409 _bfd_dummy_target }, \
5410 /* bfd_set_format */ \
5411 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5412 /* bfd_write_contents */ \
5413 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5416 BFD_JUMP_TABLE_GENERIC (coff), \
5417 BFD_JUMP_TABLE_COPY (coff), \
5418 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5419 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5420 BFD_JUMP_TABLE_SYMBOLS (coff), \
5421 BFD_JUMP_TABLE_RELOCS (coff), \
5422 BFD_JUMP_TABLE_WRITE (coff), \
5423 BFD_JUMP_TABLE_LINK (coff), \
5424 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5431 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
5432 const bfd_target VAR = \
5435 bfd_target_coff_flavour, \
5436 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
5437 BFD_ENDIAN_LITTLE, /* header byte order is little */ \
5438 /* object flags */ \
5439 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5440 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5441 /* section flags */ \
5442 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5443 UNDER, /* leading symbol underscore */ \
5444 '/', /* ar_pad_char */ \
5445 15, /* ar_max_namelen */ \
5447 /* Data conversion functions. */ \
5448 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5449 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5450 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5451 /* Header conversion functions. */ \
5452 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5453 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5454 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5455 /* bfd_check_format */ \
5456 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5457 _bfd_dummy_target }, \
5458 /* bfd_set_format */ \
5459 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5460 /* bfd_write_contents */ \
5461 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5464 BFD_JUMP_TABLE_GENERIC (coff), \
5465 BFD_JUMP_TABLE_COPY (coff), \
5466 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5467 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5468 BFD_JUMP_TABLE_SYMBOLS (coff), \
5469 BFD_JUMP_TABLE_RELOCS (coff), \
5470 BFD_JUMP_TABLE_WRITE (coff), \
5471 BFD_JUMP_TABLE_LINK (coff), \
5472 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \