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
*));
345 /* void warning(); */
347 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
348 the incoming SEC_* flags. The inverse of this function is
349 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
350 should probably mirror the changes in styp_to_sec_flags(). */
354 /* Macros for setting debugging flags. */
356 #define STYP_XCOFF_DEBUG STYP_DEBUG
358 #define STYP_XCOFF_DEBUG STYP_INFO
361 #ifdef COFF_ALIGN_IN_S_FLAGS
362 #define STYP_DEBUG_INFO STYP_DSECT
364 #define STYP_DEBUG_INFO STYP_INFO
368 sec_to_styp_flags (sec_name
, sec_flags
)
369 const char *sec_name
;
374 if (!strcmp (sec_name
, _TEXT
))
376 styp_flags
= STYP_TEXT
;
378 else if (!strcmp (sec_name
, _DATA
))
380 styp_flags
= STYP_DATA
;
382 else if (!strcmp (sec_name
, _BSS
))
384 styp_flags
= STYP_BSS
;
387 else if (!strcmp (sec_name
, _COMMENT
))
389 styp_flags
= STYP_INFO
;
390 #endif /* _COMMENT */
393 else if (!strcmp (sec_name
, _LIB
))
395 styp_flags
= STYP_LIB
;
399 else if (!strcmp (sec_name
, _LIT
))
401 styp_flags
= STYP_LIT
;
404 else if (!strncmp (sec_name
, ".debug", 6))
406 /* Handle the XCOFF debug section and DWARF2 debug sections. */
408 styp_flags
= STYP_XCOFF_DEBUG
;
410 styp_flags
= STYP_DEBUG_INFO
;
412 else if (!strncmp (sec_name
, ".stab", 5))
414 styp_flags
= STYP_DEBUG_INFO
;
416 #ifdef COFF_LONG_SECTION_NAMES
417 else if (!strncmp (sec_name
, ".gnu.linkonce.wi.", 17))
419 styp_flags
= STYP_DEBUG_INFO
;
423 else if (!strcmp (sec_name
, _PAD
))
425 styp_flags
= STYP_PAD
;
427 else if (!strcmp (sec_name
, _LOADER
))
429 styp_flags
= STYP_LOADER
;
431 else if (!strcmp (sec_name
, _EXCEPT
))
433 styp_flags
= STYP_EXCEPT
;
435 else if (!strcmp (sec_name
, _TYPCHK
))
437 styp_flags
= STYP_TYPCHK
;
440 /* Try and figure out what it should be */
441 else if (sec_flags
& SEC_CODE
)
443 styp_flags
= STYP_TEXT
;
445 else if (sec_flags
& SEC_DATA
)
447 styp_flags
= STYP_DATA
;
449 else if (sec_flags
& SEC_READONLY
)
451 #ifdef STYP_LIT /* 29k readonly text/data section */
452 styp_flags
= STYP_LIT
;
454 styp_flags
= STYP_TEXT
;
455 #endif /* STYP_LIT */
457 else if (sec_flags
& SEC_LOAD
)
459 styp_flags
= STYP_TEXT
;
461 else if (sec_flags
& SEC_ALLOC
)
463 styp_flags
= STYP_BSS
;
467 if (sec_flags
& SEC_CLINK
)
468 styp_flags
|= STYP_CLINK
;
472 if (sec_flags
& SEC_BLOCK
)
473 styp_flags
|= STYP_BLOCK
;
477 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
478 styp_flags
|= STYP_NOLOAD
;
484 #else /* COFF_WITH_PE */
486 /* The PE version; see above for the general comments. The non-PE
487 case seems to be more guessing, and breaks PE format; specifically,
488 .rdata is readonly, but it sure ain't text. Really, all this
489 should be set up properly in gas (or whatever assembler is in use),
490 and honor whatever objcopy/strip, etc. sent us as input. */
493 sec_to_styp_flags (sec_name
, sec_flags
)
494 const char *sec_name ATTRIBUTE_UNUSED
;
499 /* caution: there are at least three groups of symbols that have
500 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
501 SEC_* are the BFD internal flags, used for generic BFD
502 information. STYP_* are the COFF section flags which appear in
503 COFF files. IMAGE_SCN_* are the PE section flags which appear in
504 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
505 but there are more IMAGE_SCN_* flags. */
510 if ((sec_flags
& SEC_CODE
) != 0)
511 styp_flags
|= IMAGE_SCN_CNT_CODE
;
512 if ((sec_flags
& SEC_DATA
) != 0)
513 styp_flags
|= IMAGE_SCN_CNT_INITIALIZED_DATA
;
514 if ((sec_flags
& SEC_ALLOC
) != 0 && (sec_flags
& SEC_LOAD
) == 0)
515 styp_flags
|= IMAGE_SCN_CNT_UNINITIALIZED_DATA
; /* ==STYP_BSS */
517 /* skip constRUCTOR */
520 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
521 styp_flags
|= STYP_NOLOAD
;
523 if ((sec_flags
& SEC_IS_COMMON
) != 0)
524 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
525 if ((sec_flags
& SEC_DEBUGGING
) != 0)
526 styp_flags
|= IMAGE_SCN_MEM_DISCARDABLE
;
527 if ((sec_flags
& SEC_EXCLUDE
) != 0)
528 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
529 if ((sec_flags
& SEC_NEVER_LOAD
) != 0)
530 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
533 if (sec_flags
& SEC_LINK_ONCE
)
534 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
535 /* skip LINK_DUPLICATES */
536 /* skip LINKER_CREATED */
538 /* For now, the read/write bits are mapped onto SEC_READONLY, even
539 though the semantics don't quite match. The bits from the input
540 are retained in pei_section_data(abfd, section)->pe_flags */
542 styp_flags
|= IMAGE_SCN_MEM_READ
; /* always readable. */
543 if ((sec_flags
& SEC_READONLY
) == 0)
544 styp_flags
|= IMAGE_SCN_MEM_WRITE
; /* Invert READONLY for write */
545 if (sec_flags
& SEC_CODE
)
546 styp_flags
|= IMAGE_SCN_MEM_EXECUTE
; /* CODE->EXECUTE */
547 if (sec_flags
& SEC_SHARED
)
548 styp_flags
|= IMAGE_SCN_MEM_SHARED
; /* Shared remains meaningful */
553 #endif /* COFF_WITH_PE */
555 /* Return a word with SEC_* flags set to represent the incoming STYP_*
556 flags (from scnhdr.s_flags). The inverse of this function is
557 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
558 should probably mirror the changes in sec_to_styp_flags(). */
563 styp_to_sec_flags (abfd
, hdr
, name
, section
, flags_ptr
)
564 bfd
*abfd ATTRIBUTE_UNUSED
;
567 asection
*section ATTRIBUTE_UNUSED
;
570 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
571 long styp_flags
= internal_s
->s_flags
;
572 flagword sec_flags
= 0;
575 if (styp_flags
& STYP_BLOCK
)
576 sec_flags
|= SEC_BLOCK
;
580 if (styp_flags
& STYP_CLINK
)
581 sec_flags
|= SEC_CLINK
;
585 if (styp_flags
& STYP_NOLOAD
)
586 sec_flags
|= SEC_NEVER_LOAD
;
587 #endif /* STYP_NOLOAD */
589 /* For 386 COFF, at least, an unloadable text or data section is
590 actually a shared library section. */
591 if (styp_flags
& STYP_TEXT
)
593 if (sec_flags
& SEC_NEVER_LOAD
)
594 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
596 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
598 else if (styp_flags
& STYP_DATA
)
600 if (sec_flags
& SEC_NEVER_LOAD
)
601 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
603 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
605 else if (styp_flags
& STYP_BSS
)
607 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
608 if (sec_flags
& SEC_NEVER_LOAD
)
609 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
612 sec_flags
|= SEC_ALLOC
;
614 else if (styp_flags
& STYP_INFO
)
616 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
617 defined. coff_compute_section_file_positions uses
618 COFF_PAGE_SIZE to ensure that the low order bits of the
619 section VMA and the file offset match. If we don't know
620 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
621 and demand page loading of the file will fail. */
622 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
623 sec_flags
|= SEC_DEBUGGING
;
626 else if (styp_flags
& STYP_PAD
)
628 else if (strcmp (name
, _TEXT
) == 0)
630 if (sec_flags
& SEC_NEVER_LOAD
)
631 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
633 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
635 else if (strcmp (name
, _DATA
) == 0)
637 if (sec_flags
& SEC_NEVER_LOAD
)
638 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
640 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
642 else if (strcmp (name
, _BSS
) == 0)
644 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
645 if (sec_flags
& SEC_NEVER_LOAD
)
646 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
649 sec_flags
|= SEC_ALLOC
;
651 else if (strncmp (name
, ".debug", 6) == 0
653 || strcmp (name
, _COMMENT
) == 0
655 #ifdef COFF_LONG_SECTION_NAMES
656 || strncmp (name
, ".gnu.linkonce.wi.", 17) == 0
658 || strncmp (name
, ".stab", 5) == 0)
660 #ifdef COFF_PAGE_SIZE
661 sec_flags
|= SEC_DEBUGGING
;
665 else if (strcmp (name
, _LIB
) == 0)
669 else if (strcmp (name
, _LIT
) == 0)
670 sec_flags
= SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
673 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
675 #ifdef STYP_LIT /* A29k readonly text/data section type */
676 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
677 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
678 #endif /* STYP_LIT */
680 #ifdef STYP_OTHER_LOAD /* Other loaded sections */
681 if (styp_flags
& STYP_OTHER_LOAD
)
682 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
683 #endif /* STYP_SDATA */
685 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
686 /* As a GNU extension, if the name begins with .gnu.linkonce, we
687 only link a single copy of the section. This is used to support
688 g++. g++ will emit each template expansion in its own section.
689 The symbols will be defined as weak, so that multiple definitions
690 are permitted. The GNU linker extension is to actually discard
691 all but one of the sections. */
692 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
693 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
696 if (flags_ptr
== NULL
)
699 * flags_ptr
= sec_flags
;
703 #else /* COFF_WITH_PE */
706 handle_COMDAT (abfd
, sec_flags
, hdr
, name
, section
)
713 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
714 bfd_byte
*esymstart
, *esym
, *esymend
;
716 char *target_name
= NULL
;
718 sec_flags
|= SEC_LINK_ONCE
;
720 /* Unfortunately, the PE format stores essential information in
721 the symbol table, of all places. We need to extract that
722 information now, so that objdump and the linker will know how
723 to handle the section without worrying about the symbols. We
724 can't call slurp_symtab, because the linker doesn't want the
727 /* COMDAT sections are special. The first symbol is the section
728 symbol, which tells what kind of COMDAT section it is. The
729 second symbol is the "comdat symbol" - the one with the
730 unique name. GNU uses the section symbol for the unique
731 name; MS uses ".text" for every comdat section. Sigh. - DJ */
733 /* This is not mirrored in sec_to_styp_flags(), but there
734 doesn't seem to be a need to, either, and it would at best be
737 if (! _bfd_coff_get_external_symbols (abfd
))
740 esymstart
= esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
741 esymend
= esym
+ obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
743 while (esym
< esymend
)
745 struct internal_syment isym
;
746 char buf
[SYMNMLEN
+ 1];
749 bfd_coff_swap_sym_in (abfd
, (PTR
) esym
, (PTR
) &isym
);
751 if (sizeof (internal_s
->s_name
) > SYMNMLEN
)
753 /* This case implies that the matching
754 symbol name will be in the string table. */
758 if (isym
.n_scnum
== section
->target_index
)
760 /* According to the MSVC documentation, the first
761 TWO entries with the section # are both of
762 interest to us. The first one is the "section
763 symbol" (section name). The second is the comdat
764 symbol name. Here, we've found the first
765 qualifying entry; we distinguish it from the
766 second with a state flag.
768 In the case of gas-generated (at least until that
769 is fixed) .o files, it isn't necessarily the
770 second one. It may be some other later symbol.
772 Since gas also doesn't follow MS conventions and
773 emits the section similar to .text$<name>, where
774 <something> is the name we're looking for, we
775 distinguish the two as follows:
777 If the section name is simply a section name (no
778 $) we presume it's MS-generated, and look at
779 precisely the second symbol for the comdat name.
780 If the section name has a $, we assume it's
781 gas-generated, and look for <something> (whatever
782 follows the $) as the comdat symbol. */
784 /* All 3 branches use this */
785 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
, buf
);
794 /* The first time we've seen the symbol. */
795 union internal_auxent aux
;
799 /* If it isn't the stuff we're expecting, die;
800 The MS documentation is vague, but it
801 appears that the second entry serves BOTH
802 as the comdat symbol and the defining
803 symbol record (either C_STAT or C_EXT,
804 possibly with an aux entry with debug
805 information if it's a function.) It
806 appears the only way to find the second one
807 is to count. (On Intel, they appear to be
808 adjacent, but on Alpha, they have been
811 Here, we think we've found the first one,
812 but there's some checking we can do to be
815 if (! (isym
.n_sclass
== C_STAT
816 && isym
.n_type
== T_NULL
817 && isym
.n_value
== 0))
820 /* FIXME LATER: MSVC generates section names
821 like .text for comdats. Gas generates
822 names like .text$foo__Fv (in the case of a
823 function). See comment above for more. */
825 if (strcmp (name
, symname
) != 0)
828 /* This is the section symbol. */
829 bfd_coff_swap_aux_in (abfd
, (PTR
) (esym
+ bfd_coff_symesz (abfd
)),
830 isym
.n_type
, isym
.n_sclass
,
831 0, isym
.n_numaux
, (PTR
) &aux
);
833 target_name
= strchr (name
, '$');
834 if (target_name
!= NULL
)
842 /* FIXME: Microsoft uses NODUPLICATES and
843 ASSOCIATIVE, but gnu uses ANY and
844 SAME_SIZE. Unfortunately, gnu doesn't do
845 the comdat symbols right. So, until we can
846 fix it to do the right thing, we are
847 temporarily disabling comdats for the MS
848 types (they're used in DLLs and C++, but we
849 don't support *their* C++ libraries anyway
852 /* Cygwin does not follow the MS style, and
853 uses ANY and SAME_SIZE where NODUPLICATES
854 and ASSOCIATIVE should be used. For
855 Interix, we just do the right thing up
858 switch (aux
.x_scn
.x_comdat
)
860 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
861 #ifdef STRICT_PE_FORMAT
862 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
864 sec_flags
&= ~SEC_LINK_ONCE
;
868 case IMAGE_COMDAT_SELECT_ANY
:
869 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
872 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
873 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
876 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
877 /* Not yet fully implemented ??? */
878 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
881 /* debug$S gets this case; other
884 /* There may be no symbol... we'll search
885 the whole table... Is this the right
886 place to play this game? Or should we do
887 it when reading it in. */
888 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
889 #ifdef STRICT_PE_FORMAT
890 /* FIXME: This is not currently implemented. */
891 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
893 sec_flags
&= ~SEC_LINK_ONCE
;
897 default: /* 0 means "no symbol" */
898 /* debug$F gets this case; other
900 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
907 /* Gas mode: the first matching on partial name. */
909 #ifndef TARGET_UNDERSCORE
910 #define TARGET_UNDERSCORE 0
912 /* Is this the name we're looking for? */
913 if (strcmp (target_name
,
914 symname
+ (TARGET_UNDERSCORE
? 1 : 0)) != 0)
916 /* Not the name we're looking for */
917 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
922 /* MSVC mode: the lexically second symbol (or
923 drop through from the above). */
928 /* This must the second symbol with the
929 section #. It is the actual symbol name.
930 Intel puts the two adjacent, but Alpha (at
931 least) spreads them out. */
933 amt
= sizeof (struct bfd_comdat_info
);
934 section
->comdat
= bfd_alloc (abfd
, amt
);
935 if (section
->comdat
== NULL
)
938 section
->comdat
->symbol
=
939 (esym
- esymstart
) / bfd_coff_symesz (abfd
);
941 amt
= strlen (symname
) + 1;
942 newname
= bfd_alloc (abfd
, amt
);
946 strcpy (newname
, symname
);
947 section
->comdat
->name
= newname
;
954 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
962 /* The PE version; see above for the general comments.
964 Since to set the SEC_LINK_ONCE and associated flags, we have to
965 look at the symbol table anyway, we return the symbol table index
966 of the symbol being used as the COMDAT symbol. This is admittedly
967 ugly, but there's really nowhere else that we have access to the
968 required information. FIXME: Is the COMDAT symbol index used for
969 any purpose other than objdump? */
972 styp_to_sec_flags (abfd
, hdr
, name
, section
, flags_ptr
)
979 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
980 long styp_flags
= internal_s
->s_flags
;
982 boolean result
= true;
984 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
985 sec_flags
= SEC_READONLY
;
987 /* Process each flag bit in styp_flags in turn. */
990 long flag
= styp_flags
& - styp_flags
;
991 char * unhandled
= NULL
;
993 styp_flags
&= ~ flag
;
995 /* We infer from the distinct read/write/execute bits the settings
996 of some of the bfd flags; the actual values, should we need them,
997 are also in pei_section_data (abfd, section)->pe_flags. */
1002 unhandled
= "STYP_DSECT";
1005 unhandled
= "STYP_GROUP";
1008 unhandled
= "STYP_COPY";
1011 unhandled
= "STYP_OVER";
1013 #ifdef SEC_NEVER_LOAD
1015 sec_flags
|= SEC_NEVER_LOAD
;
1018 case IMAGE_SCN_MEM_READ
:
1019 /* Ignored, assume it always to be true. */
1021 case IMAGE_SCN_TYPE_NO_PAD
:
1024 case IMAGE_SCN_LNK_OTHER
:
1025 unhandled
= "IMAGE_SCN_LNK_OTHER";
1027 case IMAGE_SCN_MEM_NOT_CACHED
:
1028 unhandled
= "IMAGE_SCN_MEM_NOT_CACHED";
1030 case IMAGE_SCN_MEM_NOT_PAGED
:
1031 unhandled
= "IMAGE_SCN_MEM_NOT_PAGED";
1033 case IMAGE_SCN_MEM_EXECUTE
:
1034 sec_flags
|= SEC_CODE
;
1036 case IMAGE_SCN_MEM_WRITE
:
1037 sec_flags
&= ~ SEC_READONLY
;
1039 case IMAGE_SCN_MEM_DISCARDABLE
:
1040 sec_flags
|= SEC_DEBUGGING
;
1042 case IMAGE_SCN_MEM_SHARED
:
1043 sec_flags
|= SEC_SHARED
;
1045 case IMAGE_SCN_LNK_REMOVE
:
1046 sec_flags
|= SEC_EXCLUDE
;
1048 case IMAGE_SCN_CNT_CODE
:
1049 sec_flags
|= SEC_CODE
| SEC_ALLOC
| SEC_LOAD
;
1051 case IMAGE_SCN_CNT_INITIALIZED_DATA
:
1052 sec_flags
|= SEC_DATA
| SEC_ALLOC
| SEC_LOAD
;
1054 case IMAGE_SCN_CNT_UNINITIALIZED_DATA
:
1055 sec_flags
|= SEC_ALLOC
;
1057 case IMAGE_SCN_LNK_INFO
:
1058 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1059 defined. coff_compute_section_file_positions uses
1060 COFF_PAGE_SIZE to ensure that the low order bits of the
1061 section VMA and the file offset match. If we don't know
1062 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1063 and demand page loading of the file will fail. */
1064 #ifdef COFF_PAGE_SIZE
1065 sec_flags
|= SEC_DEBUGGING
;
1068 case IMAGE_SCN_LNK_COMDAT
:
1069 /* COMDAT gets very special treatment. */
1070 sec_flags
= handle_COMDAT (abfd
, sec_flags
, hdr
, name
, section
);
1073 /* Silently ignore for now. */
1077 /* If the section flag was not handled, report it here. */
1078 if (unhandled
!= NULL
)
1080 (*_bfd_error_handler
)
1081 (_("%s (%s): Section flag %s (0x%x) ignored"),
1082 bfd_archive_filename (abfd
), name
, unhandled
, flag
);
1087 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1088 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1089 only link a single copy of the section. This is used to support
1090 g++. g++ will emit each template expansion in its own section.
1091 The symbols will be defined as weak, so that multiple definitions
1092 are permitted. The GNU linker extension is to actually discard
1093 all but one of the sections. */
1094 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
1095 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1099 * flags_ptr
= sec_flags
;
1104 #endif /* COFF_WITH_PE */
1106 #define get_index(symbol) ((symbol)->udata.i)
1110 bfd_coff_backend_data
1114 .{* COFF symbol classifications. *}
1116 .enum coff_symbol_classification
1118 . {* Global symbol. *}
1119 . COFF_SYMBOL_GLOBAL,
1120 . {* Common symbol. *}
1121 . COFF_SYMBOL_COMMON,
1122 . {* Undefined symbol. *}
1123 . COFF_SYMBOL_UNDEFINED,
1124 . {* Local symbol. *}
1125 . COFF_SYMBOL_LOCAL,
1126 . {* PE section symbol. *}
1127 . COFF_SYMBOL_PE_SECTION
1130 Special entry points for gdb to swap in coff symbol table parts:
1133 . void (*_bfd_coff_swap_aux_in)
1134 . PARAMS ((bfd *, PTR, int, int, int, int, PTR));
1136 . void (*_bfd_coff_swap_sym_in)
1137 . PARAMS ((bfd *, PTR, PTR));
1139 . void (*_bfd_coff_swap_lineno_in)
1140 . PARAMS ((bfd *, PTR, PTR));
1142 . unsigned int (*_bfd_coff_swap_aux_out)
1143 . PARAMS ((bfd *, PTR, int, int, int, int, PTR));
1145 . unsigned int (*_bfd_coff_swap_sym_out)
1146 . PARAMS ((bfd *, PTR, PTR));
1148 . unsigned int (*_bfd_coff_swap_lineno_out)
1149 . PARAMS ((bfd *, PTR, PTR));
1151 . unsigned int (*_bfd_coff_swap_reloc_out)
1152 . PARAMS ((bfd *, PTR, PTR));
1154 . unsigned int (*_bfd_coff_swap_filehdr_out)
1155 . PARAMS ((bfd *, PTR, PTR));
1157 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1158 . PARAMS ((bfd *, PTR, PTR));
1160 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1161 . PARAMS ((bfd *, PTR, PTR));
1163 . unsigned int _bfd_filhsz;
1164 . unsigned int _bfd_aoutsz;
1165 . unsigned int _bfd_scnhsz;
1166 . unsigned int _bfd_symesz;
1167 . unsigned int _bfd_auxesz;
1168 . unsigned int _bfd_relsz;
1169 . unsigned int _bfd_linesz;
1170 . unsigned int _bfd_filnmlen;
1171 . boolean _bfd_coff_long_filenames;
1172 . boolean _bfd_coff_long_section_names;
1173 . unsigned int _bfd_coff_default_section_alignment_power;
1174 . boolean _bfd_coff_force_symnames_in_strings;
1175 . unsigned int _bfd_coff_debug_string_prefix_length;
1177 . void (*_bfd_coff_swap_filehdr_in)
1178 . PARAMS ((bfd *, PTR, PTR));
1180 . void (*_bfd_coff_swap_aouthdr_in)
1181 . PARAMS ((bfd *, PTR, PTR));
1183 . void (*_bfd_coff_swap_scnhdr_in)
1184 . PARAMS ((bfd *, PTR, PTR));
1186 . void (*_bfd_coff_swap_reloc_in)
1187 . PARAMS ((bfd *abfd, PTR, PTR));
1189 . boolean (*_bfd_coff_bad_format_hook)
1190 . PARAMS ((bfd *, PTR));
1192 . boolean (*_bfd_coff_set_arch_mach_hook)
1193 . PARAMS ((bfd *, PTR));
1195 . PTR (*_bfd_coff_mkobject_hook)
1196 . PARAMS ((bfd *, PTR, PTR));
1198 . boolean (*_bfd_styp_to_sec_flags_hook)
1199 . PARAMS ((bfd *, PTR, const char *, asection *, flagword *));
1201 . void (*_bfd_set_alignment_hook)
1202 . PARAMS ((bfd *, asection *, PTR));
1204 . boolean (*_bfd_coff_slurp_symbol_table)
1207 . boolean (*_bfd_coff_symname_in_debug)
1208 . PARAMS ((bfd *, struct internal_syment *));
1210 . boolean (*_bfd_coff_pointerize_aux_hook)
1211 . PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
1212 . unsigned int, combined_entry_type *));
1214 . boolean (*_bfd_coff_print_aux)
1215 . PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1216 . combined_entry_type *, unsigned int));
1218 . void (*_bfd_coff_reloc16_extra_cases)
1219 . PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1220 . bfd_byte *, unsigned int *, unsigned int *));
1222 . int (*_bfd_coff_reloc16_estimate)
1223 . PARAMS ((bfd *, asection *, arelent *, unsigned int,
1224 . struct bfd_link_info *));
1226 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1227 . PARAMS ((bfd *, struct internal_syment *));
1229 . boolean (*_bfd_coff_compute_section_file_positions)
1232 . boolean (*_bfd_coff_start_final_link)
1233 . PARAMS ((bfd *, struct bfd_link_info *));
1235 . boolean (*_bfd_coff_relocate_section)
1236 . PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1237 . struct internal_reloc *, struct internal_syment *, asection **));
1239 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1240 . PARAMS ((bfd *, asection *, struct internal_reloc *,
1241 . struct coff_link_hash_entry *, struct internal_syment *,
1244 . boolean (*_bfd_coff_adjust_symndx)\
1245 . PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
1246 . struct internal_reloc *, boolean *));
1248 . boolean (*_bfd_coff_link_add_one_symbol)
1249 . PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword,
1250 . asection *, bfd_vma, const char *, boolean, boolean,
1251 . struct bfd_link_hash_entry **));
1253 . boolean (*_bfd_coff_link_output_has_begun)
1254 . PARAMS ((bfd *, struct coff_final_link_info *));
1256 . boolean (*_bfd_coff_final_link_postscript)
1257 . PARAMS ((bfd *, struct coff_final_link_info *));
1259 .} bfd_coff_backend_data;
1261 .#define coff_backend_info(abfd) \
1262 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1264 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1265 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1267 .#define bfd_coff_swap_sym_in(a,e,i) \
1268 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1270 .#define bfd_coff_swap_lineno_in(a,e,i) \
1271 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1273 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1274 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1276 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1277 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1279 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1280 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1282 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1283 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1285 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1286 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1288 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1289 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1291 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1292 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1294 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1295 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1296 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1297 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1298 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1299 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1300 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1301 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1302 .#define bfd_coff_long_filenames(abfd) \
1303 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1304 .#define bfd_coff_long_section_names(abfd) \
1305 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1306 .#define bfd_coff_default_section_alignment_power(abfd) \
1307 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1308 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1309 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1311 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1312 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1314 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1315 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1317 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1318 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1320 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1321 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1323 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1324 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1325 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1326 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
1328 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1329 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1330 . (abfd, scnhdr, name, section, flags_ptr))
1332 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1333 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1335 .#define bfd_coff_slurp_symbol_table(abfd)\
1336 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1338 .#define bfd_coff_symname_in_debug(abfd, sym)\
1339 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1341 .#define bfd_coff_force_symnames_in_strings(abfd)\
1342 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1344 .#define bfd_coff_debug_string_prefix_length(abfd)\
1345 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1347 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1348 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1349 . (abfd, file, base, symbol, aux, indaux))
1351 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
1352 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1353 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1355 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1356 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1357 . (abfd, section, reloc, shrink, link_info))
1359 .#define bfd_coff_classify_symbol(abfd, sym)\
1360 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1363 .#define bfd_coff_compute_section_file_positions(abfd)\
1364 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1367 .#define bfd_coff_start_final_link(obfd, info)\
1368 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1370 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1371 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1372 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1373 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1374 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1375 . (abfd, sec, rel, h, sym, addendp))
1376 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1377 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1378 . (obfd, info, ibfd, sec, rel, adjustedp))
1379 .#define bfd_coff_link_add_one_symbol(info,abfd,name,flags,section,value,string,cp,coll,hashp)\
1380 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1381 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1383 .#define bfd_coff_link_output_has_begun(a,p) \
1384 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p))
1385 .#define bfd_coff_final_link_postscript(a,p) \
1386 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
1390 /* See whether the magic number matches. */
1393 coff_bad_format_hook (abfd
, filehdr
)
1394 bfd
* abfd ATTRIBUTE_UNUSED
;
1397 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1399 if (BADMAG (*internal_f
))
1402 /* if the optional header is NULL or not the correct size then
1403 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1404 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1405 optional header is of a different size.
1407 But the mips keeps extra stuff in it's opthdr, so dont check
1411 #if defined(M88) || defined(I960)
1412 if (internal_f
->f_opthdr
!= 0 && bfd_coff_aoutsz (abfd
) != internal_f
->f_opthdr
)
1419 /* Check whether this section uses an alignment other than the
1423 coff_set_custom_section_alignment (abfd
, section
, alignment_table
, table_size
)
1424 bfd
*abfd ATTRIBUTE_UNUSED
;
1426 const struct coff_section_alignment_entry
*alignment_table
;
1427 const unsigned int table_size
;
1429 const unsigned int default_alignment
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1432 for (i
= 0; i
< table_size
; ++i
)
1434 const char *secname
= bfd_get_section_name (abfd
, section
);
1435 if (alignment_table
[i
].comparison_length
== (unsigned int) -1
1436 ? strcmp (alignment_table
[i
].name
, secname
) == 0
1437 : strncmp (alignment_table
[i
].name
, secname
,
1438 alignment_table
[i
].comparison_length
) == 0)
1441 if (i
>= table_size
)
1444 if (alignment_table
[i
].default_alignment_min
!= COFF_ALIGNMENT_FIELD_EMPTY
1445 && default_alignment
< alignment_table
[i
].default_alignment_min
)
1448 if (alignment_table
[i
].default_alignment_max
!= COFF_ALIGNMENT_FIELD_EMPTY
1449 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1450 && default_alignment
> alignment_table
[i
].default_alignment_max
1455 section
->alignment_power
= alignment_table
[i
].alignment_power
;
1458 /* Custom section alignment records. */
1460 static const struct coff_section_alignment_entry
1461 coff_section_alignment_table
[] =
1463 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1464 COFF_SECTION_ALIGNMENT_ENTRIES
,
1466 /* There must not be any gaps between .stabstr sections. */
1467 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1468 1, COFF_ALIGNMENT_FIELD_EMPTY
, 0 },
1469 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1470 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1471 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1472 /* Similarly for the .ctors and .dtors sections. */
1473 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1474 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1475 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1476 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 }
1479 static const unsigned int coff_section_alignment_table_size
=
1480 sizeof coff_section_alignment_table
/ sizeof coff_section_alignment_table
[0];
1482 /* Initialize a section structure with information peculiar to this
1483 particular implementation of COFF. */
1486 coff_new_section_hook (abfd
, section
)
1490 combined_entry_type
*native
;
1493 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1496 if (xcoff_data (abfd
)->text_align_power
!= 0
1497 && strcmp (bfd_get_section_name (abfd
, section
), ".text") == 0)
1498 section
->alignment_power
= xcoff_data (abfd
)->text_align_power
;
1499 if (xcoff_data (abfd
)->data_align_power
!= 0
1500 && strcmp (bfd_get_section_name (abfd
, section
), ".data") == 0)
1501 section
->alignment_power
= xcoff_data (abfd
)->data_align_power
;
1504 /* Allocate aux records for section symbols, to store size and
1507 @@ The 10 is a guess at a plausible maximum number of aux entries
1508 (but shouldn't be a constant). */
1509 amt
= sizeof (combined_entry_type
) * 10;
1510 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
1514 /* We don't need to set up n_name, n_value, or n_scnum in the native
1515 symbol information, since they'll be overriden by the BFD symbol
1516 anyhow. However, we do need to set the type and storage class,
1517 in case this symbol winds up getting written out. The value 0
1518 for n_numaux is already correct. */
1520 native
->u
.syment
.n_type
= T_NULL
;
1521 native
->u
.syment
.n_sclass
= C_STAT
;
1523 coffsymbol (section
->symbol
)->native
= native
;
1525 coff_set_custom_section_alignment (abfd
, section
,
1526 coff_section_alignment_table
,
1527 coff_section_alignment_table_size
);
1532 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1534 /* Set the alignment of a BFD section. */
1536 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1539 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1540 bfd
* abfd ATTRIBUTE_UNUSED
;
1544 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1548 /* Extract ALIGN from 2**ALIGN stored in section header */
1549 for (i
= 0; i
< 32; i
++)
1550 if ((1 << i
) >= hdr
->s_align
)
1554 /* TI tools puts the alignment power in bits 8-11 */
1555 i
= (hdr
->s_flags
>> 8) & 0xF ;
1557 #ifdef COFF_DECODE_ALIGNMENT
1558 i
= COFF_DECODE_ALIGNMENT(hdr
->s_flags
);
1560 section
->alignment_power
= i
;
1562 #ifdef coff_set_section_load_page
1563 coff_set_section_load_page (section
, hdr
->s_page
);
1567 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1570 /* a couple of macros to help setting the alignment power field */
1571 #define ALIGN_SET(field,x,y) \
1572 if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1574 section->alignment_power = y;\
1577 #define ELIFALIGN_SET(field,x,y) \
1578 else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1580 section->alignment_power = y;\
1583 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1586 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1587 bfd
* abfd ATTRIBUTE_UNUSED
;
1591 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1594 ALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_64BYTES
, 6)
1595 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_32BYTES
, 5)
1596 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_16BYTES
, 4)
1597 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_8BYTES
, 3)
1598 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_4BYTES
, 2)
1599 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_2BYTES
, 1)
1600 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_1BYTES
, 0)
1602 /* In a PE image file, the s_paddr field holds the virtual size of a
1603 section, while the s_size field holds the raw size. We also keep
1604 the original section flag value, since not every bit can be
1605 mapped onto a generic BFD section bit. */
1606 if (coff_section_data (abfd
, section
) == NULL
)
1608 amt
= sizeof (struct coff_section_tdata
);
1609 section
->used_by_bfd
= (PTR
) bfd_zalloc (abfd
, amt
);
1610 if (section
->used_by_bfd
== NULL
)
1612 /* FIXME: Return error. */
1616 if (pei_section_data (abfd
, section
) == NULL
)
1618 amt
= sizeof (struct pei_section_tdata
);
1619 coff_section_data (abfd
, section
)->tdata
= (PTR
) bfd_zalloc (abfd
, amt
);
1620 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1622 /* FIXME: Return error. */
1626 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1627 pei_section_data (abfd
, section
)->pe_flags
= hdr
->s_flags
;
1629 section
->lma
= hdr
->s_vaddr
;
1631 /* check for extended relocs */
1632 if (hdr
->s_flags
& IMAGE_SCN_LNK_NRELOC_OVFL
)
1634 struct external_reloc dst
;
1635 struct internal_reloc n
;
1636 file_ptr oldpos
= bfd_tell (abfd
);
1637 bfd_seek (abfd
, (file_ptr
) hdr
->s_relptr
, 0);
1638 if (bfd_bread ((PTR
) &dst
, (bfd_size_type
) bfd_coff_relsz (abfd
), abfd
)
1639 != bfd_coff_relsz (abfd
))
1642 coff_swap_reloc_in (abfd
, &dst
, &n
);
1643 bfd_seek (abfd
, oldpos
, 0);
1644 section
->reloc_count
= hdr
->s_nreloc
= n
.r_vaddr
;
1648 #undef ELIFALIGN_SET
1650 #else /* ! COFF_WITH_PE */
1653 /* We grossly abuse this function to handle XCOFF overflow headers.
1654 When we see one, we correct the reloc and line number counts in the
1655 real header, and remove the section we just created. */
1657 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1660 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1665 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1669 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1672 real_sec
= coff_section_from_bfd_index (abfd
, (int) hdr
->s_nreloc
);
1673 if (real_sec
== NULL
)
1676 real_sec
->reloc_count
= hdr
->s_paddr
;
1677 real_sec
->lineno_count
= hdr
->s_vaddr
;
1679 for (ps
= &abfd
->sections
; *ps
!= NULL
; ps
= &(*ps
)->next
)
1683 bfd_section_list_remove (abfd
, ps
);
1684 --abfd
->section_count
;
1690 #else /* ! RS6000COFF_C */
1692 #define coff_set_alignment_hook \
1693 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1695 #endif /* ! RS6000COFF_C */
1696 #endif /* ! COFF_WITH_PE */
1697 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1699 #ifndef coff_mkobject
1701 static boolean coff_mkobject
PARAMS ((bfd
*));
1704 coff_mkobject (abfd
)
1707 coff_data_type
*coff
;
1708 bfd_size_type amt
= sizeof (coff_data_type
);
1710 abfd
->tdata
.coff_obj_data
= (struct coff_tdata
*) bfd_zalloc (abfd
, amt
);
1711 if (abfd
->tdata
.coff_obj_data
== 0)
1713 coff
= coff_data (abfd
);
1714 coff
->symbols
= (coff_symbol_type
*) NULL
;
1715 coff
->conversion_table
= (unsigned int *) NULL
;
1716 coff
->raw_syments
= (struct coff_ptr_struct
*) NULL
;
1717 coff
->relocbase
= 0;
1718 coff
->local_toc_sym_map
= 0;
1720 /* make_abs_section(abfd);*/
1726 /* Create the COFF backend specific information. */
1727 #ifndef coff_mkobject_hook
1729 coff_mkobject_hook (abfd
, filehdr
, aouthdr
)
1732 PTR aouthdr ATTRIBUTE_UNUSED
;
1734 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1735 coff_data_type
*coff
;
1737 if (coff_mkobject (abfd
) == false)
1740 coff
= coff_data (abfd
);
1742 coff
->sym_filepos
= internal_f
->f_symptr
;
1744 /* These members communicate important constants about the symbol
1745 table to GDB's symbol-reading code. These `constants'
1746 unfortunately vary among coff implementations... */
1747 coff
->local_n_btmask
= N_BTMASK
;
1748 coff
->local_n_btshft
= N_BTSHFT
;
1749 coff
->local_n_tmask
= N_TMASK
;
1750 coff
->local_n_tshift
= N_TSHIFT
;
1751 coff
->local_symesz
= bfd_coff_symesz (abfd
);
1752 coff
->local_auxesz
= bfd_coff_auxesz (abfd
);
1753 coff
->local_linesz
= bfd_coff_linesz (abfd
);
1755 coff
->timestamp
= internal_f
->f_timdat
;
1757 obj_raw_syment_count (abfd
) =
1758 obj_conv_table_size (abfd
) =
1759 internal_f
->f_nsyms
;
1762 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
1763 abfd
->flags
|= DYNAMIC
;
1764 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= bfd_coff_aoutsz (abfd
))
1766 struct internal_aouthdr
*internal_a
=
1767 (struct internal_aouthdr
*) aouthdr
;
1768 struct xcoff_tdata
*xcoff
;
1770 xcoff
= xcoff_data (abfd
);
1771 # ifdef U803XTOCMAGIC
1772 xcoff
->xcoff64
= internal_f
->f_magic
== U803XTOCMAGIC
;
1776 xcoff
->full_aouthdr
= true;
1777 xcoff
->toc
= internal_a
->o_toc
;
1778 xcoff
->sntoc
= internal_a
->o_sntoc
;
1779 xcoff
->snentry
= internal_a
->o_snentry
;
1780 xcoff
->text_align_power
= internal_a
->o_algntext
;
1781 xcoff
->data_align_power
= internal_a
->o_algndata
;
1782 xcoff
->modtype
= internal_a
->o_modtype
;
1783 xcoff
->cputype
= internal_a
->o_cputype
;
1784 xcoff
->maxdata
= internal_a
->o_maxdata
;
1785 xcoff
->maxstack
= internal_a
->o_maxstack
;
1790 /* Set the flags field from the COFF header read in. */
1791 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
1796 /* FIXME: I'm not sure this is ever executed, since peicode.h
1797 defines coff_mkobject_hook. */
1798 if ((internal_f
->f_flags
& IMAGE_FILE_DEBUG_STRIPPED
) == 0)
1799 abfd
->flags
|= HAS_DEBUG
;
1806 /* Determine the machine architecture and type. FIXME: This is target
1807 dependent because the magic numbers are defined in the target
1808 dependent header files. But there is no particular need for this.
1809 If the magic numbers were moved to a separate file, this function
1810 would be target independent and would also be much more successful
1811 at linking together COFF files for different architectures. */
1814 coff_set_arch_mach_hook (abfd
, filehdr
)
1818 unsigned long machine
;
1819 enum bfd_architecture arch
;
1820 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1823 switch (internal_f
->f_magic
)
1825 #ifdef OR32_MAGIC_BIG
1826 case OR32_MAGIC_BIG
:
1827 case OR32_MAGIC_LITTLE
:
1828 arch
= bfd_arch_or32
;
1834 arch
= bfd_arch_powerpc
;
1835 machine
= 0; /* what does this mean? (krk) */
1841 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler */
1842 case LYNXCOFFMAGIC
: /* shadows the m68k Lynx number below, sigh */
1843 arch
= bfd_arch_i386
;
1849 arch
= bfd_arch_ia64
;
1853 #ifdef A29K_MAGIC_BIG
1854 case A29K_MAGIC_BIG
:
1855 case A29K_MAGIC_LITTLE
:
1856 arch
= bfd_arch_a29k
;
1864 arch
= bfd_arch_arm
;
1865 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
1867 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
1868 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
1869 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
1871 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
1872 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
1873 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
1874 /* The COFF header does not have enough bits available
1875 to cover all the different ARM architectures. So
1876 we interpret F_ARM_5, the highest flag value to mean
1877 "the highest ARM architecture known to BFD" which is
1878 currently the XScale. */
1879 case F_ARM_5
: machine
= bfd_mach_arm_XScale
; break;
1886 #ifdef MC68KBCSMAGIC
1889 #ifdef APOLLOM68KMAGIC
1890 case APOLLOM68KMAGIC
:
1892 #ifdef LYNXCOFFMAGIC
1895 arch
= bfd_arch_m68k
;
1896 machine
= bfd_mach_m68020
;
1903 arch
= bfd_arch_m88k
;
1909 arch
= bfd_arch_z8k
;
1910 switch (internal_f
->f_flags
& F_MACHMASK
)
1913 machine
= bfd_mach_z8001
;
1916 machine
= bfd_mach_z8002
;
1925 arch
= bfd_arch_i860
;
1932 arch
= bfd_arch_i960
;
1933 switch (F_I960TYPE
& internal_f
->f_flags
)
1937 machine
= bfd_mach_i960_core
;
1940 machine
= bfd_mach_i960_kb_sb
;
1943 machine
= bfd_mach_i960_mc
;
1946 machine
= bfd_mach_i960_xa
;
1949 machine
= bfd_mach_i960_ca
;
1952 machine
= bfd_mach_i960_ka_sa
;
1955 machine
= bfd_mach_i960_jx
;
1958 machine
= bfd_mach_i960_hx
;
1976 if (xcoff_data (abfd
)->cputype
!= -1)
1977 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
1980 /* We did not get a value from the a.out header. If the
1981 file has not been stripped, we may be able to get the
1982 architecture information from the first symbol, if it
1983 is a .file symbol. */
1984 if (obj_raw_syment_count (abfd
) == 0)
1989 struct internal_syment sym
;
1990 bfd_size_type amt
= bfd_coff_symesz (abfd
);
1992 buf
= (bfd_byte
*) bfd_malloc (amt
);
1993 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1994 || bfd_bread (buf
, amt
, abfd
) != amt
)
1999 bfd_coff_swap_sym_in (abfd
, (PTR
) buf
, (PTR
) &sym
);
2000 if (sym
.n_sclass
== C_FILE
)
2001 cputype
= sym
.n_type
& 0xff;
2008 /* FIXME: We don't handle all cases here. */
2013 arch
= bfd_xcoff_architecture (abfd
);
2014 machine
= bfd_xcoff_machine (abfd
);
2018 arch
= bfd_arch_powerpc
;
2019 machine
= bfd_mach_ppc_601
;
2021 case 2: /* 64 bit PowerPC */
2022 arch
= bfd_arch_powerpc
;
2023 machine
= bfd_mach_ppc_620
;
2026 arch
= bfd_arch_powerpc
;
2027 machine
= bfd_mach_ppc
;
2030 arch
= bfd_arch_rs6000
;
2031 machine
= bfd_mach_rs6k
;
2040 arch
= bfd_arch_we32k
;
2047 arch
= bfd_arch_h8300
;
2048 machine
= bfd_mach_h8300
;
2049 /* !! FIXME this probably isn't the right place for this */
2050 abfd
->flags
|= BFD_IS_RELAXABLE
;
2056 arch
= bfd_arch_h8300
;
2057 machine
= bfd_mach_h8300h
;
2058 /* !! FIXME this probably isn't the right place for this */
2059 abfd
->flags
|= BFD_IS_RELAXABLE
;
2065 arch
= bfd_arch_h8300
;
2066 machine
= bfd_mach_h8300s
;
2067 /* !! FIXME this probably isn't the right place for this */
2068 abfd
->flags
|= BFD_IS_RELAXABLE
;
2072 #ifdef SH_ARCH_MAGIC_BIG
2073 case SH_ARCH_MAGIC_BIG
:
2074 case SH_ARCH_MAGIC_LITTLE
:
2076 case SH_ARCH_MAGIC_WINCE
:
2083 #ifdef MIPS_ARCH_MAGIC_WINCE
2084 case MIPS_ARCH_MAGIC_WINCE
:
2085 arch
= bfd_arch_mips
;
2092 arch
= bfd_arch_h8500
;
2099 #ifdef LYNXCOFFMAGIC
2102 arch
= bfd_arch_sparc
;
2109 arch
= bfd_arch_tic30
;
2114 #ifdef TICOFF_TARGET_ARCH
2115 /* this TI COFF section should be used by all new TI COFF v0 targets */
2117 arch
= TICOFF_TARGET_ARCH
;
2123 /* this TI COFF section should be used by all new TI COFF v1/2 targets */
2124 /* TI COFF1 and COFF2 use the target_id field to specify which arch */
2127 switch (internal_f
->f_target_id
)
2131 arch
= TICOFF_TARGET_ARCH
;
2135 arch
= bfd_arch_obscure
;
2136 (*_bfd_error_handler
)
2137 (_("Unrecognized TI COFF target id '0x%x'"),
2138 internal_f
->f_target_id
);
2144 #ifdef TIC80_ARCH_MAGIC
2145 case TIC80_ARCH_MAGIC
:
2146 arch
= bfd_arch_tic80
;
2152 arch
= bfd_arch_mcore
;
2155 default: /* Unreadable input file type */
2156 arch
= bfd_arch_obscure
;
2160 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2164 #ifdef SYMNAME_IN_DEBUG
2166 static boolean symname_in_debug_hook
2167 PARAMS ((bfd
*, struct internal_syment
*));
2170 symname_in_debug_hook (abfd
, sym
)
2171 bfd
* abfd ATTRIBUTE_UNUSED
;
2172 struct internal_syment
*sym
;
2174 return SYMNAME_IN_DEBUG (sym
) ? true : false;
2179 #define symname_in_debug_hook \
2180 (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
2187 #define FORCE_SYMNAMES_IN_STRINGS
2190 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
2192 static boolean coff_pointerize_aux_hook
2193 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
2194 unsigned int, combined_entry_type
*));
2198 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
2199 bfd
*abfd ATTRIBUTE_UNUSED
;
2200 combined_entry_type
*table_base
;
2201 combined_entry_type
*symbol
;
2202 unsigned int indaux
;
2203 combined_entry_type
*aux
;
2205 int class = symbol
->u
.syment
.n_sclass
;
2207 if ((class == C_EXT
|| class == C_HIDEXT
)
2208 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2210 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2212 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2213 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2214 aux
->fix_scnlen
= 1;
2217 /* Return true to indicate that the caller should not do any
2218 further work on this auxent. */
2222 /* Return false to indicate that this auxent should be handled by
2230 /* We don't want to pointerize bal entries. */
2232 static boolean coff_pointerize_aux_hook
2233 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
2234 unsigned int, combined_entry_type
*));
2238 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
2239 bfd
*abfd ATTRIBUTE_UNUSED
;
2240 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
2241 combined_entry_type
*symbol
;
2242 unsigned int indaux
;
2243 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
2245 /* Return true if we don't want to pointerize this aux entry, which
2246 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2248 && (symbol
->u
.syment
.n_sclass
== C_LEAFPROC
2249 || symbol
->u
.syment
.n_sclass
== C_LEAFSTAT
2250 || symbol
->u
.syment
.n_sclass
== C_LEAFEXT
));
2255 #define coff_pointerize_aux_hook 0
2258 #endif /* ! RS6000COFF_C */
2260 /* Print an aux entry. This returns true if it has printed it. */
2262 static boolean coff_print_aux
2263 PARAMS ((bfd
*, FILE *, combined_entry_type
*, combined_entry_type
*,
2264 combined_entry_type
*, unsigned int));
2267 coff_print_aux (abfd
, file
, table_base
, symbol
, aux
, indaux
)
2268 bfd
*abfd ATTRIBUTE_UNUSED
;
2269 FILE *file ATTRIBUTE_UNUSED
;
2270 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
2271 combined_entry_type
*symbol ATTRIBUTE_UNUSED
;
2272 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
2273 unsigned int indaux ATTRIBUTE_UNUSED
;
2276 if ((symbol
->u
.syment
.n_sclass
== C_EXT
2277 || symbol
->u
.syment
.n_sclass
== C_HIDEXT
)
2278 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2280 /* This is a csect entry. */
2281 fprintf (file
, "AUX ");
2282 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2284 BFD_ASSERT (! aux
->fix_scnlen
);
2286 fprintf (file
, "val %5lld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2288 fprintf (file
, "val %5ld", (long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2293 fprintf (file
, "indx ");
2294 if (! aux
->fix_scnlen
)
2296 fprintf (file
, "%4lld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2298 fprintf (file
, "%4ld", (long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2301 fprintf (file
, "%4ld",
2302 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2305 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2306 aux
->u
.auxent
.x_csect
.x_parmhash
,
2307 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2308 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2309 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2310 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2311 aux
->u
.auxent
.x_csect
.x_stab
,
2312 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2317 /* Return false to indicate that no special action was taken. */
2325 To write relocations, the back end steps though the
2326 canonical relocation table and create an
2327 @code{internal_reloc}. The symbol index to use is removed from
2328 the @code{offset} field in the symbol table supplied. The
2329 address comes directly from the sum of the section base
2330 address and the relocation offset; the type is dug directly
2331 from the howto field. Then the @code{internal_reloc} is
2332 swapped into the shape of an @code{external_reloc} and written
2339 static int compare_arelent_ptr
PARAMS ((const PTR
, const PTR
));
2341 /* AUX's ld wants relocations to be sorted */
2343 compare_arelent_ptr (x
, y
)
2347 const arelent
**a
= (const arelent
**) x
;
2348 const arelent
**b
= (const arelent
**) y
;
2349 bfd_size_type aadr
= (*a
)->address
;
2350 bfd_size_type badr
= (*b
)->address
;
2352 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2355 #endif /* TARG_AUX */
2358 coff_write_relocs (abfd
, first_undef
)
2364 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
2367 struct external_reloc dst
;
2374 /* sort relocations before we write them out */
2377 amt
= s
->reloc_count
;
2378 amt
*= sizeof (arelent
*);
2379 p
= (arelent
**) bfd_malloc (amt
);
2380 if (p
== NULL
&& s
->reloc_count
> 0)
2382 memcpy (p
, s
->orelocation
, (size_t) amt
);
2383 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2387 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2391 if (s
->reloc_count
> 0xffff)
2393 /* encode real count here as first reloc */
2394 struct internal_reloc n
;
2395 memset ((PTR
) & n
, 0, sizeof (n
));
2396 /* add one to count *this* reloc (grr) */
2397 n
.r_vaddr
= s
->reloc_count
+ 1;
2398 coff_swap_reloc_out (abfd
, &n
, &dst
);
2399 if (bfd_bwrite ((PTR
) & dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2400 abfd
) != bfd_coff_relsz (abfd
))
2405 for (i
= 0; i
< s
->reloc_count
; i
++)
2407 struct internal_reloc n
;
2409 memset ((PTR
) & n
, 0, sizeof (n
));
2411 /* Now we've renumbered the symbols we know where the
2412 undefined symbols live in the table. Check the reloc
2413 entries for symbols who's output bfd isn't the right one.
2414 This is because the symbol was undefined (which means
2415 that all the pointers are never made to point to the same
2416 place). This is a bad thing,'cause the symbols attached
2417 to the output bfd are indexed, so that the relocation
2418 entries know which symbol index they point to. So we
2419 have to look up the output symbol here. */
2421 if (q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2424 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2425 asymbol
**outsyms
= abfd
->outsymbols
;
2426 for (j
= first_undef
; outsyms
[j
]; j
++)
2428 const char *intable
= outsyms
[j
]->name
;
2429 if (strcmp (intable
, sname
) == 0) {
2430 /* got a hit, so repoint the reloc */
2431 q
->sym_ptr_ptr
= outsyms
+ j
;
2437 n
.r_vaddr
= q
->address
+ s
->vma
;
2440 /* The 29k const/consth reloc pair is a real kludge. The consth
2441 part doesn't have a symbol; it has an offset. So rebuilt
2443 if (q
->howto
->type
== R_IHCONST
)
2444 n
.r_symndx
= q
->addend
;
2449 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2450 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
,s
))
2452 if (q
->sym_ptr_ptr
== bfd_abs_section_ptr
->symbol_ptr_ptr
)
2454 /* This is a relocation relative to the absolute symbol. */
2458 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2459 /* Take notice if the symbol reloc points to a symbol
2460 we don't have in our symbol table. What should we
2462 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2467 #ifdef SWAP_OUT_RELOC_OFFSET
2468 n
.r_offset
= q
->addend
;
2472 /* Work out reloc type from what is required */
2473 SELECT_RELOC (n
, q
->howto
);
2475 n
.r_type
= q
->howto
->type
;
2477 coff_swap_reloc_out (abfd
, &n
, &dst
);
2478 if (bfd_bwrite ((PTR
) & dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2479 abfd
) != bfd_coff_relsz (abfd
))
2492 /* Set flags and magic number of a coff file from architecture and machine
2493 type. Result is true if we can represent the arch&type, false if not. */
2496 coff_set_flags (abfd
, magicp
, flagsp
)
2498 unsigned int *magicp ATTRIBUTE_UNUSED
;
2499 unsigned short *flagsp ATTRIBUTE_UNUSED
;
2501 switch (bfd_get_arch (abfd
))
2506 switch (bfd_get_mach (abfd
))
2508 case bfd_mach_z8001
:
2511 case bfd_mach_z8002
:
2525 *magicp
= I960ROMAGIC
;
2527 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2528 I960RWMAGIC); FIXME???
2530 switch (bfd_get_mach (abfd
))
2532 case bfd_mach_i960_core
:
2535 case bfd_mach_i960_kb_sb
:
2538 case bfd_mach_i960_mc
:
2541 case bfd_mach_i960_xa
:
2544 case bfd_mach_i960_ca
:
2547 case bfd_mach_i960_ka_sa
:
2550 case bfd_mach_i960_jx
:
2553 case bfd_mach_i960_hx
:
2566 case bfd_arch_tic30
:
2567 *magicp
= TIC30MAGIC
;
2571 #ifdef TICOFF_DEFAULT_MAGIC
2572 case TICOFF_TARGET_ARCH
:
2573 /* if there's no indication of which version we want, use the default */
2575 *magicp
= TICOFF_DEFAULT_MAGIC
;
2578 /* we may want to output in a different COFF version */
2579 switch (abfd
->xvec
->name
[4])
2582 *magicp
= TICOFF0MAGIC
;
2585 *magicp
= TICOFF1MAGIC
;
2588 *magicp
= TICOFF2MAGIC
;
2597 #ifdef TIC80_ARCH_MAGIC
2598 case bfd_arch_tic80
:
2599 *magicp
= TIC80_ARCH_MAGIC
;
2605 * magicp
= ARMPEMAGIC
;
2607 * magicp
= ARMMAGIC
;
2610 if (APCS_SET (abfd
))
2612 if (APCS_26_FLAG (abfd
))
2613 * flagsp
|= F_APCS26
;
2615 if (APCS_FLOAT_FLAG (abfd
))
2616 * flagsp
|= F_APCS_FLOAT
;
2618 if (PIC_FLAG (abfd
))
2621 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2622 * flagsp
|= F_INTERWORK
;
2623 switch (bfd_get_mach (abfd
))
2625 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2626 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2627 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2628 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2629 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2630 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2631 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2632 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2633 See also the comment in coff_set_arch_mach_hook(). */
2634 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break;
2635 case bfd_mach_arm_5TE
: * flagsp
|= F_ARM_5
; break;
2636 case bfd_mach_arm_XScale
: * flagsp
|= F_ARM_5
; break;
2641 case bfd_arch_powerpc
:
2648 *magicp
= I386MAGIC
;
2650 /* Just overwrite the usual value if we're doing Lynx. */
2651 *magicp
= LYNXCOFFMAGIC
;
2658 *magicp
= I860MAGIC
;
2664 *magicp
= IA64MAGIC
;
2670 #ifdef APOLLOM68KMAGIC
2671 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
2673 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2674 #ifdef NAMES_HAVE_UNDERSCORE
2675 *magicp
= MC68KBCSMAGIC
;
2677 *magicp
= MC68MAGIC
;
2681 /* Just overwrite the usual value if we're doing Lynx. */
2682 *magicp
= LYNXCOFFMAGIC
;
2690 *magicp
= MC88OMAGIC
;
2695 case bfd_arch_h8300
:
2696 switch (bfd_get_mach (abfd
))
2698 case bfd_mach_h8300
:
2699 *magicp
= H8300MAGIC
;
2701 case bfd_mach_h8300h
:
2702 *magicp
= H8300HMAGIC
;
2704 case bfd_mach_h8300s
:
2705 *magicp
= H8300SMAGIC
;
2711 #ifdef SH_ARCH_MAGIC_BIG
2713 #ifdef COFF_IMAGE_WITH_PE
2714 *magicp
= SH_ARCH_MAGIC_WINCE
;
2716 if (bfd_big_endian (abfd
))
2717 *magicp
= SH_ARCH_MAGIC_BIG
;
2719 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2725 #ifdef MIPS_ARCH_MAGIC_WINCE
2727 *magicp
= MIPS_ARCH_MAGIC_WINCE
;
2733 case bfd_arch_sparc
:
2734 *magicp
= SPARCMAGIC
;
2736 /* Just overwrite the usual value if we're doing Lynx. */
2737 *magicp
= LYNXCOFFMAGIC
;
2744 case bfd_arch_h8500
:
2745 *magicp
= H8500MAGIC
;
2749 #ifdef A29K_MAGIC_BIG
2751 if (bfd_big_endian (abfd
))
2752 *magicp
= A29K_MAGIC_BIG
;
2754 *magicp
= A29K_MAGIC_LITTLE
;
2760 case bfd_arch_we32k
:
2761 *magicp
= WE32KMAGIC
;
2767 case bfd_arch_rs6000
:
2769 case bfd_arch_powerpc
:
2772 if (bfd_get_mach (abfd
) == bfd_mach_ppc_620
2773 && !strncmp (abfd
->xvec
->name
,"aix", 3))
2774 *magicp
= U803XTOCMAGIC
;
2777 *magicp
= U802TOCMAGIC
;
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
++;
3018 free (section_list
);
3020 #else /* ! COFF_IMAGE_WITH_PE */
3022 /* Set the target_index field. */
3026 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3027 current
->target_index
= target_index
++;
3029 #endif /* ! COFF_IMAGE_WITH_PE */
3031 align_adjust
= false;
3032 for (current
= abfd
->sections
;
3033 current
!= (asection
*) NULL
;
3034 current
= current
->next
)
3036 #ifdef COFF_IMAGE_WITH_PE
3037 /* With PE we have to pad each section to be a multiple of its
3038 page size too, and remember both sizes. */
3039 if (coff_section_data (abfd
, current
) == NULL
)
3041 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
3042 current
->used_by_bfd
= (PTR
) bfd_zalloc (abfd
, amt
);
3043 if (current
->used_by_bfd
== NULL
)
3046 if (pei_section_data (abfd
, current
) == NULL
)
3048 bfd_size_type amt
= sizeof (struct pei_section_tdata
);
3049 coff_section_data (abfd
, current
)->tdata
3050 = (PTR
) bfd_zalloc (abfd
, amt
);
3051 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
3054 if (pei_section_data (abfd
, current
)->virt_size
== 0)
3055 pei_section_data (abfd
, current
)->virt_size
= current
->_raw_size
;
3058 /* Only deal with sections which have contents. */
3059 if (!(current
->flags
& SEC_HAS_CONTENTS
))
3062 #ifdef COFF_IMAGE_WITH_PE
3063 /* Make sure we skip empty sections in a PE image. */
3064 if (current
->_raw_size
== 0)
3068 /* Align the sections in the file to the same boundary on
3069 which they are aligned in virtual memory. I960 doesn't
3070 do this (FIXME) so we can stay in sync with Intel. 960
3071 doesn't yet page from files... */
3072 #ifdef ALIGN_SECTIONS_IN_FILE
3073 if ((abfd
->flags
& EXEC_P
) != 0)
3075 /* make sure this section is aligned on the right boundary - by
3076 padding the previous section up if necessary */
3080 /* AIX loader checks the text section alignment of (vma - filepos)
3081 So even though the filepos may be aligned wrt the o_algntext, for
3082 AIX executables, this check fails. This shows up when an native
3083 AIX executable is stripped with gnu strip because the default vma
3084 of native is 0x10000150 but default for gnu is 0x10000140. Gnu
3085 stripped gnu excutable passes this check because the filepos is
3087 if (!strcmp (current
->name
, _TEXT
))
3092 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3094 align
= 1 << current
->alignment_power
;
3095 pad
= abs (current
->vma
- sofar
) % align
;
3106 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3109 if (previous
!= (asection
*) NULL
)
3111 previous
->_raw_size
+= sofar
- old_sofar
;
3117 /* In demand paged files the low order bits of the file offset
3118 must match the low order bits of the virtual address. */
3119 #ifdef COFF_PAGE_SIZE
3120 if ((abfd
->flags
& D_PAGED
) != 0
3121 && (current
->flags
& SEC_ALLOC
) != 0)
3122 sofar
+= (current
->vma
- sofar
) % page_size
;
3124 current
->filepos
= sofar
;
3126 #ifdef COFF_IMAGE_WITH_PE
3127 /* Set the padded size. */
3128 current
->_raw_size
= (current
->_raw_size
+ page_size
-1) & -page_size
;
3131 sofar
+= current
->_raw_size
;
3133 #ifdef ALIGN_SECTIONS_IN_FILE
3134 /* make sure that this section is of the right size too */
3135 if ((abfd
->flags
& EXEC_P
) == 0)
3137 bfd_size_type old_size
;
3139 old_size
= current
->_raw_size
;
3140 current
->_raw_size
= BFD_ALIGN (current
->_raw_size
,
3141 1 << current
->alignment_power
);
3142 align_adjust
= current
->_raw_size
!= old_size
;
3143 sofar
+= current
->_raw_size
- old_size
;
3148 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3149 align_adjust
= sofar
!= old_sofar
;
3150 current
->_raw_size
+= sofar
- old_sofar
;
3154 #ifdef COFF_IMAGE_WITH_PE
3155 /* For PE we need to make sure we pad out to the aligned
3156 _raw_size, in case the caller only writes out data to the
3157 unaligned _raw_size. */
3158 if (pei_section_data (abfd
, current
)->virt_size
< current
->_raw_size
)
3159 align_adjust
= true;
3163 /* Force .lib sections to start at zero. The vma is then
3164 incremented in coff_set_section_contents. This is right for
3166 if (strcmp (current
->name
, _LIB
) == 0)
3167 bfd_set_section_vma (abfd
, current
, 0);
3173 /* It is now safe to write to the output file. If we needed an
3174 alignment adjustment for the last section, then make sure that
3175 there is a byte at offset sofar. If there are no symbols and no
3176 relocs, then nothing follows the last section. If we don't force
3177 the last byte out, then the file may appear to be truncated. */
3183 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
3184 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3188 /* Make sure the relocations are aligned. We don't need to make
3189 sure that this byte exists, because it will only matter if there
3190 really are relocs. */
3191 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
3193 obj_relocbase (abfd
) = sofar
;
3194 abfd
->output_has_begun
= true;
3201 /* This can never work, because it is called too late--after the
3202 section positions have been set. I can't figure out what it is
3203 for, so I am going to disable it--Ian Taylor 20 March 1996. */
3205 /* If .file, .text, .data, .bss symbols are missing, add them. */
3206 /* @@ Should we only be adding missing symbols, or overriding the aux
3207 values for existing section symbols? */
3209 coff_add_missing_symbols (abfd
)
3212 unsigned int nsyms
= bfd_get_symcount (abfd
);
3213 asymbol
**sympp
= abfd
->outsymbols
;
3216 int need_text
= 1, need_data
= 1, need_bss
= 1, need_file
= 1;
3219 for (i
= 0; i
< nsyms
; i
++)
3221 coff_symbol_type
*csym
= coff_symbol_from (abfd
, sympp
[i
]);
3225 /* only do this if there is a coff representation of the input
3227 if (csym
->native
&& csym
->native
->u
.syment
.n_sclass
== C_FILE
)
3232 name
= csym
->symbol
.name
;
3235 if (!strcmp (name
, _TEXT
))
3238 else if (!strcmp (name
, ".wtext"))
3241 else if (!strcmp (name
, _DATA
))
3243 else if (!strcmp (name
, _BSS
))
3247 /* Now i == bfd_get_symcount (abfd). */
3248 /* @@ For now, don't deal with .file symbol. */
3251 if (!need_text
&& !need_data
&& !need_bss
&& !need_file
)
3253 nsyms
+= need_text
+ need_data
+ need_bss
+ need_file
;
3255 amt
*= sizeof (asymbol
*);
3256 sympp2
= (asymbol
**) bfd_alloc (abfd
, amt
);
3259 memcpy (sympp2
, sympp
, i
* sizeof (asymbol
*));
3262 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
3266 sympp2
[i
++] = coff_section_symbol (abfd
, _TEXT
);
3268 sympp2
[i
++] = coff_section_symbol (abfd
, _DATA
);
3270 sympp2
[i
++] = coff_section_symbol (abfd
, _BSS
);
3271 BFD_ASSERT (i
== nsyms
);
3272 bfd_set_symtab (abfd
, sympp2
, nsyms
);
3281 coff_write_object_contents (abfd
)
3285 boolean hasrelocs
= false;
3286 boolean haslinno
= false;
3287 boolean hasdebug
= false;
3289 file_ptr reloc_base
;
3290 file_ptr lineno_base
;
3292 unsigned long reloc_size
= 0, reloc_count
= 0;
3293 unsigned long lnno_size
= 0;
3294 boolean long_section_names
;
3295 asection
*text_sec
= NULL
;
3296 asection
*data_sec
= NULL
;
3297 asection
*bss_sec
= NULL
;
3298 struct internal_filehdr internal_f
;
3299 struct internal_aouthdr internal_a
;
3300 #ifdef COFF_LONG_SECTION_NAMES
3301 size_t string_size
= STRING_SIZE_SIZE
;
3304 bfd_set_error (bfd_error_system_call
);
3306 /* Make a pass through the symbol table to count line number entries and
3307 put them into the correct asections */
3309 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3311 if (abfd
->output_has_begun
== false)
3313 if (! coff_compute_section_file_positions (abfd
))
3317 reloc_base
= obj_relocbase (abfd
);
3319 /* Work out the size of the reloc and linno areas */
3321 for (current
= abfd
->sections
; current
!= NULL
; current
=
3325 /* we store the actual reloc count in the first reloc's addr */
3326 if (current
->reloc_count
> 0xffff)
3329 reloc_count
+= current
->reloc_count
;
3332 reloc_size
= reloc_count
* bfd_coff_relsz (abfd
);
3334 lineno_base
= reloc_base
+ reloc_size
;
3335 sym_base
= lineno_base
+ lnno_size
;
3337 /* Indicate in each section->line_filepos its actual file address */
3338 for (current
= abfd
->sections
; current
!= NULL
; current
=
3341 if (current
->lineno_count
)
3343 current
->line_filepos
= lineno_base
;
3344 current
->moving_line_filepos
= lineno_base
;
3345 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3349 current
->line_filepos
= 0;
3351 if (current
->reloc_count
)
3353 current
->rel_filepos
= reloc_base
;
3354 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3356 /* extra reloc to hold real count */
3357 if (current
->reloc_count
> 0xffff)
3358 reloc_base
+= bfd_coff_relsz (abfd
);
3363 current
->rel_filepos
= 0;
3367 /* Write section headers to the file. */
3368 internal_f
.f_nscns
= 0;
3370 if ((abfd
->flags
& EXEC_P
) != 0)
3371 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3374 scn_base
= bfd_coff_filhsz (abfd
);
3377 if (xcoff_data (abfd
)->full_aouthdr
)
3378 scn_base
+= bfd_coff_aoutsz (abfd
);
3380 scn_base
+= SMALL_AOUTSZ
;
3385 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3388 long_section_names
= false;
3389 for (current
= abfd
->sections
;
3391 current
= current
->next
)
3393 struct internal_scnhdr section
;
3394 boolean is_reloc_section
= false;
3396 #ifdef COFF_IMAGE_WITH_PE
3397 if (strcmp (current
->name
, ".reloc") == 0)
3399 is_reloc_section
= true;
3401 pe_data (abfd
)->has_reloc_section
= 1;
3405 internal_f
.f_nscns
++;
3407 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3409 #ifdef COFF_LONG_SECTION_NAMES
3410 /* Handle long section names as in PE. This must be compatible
3411 with the code in coff_write_symbols and _bfd_coff_final_link. */
3415 len
= strlen (current
->name
);
3418 memset (section
.s_name
, 0, SCNNMLEN
);
3419 sprintf (section
.s_name
, "/%lu", (unsigned long) string_size
);
3420 string_size
+= len
+ 1;
3421 long_section_names
= true;
3427 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3428 Ian Taylor <ian@cygnus.com>. */
3429 if (strcmp (current
->name
, _LIB
) == 0)
3430 section
.s_vaddr
= 0;
3433 section
.s_vaddr
= current
->vma
;
3434 section
.s_paddr
= current
->lma
;
3435 section
.s_size
= current
->_raw_size
;
3436 #ifdef coff_get_section_load_page
3437 section
.s_page
= coff_get_section_load_page (current
);
3441 section
.s_paddr
= 0;
3443 #ifdef COFF_IMAGE_WITH_PE
3444 /* Reminder: s_paddr holds the virtual size of the section. */
3445 if (coff_section_data (abfd
, current
) != NULL
3446 && pei_section_data (abfd
, current
) != NULL
)
3447 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3449 section
.s_paddr
= 0;
3453 If this section has no size or is unloadable then the scnptr
3456 if (current
->_raw_size
== 0 ||
3457 (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3459 section
.s_scnptr
= 0;
3463 section
.s_scnptr
= current
->filepos
;
3465 section
.s_relptr
= current
->rel_filepos
;
3466 section
.s_lnnoptr
= current
->line_filepos
;
3467 section
.s_nreloc
= current
->reloc_count
;
3468 section
.s_nlnno
= current
->lineno_count
;
3469 #ifndef COFF_IMAGE_WITH_PE
3470 /* In PEI, relocs come in the .reloc section. */
3471 if (current
->reloc_count
!= 0)
3474 if (current
->lineno_count
!= 0)
3476 if ((current
->flags
& SEC_DEBUGGING
) != 0
3477 && ! is_reloc_section
)
3482 /* Indicate the use of an XCOFF overflow section header. */
3483 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3485 section
.s_nreloc
= 0xffff;
3486 section
.s_nlnno
= 0xffff;
3491 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3493 if (!strcmp (current
->name
, _TEXT
))
3497 else if (!strcmp (current
->name
, _DATA
))
3501 else if (!strcmp (current
->name
, _BSS
))
3507 section
.s_align
= (current
->alignment_power
3508 ? 1 << current
->alignment_power
3512 /* TI COFF puts the alignment power in bits 8-11 of the flags */
3513 section
.s_flags
|= (current
->alignment_power
& 0xF) << 8;
3515 #ifdef COFF_ENCODE_ALIGNMENT
3516 COFF_ENCODE_ALIGNMENT(section
, current
->alignment_power
);
3519 #ifdef COFF_IMAGE_WITH_PE
3520 /* Suppress output of the sections if they are null. ld
3521 includes the bss and data sections even if there is no size
3522 assigned to them. NT loader doesn't like it if these section
3523 headers are included if the sections themselves are not
3524 needed. See also coff_compute_section_file_positions. */
3525 if (section
.s_size
== 0)
3526 internal_f
.f_nscns
--;
3531 bfd_size_type amt
= bfd_coff_scnhsz (abfd
);
3533 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3534 || bfd_bwrite ((PTR
) &buff
, amt
, abfd
) != amt
)
3539 /* PE stores COMDAT section information in the symbol table. If
3540 this section is supposed to have some COMDAT info, track down
3541 the symbol in the symbol table and modify it. */
3542 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3544 unsigned int i
, count
;
3546 coff_symbol_type
*csym
= NULL
;
3550 count
= bfd_get_symcount (abfd
);
3551 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3553 if ((*psym
)->section
!= current
)
3556 /* Remember the location of the first symbol in this
3558 if (psymsec
== NULL
)
3561 /* See if this is the section symbol. */
3562 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3564 csym
= coff_symbol_from (abfd
, *psym
);
3566 || csym
->native
== NULL
3567 || csym
->native
->u
.syment
.n_numaux
< 1
3568 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3569 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3572 /* Here *PSYM is the section symbol for CURRENT. */
3579 Note that we might not if we're converting the file from
3580 some other object file format. */
3583 combined_entry_type
*aux
;
3585 /* We don't touch the x_checksum field. The
3586 x_associated field is not currently supported. */
3588 aux
= csym
->native
+ 1;
3589 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3591 case SEC_LINK_DUPLICATES_DISCARD
:
3592 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3595 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3596 aux
->u
.auxent
.x_scn
.x_comdat
=
3597 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3600 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3601 aux
->u
.auxent
.x_scn
.x_comdat
=
3602 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3605 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3606 aux
->u
.auxent
.x_scn
.x_comdat
=
3607 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3611 /* The COMDAT symbol must be the first symbol from this
3612 section in the symbol table. In order to make this
3613 work, we move the COMDAT symbol before the first
3614 symbol we found in the search above. It's OK to
3615 rearrange the symbol table at this point, because
3616 coff_renumber_symbols is going to rearrange it
3617 further and fix up all the aux entries. */
3618 if (psym
!= psymsec
)
3624 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3625 pcopy
[0] = pcopy
[-1];
3630 #endif /* COFF_WITH_PE */
3635 /* XCOFF handles overflows in the reloc and line number count fields
3636 by creating a new section header to hold the correct values. */
3637 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3639 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3641 struct internal_scnhdr scnhdr
;
3645 internal_f
.f_nscns
++;
3646 strncpy (&(scnhdr
.s_name
[0]), current
->name
, 8);
3647 scnhdr
.s_paddr
= current
->reloc_count
;
3648 scnhdr
.s_vaddr
= current
->lineno_count
;
3650 scnhdr
.s_scnptr
= 0;
3651 scnhdr
.s_relptr
= current
->rel_filepos
;
3652 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3653 scnhdr
.s_nreloc
= current
->target_index
;
3654 scnhdr
.s_nlnno
= current
->target_index
;
3655 scnhdr
.s_flags
= STYP_OVRFLO
;
3656 amt
= bfd_coff_scnhsz (abfd
);
3657 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3658 || bfd_bwrite ((PTR
) &buff
, amt
, abfd
) != amt
)
3665 /* OK, now set up the filehdr... */
3667 /* Don't include the internal abs section in the section count */
3670 We will NOT put a fucking timestamp in the header here. Every time you
3671 put it back, I will come in and take it out again. I'm sorry. This
3672 field does not belong here. We fill it with a 0 so it compares the
3673 same but is not a reasonable time. -- gnu@cygnus.com
3675 internal_f
.f_timdat
= 0;
3677 internal_f
.f_flags
= 0;
3679 if (abfd
->flags
& EXEC_P
)
3680 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3683 internal_f
.f_opthdr
= 0;
3686 if (xcoff_data (abfd
)->full_aouthdr
)
3687 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3689 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
3695 internal_f
.f_flags
|= F_RELFLG
;
3697 internal_f
.f_flags
|= F_LNNO
;
3698 if (abfd
->flags
& EXEC_P
)
3699 internal_f
.f_flags
|= F_EXEC
;
3700 #ifdef COFF_IMAGE_WITH_PE
3702 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
3705 #ifndef COFF_WITH_PE
3706 if (bfd_little_endian (abfd
))
3707 internal_f
.f_flags
|= F_AR32WR
;
3709 internal_f
.f_flags
|= F_AR32W
;
3713 /* target id is used in TI COFF v1 and later; COFF0 won't use this field,
3714 but it doesn't hurt to set it internally */
3715 internal_f
.f_target_id
= TI_TARGET_ID
;
3717 #ifdef TIC80_TARGET_ID
3718 internal_f
.f_target_id
= TIC80_TARGET_ID
;
3722 FIXME, should do something about the other byte orders and
3727 if ((abfd
->flags
& DYNAMIC
) != 0)
3728 internal_f
.f_flags
|= F_SHROBJ
;
3729 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
3730 internal_f
.f_flags
|= F_DYNLOAD
;
3733 memset (&internal_a
, 0, sizeof internal_a
);
3735 /* Set up architecture-dependent stuff */
3738 unsigned int magic
= 0;
3739 unsigned short flags
= 0;
3740 coff_set_flags (abfd
, &magic
, &flags
);
3741 internal_f
.f_magic
= magic
;
3742 internal_f
.f_flags
|= flags
;
3743 /* ...and the "opt"hdr... */
3746 #ifdef ULTRA3 /* NYU's machine */
3747 /* FIXME: This is a bogus check. I really want to see if there
3748 * is a .shbss or a .shdata section, if so then set the magic
3749 * number to indicate a shared data executable.
3751 if (internal_f
.f_nscns
>= 7)
3752 internal_a
.magic
= SHMAGIC
; /* Shared magic */
3755 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
3756 #define __A_MAGIC_SET__
3758 #ifdef TICOFF_AOUT_MAGIC
3759 internal_a
.magic
= TICOFF_AOUT_MAGIC
;
3760 #define __A_MAGIC_SET__
3763 internal_a
.magic
= TIC80_ARCH_MAGIC
;
3764 #define __A_MAGIC_SET__
3767 /* FIXME: What are the a.out magic numbers for the i860? */
3768 internal_a
.magic
= 0;
3769 #define __A_MAGIC_SET__
3772 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
3773 #define __A_MAGIC_SET__
3776 #define __A_MAGIC_SET__
3777 internal_a
.magic
= PAGEMAGICBCS
;
3781 #define __A_MAGIC_SET__
3782 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
3785 #if defined(M68) || defined(WE32K) || defined(M68K)
3786 #define __A_MAGIC_SET__
3788 internal_a
.magic
= LYNXCOFFMAGIC
;
3790 #if defined(TARG_AUX)
3791 internal_a
.magic
= (abfd
->flags
& D_PAGED
? PAGEMAGICPEXECPAGED
:
3792 abfd
->flags
& WP_TEXT
? PAGEMAGICPEXECSWAPPED
:
3793 PAGEMAGICEXECSWAPPED
);
3795 #if defined (PAGEMAGICPEXECPAGED)
3796 internal_a
.magic
= PAGEMAGICPEXECPAGED
;
3798 #endif /* TARG_AUX */
3800 #endif /* M68 || WE32K || M68K */
3803 #define __A_MAGIC_SET__
3804 internal_a
.magic
= ZMAGIC
;
3808 #define __A_MAGIC_SET__
3809 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3812 #if defined MCORE_PE
3813 #define __A_MAGIC_SET__
3814 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3818 #define __A_MAGIC_SET__
3820 internal_a
.magic
= LYNXCOFFMAGIC
;
3822 internal_a
.magic
= ZMAGIC
;
3827 #define __A_MAGIC_SET__
3828 internal_a
.magic
= ZMAGIC
;
3832 #define __A_MAGIC_SET__
3834 internal_a
.magic
= LYNXCOFFMAGIC
;
3839 #define __A_MAGIC_SET__
3840 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
3841 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
3842 RS6K_AOUTHDR_OMAGIC
;
3845 #if defined(SH) && defined(COFF_WITH_PE)
3846 #define __A_MAGIC_SET__
3847 internal_a
.magic
= SH_PE_MAGIC
;
3850 #if defined(MIPS) && defined(COFF_WITH_PE)
3851 #define __A_MAGIC_SET__
3852 internal_a
.magic
= MIPS_PE_MAGIC
;
3856 #define __A_MAGIC_SET__
3857 internal_a
.magic
= NMAGIC
; /* Assume separate i/d. */
3860 #ifndef __A_MAGIC_SET__
3861 #include "Your aouthdr magic number is not being set!"
3863 #undef __A_MAGIC_SET__
3867 /* FIXME: Does anybody ever set this to another value? */
3868 internal_a
.vstamp
= 0;
3870 /* Now should write relocs, strings, syms */
3871 obj_sym_filepos (abfd
) = sym_base
;
3873 if (bfd_get_symcount (abfd
) != 0)
3877 if (!coff_add_missing_symbols (abfd
))
3880 if (!coff_renumber_symbols (abfd
, &firstundef
))
3882 coff_mangle_symbols (abfd
);
3883 if (! coff_write_symbols (abfd
))
3885 if (! coff_write_linenumbers (abfd
))
3887 if (! coff_write_relocs (abfd
, firstundef
))
3890 #ifdef COFF_LONG_SECTION_NAMES
3891 else if (long_section_names
&& ! obj_coff_strings_written (abfd
))
3893 /* If we have long section names we have to write out the string
3894 table even if there are no symbols. */
3895 if (! coff_write_symbols (abfd
))
3899 #ifdef COFF_IMAGE_WITH_PE
3901 else if ((abfd
->flags
& EXEC_P
) != 0)
3905 /* PowerPC PE appears to require that all executable files be
3906 rounded up to the page size. */
3909 (file_ptr
) BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
3911 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3917 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3918 backend linker, and obj_raw_syment_count is not valid until after
3919 coff_write_symbols is called. */
3920 if (obj_raw_syment_count (abfd
) != 0)
3922 internal_f
.f_symptr
= sym_base
;
3924 /* AIX appears to require that F_RELFLG not be set if there are
3925 local symbols but no relocations. */
3926 internal_f
.f_flags
&=~ F_RELFLG
;
3931 if (long_section_names
)
3932 internal_f
.f_symptr
= sym_base
;
3934 internal_f
.f_symptr
= 0;
3935 internal_f
.f_flags
|= F_LSYMS
;
3940 internal_a
.tsize
= bfd_get_section_size_before_reloc (text_sec
);
3941 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
3945 internal_a
.dsize
= bfd_get_section_size_before_reloc (data_sec
);
3946 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
3950 internal_a
.bsize
= bfd_get_section_size_before_reloc (bss_sec
);
3951 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
3952 internal_a
.data_start
= bss_sec
->vma
;
3955 internal_a
.entry
= bfd_get_start_address (abfd
);
3956 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
3959 if (xcoff_data (abfd
)->full_aouthdr
)
3962 asection
*loader_sec
;
3964 internal_a
.vstamp
= 1;
3966 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
3967 if (internal_a
.o_snentry
== 0)
3968 internal_a
.entry
= (bfd_vma
) -1;
3970 if (text_sec
!= NULL
)
3972 internal_a
.o_sntext
= text_sec
->target_index
;
3973 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
3977 internal_a
.o_sntext
= 0;
3978 internal_a
.o_algntext
= 0;
3980 if (data_sec
!= NULL
)
3982 internal_a
.o_sndata
= data_sec
->target_index
;
3983 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
3987 internal_a
.o_sndata
= 0;
3988 internal_a
.o_algndata
= 0;
3990 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
3991 if (loader_sec
!= NULL
)
3992 internal_a
.o_snloader
= loader_sec
->target_index
;
3994 internal_a
.o_snloader
= 0;
3995 if (bss_sec
!= NULL
)
3996 internal_a
.o_snbss
= bss_sec
->target_index
;
3998 internal_a
.o_snbss
= 0;
4000 toc
= xcoff_data (abfd
)->toc
;
4001 internal_a
.o_toc
= toc
;
4002 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
4004 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
4005 if (xcoff_data (abfd
)->cputype
!= -1)
4006 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
4009 switch (bfd_get_arch (abfd
))
4011 case bfd_arch_rs6000
:
4012 internal_a
.o_cputype
= 4;
4014 case bfd_arch_powerpc
:
4015 if (bfd_get_mach (abfd
) == 0)
4016 internal_a
.o_cputype
= 3;
4018 internal_a
.o_cputype
= 1;
4024 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
4025 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
4029 /* now write them */
4030 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
4035 bfd_size_type amount
= bfd_coff_filhsz (abfd
);
4037 buff
= bfd_malloc (amount
);
4041 bfd_coff_swap_filehdr_out (abfd
, (PTR
) &internal_f
, (PTR
) buff
);
4042 amount
= bfd_bwrite ((PTR
) buff
, amount
, abfd
);
4046 if (amount
!= bfd_coff_filhsz (abfd
))
4050 if (abfd
->flags
& EXEC_P
)
4052 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4053 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)) */
4055 bfd_size_type amount
= bfd_coff_aoutsz (abfd
);
4057 buff
= bfd_malloc (amount
);
4061 coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, (PTR
) buff
);
4062 amount
= bfd_bwrite ((PTR
) buff
, amount
, abfd
);
4066 if (amount
!= bfd_coff_aoutsz (abfd
))
4075 /* XCOFF seems to always write at least a small a.out header. */
4076 coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, (PTR
) &buff
);
4077 if (xcoff_data (abfd
)->full_aouthdr
)
4078 size
= bfd_coff_aoutsz (abfd
);
4080 size
= SMALL_AOUTSZ
;
4081 if (bfd_bwrite ((PTR
) &buff
, (bfd_size_type
) size
, abfd
) != size
)
4090 coff_set_section_contents (abfd
, section
, location
, offset
, count
)
4095 bfd_size_type count
;
4097 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
4099 if (! coff_compute_section_file_positions (abfd
))
4103 #if defined(_LIB) && !defined(TARG_AUX)
4105 /* The physical address field of a .lib section is used to hold the
4106 number of shared libraries in the section. This code counts the
4107 number of sections being written, and increments the lma field
4110 I have found no documentation on the contents of this section.
4111 Experimentation indicates that the section contains zero or more
4112 records, each of which has the following structure:
4114 - a (four byte) word holding the length of this record, in words,
4115 - a word that always seems to be set to "2",
4116 - the path to a shared library, null-terminated and then padded
4117 to a whole word boundary.
4119 bfd_assert calls have been added to alert if an attempt is made
4120 to write a section which doesn't follow these assumptions. The
4121 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4122 <robertl@arnet.com> (Thanks!).
4124 Gvran Uddeborg <gvran@uddeborg.pp.se> */
4126 if (strcmp (section
->name
, _LIB
) == 0)
4128 bfd_byte
*rec
, *recend
;
4130 rec
= (bfd_byte
*) location
;
4131 recend
= rec
+ count
;
4132 while (rec
< recend
)
4135 rec
+= bfd_get_32 (abfd
, rec
) * 4;
4138 BFD_ASSERT (rec
== recend
);
4143 /* Don't write out bss sections - one way to do this is to
4144 see if the filepos has not been set. */
4145 if (section
->filepos
== 0)
4148 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0)
4154 return bfd_bwrite (location
, count
, abfd
) == count
;
4158 coff_close_and_cleanup (abfd
)
4161 if (!bfd_read_p (abfd
))
4162 switch (abfd
->format
)
4165 if (!_bfd_write_archive_contents (abfd
))
4169 if (!coff_write_object_contents (abfd
))
4173 bfd_set_error (bfd_error_invalid_operation
);
4177 /* We depend on bfd_close to free all the memory on the objalloc. */
4184 buy_and_read (abfd
, where
, size
)
4189 PTR area
= (PTR
) bfd_alloc (abfd
, size
);
4192 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0
4193 || bfd_bread (area
, size
, abfd
) != size
)
4196 } /* buy_and_read() */
4202 Creating the linenumber table is done by reading in the entire
4203 coff linenumber table, and creating another table for internal use.
4205 A coff linenumber table is structured so that each function
4206 is marked as having a line number of 0. Each line within the
4207 function is an offset from the first line in the function. The
4208 base of the line number information for the table is stored in
4209 the symbol associated with the function.
4211 Note: The PE format uses line number 0 for a flag indicating a
4214 The information is copied from the external to the internal
4215 table, and each symbol which marks a function is marked by
4218 How does this work ?
4223 coff_slurp_line_table (abfd
, asect
)
4227 LINENO
*native_lineno
;
4228 alent
*lineno_cache
;
4231 BFD_ASSERT (asect
->lineno
== (alent
*) NULL
);
4233 amt
= (bfd_size_type
) bfd_coff_linesz (abfd
) * asect
->lineno_count
;
4234 native_lineno
= (LINENO
*) buy_and_read (abfd
, asect
->line_filepos
, amt
);
4235 amt
= ((bfd_size_type
) asect
->lineno_count
+ 1) * sizeof (alent
);
4236 lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
);
4237 if (lineno_cache
== NULL
)
4241 unsigned int counter
= 0;
4242 alent
*cache_ptr
= lineno_cache
;
4243 LINENO
*src
= native_lineno
;
4245 while (counter
< asect
->lineno_count
)
4247 struct internal_lineno dst
;
4248 bfd_coff_swap_lineno_in (abfd
, src
, &dst
);
4249 cache_ptr
->line_number
= dst
.l_lnno
;
4251 if (cache_ptr
->line_number
== 0)
4254 bfd_signed_vma symndx
;
4255 coff_symbol_type
*sym
;
4258 symndx
= dst
.l_addr
.l_symndx
;
4260 || (bfd_vma
) symndx
>= obj_raw_syment_count (abfd
))
4262 (*_bfd_error_handler
)
4263 (_("%s: warning: illegal symbol index %ld in line numbers"),
4264 bfd_archive_filename (abfd
), dst
.l_addr
.l_symndx
);
4268 /* FIXME: We should not be casting between ints and
4269 pointers like this. */
4270 sym
= ((coff_symbol_type
*)
4271 ((symndx
+ obj_raw_syments (abfd
))
4272 ->u
.syment
._n
._n_n
._n_zeroes
));
4273 cache_ptr
->u
.sym
= (asymbol
*) sym
;
4274 if (sym
->lineno
!= NULL
&& ! warned
)
4276 (*_bfd_error_handler
)
4277 (_("%s: warning: duplicate line number information for `%s'"),
4278 bfd_archive_filename (abfd
),
4279 bfd_asymbol_name (&sym
->symbol
));
4281 sym
->lineno
= cache_ptr
;
4285 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
4286 - bfd_section_vma (abfd
, asect
);
4287 } /* If no linenumber expect a symbol index */
4293 cache_ptr
->line_number
= 0;
4296 asect
->lineno
= lineno_cache
;
4297 /* FIXME, free native_lineno here, or use alloca or something. */
4301 /* Slurp in the symbol table, converting it to generic form. Note
4302 that if coff_relocate_section is defined, the linker will read
4303 symbols via coff_link_add_symbols, rather than via this routine. */
4306 coff_slurp_symbol_table (abfd
)
4309 combined_entry_type
*native_symbols
;
4310 coff_symbol_type
*cached_area
;
4311 unsigned int *table_ptr
;
4314 unsigned int number_of_symbols
= 0;
4316 if (obj_symbols (abfd
))
4319 /* Read in the symbol table */
4320 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4325 /* Allocate enough room for all the symbols in cached form */
4326 amt
= obj_raw_syment_count (abfd
);
4327 amt
*= sizeof (coff_symbol_type
);
4328 cached_area
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
4329 if (cached_area
== NULL
)
4332 amt
= obj_raw_syment_count (abfd
);
4333 amt
*= sizeof (unsigned int);
4334 table_ptr
= (unsigned int *) bfd_alloc (abfd
, amt
);
4336 if (table_ptr
== NULL
)
4340 coff_symbol_type
*dst
= cached_area
;
4341 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4342 unsigned int this_index
= 0;
4343 while (this_index
< last_native_index
)
4345 combined_entry_type
*src
= native_symbols
+ this_index
;
4346 table_ptr
[this_index
] = number_of_symbols
;
4347 dst
->symbol
.the_bfd
= abfd
;
4349 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4350 /* We use the native name field to point to the cached field. */
4351 src
->u
.syment
._n
._n_n
._n_zeroes
= (long) dst
;
4352 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4353 src
->u
.syment
.n_scnum
);
4354 dst
->symbol
.flags
= 0;
4355 dst
->done_lineno
= false;
4357 switch (src
->u
.syment
.n_sclass
)
4362 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
4363 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4364 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4366 /* Fall through to next case */
4374 case C_THUMBEXTFUNC
:
4380 case C_SYSTEM
: /* System Wide variable */
4383 /* In PE, 0x68 (104) denotes a section symbol */
4385 /* In PE, 0x69 (105) denotes a weak external symbol. */
4388 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4390 case COFF_SYMBOL_GLOBAL
:
4391 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4392 #if defined COFF_WITH_PE
4393 /* PE sets the symbol to a value relative to the
4394 start of the section. */
4395 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4397 dst
->symbol
.value
= (src
->u
.syment
.n_value
4398 - dst
->symbol
.section
->vma
);
4400 if (ISFCN ((src
->u
.syment
.n_type
)))
4402 /* A function ext does not go at the end of a
4404 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4408 case COFF_SYMBOL_COMMON
:
4409 dst
->symbol
.section
= bfd_com_section_ptr
;
4410 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4413 case COFF_SYMBOL_UNDEFINED
:
4414 dst
->symbol
.section
= bfd_und_section_ptr
;
4415 dst
->symbol
.value
= 0;
4418 case COFF_SYMBOL_PE_SECTION
:
4419 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4420 dst
->symbol
.value
= 0;
4423 case COFF_SYMBOL_LOCAL
:
4424 dst
->symbol
.flags
= BSF_LOCAL
;
4425 #if defined COFF_WITH_PE
4426 /* PE sets the symbol to a value relative to the
4427 start of the section. */
4428 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4430 dst
->symbol
.value
= (src
->u
.syment
.n_value
4431 - dst
->symbol
.section
->vma
);
4433 if (ISFCN ((src
->u
.syment
.n_type
)))
4434 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4439 /* A symbol with a csect entry should not go at the end. */
4440 if (src
->u
.syment
.n_numaux
> 0)
4441 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4445 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4446 dst
->symbol
.flags
= BSF_WEAK
;
4447 if (src
->u
.syment
.n_sclass
== C_SECTION
4448 && src
->u
.syment
.n_scnum
> 0)
4450 dst
->symbol
.flags
= BSF_LOCAL
;
4454 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
)
4455 dst
->symbol
.flags
= BSF_WEAK
;
4459 case C_STAT
: /* static */
4461 case C_LEAFSTAT
: /* static leaf procedure */
4464 case C_THUMBSTAT
: /* Thumb static */
4465 case C_THUMBLABEL
: /* Thumb label */
4466 case C_THUMBSTATFUNC
:/* Thumb static function */
4468 case C_LABEL
: /* label */
4469 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4470 dst
->symbol
.flags
= BSF_DEBUGGING
;
4472 dst
->symbol
.flags
= BSF_LOCAL
;
4474 /* Base the value as an index from the base of the
4475 section, if there is one. */
4476 if (dst
->symbol
.section
)
4478 #if defined COFF_WITH_PE
4479 /* PE sets the symbol to a value relative to the
4480 start of the section. */
4481 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4483 dst
->symbol
.value
= (src
->u
.syment
.n_value
4484 - dst
->symbol
.section
->vma
);
4488 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4491 case C_MOS
: /* member of structure */
4492 case C_EOS
: /* end of structure */
4493 #ifdef NOTDEF /* C_AUTOARG has the same value */
4495 case C_GLBLREG
: /* A29k-specific storage class */
4498 case C_REGPARM
: /* register parameter */
4499 case C_REG
: /* register variable */
4500 /* C_AUTOARG conflictes with TI COFF C_UEXT */
4501 #if !defined (TIC80COFF) && !defined (TICOFF)
4503 case C_AUTOARG
: /* 960-specific storage class */
4506 case C_TPDEF
: /* type definition */
4508 case C_AUTO
: /* automatic variable */
4509 case C_FIELD
: /* bit field */
4510 case C_ENTAG
: /* enumeration tag */
4511 case C_MOE
: /* member of enumeration */
4512 case C_MOU
: /* member of union */
4513 case C_UNTAG
: /* union tag */
4514 dst
->symbol
.flags
= BSF_DEBUGGING
;
4515 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4518 case C_FILE
: /* file name */
4519 case C_STRTAG
: /* structure tag */
4534 dst
->symbol
.flags
= BSF_DEBUGGING
;
4535 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4539 case C_BINCL
: /* beginning of include file */
4540 case C_EINCL
: /* ending of include file */
4541 /* The value is actually a pointer into the line numbers
4542 of the file. We locate the line number entry, and
4543 set the section to the section which contains it, and
4544 the value to the index in that section. */
4548 dst
->symbol
.flags
= BSF_DEBUGGING
;
4549 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4550 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4551 && ((file_ptr
) (sec
->line_filepos
4552 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4553 > (file_ptr
) src
->u
.syment
.n_value
))
4556 dst
->symbol
.value
= 0;
4559 dst
->symbol
.section
= sec
;
4560 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4561 - sec
->line_filepos
)
4562 / bfd_coff_linesz (abfd
));
4569 dst
->symbol
.flags
= BSF_DEBUGGING
;
4571 /* The value is actually a symbol index. Save a pointer
4572 to the symbol instead of the index. FIXME: This
4573 should use a union. */
4574 src
->u
.syment
.n_value
=
4575 (long) (native_symbols
+ src
->u
.syment
.n_value
);
4576 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4581 case C_BLOCK
: /* ".bb" or ".eb" */
4582 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf") */
4583 case C_EFCN
: /* physical end of function */
4584 #if defined COFF_WITH_PE
4585 /* PE sets the symbol to a value relative to the start
4587 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4588 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4590 /* PE uses funny values for .ef and .lf; don't
4592 dst
->symbol
.flags
= BSF_DEBUGGING
;
4595 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4597 /* Base the value as an index from the base of the
4599 dst
->symbol
.flags
= BSF_LOCAL
;
4600 dst
->symbol
.value
= (src
->u
.syment
.n_value
4601 - dst
->symbol
.section
->vma
);
4605 case C_STATLAB
: /* Static load time label */
4606 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4607 dst
->symbol
.flags
= BSF_GLOBAL
;
4611 /* PE DLLs sometimes have zeroed out symbols for some
4612 reason. Just ignore them without a warning. */
4613 if (src
->u
.syment
.n_type
== 0
4614 && src
->u
.syment
.n_value
== 0
4615 && src
->u
.syment
.n_scnum
== 0)
4618 case C_EXTDEF
: /* external definition */
4619 case C_ULABEL
: /* undefined label */
4620 case C_USTATIC
: /* undefined static */
4621 #ifndef COFF_WITH_PE
4622 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4623 class to represent a section symbol */
4624 case C_LINE
: /* line # reformatted as symbol table entry */
4625 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4626 case C_ALIAS
: /* duplicate tag */
4628 /* New storage classes for TI COFF */
4629 #if defined(TIC80COFF) || defined(TICOFF)
4630 case C_UEXT
: /* Tentative external definition */
4632 case C_EXTLAB
: /* External load time label */
4633 case C_HIDDEN
: /* ext symbol in dmert public lib */
4635 (*_bfd_error_handler
)
4636 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
4637 bfd_archive_filename (abfd
), src
->u
.syment
.n_sclass
,
4638 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4639 dst
->symbol
.flags
= BSF_DEBUGGING
;
4640 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4644 /* BFD_ASSERT(dst->symbol.flags != 0);*/
4648 dst
->symbol
.udata
.i
= 0;
4649 dst
->lineno
= (alent
*) NULL
;
4650 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
4652 number_of_symbols
++;
4653 } /* walk the native symtab */
4654 } /* bfdize the native symtab */
4656 obj_symbols (abfd
) = cached_area
;
4657 obj_raw_syments (abfd
) = native_symbols
;
4659 bfd_get_symcount (abfd
) = number_of_symbols
;
4660 obj_convert (abfd
) = table_ptr
;
4661 /* Slurp the line tables for each section too */
4667 coff_slurp_line_table (abfd
, p
);
4672 } /* coff_slurp_symbol_table() */
4674 /* Classify a COFF symbol. A couple of targets have globally visible
4675 symbols which are not class C_EXT, and this handles those. It also
4676 recognizes some special PE cases. */
4678 static enum coff_symbol_classification
4679 coff_classify_symbol (abfd
, syment
)
4681 struct internal_syment
*syment
;
4683 /* FIXME: This partially duplicates the switch in
4684 coff_slurp_symbol_table. */
4685 switch (syment
->n_sclass
)
4694 case C_THUMBEXTFUNC
:
4702 if (syment
->n_scnum
== 0)
4704 if (syment
->n_value
== 0)
4705 return COFF_SYMBOL_UNDEFINED
;
4707 return COFF_SYMBOL_COMMON
;
4709 return COFF_SYMBOL_GLOBAL
;
4716 if (syment
->n_sclass
== C_STAT
)
4718 if (syment
->n_scnum
== 0)
4720 /* The Microsoft compiler sometimes generates these if a
4721 small static function is inlined every time it is used.
4722 The function is discarded, but the symbol table entry
4724 return COFF_SYMBOL_LOCAL
;
4727 #ifdef STRICT_PE_FORMAT
4728 /* This is correct for Microsoft generated objects, but it
4729 breaks gas generated objects. */
4731 if (syment
->n_value
== 0)
4734 char buf
[SYMNMLEN
+ 1];
4736 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
4738 && (strcmp (bfd_get_section_name (abfd
, sec
),
4739 _bfd_coff_internal_syment_name (abfd
, syment
, buf
))
4741 return COFF_SYMBOL_PE_SECTION
;
4745 return COFF_SYMBOL_LOCAL
;
4748 if (syment
->n_sclass
== C_SECTION
)
4750 /* In some cases in a DLL generated by the Microsoft linker, the
4751 n_value field will contain garbage. FIXME: This should
4752 probably be handled by the swapping function instead. */
4753 syment
->n_value
= 0;
4754 if (syment
->n_scnum
== 0)
4755 return COFF_SYMBOL_UNDEFINED
;
4756 return COFF_SYMBOL_PE_SECTION
;
4758 #endif /* COFF_WITH_PE */
4760 /* If it is not a global symbol, we presume it is a local symbol. */
4762 if (syment
->n_scnum
== 0)
4764 char buf
[SYMNMLEN
+ 1];
4766 (*_bfd_error_handler
)
4767 (_("warning: %s: local symbol `%s' has no section"),
4768 bfd_archive_filename (abfd
),
4769 _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
4772 return COFF_SYMBOL_LOCAL
;
4779 Coff relocations are easily transformed into the internal BFD form
4782 Reading a coff relocation table is done in the following stages:
4784 o Read the entire coff relocation table into memory.
4786 o Process each relocation in turn; first swap it from the
4787 external to the internal form.
4789 o Turn the symbol referenced in the relocation's symbol index
4790 into a pointer into the canonical symbol table.
4791 This table is the same as the one returned by a call to
4792 @code{bfd_canonicalize_symtab}. The back end will call that
4793 routine and save the result if a canonicalization hasn't been done.
4795 o The reloc index is turned into a pointer to a howto
4796 structure, in a back end specific way. For instance, the 386
4797 and 960 use the @code{r_type} to directly produce an index
4798 into a howto table vector; the 88k subtracts a number from the
4799 @code{r_type} field and creates an addend field.
4804 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
4806 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
4807 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
4808 coffsym = (obj_symbols (abfd) \
4809 + (cache_ptr->sym_ptr_ptr - symbols)); \
4811 coffsym = coff_symbol_from (abfd, ptr); \
4812 if (coffsym != (coff_symbol_type *) NULL \
4813 && coffsym->native->u.syment.n_scnum == 0) \
4814 cache_ptr->addend = 0; \
4815 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
4816 && ptr->section != (asection *) NULL) \
4817 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
4819 cache_ptr->addend = 0; \
4824 coff_slurp_reloc_table (abfd
, asect
, symbols
)
4829 RELOC
*native_relocs
;
4830 arelent
*reloc_cache
;
4835 if (asect
->relocation
)
4837 if (asect
->reloc_count
== 0)
4839 if (asect
->flags
& SEC_CONSTRUCTOR
)
4841 if (!coff_slurp_symbol_table (abfd
))
4843 amt
= (bfd_size_type
) bfd_coff_relsz (abfd
) * asect
->reloc_count
;
4844 native_relocs
= (RELOC
*) buy_and_read (abfd
, asect
->rel_filepos
, amt
);
4845 amt
= (bfd_size_type
) asect
->reloc_count
* sizeof (arelent
);
4846 reloc_cache
= (arelent
*) bfd_alloc (abfd
, amt
);
4848 if (reloc_cache
== NULL
)
4851 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
4853 struct internal_reloc dst
;
4854 struct external_reloc
*src
;
4855 #ifndef RELOC_PROCESSING
4859 cache_ptr
= reloc_cache
+ idx
;
4860 src
= native_relocs
+ idx
;
4862 coff_swap_reloc_in (abfd
, src
, &dst
);
4864 #ifdef RELOC_PROCESSING
4865 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
4867 cache_ptr
->address
= dst
.r_vaddr
;
4869 if (dst
.r_symndx
!= -1)
4871 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
4873 (*_bfd_error_handler
)
4874 (_("%s: warning: illegal symbol index %ld in relocs"),
4875 bfd_archive_filename (abfd
), dst
.r_symndx
);
4876 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
4881 cache_ptr
->sym_ptr_ptr
= (symbols
4882 + obj_convert (abfd
)[dst
.r_symndx
]);
4883 ptr
= *(cache_ptr
->sym_ptr_ptr
);
4888 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
4892 /* The symbols definitions that we have read in have been
4893 relocated as if their sections started at 0. But the offsets
4894 refering to the symbols in the raw data have not been
4895 modified, so we have to have a negative addend to compensate.
4897 Note that symbols which used to be common must be left alone */
4899 /* Calculate any reloc addend by looking at the symbol */
4900 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
4902 cache_ptr
->address
-= asect
->vma
;
4903 /* !! cache_ptr->section = (asection *) NULL;*/
4905 /* Fill in the cache_ptr->howto field from dst.r_type */
4906 RTYPE2HOWTO (cache_ptr
, &dst
);
4907 #endif /* RELOC_PROCESSING */
4909 if (cache_ptr
->howto
== NULL
)
4911 (*_bfd_error_handler
)
4912 (_("%s: illegal relocation type %d at address 0x%lx"),
4913 bfd_archive_filename (abfd
), dst
.r_type
, (long) dst
.r_vaddr
);
4914 bfd_set_error (bfd_error_bad_value
);
4919 asect
->relocation
= reloc_cache
;
4923 #ifndef coff_rtype_to_howto
4926 /* Get the howto structure for a reloc. This is only used if the file
4927 including this one defines coff_relocate_section to be
4928 _bfd_coff_generic_relocate_section, so it is OK if it does not
4929 always work. It is the responsibility of the including file to
4930 make sure it is reasonable if it is needed. */
4932 static reloc_howto_type
*coff_rtype_to_howto
4933 PARAMS ((bfd
*, asection
*, struct internal_reloc
*,
4934 struct coff_link_hash_entry
*, struct internal_syment
*,
4938 static reloc_howto_type
*
4939 coff_rtype_to_howto (abfd
, sec
, rel
, h
, sym
, addendp
)
4940 bfd
*abfd ATTRIBUTE_UNUSED
;
4941 asection
*sec ATTRIBUTE_UNUSED
;
4942 struct internal_reloc
*rel
;
4943 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
;
4944 struct internal_syment
*sym ATTRIBUTE_UNUSED
;
4945 bfd_vma
*addendp ATTRIBUTE_UNUSED
;
4949 RTYPE2HOWTO (&genrel
, rel
);
4950 return genrel
.howto
;
4953 #else /* ! defined (RTYPE2HOWTO) */
4955 #define coff_rtype_to_howto NULL
4957 #endif /* ! defined (RTYPE2HOWTO) */
4958 #endif /* ! defined (coff_rtype_to_howto) */
4960 /* This is stupid. This function should be a boolean predicate. */
4962 coff_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
4968 arelent
*tblptr
= section
->relocation
;
4969 unsigned int count
= 0;
4971 if (section
->flags
& SEC_CONSTRUCTOR
)
4973 /* this section has relocs made up by us, they are not in the
4974 file, so take them out of their chain and place them into
4975 the data area provided */
4976 arelent_chain
*chain
= section
->constructor_chain
;
4977 for (count
= 0; count
< section
->reloc_count
; count
++)
4979 *relptr
++ = &chain
->relent
;
4980 chain
= chain
->next
;
4986 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
4989 tblptr
= section
->relocation
;
4991 for (; count
++ < section
->reloc_count
;)
4992 *relptr
++ = tblptr
++;
4995 return section
->reloc_count
;
5000 coff_sym_filepos (abfd
)
5003 return obj_sym_filepos (abfd
);
5007 #ifndef coff_reloc16_estimate
5008 #define coff_reloc16_estimate dummy_reloc16_estimate
5010 static int dummy_reloc16_estimate
5011 PARAMS ((bfd
*, asection
*, arelent
*, unsigned int,
5012 struct bfd_link_info
*));
5015 dummy_reloc16_estimate (abfd
, input_section
, reloc
, shrink
, link_info
)
5016 bfd
*abfd ATTRIBUTE_UNUSED
;
5017 asection
*input_section ATTRIBUTE_UNUSED
;
5018 arelent
*reloc ATTRIBUTE_UNUSED
;
5019 unsigned int shrink ATTRIBUTE_UNUSED
;
5020 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
5028 #ifndef coff_reloc16_extra_cases
5030 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5032 /* This works even if abort is not declared in any header file. */
5034 static void dummy_reloc16_extra_cases
5035 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*, arelent
*,
5036 bfd_byte
*, unsigned int *, unsigned int *));
5039 dummy_reloc16_extra_cases (abfd
, link_info
, link_order
, reloc
, data
, src_ptr
,
5041 bfd
*abfd ATTRIBUTE_UNUSED
;
5042 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
5043 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
;
5044 arelent
*reloc ATTRIBUTE_UNUSED
;
5045 bfd_byte
*data ATTRIBUTE_UNUSED
;
5046 unsigned int *src_ptr ATTRIBUTE_UNUSED
;
5047 unsigned int *dst_ptr ATTRIBUTE_UNUSED
;
5053 /* If coff_relocate_section is defined, we can use the optimized COFF
5054 backend linker. Otherwise we must continue to use the old linker. */
5055 #ifdef coff_relocate_section
5056 #ifndef coff_bfd_link_hash_table_create
5057 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5059 #ifndef coff_bfd_link_add_symbols
5060 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5062 #ifndef coff_bfd_final_link
5063 #define coff_bfd_final_link _bfd_coff_final_link
5065 #else /* ! defined (coff_relocate_section) */
5066 #define coff_relocate_section NULL
5067 #ifndef coff_bfd_link_hash_table_create
5068 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5070 #ifndef coff_bfd_link_add_symbols
5071 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5073 #define coff_bfd_final_link _bfd_generic_final_link
5074 #endif /* ! defined (coff_relocate_section) */
5076 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5078 #ifndef coff_start_final_link
5079 #define coff_start_final_link NULL
5082 #ifndef coff_adjust_symndx
5083 #define coff_adjust_symndx NULL
5086 #ifndef coff_link_add_one_symbol
5087 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5090 #ifndef coff_link_output_has_begun
5092 static boolean coff_link_output_has_begun
5093 PARAMS ((bfd
*, struct coff_final_link_info
*));
5096 coff_link_output_has_begun (abfd
, info
)
5098 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
;
5100 return abfd
->output_has_begun
;
5104 #ifndef coff_final_link_postscript
5106 static boolean coff_final_link_postscript
5107 PARAMS ((bfd
*, struct coff_final_link_info
*));
5110 coff_final_link_postscript (abfd
, pfinfo
)
5111 bfd
* abfd ATTRIBUTE_UNUSED
;
5112 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
;
5118 #ifndef coff_SWAP_aux_in
5119 #define coff_SWAP_aux_in coff_swap_aux_in
5121 #ifndef coff_SWAP_sym_in
5122 #define coff_SWAP_sym_in coff_swap_sym_in
5124 #ifndef coff_SWAP_lineno_in
5125 #define coff_SWAP_lineno_in coff_swap_lineno_in
5127 #ifndef coff_SWAP_aux_out
5128 #define coff_SWAP_aux_out coff_swap_aux_out
5130 #ifndef coff_SWAP_sym_out
5131 #define coff_SWAP_sym_out coff_swap_sym_out
5133 #ifndef coff_SWAP_lineno_out
5134 #define coff_SWAP_lineno_out coff_swap_lineno_out
5136 #ifndef coff_SWAP_reloc_out
5137 #define coff_SWAP_reloc_out coff_swap_reloc_out
5139 #ifndef coff_SWAP_filehdr_out
5140 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5142 #ifndef coff_SWAP_aouthdr_out
5143 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5145 #ifndef coff_SWAP_scnhdr_out
5146 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5148 #ifndef coff_SWAP_reloc_in
5149 #define coff_SWAP_reloc_in coff_swap_reloc_in
5151 #ifndef coff_SWAP_filehdr_in
5152 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5154 #ifndef coff_SWAP_aouthdr_in
5155 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5157 #ifndef coff_SWAP_scnhdr_in
5158 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5161 static const bfd_coff_backend_data bfd_coff_std_swap_table
=
5163 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5164 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5165 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5166 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5167 coff_SWAP_scnhdr_out
,
5168 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5169 #ifdef COFF_LONG_FILENAMES
5174 #ifdef COFF_LONG_SECTION_NAMES
5179 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5180 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5185 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5190 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5191 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5192 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5193 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5194 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5195 coff_classify_symbol
, coff_compute_section_file_positions
,
5196 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5197 coff_adjust_symndx
, coff_link_add_one_symbol
,
5198 coff_link_output_has_begun
, coff_final_link_postscript
5201 #ifndef coff_close_and_cleanup
5202 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5205 #ifndef coff_bfd_free_cached_info
5206 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5209 #ifndef coff_get_section_contents
5210 #define coff_get_section_contents _bfd_generic_get_section_contents
5213 #ifndef coff_bfd_copy_private_symbol_data
5214 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5217 #ifndef coff_bfd_copy_private_section_data
5218 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5221 #ifndef coff_bfd_copy_private_bfd_data
5222 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5225 #ifndef coff_bfd_merge_private_bfd_data
5226 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5229 #ifndef coff_bfd_set_private_flags
5230 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5233 #ifndef coff_bfd_print_private_bfd_data
5234 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5237 #ifndef coff_bfd_is_local_label_name
5238 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5241 #ifndef coff_read_minisymbols
5242 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5245 #ifndef coff_minisymbol_to_symbol
5246 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5249 /* The reloc lookup routine must be supplied by each individual COFF
5251 #ifndef coff_bfd_reloc_type_lookup
5252 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5255 #ifndef coff_bfd_get_relocated_section_contents
5256 #define coff_bfd_get_relocated_section_contents \
5257 bfd_generic_get_relocated_section_contents
5260 #ifndef coff_bfd_relax_section
5261 #define coff_bfd_relax_section bfd_generic_relax_section
5264 #ifndef coff_bfd_gc_sections
5265 #define coff_bfd_gc_sections bfd_generic_gc_sections
5268 #ifndef coff_bfd_merge_sections
5269 #define coff_bfd_merge_sections bfd_generic_merge_sections
5272 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
5273 const bfd_target VAR = \
5276 bfd_target_coff_flavour, \
5277 BFD_ENDIAN_BIG, /* data byte order is big */ \
5278 BFD_ENDIAN_BIG, /* header byte order is big */ \
5279 /* object flags */ \
5280 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5281 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5282 /* section flags */ \
5283 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5284 UNDER, /* leading symbol underscore */ \
5285 '/', /* ar_pad_char */ \
5286 15, /* ar_max_namelen */ \
5288 /* Data conversion functions. */ \
5289 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5290 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5291 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5293 /* Header conversion functions. */ \
5294 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5295 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5296 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5298 /* bfd_check_format */ \
5299 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5300 _bfd_dummy_target }, \
5301 /* bfd_set_format */ \
5302 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5303 /* bfd_write_contents */ \
5304 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5307 BFD_JUMP_TABLE_GENERIC (coff), \
5308 BFD_JUMP_TABLE_COPY (coff), \
5309 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5310 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5311 BFD_JUMP_TABLE_SYMBOLS (coff), \
5312 BFD_JUMP_TABLE_RELOCS (coff), \
5313 BFD_JUMP_TABLE_WRITE (coff), \
5314 BFD_JUMP_TABLE_LINK (coff), \
5315 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5322 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
5323 const bfd_target VAR = \
5326 bfd_target_coff_flavour, \
5327 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
5328 BFD_ENDIAN_LITTLE, /* header byte order is little */ \
5329 /* object flags */ \
5330 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5331 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5332 /* section flags */ \
5333 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5334 UNDER, /* leading symbol underscore */ \
5335 '/', /* ar_pad_char */ \
5336 15, /* ar_max_namelen */ \
5338 /* Data conversion functions. */ \
5339 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5340 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5341 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5342 /* Header conversion functions. */ \
5343 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5344 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5345 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5346 /* bfd_check_format */ \
5347 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5348 _bfd_dummy_target }, \
5349 /* bfd_set_format */ \
5350 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5351 /* bfd_write_contents */ \
5352 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5355 BFD_JUMP_TABLE_GENERIC (coff), \
5356 BFD_JUMP_TABLE_COPY (coff), \
5357 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5358 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5359 BFD_JUMP_TABLE_SYMBOLS (coff), \
5360 BFD_JUMP_TABLE_RELOCS (coff), \
5361 BFD_JUMP_TABLE_WRITE (coff), \
5362 BFD_JUMP_TABLE_LINK (coff), \
5363 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \