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 case F_ARM_5
: machine
= bfd_mach_arm_5
; break;
1881 #ifdef MC68KBCSMAGIC
1884 #ifdef APOLLOM68KMAGIC
1885 case APOLLOM68KMAGIC
:
1887 #ifdef LYNXCOFFMAGIC
1890 arch
= bfd_arch_m68k
;
1891 machine
= bfd_mach_m68020
;
1898 arch
= bfd_arch_m88k
;
1904 arch
= bfd_arch_z8k
;
1905 switch (internal_f
->f_flags
& F_MACHMASK
)
1908 machine
= bfd_mach_z8001
;
1911 machine
= bfd_mach_z8002
;
1920 arch
= bfd_arch_i860
;
1927 arch
= bfd_arch_i960
;
1928 switch (F_I960TYPE
& internal_f
->f_flags
)
1932 machine
= bfd_mach_i960_core
;
1935 machine
= bfd_mach_i960_kb_sb
;
1938 machine
= bfd_mach_i960_mc
;
1941 machine
= bfd_mach_i960_xa
;
1944 machine
= bfd_mach_i960_ca
;
1947 machine
= bfd_mach_i960_ka_sa
;
1950 machine
= bfd_mach_i960_jx
;
1953 machine
= bfd_mach_i960_hx
;
1971 if (xcoff_data (abfd
)->cputype
!= -1)
1972 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
1975 /* We did not get a value from the a.out header. If the
1976 file has not been stripped, we may be able to get the
1977 architecture information from the first symbol, if it
1978 is a .file symbol. */
1979 if (obj_raw_syment_count (abfd
) == 0)
1984 struct internal_syment sym
;
1985 bfd_size_type amt
= bfd_coff_symesz (abfd
);
1987 buf
= (bfd_byte
*) bfd_malloc (amt
);
1988 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1989 || bfd_bread (buf
, amt
, abfd
) != amt
)
1994 bfd_coff_swap_sym_in (abfd
, (PTR
) buf
, (PTR
) &sym
);
1995 if (sym
.n_sclass
== C_FILE
)
1996 cputype
= sym
.n_type
& 0xff;
2003 /* FIXME: We don't handle all cases here. */
2008 arch
= bfd_xcoff_architecture (abfd
);
2009 machine
= bfd_xcoff_machine (abfd
);
2013 arch
= bfd_arch_powerpc
;
2014 machine
= bfd_mach_ppc_601
;
2016 case 2: /* 64 bit PowerPC */
2017 arch
= bfd_arch_powerpc
;
2018 machine
= bfd_mach_ppc_620
;
2021 arch
= bfd_arch_powerpc
;
2022 machine
= bfd_mach_ppc
;
2025 arch
= bfd_arch_rs6000
;
2026 machine
= bfd_mach_rs6k
;
2035 arch
= bfd_arch_we32k
;
2042 arch
= bfd_arch_h8300
;
2043 machine
= bfd_mach_h8300
;
2044 /* !! FIXME this probably isn't the right place for this */
2045 abfd
->flags
|= BFD_IS_RELAXABLE
;
2051 arch
= bfd_arch_h8300
;
2052 machine
= bfd_mach_h8300h
;
2053 /* !! FIXME this probably isn't the right place for this */
2054 abfd
->flags
|= BFD_IS_RELAXABLE
;
2060 arch
= bfd_arch_h8300
;
2061 machine
= bfd_mach_h8300s
;
2062 /* !! FIXME this probably isn't the right place for this */
2063 abfd
->flags
|= BFD_IS_RELAXABLE
;
2067 #ifdef SH_ARCH_MAGIC_BIG
2068 case SH_ARCH_MAGIC_BIG
:
2069 case SH_ARCH_MAGIC_LITTLE
:
2071 case SH_ARCH_MAGIC_WINCE
:
2078 #ifdef MIPS_ARCH_MAGIC_WINCE
2079 case MIPS_ARCH_MAGIC_WINCE
:
2080 arch
= bfd_arch_mips
;
2087 arch
= bfd_arch_h8500
;
2094 #ifdef LYNXCOFFMAGIC
2097 arch
= bfd_arch_sparc
;
2104 arch
= bfd_arch_tic30
;
2109 #ifdef TICOFF_TARGET_ARCH
2110 /* this TI COFF section should be used by all new TI COFF v0 targets */
2112 arch
= TICOFF_TARGET_ARCH
;
2118 /* this TI COFF section should be used by all new TI COFF v1/2 targets */
2119 /* TI COFF1 and COFF2 use the target_id field to specify which arch */
2122 switch (internal_f
->f_target_id
)
2126 arch
= TICOFF_TARGET_ARCH
;
2130 arch
= bfd_arch_obscure
;
2131 (*_bfd_error_handler
)
2132 (_("Unrecognized TI COFF target id '0x%x'"),
2133 internal_f
->f_target_id
);
2139 #ifdef TIC80_ARCH_MAGIC
2140 case TIC80_ARCH_MAGIC
:
2141 arch
= bfd_arch_tic80
;
2147 arch
= bfd_arch_mcore
;
2150 default: /* Unreadable input file type */
2151 arch
= bfd_arch_obscure
;
2155 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2159 #ifdef SYMNAME_IN_DEBUG
2161 static boolean symname_in_debug_hook
2162 PARAMS ((bfd
*, struct internal_syment
*));
2165 symname_in_debug_hook (abfd
, sym
)
2166 bfd
* abfd ATTRIBUTE_UNUSED
;
2167 struct internal_syment
*sym
;
2169 return SYMNAME_IN_DEBUG (sym
) ? true : false;
2174 #define symname_in_debug_hook \
2175 (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
2182 #define FORCE_SYMNAMES_IN_STRINGS
2185 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
2187 static boolean coff_pointerize_aux_hook
2188 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
2189 unsigned int, combined_entry_type
*));
2193 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
2194 bfd
*abfd ATTRIBUTE_UNUSED
;
2195 combined_entry_type
*table_base
;
2196 combined_entry_type
*symbol
;
2197 unsigned int indaux
;
2198 combined_entry_type
*aux
;
2200 int class = symbol
->u
.syment
.n_sclass
;
2202 if ((class == C_EXT
|| class == C_HIDEXT
)
2203 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2205 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2207 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2208 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2209 aux
->fix_scnlen
= 1;
2212 /* Return true to indicate that the caller should not do any
2213 further work on this auxent. */
2217 /* Return false to indicate that this auxent should be handled by
2225 /* We don't want to pointerize bal entries. */
2227 static boolean coff_pointerize_aux_hook
2228 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
2229 unsigned int, combined_entry_type
*));
2233 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
2234 bfd
*abfd ATTRIBUTE_UNUSED
;
2235 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
2236 combined_entry_type
*symbol
;
2237 unsigned int indaux
;
2238 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
2240 /* Return true if we don't want to pointerize this aux entry, which
2241 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2243 && (symbol
->u
.syment
.n_sclass
== C_LEAFPROC
2244 || symbol
->u
.syment
.n_sclass
== C_LEAFSTAT
2245 || symbol
->u
.syment
.n_sclass
== C_LEAFEXT
));
2250 #define coff_pointerize_aux_hook 0
2253 #endif /* ! RS6000COFF_C */
2255 /* Print an aux entry. This returns true if it has printed it. */
2257 static boolean coff_print_aux
2258 PARAMS ((bfd
*, FILE *, combined_entry_type
*, combined_entry_type
*,
2259 combined_entry_type
*, unsigned int));
2262 coff_print_aux (abfd
, file
, table_base
, symbol
, aux
, indaux
)
2263 bfd
*abfd ATTRIBUTE_UNUSED
;
2264 FILE *file ATTRIBUTE_UNUSED
;
2265 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
2266 combined_entry_type
*symbol ATTRIBUTE_UNUSED
;
2267 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
2268 unsigned int indaux ATTRIBUTE_UNUSED
;
2271 if ((symbol
->u
.syment
.n_sclass
== C_EXT
2272 || symbol
->u
.syment
.n_sclass
== C_HIDEXT
)
2273 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2275 /* This is a csect entry. */
2276 fprintf (file
, "AUX ");
2277 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2279 BFD_ASSERT (! aux
->fix_scnlen
);
2281 fprintf (file
, "val %5lld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2283 fprintf (file
, "val %5ld", (long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2288 fprintf (file
, "indx ");
2289 if (! aux
->fix_scnlen
)
2291 fprintf (file
, "%4lld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2293 fprintf (file
, "%4ld", (long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2296 fprintf (file
, "%4ld",
2297 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2300 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2301 aux
->u
.auxent
.x_csect
.x_parmhash
,
2302 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2303 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2304 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2305 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2306 aux
->u
.auxent
.x_csect
.x_stab
,
2307 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2312 /* Return false to indicate that no special action was taken. */
2320 To write relocations, the back end steps though the
2321 canonical relocation table and create an
2322 @code{internal_reloc}. The symbol index to use is removed from
2323 the @code{offset} field in the symbol table supplied. The
2324 address comes directly from the sum of the section base
2325 address and the relocation offset; the type is dug directly
2326 from the howto field. Then the @code{internal_reloc} is
2327 swapped into the shape of an @code{external_reloc} and written
2334 static int compare_arelent_ptr
PARAMS ((const PTR
, const PTR
));
2336 /* AUX's ld wants relocations to be sorted */
2338 compare_arelent_ptr (x
, y
)
2342 const arelent
**a
= (const arelent
**) x
;
2343 const arelent
**b
= (const arelent
**) y
;
2344 bfd_size_type aadr
= (*a
)->address
;
2345 bfd_size_type badr
= (*b
)->address
;
2347 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2350 #endif /* TARG_AUX */
2353 coff_write_relocs (abfd
, first_undef
)
2359 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
2362 struct external_reloc dst
;
2369 /* sort relocations before we write them out */
2372 amt
= s
->reloc_count
;
2373 amt
*= sizeof (arelent
*);
2374 p
= (arelent
**) bfd_malloc (amt
);
2375 if (p
== NULL
&& s
->reloc_count
> 0)
2377 memcpy (p
, s
->orelocation
, (size_t) amt
);
2378 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2382 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2386 if (s
->reloc_count
> 0xffff)
2388 /* encode real count here as first reloc */
2389 struct internal_reloc n
;
2390 memset ((PTR
) & n
, 0, sizeof (n
));
2391 /* add one to count *this* reloc (grr) */
2392 n
.r_vaddr
= s
->reloc_count
+ 1;
2393 coff_swap_reloc_out (abfd
, &n
, &dst
);
2394 if (bfd_bwrite ((PTR
) & dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2395 abfd
) != bfd_coff_relsz (abfd
))
2400 for (i
= 0; i
< s
->reloc_count
; i
++)
2402 struct internal_reloc n
;
2404 memset ((PTR
) & n
, 0, sizeof (n
));
2406 /* Now we've renumbered the symbols we know where the
2407 undefined symbols live in the table. Check the reloc
2408 entries for symbols who's output bfd isn't the right one.
2409 This is because the symbol was undefined (which means
2410 that all the pointers are never made to point to the same
2411 place). This is a bad thing,'cause the symbols attached
2412 to the output bfd are indexed, so that the relocation
2413 entries know which symbol index they point to. So we
2414 have to look up the output symbol here. */
2416 if (q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2419 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2420 asymbol
**outsyms
= abfd
->outsymbols
;
2421 for (j
= first_undef
; outsyms
[j
]; j
++)
2423 const char *intable
= outsyms
[j
]->name
;
2424 if (strcmp (intable
, sname
) == 0) {
2425 /* got a hit, so repoint the reloc */
2426 q
->sym_ptr_ptr
= outsyms
+ j
;
2432 n
.r_vaddr
= q
->address
+ s
->vma
;
2435 /* The 29k const/consth reloc pair is a real kludge. The consth
2436 part doesn't have a symbol; it has an offset. So rebuilt
2438 if (q
->howto
->type
== R_IHCONST
)
2439 n
.r_symndx
= q
->addend
;
2444 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2445 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
,s
))
2447 if (q
->sym_ptr_ptr
== bfd_abs_section_ptr
->symbol_ptr_ptr
)
2449 /* This is a relocation relative to the absolute symbol. */
2453 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2454 /* Take notice if the symbol reloc points to a symbol
2455 we don't have in our symbol table. What should we
2457 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2462 #ifdef SWAP_OUT_RELOC_OFFSET
2463 n
.r_offset
= q
->addend
;
2467 /* Work out reloc type from what is required */
2468 SELECT_RELOC (n
, q
->howto
);
2470 n
.r_type
= q
->howto
->type
;
2472 coff_swap_reloc_out (abfd
, &n
, &dst
);
2473 if (bfd_bwrite ((PTR
) & dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2474 abfd
) != bfd_coff_relsz (abfd
))
2487 /* Set flags and magic number of a coff file from architecture and machine
2488 type. Result is true if we can represent the arch&type, false if not. */
2491 coff_set_flags (abfd
, magicp
, flagsp
)
2493 unsigned int *magicp ATTRIBUTE_UNUSED
;
2494 unsigned short *flagsp ATTRIBUTE_UNUSED
;
2496 switch (bfd_get_arch (abfd
))
2501 switch (bfd_get_mach (abfd
))
2503 case bfd_mach_z8001
:
2506 case bfd_mach_z8002
:
2520 *magicp
= I960ROMAGIC
;
2522 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2523 I960RWMAGIC); FIXME???
2525 switch (bfd_get_mach (abfd
))
2527 case bfd_mach_i960_core
:
2530 case bfd_mach_i960_kb_sb
:
2533 case bfd_mach_i960_mc
:
2536 case bfd_mach_i960_xa
:
2539 case bfd_mach_i960_ca
:
2542 case bfd_mach_i960_ka_sa
:
2545 case bfd_mach_i960_jx
:
2548 case bfd_mach_i960_hx
:
2561 case bfd_arch_tic30
:
2562 *magicp
= TIC30MAGIC
;
2566 #ifdef TICOFF_DEFAULT_MAGIC
2567 case TICOFF_TARGET_ARCH
:
2568 /* if there's no indication of which version we want, use the default */
2570 *magicp
= TICOFF_DEFAULT_MAGIC
;
2573 /* we may want to output in a different COFF version */
2574 switch (abfd
->xvec
->name
[4])
2577 *magicp
= TICOFF0MAGIC
;
2580 *magicp
= TICOFF1MAGIC
;
2583 *magicp
= TICOFF2MAGIC
;
2592 #ifdef TIC80_ARCH_MAGIC
2593 case bfd_arch_tic80
:
2594 *magicp
= TIC80_ARCH_MAGIC
;
2600 * magicp
= ARMPEMAGIC
;
2602 * magicp
= ARMMAGIC
;
2605 if (APCS_SET (abfd
))
2607 if (APCS_26_FLAG (abfd
))
2608 * flagsp
|= F_APCS26
;
2610 if (APCS_FLOAT_FLAG (abfd
))
2611 * flagsp
|= F_APCS_FLOAT
;
2613 if (PIC_FLAG (abfd
))
2616 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2617 * flagsp
|= F_INTERWORK
;
2618 switch (bfd_get_mach (abfd
))
2620 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2621 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2622 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2623 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2624 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2625 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2626 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2627 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5. */
2628 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break;
2629 case bfd_mach_arm_5TE
: * flagsp
|= F_ARM_5
; break;
2630 case bfd_mach_arm_XScale
: * flagsp
|= F_ARM_5
; break;
2635 case bfd_arch_powerpc
:
2642 *magicp
= I386MAGIC
;
2644 /* Just overwrite the usual value if we're doing Lynx. */
2645 *magicp
= LYNXCOFFMAGIC
;
2652 *magicp
= I860MAGIC
;
2658 *magicp
= IA64MAGIC
;
2664 #ifdef APOLLOM68KMAGIC
2665 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
2667 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2668 #ifdef NAMES_HAVE_UNDERSCORE
2669 *magicp
= MC68KBCSMAGIC
;
2671 *magicp
= MC68MAGIC
;
2675 /* Just overwrite the usual value if we're doing Lynx. */
2676 *magicp
= LYNXCOFFMAGIC
;
2684 *magicp
= MC88OMAGIC
;
2689 case bfd_arch_h8300
:
2690 switch (bfd_get_mach (abfd
))
2692 case bfd_mach_h8300
:
2693 *magicp
= H8300MAGIC
;
2695 case bfd_mach_h8300h
:
2696 *magicp
= H8300HMAGIC
;
2698 case bfd_mach_h8300s
:
2699 *magicp
= H8300SMAGIC
;
2705 #ifdef SH_ARCH_MAGIC_BIG
2707 #ifdef COFF_IMAGE_WITH_PE
2708 *magicp
= SH_ARCH_MAGIC_WINCE
;
2710 if (bfd_big_endian (abfd
))
2711 *magicp
= SH_ARCH_MAGIC_BIG
;
2713 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2719 #ifdef MIPS_ARCH_MAGIC_WINCE
2721 *magicp
= MIPS_ARCH_MAGIC_WINCE
;
2727 case bfd_arch_sparc
:
2728 *magicp
= SPARCMAGIC
;
2730 /* Just overwrite the usual value if we're doing Lynx. */
2731 *magicp
= LYNXCOFFMAGIC
;
2738 case bfd_arch_h8500
:
2739 *magicp
= H8500MAGIC
;
2743 #ifdef A29K_MAGIC_BIG
2745 if (bfd_big_endian (abfd
))
2746 *magicp
= A29K_MAGIC_BIG
;
2748 *magicp
= A29K_MAGIC_LITTLE
;
2754 case bfd_arch_we32k
:
2755 *magicp
= WE32KMAGIC
;
2761 case bfd_arch_rs6000
:
2763 case bfd_arch_powerpc
:
2766 if (bfd_get_mach (abfd
) == bfd_mach_ppc_620
2767 && !strncmp (abfd
->xvec
->name
,"aix", 3))
2768 *magicp
= U803XTOCMAGIC
;
2771 *magicp
= U802TOCMAGIC
;
2778 case bfd_arch_mcore
:
2779 * magicp
= MCOREMAGIC
;
2789 #ifdef OR32_MAGIC_BIG
2791 if (bfd_big_endian (abfd
))
2792 * magicp
= OR32_MAGIC_BIG
;
2794 * magicp
= OR32_MAGIC_LITTLE
;
2798 default: /* Unknown architecture. */
2799 /* Fall through to "return false" below, to avoid
2800 "statement never reached" errors on the one below. */
2808 coff_set_arch_mach (abfd
, arch
, machine
)
2810 enum bfd_architecture arch
;
2811 unsigned long machine
;
2814 unsigned short dummy2
;
2816 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
2819 if (arch
!= bfd_arch_unknown
&&
2820 coff_set_flags (abfd
, &dummy1
, &dummy2
) != true)
2821 return false; /* We can't represent this type */
2823 return true; /* We're easy ... */
2826 #ifdef COFF_IMAGE_WITH_PE
2828 /* This is used to sort sections by VMA, as required by PE image
2831 static int sort_by_secaddr
PARAMS ((const PTR
, const PTR
));
2834 sort_by_secaddr (arg1
, arg2
)
2838 const asection
*a
= *(const asection
**) arg1
;
2839 const asection
*b
= *(const asection
**) arg2
;
2841 if (a
->vma
< b
->vma
)
2843 else if (a
->vma
> b
->vma
)
2849 #endif /* COFF_IMAGE_WITH_PE */
2851 /* Calculate the file position for each section. */
2854 #define ALIGN_SECTIONS_IN_FILE
2856 #if defined(TIC80COFF) || defined(TICOFF)
2857 #undef ALIGN_SECTIONS_IN_FILE
2861 coff_compute_section_file_positions (abfd
)
2865 asection
*previous
= (asection
*) NULL
;
2866 file_ptr sofar
= bfd_coff_filhsz (abfd
);
2867 boolean align_adjust
;
2868 #ifdef ALIGN_SECTIONS_IN_FILE
2873 /* On XCOFF, if we have symbols, set up the .debug section. */
2874 if (bfd_get_symcount (abfd
) > 0)
2877 bfd_size_type i
, symcount
;
2881 symcount
= bfd_get_symcount (abfd
);
2882 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
2884 coff_symbol_type
*cf
;
2886 cf
= coff_symbol_from (abfd
, *symp
);
2888 && cf
->native
!= NULL
2889 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
2893 len
= strlen (bfd_asymbol_name (*symp
));
2894 if (len
> SYMNMLEN
|| bfd_coff_force_symnames_in_strings (abfd
))
2895 sz
+= len
+ 1 + bfd_coff_debug_string_prefix_length (abfd
);
2902 dsec
= bfd_make_section_old_way (abfd
, ".debug");
2905 dsec
->_raw_size
= sz
;
2906 dsec
->flags
|= SEC_HAS_CONTENTS
;
2911 #ifdef COFF_IMAGE_WITH_PE
2913 if (coff_data (abfd
)->link_info
)
2915 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
2918 page_size
= PE_DEF_FILE_ALIGNMENT
;
2920 #ifdef COFF_PAGE_SIZE
2921 int page_size
= COFF_PAGE_SIZE
;
2925 if (bfd_get_start_address (abfd
))
2927 /* A start address may have been added to the original file. In this
2928 case it will need an optional header to record it. */
2929 abfd
->flags
|= EXEC_P
;
2932 if (abfd
->flags
& EXEC_P
)
2933 sofar
+= bfd_coff_aoutsz (abfd
);
2935 else if (xcoff_data (abfd
)->full_aouthdr
)
2936 sofar
+= bfd_coff_aoutsz (abfd
);
2938 sofar
+= SMALL_AOUTSZ
;
2941 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2944 /* XCOFF handles overflows in the reloc and line number count fields
2945 by allocating a new section header to hold the correct counts. */
2946 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2947 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
2948 sofar
+= bfd_coff_scnhsz (abfd
);
2951 #ifdef COFF_IMAGE_WITH_PE
2953 /* PE requires the sections to be in memory order when listed in
2954 the section headers. It also does not like empty loadable
2955 sections. The sections apparently do not have to be in the
2956 right order in the image file itself, but we do need to get the
2957 target_index values right. */
2960 asection
**section_list
;
2966 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2969 /* We allocate an extra cell to simplify the final loop. */
2970 amt
= sizeof (struct asection
*) * (count
+ 1);
2971 section_list
= bfd_malloc (amt
);
2972 if (section_list
== NULL
)
2976 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2978 section_list
[i
] = current
;
2981 section_list
[i
] = NULL
;
2983 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
2985 /* Rethread the linked list into sorted order; at the same time,
2986 assign target_index values. */
2988 abfd
->sections
= section_list
[0];
2989 for (i
= 0; i
< count
; i
++)
2991 current
= section_list
[i
];
2992 current
->next
= section_list
[i
+ 1];
2994 /* Later, if the section has zero size, we'll be throwing it
2995 away, so we don't want to number it now. Note that having
2996 a zero size and having real contents are different
2997 concepts: .bss has no contents, but (usually) non-zero
2999 if (current
->_raw_size
== 0)
3001 /* Discard. However, it still might have (valid) symbols
3002 in it, so arbitrarily set it to section 1 (indexing is
3003 1-based here; usually .text). __end__ and other
3004 contents of .endsection really have this happen.
3005 FIXME: This seems somewhat dubious. */
3006 current
->target_index
= 1;
3009 current
->target_index
= target_index
++;
3012 free (section_list
);
3014 #else /* ! COFF_IMAGE_WITH_PE */
3016 /* Set the target_index field. */
3020 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3021 current
->target_index
= target_index
++;
3023 #endif /* ! COFF_IMAGE_WITH_PE */
3025 align_adjust
= false;
3026 for (current
= abfd
->sections
;
3027 current
!= (asection
*) NULL
;
3028 current
= current
->next
)
3030 #ifdef COFF_IMAGE_WITH_PE
3031 /* With PE we have to pad each section to be a multiple of its
3032 page size too, and remember both sizes. */
3033 if (coff_section_data (abfd
, current
) == NULL
)
3035 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
3036 current
->used_by_bfd
= (PTR
) bfd_zalloc (abfd
, amt
);
3037 if (current
->used_by_bfd
== NULL
)
3040 if (pei_section_data (abfd
, current
) == NULL
)
3042 bfd_size_type amt
= sizeof (struct pei_section_tdata
);
3043 coff_section_data (abfd
, current
)->tdata
3044 = (PTR
) bfd_zalloc (abfd
, amt
);
3045 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
3048 if (pei_section_data (abfd
, current
)->virt_size
== 0)
3049 pei_section_data (abfd
, current
)->virt_size
= current
->_raw_size
;
3052 /* Only deal with sections which have contents. */
3053 if (!(current
->flags
& SEC_HAS_CONTENTS
))
3056 #ifdef COFF_IMAGE_WITH_PE
3057 /* Make sure we skip empty sections in a PE image. */
3058 if (current
->_raw_size
== 0)
3062 /* Align the sections in the file to the same boundary on
3063 which they are aligned in virtual memory. I960 doesn't
3064 do this (FIXME) so we can stay in sync with Intel. 960
3065 doesn't yet page from files... */
3066 #ifdef ALIGN_SECTIONS_IN_FILE
3067 if ((abfd
->flags
& EXEC_P
) != 0)
3069 /* make sure this section is aligned on the right boundary - by
3070 padding the previous section up if necessary */
3074 /* AIX loader checks the text section alignment of (vma - filepos)
3075 So even though the filepos may be aligned wrt the o_algntext, for
3076 AIX executables, this check fails. This shows up when an native
3077 AIX executable is stripped with gnu strip because the default vma
3078 of native is 0x10000150 but default for gnu is 0x10000140. Gnu
3079 stripped gnu excutable passes this check because the filepos is
3081 if (!strcmp (current
->name
, _TEXT
))
3086 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3088 align
= 1 << current
->alignment_power
;
3089 pad
= abs (current
->vma
- sofar
) % align
;
3100 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3103 if (previous
!= (asection
*) NULL
)
3105 previous
->_raw_size
+= sofar
- old_sofar
;
3111 /* In demand paged files the low order bits of the file offset
3112 must match the low order bits of the virtual address. */
3113 #ifdef COFF_PAGE_SIZE
3114 if ((abfd
->flags
& D_PAGED
) != 0
3115 && (current
->flags
& SEC_ALLOC
) != 0)
3116 sofar
+= (current
->vma
- sofar
) % page_size
;
3118 current
->filepos
= sofar
;
3120 #ifdef COFF_IMAGE_WITH_PE
3121 /* Set the padded size. */
3122 current
->_raw_size
= (current
->_raw_size
+ page_size
-1) & -page_size
;
3125 sofar
+= current
->_raw_size
;
3127 #ifdef ALIGN_SECTIONS_IN_FILE
3128 /* make sure that this section is of the right size too */
3129 if ((abfd
->flags
& EXEC_P
) == 0)
3131 bfd_size_type old_size
;
3133 old_size
= current
->_raw_size
;
3134 current
->_raw_size
= BFD_ALIGN (current
->_raw_size
,
3135 1 << current
->alignment_power
);
3136 align_adjust
= current
->_raw_size
!= old_size
;
3137 sofar
+= current
->_raw_size
- old_size
;
3142 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3143 align_adjust
= sofar
!= old_sofar
;
3144 current
->_raw_size
+= sofar
- old_sofar
;
3148 #ifdef COFF_IMAGE_WITH_PE
3149 /* For PE we need to make sure we pad out to the aligned
3150 _raw_size, in case the caller only writes out data to the
3151 unaligned _raw_size. */
3152 if (pei_section_data (abfd
, current
)->virt_size
< current
->_raw_size
)
3153 align_adjust
= true;
3157 /* Force .lib sections to start at zero. The vma is then
3158 incremented in coff_set_section_contents. This is right for
3160 if (strcmp (current
->name
, _LIB
) == 0)
3161 bfd_set_section_vma (abfd
, current
, 0);
3167 /* It is now safe to write to the output file. If we needed an
3168 alignment adjustment for the last section, then make sure that
3169 there is a byte at offset sofar. If there are no symbols and no
3170 relocs, then nothing follows the last section. If we don't force
3171 the last byte out, then the file may appear to be truncated. */
3177 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
3178 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3182 /* Make sure the relocations are aligned. We don't need to make
3183 sure that this byte exists, because it will only matter if there
3184 really are relocs. */
3185 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
3187 obj_relocbase (abfd
) = sofar
;
3188 abfd
->output_has_begun
= true;
3195 /* This can never work, because it is called too late--after the
3196 section positions have been set. I can't figure out what it is
3197 for, so I am going to disable it--Ian Taylor 20 March 1996. */
3199 /* If .file, .text, .data, .bss symbols are missing, add them. */
3200 /* @@ Should we only be adding missing symbols, or overriding the aux
3201 values for existing section symbols? */
3203 coff_add_missing_symbols (abfd
)
3206 unsigned int nsyms
= bfd_get_symcount (abfd
);
3207 asymbol
**sympp
= abfd
->outsymbols
;
3210 int need_text
= 1, need_data
= 1, need_bss
= 1, need_file
= 1;
3213 for (i
= 0; i
< nsyms
; i
++)
3215 coff_symbol_type
*csym
= coff_symbol_from (abfd
, sympp
[i
]);
3219 /* only do this if there is a coff representation of the input
3221 if (csym
->native
&& csym
->native
->u
.syment
.n_sclass
== C_FILE
)
3226 name
= csym
->symbol
.name
;
3229 if (!strcmp (name
, _TEXT
))
3232 else if (!strcmp (name
, ".wtext"))
3235 else if (!strcmp (name
, _DATA
))
3237 else if (!strcmp (name
, _BSS
))
3241 /* Now i == bfd_get_symcount (abfd). */
3242 /* @@ For now, don't deal with .file symbol. */
3245 if (!need_text
&& !need_data
&& !need_bss
&& !need_file
)
3247 nsyms
+= need_text
+ need_data
+ need_bss
+ need_file
;
3249 amt
*= sizeof (asymbol
*);
3250 sympp2
= (asymbol
**) bfd_alloc (abfd
, amt
);
3253 memcpy (sympp2
, sympp
, i
* sizeof (asymbol
*));
3256 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
3260 sympp2
[i
++] = coff_section_symbol (abfd
, _TEXT
);
3262 sympp2
[i
++] = coff_section_symbol (abfd
, _DATA
);
3264 sympp2
[i
++] = coff_section_symbol (abfd
, _BSS
);
3265 BFD_ASSERT (i
== nsyms
);
3266 bfd_set_symtab (abfd
, sympp2
, nsyms
);
3275 coff_write_object_contents (abfd
)
3279 boolean hasrelocs
= false;
3280 boolean haslinno
= false;
3281 boolean hasdebug
= false;
3283 file_ptr reloc_base
;
3284 file_ptr lineno_base
;
3286 unsigned long reloc_size
= 0, reloc_count
= 0;
3287 unsigned long lnno_size
= 0;
3288 boolean long_section_names
;
3289 asection
*text_sec
= NULL
;
3290 asection
*data_sec
= NULL
;
3291 asection
*bss_sec
= NULL
;
3292 struct internal_filehdr internal_f
;
3293 struct internal_aouthdr internal_a
;
3294 #ifdef COFF_LONG_SECTION_NAMES
3295 size_t string_size
= STRING_SIZE_SIZE
;
3298 bfd_set_error (bfd_error_system_call
);
3300 /* Make a pass through the symbol table to count line number entries and
3301 put them into the correct asections */
3303 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3305 if (abfd
->output_has_begun
== false)
3307 if (! coff_compute_section_file_positions (abfd
))
3311 reloc_base
= obj_relocbase (abfd
);
3313 /* Work out the size of the reloc and linno areas */
3315 for (current
= abfd
->sections
; current
!= NULL
; current
=
3319 /* we store the actual reloc count in the first reloc's addr */
3320 if (current
->reloc_count
> 0xffff)
3323 reloc_count
+= current
->reloc_count
;
3326 reloc_size
= reloc_count
* bfd_coff_relsz (abfd
);
3328 lineno_base
= reloc_base
+ reloc_size
;
3329 sym_base
= lineno_base
+ lnno_size
;
3331 /* Indicate in each section->line_filepos its actual file address */
3332 for (current
= abfd
->sections
; current
!= NULL
; current
=
3335 if (current
->lineno_count
)
3337 current
->line_filepos
= lineno_base
;
3338 current
->moving_line_filepos
= lineno_base
;
3339 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3343 current
->line_filepos
= 0;
3345 if (current
->reloc_count
)
3347 current
->rel_filepos
= reloc_base
;
3348 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3350 /* extra reloc to hold real count */
3351 if (current
->reloc_count
> 0xffff)
3352 reloc_base
+= bfd_coff_relsz (abfd
);
3357 current
->rel_filepos
= 0;
3361 /* Write section headers to the file. */
3362 internal_f
.f_nscns
= 0;
3364 if ((abfd
->flags
& EXEC_P
) != 0)
3365 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3368 scn_base
= bfd_coff_filhsz (abfd
);
3371 if (xcoff_data (abfd
)->full_aouthdr
)
3372 scn_base
+= bfd_coff_aoutsz (abfd
);
3374 scn_base
+= SMALL_AOUTSZ
;
3379 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3382 long_section_names
= false;
3383 for (current
= abfd
->sections
;
3385 current
= current
->next
)
3387 struct internal_scnhdr section
;
3388 boolean is_reloc_section
= false;
3390 #ifdef COFF_IMAGE_WITH_PE
3391 if (strcmp (current
->name
, ".reloc") == 0)
3393 is_reloc_section
= true;
3395 pe_data (abfd
)->has_reloc_section
= 1;
3399 internal_f
.f_nscns
++;
3401 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3403 #ifdef COFF_LONG_SECTION_NAMES
3404 /* Handle long section names as in PE. This must be compatible
3405 with the code in coff_write_symbols and _bfd_coff_final_link. */
3409 len
= strlen (current
->name
);
3412 memset (section
.s_name
, 0, SCNNMLEN
);
3413 sprintf (section
.s_name
, "/%lu", (unsigned long) string_size
);
3414 string_size
+= len
+ 1;
3415 long_section_names
= true;
3421 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3422 Ian Taylor <ian@cygnus.com>. */
3423 if (strcmp (current
->name
, _LIB
) == 0)
3424 section
.s_vaddr
= 0;
3427 section
.s_vaddr
= current
->vma
;
3428 section
.s_paddr
= current
->lma
;
3429 section
.s_size
= current
->_raw_size
;
3430 #ifdef coff_get_section_load_page
3431 section
.s_page
= coff_get_section_load_page (current
);
3435 section
.s_paddr
= 0;
3437 #ifdef COFF_IMAGE_WITH_PE
3438 /* Reminder: s_paddr holds the virtual size of the section. */
3439 if (coff_section_data (abfd
, current
) != NULL
3440 && pei_section_data (abfd
, current
) != NULL
)
3441 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3443 section
.s_paddr
= 0;
3447 If this section has no size or is unloadable then the scnptr
3450 if (current
->_raw_size
== 0 ||
3451 (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3453 section
.s_scnptr
= 0;
3457 section
.s_scnptr
= current
->filepos
;
3459 section
.s_relptr
= current
->rel_filepos
;
3460 section
.s_lnnoptr
= current
->line_filepos
;
3461 section
.s_nreloc
= current
->reloc_count
;
3462 section
.s_nlnno
= current
->lineno_count
;
3463 #ifndef COFF_IMAGE_WITH_PE
3464 /* In PEI, relocs come in the .reloc section. */
3465 if (current
->reloc_count
!= 0)
3468 if (current
->lineno_count
!= 0)
3470 if ((current
->flags
& SEC_DEBUGGING
) != 0
3471 && ! is_reloc_section
)
3476 /* Indicate the use of an XCOFF overflow section header. */
3477 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3479 section
.s_nreloc
= 0xffff;
3480 section
.s_nlnno
= 0xffff;
3485 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3487 if (!strcmp (current
->name
, _TEXT
))
3491 else if (!strcmp (current
->name
, _DATA
))
3495 else if (!strcmp (current
->name
, _BSS
))
3501 section
.s_align
= (current
->alignment_power
3502 ? 1 << current
->alignment_power
3506 /* TI COFF puts the alignment power in bits 8-11 of the flags */
3507 section
.s_flags
|= (current
->alignment_power
& 0xF) << 8;
3509 #ifdef COFF_ENCODE_ALIGNMENT
3510 COFF_ENCODE_ALIGNMENT(section
, current
->alignment_power
);
3513 #ifdef COFF_IMAGE_WITH_PE
3514 /* Suppress output of the sections if they are null. ld
3515 includes the bss and data sections even if there is no size
3516 assigned to them. NT loader doesn't like it if these section
3517 headers are included if the sections themselves are not
3518 needed. See also coff_compute_section_file_positions. */
3519 if (section
.s_size
== 0)
3520 internal_f
.f_nscns
--;
3525 bfd_size_type amt
= bfd_coff_scnhsz (abfd
);
3527 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3528 || bfd_bwrite ((PTR
) &buff
, amt
, abfd
) != amt
)
3533 /* PE stores COMDAT section information in the symbol table. If
3534 this section is supposed to have some COMDAT info, track down
3535 the symbol in the symbol table and modify it. */
3536 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3538 unsigned int i
, count
;
3540 coff_symbol_type
*csym
= NULL
;
3544 count
= bfd_get_symcount (abfd
);
3545 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3547 if ((*psym
)->section
!= current
)
3550 /* Remember the location of the first symbol in this
3552 if (psymsec
== NULL
)
3555 /* See if this is the section symbol. */
3556 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3558 csym
= coff_symbol_from (abfd
, *psym
);
3560 || csym
->native
== NULL
3561 || csym
->native
->u
.syment
.n_numaux
< 1
3562 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3563 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3566 /* Here *PSYM is the section symbol for CURRENT. */
3573 Note that we might not if we're converting the file from
3574 some other object file format. */
3577 combined_entry_type
*aux
;
3579 /* We don't touch the x_checksum field. The
3580 x_associated field is not currently supported. */
3582 aux
= csym
->native
+ 1;
3583 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3585 case SEC_LINK_DUPLICATES_DISCARD
:
3586 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3589 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3590 aux
->u
.auxent
.x_scn
.x_comdat
=
3591 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3594 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3595 aux
->u
.auxent
.x_scn
.x_comdat
=
3596 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3599 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3600 aux
->u
.auxent
.x_scn
.x_comdat
=
3601 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3605 /* The COMDAT symbol must be the first symbol from this
3606 section in the symbol table. In order to make this
3607 work, we move the COMDAT symbol before the first
3608 symbol we found in the search above. It's OK to
3609 rearrange the symbol table at this point, because
3610 coff_renumber_symbols is going to rearrange it
3611 further and fix up all the aux entries. */
3612 if (psym
!= psymsec
)
3618 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3619 pcopy
[0] = pcopy
[-1];
3624 #endif /* COFF_WITH_PE */
3629 /* XCOFF handles overflows in the reloc and line number count fields
3630 by creating a new section header to hold the correct values. */
3631 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3633 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3635 struct internal_scnhdr scnhdr
;
3639 internal_f
.f_nscns
++;
3640 strncpy (&(scnhdr
.s_name
[0]), current
->name
, 8);
3641 scnhdr
.s_paddr
= current
->reloc_count
;
3642 scnhdr
.s_vaddr
= current
->lineno_count
;
3644 scnhdr
.s_scnptr
= 0;
3645 scnhdr
.s_relptr
= current
->rel_filepos
;
3646 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3647 scnhdr
.s_nreloc
= current
->target_index
;
3648 scnhdr
.s_nlnno
= current
->target_index
;
3649 scnhdr
.s_flags
= STYP_OVRFLO
;
3650 amt
= bfd_coff_scnhsz (abfd
);
3651 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3652 || bfd_bwrite ((PTR
) &buff
, amt
, abfd
) != amt
)
3659 /* OK, now set up the filehdr... */
3661 /* Don't include the internal abs section in the section count */
3664 We will NOT put a fucking timestamp in the header here. Every time you
3665 put it back, I will come in and take it out again. I'm sorry. This
3666 field does not belong here. We fill it with a 0 so it compares the
3667 same but is not a reasonable time. -- gnu@cygnus.com
3669 internal_f
.f_timdat
= 0;
3671 internal_f
.f_flags
= 0;
3673 if (abfd
->flags
& EXEC_P
)
3674 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3677 internal_f
.f_opthdr
= 0;
3680 if (xcoff_data (abfd
)->full_aouthdr
)
3681 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3683 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
3689 internal_f
.f_flags
|= F_RELFLG
;
3691 internal_f
.f_flags
|= F_LNNO
;
3692 if (abfd
->flags
& EXEC_P
)
3693 internal_f
.f_flags
|= F_EXEC
;
3694 #ifdef COFF_IMAGE_WITH_PE
3696 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
3699 #ifndef COFF_WITH_PE
3700 if (bfd_little_endian (abfd
))
3701 internal_f
.f_flags
|= F_AR32WR
;
3703 internal_f
.f_flags
|= F_AR32W
;
3707 /* target id is used in TI COFF v1 and later; COFF0 won't use this field,
3708 but it doesn't hurt to set it internally */
3709 internal_f
.f_target_id
= TI_TARGET_ID
;
3711 #ifdef TIC80_TARGET_ID
3712 internal_f
.f_target_id
= TIC80_TARGET_ID
;
3716 FIXME, should do something about the other byte orders and
3721 if ((abfd
->flags
& DYNAMIC
) != 0)
3722 internal_f
.f_flags
|= F_SHROBJ
;
3723 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
3724 internal_f
.f_flags
|= F_DYNLOAD
;
3727 memset (&internal_a
, 0, sizeof internal_a
);
3729 /* Set up architecture-dependent stuff */
3732 unsigned int magic
= 0;
3733 unsigned short flags
= 0;
3734 coff_set_flags (abfd
, &magic
, &flags
);
3735 internal_f
.f_magic
= magic
;
3736 internal_f
.f_flags
|= flags
;
3737 /* ...and the "opt"hdr... */
3740 #ifdef ULTRA3 /* NYU's machine */
3741 /* FIXME: This is a bogus check. I really want to see if there
3742 * is a .shbss or a .shdata section, if so then set the magic
3743 * number to indicate a shared data executable.
3745 if (internal_f
.f_nscns
>= 7)
3746 internal_a
.magic
= SHMAGIC
; /* Shared magic */
3749 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
3750 #define __A_MAGIC_SET__
3752 #ifdef TICOFF_AOUT_MAGIC
3753 internal_a
.magic
= TICOFF_AOUT_MAGIC
;
3754 #define __A_MAGIC_SET__
3757 internal_a
.magic
= TIC80_ARCH_MAGIC
;
3758 #define __A_MAGIC_SET__
3761 /* FIXME: What are the a.out magic numbers for the i860? */
3762 internal_a
.magic
= 0;
3763 #define __A_MAGIC_SET__
3766 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
3767 #define __A_MAGIC_SET__
3770 #define __A_MAGIC_SET__
3771 internal_a
.magic
= PAGEMAGICBCS
;
3775 #define __A_MAGIC_SET__
3776 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
3779 #if defined(M68) || defined(WE32K) || defined(M68K)
3780 #define __A_MAGIC_SET__
3782 internal_a
.magic
= LYNXCOFFMAGIC
;
3784 #if defined(TARG_AUX)
3785 internal_a
.magic
= (abfd
->flags
& D_PAGED
? PAGEMAGICPEXECPAGED
:
3786 abfd
->flags
& WP_TEXT
? PAGEMAGICPEXECSWAPPED
:
3787 PAGEMAGICEXECSWAPPED
);
3789 #if defined (PAGEMAGICPEXECPAGED)
3790 internal_a
.magic
= PAGEMAGICPEXECPAGED
;
3792 #endif /* TARG_AUX */
3794 #endif /* M68 || WE32K || M68K */
3797 #define __A_MAGIC_SET__
3798 internal_a
.magic
= ZMAGIC
;
3802 #define __A_MAGIC_SET__
3803 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3806 #if defined MCORE_PE
3807 #define __A_MAGIC_SET__
3808 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3812 #define __A_MAGIC_SET__
3814 internal_a
.magic
= LYNXCOFFMAGIC
;
3816 internal_a
.magic
= ZMAGIC
;
3821 #define __A_MAGIC_SET__
3822 internal_a
.magic
= ZMAGIC
;
3826 #define __A_MAGIC_SET__
3828 internal_a
.magic
= LYNXCOFFMAGIC
;
3833 #define __A_MAGIC_SET__
3834 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
3835 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
3836 RS6K_AOUTHDR_OMAGIC
;
3839 #if defined(SH) && defined(COFF_WITH_PE)
3840 #define __A_MAGIC_SET__
3841 internal_a
.magic
= SH_PE_MAGIC
;
3844 #if defined(MIPS) && defined(COFF_WITH_PE)
3845 #define __A_MAGIC_SET__
3846 internal_a
.magic
= MIPS_PE_MAGIC
;
3850 #define __A_MAGIC_SET__
3851 internal_a
.magic
= NMAGIC
; /* Assume separate i/d. */
3854 #ifndef __A_MAGIC_SET__
3855 #include "Your aouthdr magic number is not being set!"
3857 #undef __A_MAGIC_SET__
3861 /* FIXME: Does anybody ever set this to another value? */
3862 internal_a
.vstamp
= 0;
3864 /* Now should write relocs, strings, syms */
3865 obj_sym_filepos (abfd
) = sym_base
;
3867 if (bfd_get_symcount (abfd
) != 0)
3871 if (!coff_add_missing_symbols (abfd
))
3874 if (!coff_renumber_symbols (abfd
, &firstundef
))
3876 coff_mangle_symbols (abfd
);
3877 if (! coff_write_symbols (abfd
))
3879 if (! coff_write_linenumbers (abfd
))
3881 if (! coff_write_relocs (abfd
, firstundef
))
3884 #ifdef COFF_LONG_SECTION_NAMES
3885 else if (long_section_names
&& ! obj_coff_strings_written (abfd
))
3887 /* If we have long section names we have to write out the string
3888 table even if there are no symbols. */
3889 if (! coff_write_symbols (abfd
))
3893 #ifdef COFF_IMAGE_WITH_PE
3895 else if ((abfd
->flags
& EXEC_P
) != 0)
3899 /* PowerPC PE appears to require that all executable files be
3900 rounded up to the page size. */
3903 (file_ptr
) BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
3905 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3911 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3912 backend linker, and obj_raw_syment_count is not valid until after
3913 coff_write_symbols is called. */
3914 if (obj_raw_syment_count (abfd
) != 0)
3916 internal_f
.f_symptr
= sym_base
;
3918 /* AIX appears to require that F_RELFLG not be set if there are
3919 local symbols but no relocations. */
3920 internal_f
.f_flags
&=~ F_RELFLG
;
3925 if (long_section_names
)
3926 internal_f
.f_symptr
= sym_base
;
3928 internal_f
.f_symptr
= 0;
3929 internal_f
.f_flags
|= F_LSYMS
;
3934 internal_a
.tsize
= bfd_get_section_size_before_reloc (text_sec
);
3935 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
3939 internal_a
.dsize
= bfd_get_section_size_before_reloc (data_sec
);
3940 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
3944 internal_a
.bsize
= bfd_get_section_size_before_reloc (bss_sec
);
3945 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
3946 internal_a
.data_start
= bss_sec
->vma
;
3949 internal_a
.entry
= bfd_get_start_address (abfd
);
3950 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
3953 if (xcoff_data (abfd
)->full_aouthdr
)
3956 asection
*loader_sec
;
3958 internal_a
.vstamp
= 1;
3960 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
3961 if (internal_a
.o_snentry
== 0)
3962 internal_a
.entry
= (bfd_vma
) -1;
3964 if (text_sec
!= NULL
)
3966 internal_a
.o_sntext
= text_sec
->target_index
;
3967 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
3971 internal_a
.o_sntext
= 0;
3972 internal_a
.o_algntext
= 0;
3974 if (data_sec
!= NULL
)
3976 internal_a
.o_sndata
= data_sec
->target_index
;
3977 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
3981 internal_a
.o_sndata
= 0;
3982 internal_a
.o_algndata
= 0;
3984 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
3985 if (loader_sec
!= NULL
)
3986 internal_a
.o_snloader
= loader_sec
->target_index
;
3988 internal_a
.o_snloader
= 0;
3989 if (bss_sec
!= NULL
)
3990 internal_a
.o_snbss
= bss_sec
->target_index
;
3992 internal_a
.o_snbss
= 0;
3994 toc
= xcoff_data (abfd
)->toc
;
3995 internal_a
.o_toc
= toc
;
3996 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
3998 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
3999 if (xcoff_data (abfd
)->cputype
!= -1)
4000 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
4003 switch (bfd_get_arch (abfd
))
4005 case bfd_arch_rs6000
:
4006 internal_a
.o_cputype
= 4;
4008 case bfd_arch_powerpc
:
4009 if (bfd_get_mach (abfd
) == 0)
4010 internal_a
.o_cputype
= 3;
4012 internal_a
.o_cputype
= 1;
4018 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
4019 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
4023 /* now write them */
4024 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
4029 bfd_size_type amount
= bfd_coff_filhsz (abfd
);
4031 buff
= bfd_malloc (amount
);
4035 bfd_coff_swap_filehdr_out (abfd
, (PTR
) &internal_f
, (PTR
) buff
);
4036 amount
= bfd_bwrite ((PTR
) buff
, amount
, abfd
);
4040 if (amount
!= bfd_coff_filhsz (abfd
))
4044 if (abfd
->flags
& EXEC_P
)
4046 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4047 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)) */
4049 bfd_size_type amount
= bfd_coff_aoutsz (abfd
);
4051 buff
= bfd_malloc (amount
);
4055 coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, (PTR
) buff
);
4056 amount
= bfd_bwrite ((PTR
) buff
, amount
, abfd
);
4060 if (amount
!= bfd_coff_aoutsz (abfd
))
4069 /* XCOFF seems to always write at least a small a.out header. */
4070 coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, (PTR
) &buff
);
4071 if (xcoff_data (abfd
)->full_aouthdr
)
4072 size
= bfd_coff_aoutsz (abfd
);
4074 size
= SMALL_AOUTSZ
;
4075 if (bfd_bwrite ((PTR
) &buff
, (bfd_size_type
) size
, abfd
) != size
)
4084 coff_set_section_contents (abfd
, section
, location
, offset
, count
)
4089 bfd_size_type count
;
4091 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
4093 if (! coff_compute_section_file_positions (abfd
))
4097 #if defined(_LIB) && !defined(TARG_AUX)
4099 /* The physical address field of a .lib section is used to hold the
4100 number of shared libraries in the section. This code counts the
4101 number of sections being written, and increments the lma field
4104 I have found no documentation on the contents of this section.
4105 Experimentation indicates that the section contains zero or more
4106 records, each of which has the following structure:
4108 - a (four byte) word holding the length of this record, in words,
4109 - a word that always seems to be set to "2",
4110 - the path to a shared library, null-terminated and then padded
4111 to a whole word boundary.
4113 bfd_assert calls have been added to alert if an attempt is made
4114 to write a section which doesn't follow these assumptions. The
4115 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4116 <robertl@arnet.com> (Thanks!).
4118 Gvran Uddeborg <gvran@uddeborg.pp.se> */
4120 if (strcmp (section
->name
, _LIB
) == 0)
4122 bfd_byte
*rec
, *recend
;
4124 rec
= (bfd_byte
*) location
;
4125 recend
= rec
+ count
;
4126 while (rec
< recend
)
4129 rec
+= bfd_get_32 (abfd
, rec
) * 4;
4132 BFD_ASSERT (rec
== recend
);
4137 /* Don't write out bss sections - one way to do this is to
4138 see if the filepos has not been set. */
4139 if (section
->filepos
== 0)
4142 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0)
4148 return bfd_bwrite (location
, count
, abfd
) == count
;
4152 coff_close_and_cleanup (abfd
)
4155 if (!bfd_read_p (abfd
))
4156 switch (abfd
->format
)
4159 if (!_bfd_write_archive_contents (abfd
))
4163 if (!coff_write_object_contents (abfd
))
4167 bfd_set_error (bfd_error_invalid_operation
);
4171 /* We depend on bfd_close to free all the memory on the objalloc. */
4178 buy_and_read (abfd
, where
, size
)
4183 PTR area
= (PTR
) bfd_alloc (abfd
, size
);
4186 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0
4187 || bfd_bread (area
, size
, abfd
) != size
)
4190 } /* buy_and_read() */
4196 Creating the linenumber table is done by reading in the entire
4197 coff linenumber table, and creating another table for internal use.
4199 A coff linenumber table is structured so that each function
4200 is marked as having a line number of 0. Each line within the
4201 function is an offset from the first line in the function. The
4202 base of the line number information for the table is stored in
4203 the symbol associated with the function.
4205 Note: The PE format uses line number 0 for a flag indicating a
4208 The information is copied from the external to the internal
4209 table, and each symbol which marks a function is marked by
4212 How does this work ?
4217 coff_slurp_line_table (abfd
, asect
)
4221 LINENO
*native_lineno
;
4222 alent
*lineno_cache
;
4225 BFD_ASSERT (asect
->lineno
== (alent
*) NULL
);
4227 amt
= (bfd_size_type
) bfd_coff_linesz (abfd
) * asect
->lineno_count
;
4228 native_lineno
= (LINENO
*) buy_and_read (abfd
, asect
->line_filepos
, amt
);
4229 amt
= ((bfd_size_type
) asect
->lineno_count
+ 1) * sizeof (alent
);
4230 lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
);
4231 if (lineno_cache
== NULL
)
4235 unsigned int counter
= 0;
4236 alent
*cache_ptr
= lineno_cache
;
4237 LINENO
*src
= native_lineno
;
4239 while (counter
< asect
->lineno_count
)
4241 struct internal_lineno dst
;
4242 bfd_coff_swap_lineno_in (abfd
, src
, &dst
);
4243 cache_ptr
->line_number
= dst
.l_lnno
;
4245 if (cache_ptr
->line_number
== 0)
4248 bfd_signed_vma symndx
;
4249 coff_symbol_type
*sym
;
4252 symndx
= dst
.l_addr
.l_symndx
;
4254 || (bfd_vma
) symndx
>= obj_raw_syment_count (abfd
))
4256 (*_bfd_error_handler
)
4257 (_("%s: warning: illegal symbol index %ld in line numbers"),
4258 bfd_archive_filename (abfd
), dst
.l_addr
.l_symndx
);
4262 /* FIXME: We should not be casting between ints and
4263 pointers like this. */
4264 sym
= ((coff_symbol_type
*)
4265 ((symndx
+ obj_raw_syments (abfd
))
4266 ->u
.syment
._n
._n_n
._n_zeroes
));
4267 cache_ptr
->u
.sym
= (asymbol
*) sym
;
4268 if (sym
->lineno
!= NULL
&& ! warned
)
4270 (*_bfd_error_handler
)
4271 (_("%s: warning: duplicate line number information for `%s'"),
4272 bfd_archive_filename (abfd
),
4273 bfd_asymbol_name (&sym
->symbol
));
4275 sym
->lineno
= cache_ptr
;
4279 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
4280 - bfd_section_vma (abfd
, asect
);
4281 } /* If no linenumber expect a symbol index */
4287 cache_ptr
->line_number
= 0;
4290 asect
->lineno
= lineno_cache
;
4291 /* FIXME, free native_lineno here, or use alloca or something. */
4295 /* Slurp in the symbol table, converting it to generic form. Note
4296 that if coff_relocate_section is defined, the linker will read
4297 symbols via coff_link_add_symbols, rather than via this routine. */
4300 coff_slurp_symbol_table (abfd
)
4303 combined_entry_type
*native_symbols
;
4304 coff_symbol_type
*cached_area
;
4305 unsigned int *table_ptr
;
4308 unsigned int number_of_symbols
= 0;
4310 if (obj_symbols (abfd
))
4313 /* Read in the symbol table */
4314 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4319 /* Allocate enough room for all the symbols in cached form */
4320 amt
= obj_raw_syment_count (abfd
);
4321 amt
*= sizeof (coff_symbol_type
);
4322 cached_area
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
4323 if (cached_area
== NULL
)
4326 amt
= obj_raw_syment_count (abfd
);
4327 amt
*= sizeof (unsigned int);
4328 table_ptr
= (unsigned int *) bfd_alloc (abfd
, amt
);
4330 if (table_ptr
== NULL
)
4334 coff_symbol_type
*dst
= cached_area
;
4335 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4336 unsigned int this_index
= 0;
4337 while (this_index
< last_native_index
)
4339 combined_entry_type
*src
= native_symbols
+ this_index
;
4340 table_ptr
[this_index
] = number_of_symbols
;
4341 dst
->symbol
.the_bfd
= abfd
;
4343 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4344 /* We use the native name field to point to the cached field. */
4345 src
->u
.syment
._n
._n_n
._n_zeroes
= (long) dst
;
4346 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4347 src
->u
.syment
.n_scnum
);
4348 dst
->symbol
.flags
= 0;
4349 dst
->done_lineno
= false;
4351 switch (src
->u
.syment
.n_sclass
)
4356 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
4357 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4358 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4360 /* Fall through to next case */
4368 case C_THUMBEXTFUNC
:
4374 case C_SYSTEM
: /* System Wide variable */
4377 /* In PE, 0x68 (104) denotes a section symbol */
4379 /* In PE, 0x69 (105) denotes a weak external symbol. */
4382 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4384 case COFF_SYMBOL_GLOBAL
:
4385 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4386 #if defined COFF_WITH_PE
4387 /* PE sets the symbol to a value relative to the
4388 start of the section. */
4389 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4391 dst
->symbol
.value
= (src
->u
.syment
.n_value
4392 - dst
->symbol
.section
->vma
);
4394 if (ISFCN ((src
->u
.syment
.n_type
)))
4396 /* A function ext does not go at the end of a
4398 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4402 case COFF_SYMBOL_COMMON
:
4403 dst
->symbol
.section
= bfd_com_section_ptr
;
4404 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4407 case COFF_SYMBOL_UNDEFINED
:
4408 dst
->symbol
.section
= bfd_und_section_ptr
;
4409 dst
->symbol
.value
= 0;
4412 case COFF_SYMBOL_PE_SECTION
:
4413 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4414 dst
->symbol
.value
= 0;
4417 case COFF_SYMBOL_LOCAL
:
4418 dst
->symbol
.flags
= BSF_LOCAL
;
4419 #if defined COFF_WITH_PE
4420 /* PE sets the symbol to a value relative to the
4421 start of the section. */
4422 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4424 dst
->symbol
.value
= (src
->u
.syment
.n_value
4425 - dst
->symbol
.section
->vma
);
4427 if (ISFCN ((src
->u
.syment
.n_type
)))
4428 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4433 /* A symbol with a csect entry should not go at the end. */
4434 if (src
->u
.syment
.n_numaux
> 0)
4435 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4439 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4440 dst
->symbol
.flags
= BSF_WEAK
;
4441 if (src
->u
.syment
.n_sclass
== C_SECTION
4442 && src
->u
.syment
.n_scnum
> 0)
4444 dst
->symbol
.flags
= BSF_LOCAL
;
4448 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
)
4449 dst
->symbol
.flags
= BSF_WEAK
;
4453 case C_STAT
: /* static */
4455 case C_LEAFSTAT
: /* static leaf procedure */
4458 case C_THUMBSTAT
: /* Thumb static */
4459 case C_THUMBLABEL
: /* Thumb label */
4460 case C_THUMBSTATFUNC
:/* Thumb static function */
4462 case C_LABEL
: /* label */
4463 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4464 dst
->symbol
.flags
= BSF_DEBUGGING
;
4466 dst
->symbol
.flags
= BSF_LOCAL
;
4468 /* Base the value as an index from the base of the
4469 section, if there is one. */
4470 if (dst
->symbol
.section
)
4472 #if defined COFF_WITH_PE
4473 /* PE sets the symbol to a value relative to the
4474 start of the section. */
4475 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4477 dst
->symbol
.value
= (src
->u
.syment
.n_value
4478 - dst
->symbol
.section
->vma
);
4482 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4485 case C_MOS
: /* member of structure */
4486 case C_EOS
: /* end of structure */
4487 #ifdef NOTDEF /* C_AUTOARG has the same value */
4489 case C_GLBLREG
: /* A29k-specific storage class */
4492 case C_REGPARM
: /* register parameter */
4493 case C_REG
: /* register variable */
4494 /* C_AUTOARG conflictes with TI COFF C_UEXT */
4495 #if !defined (TIC80COFF) && !defined (TICOFF)
4497 case C_AUTOARG
: /* 960-specific storage class */
4500 case C_TPDEF
: /* type definition */
4502 case C_AUTO
: /* automatic variable */
4503 case C_FIELD
: /* bit field */
4504 case C_ENTAG
: /* enumeration tag */
4505 case C_MOE
: /* member of enumeration */
4506 case C_MOU
: /* member of union */
4507 case C_UNTAG
: /* union tag */
4508 dst
->symbol
.flags
= BSF_DEBUGGING
;
4509 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4512 case C_FILE
: /* file name */
4513 case C_STRTAG
: /* structure tag */
4528 dst
->symbol
.flags
= BSF_DEBUGGING
;
4529 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4533 case C_BINCL
: /* beginning of include file */
4534 case C_EINCL
: /* ending of include file */
4535 /* The value is actually a pointer into the line numbers
4536 of the file. We locate the line number entry, and
4537 set the section to the section which contains it, and
4538 the value to the index in that section. */
4542 dst
->symbol
.flags
= BSF_DEBUGGING
;
4543 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4544 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4545 && ((file_ptr
) (sec
->line_filepos
4546 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4547 > (file_ptr
) src
->u
.syment
.n_value
))
4550 dst
->symbol
.value
= 0;
4553 dst
->symbol
.section
= sec
;
4554 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4555 - sec
->line_filepos
)
4556 / bfd_coff_linesz (abfd
));
4563 dst
->symbol
.flags
= BSF_DEBUGGING
;
4565 /* The value is actually a symbol index. Save a pointer
4566 to the symbol instead of the index. FIXME: This
4567 should use a union. */
4568 src
->u
.syment
.n_value
=
4569 (long) (native_symbols
+ src
->u
.syment
.n_value
);
4570 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4575 case C_BLOCK
: /* ".bb" or ".eb" */
4576 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf") */
4577 case C_EFCN
: /* physical end of function */
4578 #if defined COFF_WITH_PE
4579 /* PE sets the symbol to a value relative to the start
4581 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4582 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4584 /* PE uses funny values for .ef and .lf; don't
4586 dst
->symbol
.flags
= BSF_DEBUGGING
;
4589 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4591 /* Base the value as an index from the base of the
4593 dst
->symbol
.flags
= BSF_LOCAL
;
4594 dst
->symbol
.value
= (src
->u
.syment
.n_value
4595 - dst
->symbol
.section
->vma
);
4599 case C_STATLAB
: /* Static load time label */
4600 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4601 dst
->symbol
.flags
= BSF_GLOBAL
;
4605 /* PE DLLs sometimes have zeroed out symbols for some
4606 reason. Just ignore them without a warning. */
4607 if (src
->u
.syment
.n_type
== 0
4608 && src
->u
.syment
.n_value
== 0
4609 && src
->u
.syment
.n_scnum
== 0)
4612 case C_EXTDEF
: /* external definition */
4613 case C_ULABEL
: /* undefined label */
4614 case C_USTATIC
: /* undefined static */
4615 #ifndef COFF_WITH_PE
4616 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4617 class to represent a section symbol */
4618 case C_LINE
: /* line # reformatted as symbol table entry */
4619 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4620 case C_ALIAS
: /* duplicate tag */
4622 /* New storage classes for TI COFF */
4623 #if defined(TIC80COFF) || defined(TICOFF)
4624 case C_UEXT
: /* Tentative external definition */
4626 case C_EXTLAB
: /* External load time label */
4627 case C_HIDDEN
: /* ext symbol in dmert public lib */
4629 (*_bfd_error_handler
)
4630 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
4631 bfd_archive_filename (abfd
), src
->u
.syment
.n_sclass
,
4632 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4633 dst
->symbol
.flags
= BSF_DEBUGGING
;
4634 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4638 /* BFD_ASSERT(dst->symbol.flags != 0);*/
4642 dst
->symbol
.udata
.i
= 0;
4643 dst
->lineno
= (alent
*) NULL
;
4644 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
4646 number_of_symbols
++;
4647 } /* walk the native symtab */
4648 } /* bfdize the native symtab */
4650 obj_symbols (abfd
) = cached_area
;
4651 obj_raw_syments (abfd
) = native_symbols
;
4653 bfd_get_symcount (abfd
) = number_of_symbols
;
4654 obj_convert (abfd
) = table_ptr
;
4655 /* Slurp the line tables for each section too */
4661 coff_slurp_line_table (abfd
, p
);
4666 } /* coff_slurp_symbol_table() */
4668 /* Classify a COFF symbol. A couple of targets have globally visible
4669 symbols which are not class C_EXT, and this handles those. It also
4670 recognizes some special PE cases. */
4672 static enum coff_symbol_classification
4673 coff_classify_symbol (abfd
, syment
)
4675 struct internal_syment
*syment
;
4677 /* FIXME: This partially duplicates the switch in
4678 coff_slurp_symbol_table. */
4679 switch (syment
->n_sclass
)
4688 case C_THUMBEXTFUNC
:
4696 if (syment
->n_scnum
== 0)
4698 if (syment
->n_value
== 0)
4699 return COFF_SYMBOL_UNDEFINED
;
4701 return COFF_SYMBOL_COMMON
;
4703 return COFF_SYMBOL_GLOBAL
;
4710 if (syment
->n_sclass
== C_STAT
)
4712 if (syment
->n_scnum
== 0)
4714 /* The Microsoft compiler sometimes generates these if a
4715 small static function is inlined every time it is used.
4716 The function is discarded, but the symbol table entry
4718 return COFF_SYMBOL_LOCAL
;
4721 #ifdef STRICT_PE_FORMAT
4722 /* This is correct for Microsoft generated objects, but it
4723 breaks gas generated objects. */
4725 if (syment
->n_value
== 0)
4728 char buf
[SYMNMLEN
+ 1];
4730 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
4732 && (strcmp (bfd_get_section_name (abfd
, sec
),
4733 _bfd_coff_internal_syment_name (abfd
, syment
, buf
))
4735 return COFF_SYMBOL_PE_SECTION
;
4739 return COFF_SYMBOL_LOCAL
;
4742 if (syment
->n_sclass
== C_SECTION
)
4744 /* In some cases in a DLL generated by the Microsoft linker, the
4745 n_value field will contain garbage. FIXME: This should
4746 probably be handled by the swapping function instead. */
4747 syment
->n_value
= 0;
4748 if (syment
->n_scnum
== 0)
4749 return COFF_SYMBOL_UNDEFINED
;
4750 return COFF_SYMBOL_PE_SECTION
;
4752 #endif /* COFF_WITH_PE */
4754 /* If it is not a global symbol, we presume it is a local symbol. */
4756 if (syment
->n_scnum
== 0)
4758 char buf
[SYMNMLEN
+ 1];
4760 (*_bfd_error_handler
)
4761 (_("warning: %s: local symbol `%s' has no section"),
4762 bfd_archive_filename (abfd
),
4763 _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
4766 return COFF_SYMBOL_LOCAL
;
4773 Coff relocations are easily transformed into the internal BFD form
4776 Reading a coff relocation table is done in the following stages:
4778 o Read the entire coff relocation table into memory.
4780 o Process each relocation in turn; first swap it from the
4781 external to the internal form.
4783 o Turn the symbol referenced in the relocation's symbol index
4784 into a pointer into the canonical symbol table.
4785 This table is the same as the one returned by a call to
4786 @code{bfd_canonicalize_symtab}. The back end will call that
4787 routine and save the result if a canonicalization hasn't been done.
4789 o The reloc index is turned into a pointer to a howto
4790 structure, in a back end specific way. For instance, the 386
4791 and 960 use the @code{r_type} to directly produce an index
4792 into a howto table vector; the 88k subtracts a number from the
4793 @code{r_type} field and creates an addend field.
4798 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
4800 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
4801 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
4802 coffsym = (obj_symbols (abfd) \
4803 + (cache_ptr->sym_ptr_ptr - symbols)); \
4805 coffsym = coff_symbol_from (abfd, ptr); \
4806 if (coffsym != (coff_symbol_type *) NULL \
4807 && coffsym->native->u.syment.n_scnum == 0) \
4808 cache_ptr->addend = 0; \
4809 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
4810 && ptr->section != (asection *) NULL) \
4811 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
4813 cache_ptr->addend = 0; \
4818 coff_slurp_reloc_table (abfd
, asect
, symbols
)
4823 RELOC
*native_relocs
;
4824 arelent
*reloc_cache
;
4829 if (asect
->relocation
)
4831 if (asect
->reloc_count
== 0)
4833 if (asect
->flags
& SEC_CONSTRUCTOR
)
4835 if (!coff_slurp_symbol_table (abfd
))
4837 amt
= (bfd_size_type
) bfd_coff_relsz (abfd
) * asect
->reloc_count
;
4838 native_relocs
= (RELOC
*) buy_and_read (abfd
, asect
->rel_filepos
, amt
);
4839 amt
= (bfd_size_type
) asect
->reloc_count
* sizeof (arelent
);
4840 reloc_cache
= (arelent
*) bfd_alloc (abfd
, amt
);
4842 if (reloc_cache
== NULL
)
4845 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
4847 struct internal_reloc dst
;
4848 struct external_reloc
*src
;
4849 #ifndef RELOC_PROCESSING
4853 cache_ptr
= reloc_cache
+ idx
;
4854 src
= native_relocs
+ idx
;
4856 coff_swap_reloc_in (abfd
, src
, &dst
);
4858 #ifdef RELOC_PROCESSING
4859 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
4861 cache_ptr
->address
= dst
.r_vaddr
;
4863 if (dst
.r_symndx
!= -1)
4865 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
4867 (*_bfd_error_handler
)
4868 (_("%s: warning: illegal symbol index %ld in relocs"),
4869 bfd_archive_filename (abfd
), dst
.r_symndx
);
4870 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
4875 cache_ptr
->sym_ptr_ptr
= (symbols
4876 + obj_convert (abfd
)[dst
.r_symndx
]);
4877 ptr
= *(cache_ptr
->sym_ptr_ptr
);
4882 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
4886 /* The symbols definitions that we have read in have been
4887 relocated as if their sections started at 0. But the offsets
4888 refering to the symbols in the raw data have not been
4889 modified, so we have to have a negative addend to compensate.
4891 Note that symbols which used to be common must be left alone */
4893 /* Calculate any reloc addend by looking at the symbol */
4894 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
4896 cache_ptr
->address
-= asect
->vma
;
4897 /* !! cache_ptr->section = (asection *) NULL;*/
4899 /* Fill in the cache_ptr->howto field from dst.r_type */
4900 RTYPE2HOWTO (cache_ptr
, &dst
);
4901 #endif /* RELOC_PROCESSING */
4903 if (cache_ptr
->howto
== NULL
)
4905 (*_bfd_error_handler
)
4906 (_("%s: illegal relocation type %d at address 0x%lx"),
4907 bfd_archive_filename (abfd
), dst
.r_type
, (long) dst
.r_vaddr
);
4908 bfd_set_error (bfd_error_bad_value
);
4913 asect
->relocation
= reloc_cache
;
4917 #ifndef coff_rtype_to_howto
4920 /* Get the howto structure for a reloc. This is only used if the file
4921 including this one defines coff_relocate_section to be
4922 _bfd_coff_generic_relocate_section, so it is OK if it does not
4923 always work. It is the responsibility of the including file to
4924 make sure it is reasonable if it is needed. */
4926 static reloc_howto_type
*coff_rtype_to_howto
4927 PARAMS ((bfd
*, asection
*, struct internal_reloc
*,
4928 struct coff_link_hash_entry
*, struct internal_syment
*,
4932 static reloc_howto_type
*
4933 coff_rtype_to_howto (abfd
, sec
, rel
, h
, sym
, addendp
)
4934 bfd
*abfd ATTRIBUTE_UNUSED
;
4935 asection
*sec ATTRIBUTE_UNUSED
;
4936 struct internal_reloc
*rel
;
4937 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
;
4938 struct internal_syment
*sym ATTRIBUTE_UNUSED
;
4939 bfd_vma
*addendp ATTRIBUTE_UNUSED
;
4943 RTYPE2HOWTO (&genrel
, rel
);
4944 return genrel
.howto
;
4947 #else /* ! defined (RTYPE2HOWTO) */
4949 #define coff_rtype_to_howto NULL
4951 #endif /* ! defined (RTYPE2HOWTO) */
4952 #endif /* ! defined (coff_rtype_to_howto) */
4954 /* This is stupid. This function should be a boolean predicate. */
4956 coff_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
4962 arelent
*tblptr
= section
->relocation
;
4963 unsigned int count
= 0;
4965 if (section
->flags
& SEC_CONSTRUCTOR
)
4967 /* this section has relocs made up by us, they are not in the
4968 file, so take them out of their chain and place them into
4969 the data area provided */
4970 arelent_chain
*chain
= section
->constructor_chain
;
4971 for (count
= 0; count
< section
->reloc_count
; count
++)
4973 *relptr
++ = &chain
->relent
;
4974 chain
= chain
->next
;
4980 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
4983 tblptr
= section
->relocation
;
4985 for (; count
++ < section
->reloc_count
;)
4986 *relptr
++ = tblptr
++;
4989 return section
->reloc_count
;
4994 coff_sym_filepos (abfd
)
4997 return obj_sym_filepos (abfd
);
5001 #ifndef coff_reloc16_estimate
5002 #define coff_reloc16_estimate dummy_reloc16_estimate
5004 static int dummy_reloc16_estimate
5005 PARAMS ((bfd
*, asection
*, arelent
*, unsigned int,
5006 struct bfd_link_info
*));
5009 dummy_reloc16_estimate (abfd
, input_section
, reloc
, shrink
, link_info
)
5010 bfd
*abfd ATTRIBUTE_UNUSED
;
5011 asection
*input_section ATTRIBUTE_UNUSED
;
5012 arelent
*reloc ATTRIBUTE_UNUSED
;
5013 unsigned int shrink ATTRIBUTE_UNUSED
;
5014 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
5022 #ifndef coff_reloc16_extra_cases
5024 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5026 /* This works even if abort is not declared in any header file. */
5028 static void dummy_reloc16_extra_cases
5029 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*, arelent
*,
5030 bfd_byte
*, unsigned int *, unsigned int *));
5033 dummy_reloc16_extra_cases (abfd
, link_info
, link_order
, reloc
, data
, src_ptr
,
5035 bfd
*abfd ATTRIBUTE_UNUSED
;
5036 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
5037 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
;
5038 arelent
*reloc ATTRIBUTE_UNUSED
;
5039 bfd_byte
*data ATTRIBUTE_UNUSED
;
5040 unsigned int *src_ptr ATTRIBUTE_UNUSED
;
5041 unsigned int *dst_ptr ATTRIBUTE_UNUSED
;
5047 /* If coff_relocate_section is defined, we can use the optimized COFF
5048 backend linker. Otherwise we must continue to use the old linker. */
5049 #ifdef coff_relocate_section
5050 #ifndef coff_bfd_link_hash_table_create
5051 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5053 #ifndef coff_bfd_link_add_symbols
5054 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5056 #ifndef coff_bfd_final_link
5057 #define coff_bfd_final_link _bfd_coff_final_link
5059 #else /* ! defined (coff_relocate_section) */
5060 #define coff_relocate_section NULL
5061 #ifndef coff_bfd_link_hash_table_create
5062 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5064 #ifndef coff_bfd_link_add_symbols
5065 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5067 #define coff_bfd_final_link _bfd_generic_final_link
5068 #endif /* ! defined (coff_relocate_section) */
5070 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5072 #ifndef coff_start_final_link
5073 #define coff_start_final_link NULL
5076 #ifndef coff_adjust_symndx
5077 #define coff_adjust_symndx NULL
5080 #ifndef coff_link_add_one_symbol
5081 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5084 #ifndef coff_link_output_has_begun
5086 static boolean coff_link_output_has_begun
5087 PARAMS ((bfd
*, struct coff_final_link_info
*));
5090 coff_link_output_has_begun (abfd
, info
)
5092 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
;
5094 return abfd
->output_has_begun
;
5098 #ifndef coff_final_link_postscript
5100 static boolean coff_final_link_postscript
5101 PARAMS ((bfd
*, struct coff_final_link_info
*));
5104 coff_final_link_postscript (abfd
, pfinfo
)
5105 bfd
* abfd ATTRIBUTE_UNUSED
;
5106 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
;
5112 #ifndef coff_SWAP_aux_in
5113 #define coff_SWAP_aux_in coff_swap_aux_in
5115 #ifndef coff_SWAP_sym_in
5116 #define coff_SWAP_sym_in coff_swap_sym_in
5118 #ifndef coff_SWAP_lineno_in
5119 #define coff_SWAP_lineno_in coff_swap_lineno_in
5121 #ifndef coff_SWAP_aux_out
5122 #define coff_SWAP_aux_out coff_swap_aux_out
5124 #ifndef coff_SWAP_sym_out
5125 #define coff_SWAP_sym_out coff_swap_sym_out
5127 #ifndef coff_SWAP_lineno_out
5128 #define coff_SWAP_lineno_out coff_swap_lineno_out
5130 #ifndef coff_SWAP_reloc_out
5131 #define coff_SWAP_reloc_out coff_swap_reloc_out
5133 #ifndef coff_SWAP_filehdr_out
5134 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5136 #ifndef coff_SWAP_aouthdr_out
5137 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5139 #ifndef coff_SWAP_scnhdr_out
5140 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5142 #ifndef coff_SWAP_reloc_in
5143 #define coff_SWAP_reloc_in coff_swap_reloc_in
5145 #ifndef coff_SWAP_filehdr_in
5146 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5148 #ifndef coff_SWAP_aouthdr_in
5149 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5151 #ifndef coff_SWAP_scnhdr_in
5152 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5155 static const bfd_coff_backend_data bfd_coff_std_swap_table
=
5157 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5158 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5159 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5160 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5161 coff_SWAP_scnhdr_out
,
5162 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5163 #ifdef COFF_LONG_FILENAMES
5168 #ifdef COFF_LONG_SECTION_NAMES
5173 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5174 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5179 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5184 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5185 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5186 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5187 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5188 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5189 coff_classify_symbol
, coff_compute_section_file_positions
,
5190 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5191 coff_adjust_symndx
, coff_link_add_one_symbol
,
5192 coff_link_output_has_begun
, coff_final_link_postscript
5195 #ifndef coff_close_and_cleanup
5196 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5199 #ifndef coff_bfd_free_cached_info
5200 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5203 #ifndef coff_get_section_contents
5204 #define coff_get_section_contents _bfd_generic_get_section_contents
5207 #ifndef coff_bfd_copy_private_symbol_data
5208 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5211 #ifndef coff_bfd_copy_private_section_data
5212 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5215 #ifndef coff_bfd_copy_private_bfd_data
5216 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5219 #ifndef coff_bfd_merge_private_bfd_data
5220 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5223 #ifndef coff_bfd_set_private_flags
5224 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5227 #ifndef coff_bfd_print_private_bfd_data
5228 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5231 #ifndef coff_bfd_is_local_label_name
5232 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5235 #ifndef coff_read_minisymbols
5236 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5239 #ifndef coff_minisymbol_to_symbol
5240 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5243 /* The reloc lookup routine must be supplied by each individual COFF
5245 #ifndef coff_bfd_reloc_type_lookup
5246 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5249 #ifndef coff_bfd_get_relocated_section_contents
5250 #define coff_bfd_get_relocated_section_contents \
5251 bfd_generic_get_relocated_section_contents
5254 #ifndef coff_bfd_relax_section
5255 #define coff_bfd_relax_section bfd_generic_relax_section
5258 #ifndef coff_bfd_gc_sections
5259 #define coff_bfd_gc_sections bfd_generic_gc_sections
5262 #ifndef coff_bfd_merge_sections
5263 #define coff_bfd_merge_sections bfd_generic_merge_sections
5266 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
5267 const bfd_target VAR = \
5270 bfd_target_coff_flavour, \
5271 BFD_ENDIAN_BIG, /* data byte order is big */ \
5272 BFD_ENDIAN_BIG, /* header byte order is big */ \
5273 /* object flags */ \
5274 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5275 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5276 /* section flags */ \
5277 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5278 UNDER, /* leading symbol underscore */ \
5279 '/', /* ar_pad_char */ \
5280 15, /* ar_max_namelen */ \
5282 /* Data conversion functions. */ \
5283 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5284 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5285 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5287 /* Header conversion functions. */ \
5288 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5289 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5290 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5292 /* bfd_check_format */ \
5293 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5294 _bfd_dummy_target }, \
5295 /* bfd_set_format */ \
5296 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5297 /* bfd_write_contents */ \
5298 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5301 BFD_JUMP_TABLE_GENERIC (coff), \
5302 BFD_JUMP_TABLE_COPY (coff), \
5303 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5304 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5305 BFD_JUMP_TABLE_SYMBOLS (coff), \
5306 BFD_JUMP_TABLE_RELOCS (coff), \
5307 BFD_JUMP_TABLE_WRITE (coff), \
5308 BFD_JUMP_TABLE_LINK (coff), \
5309 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5316 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
5317 const bfd_target VAR = \
5320 bfd_target_coff_flavour, \
5321 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
5322 BFD_ENDIAN_LITTLE, /* header byte order is little */ \
5323 /* object flags */ \
5324 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5325 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5326 /* section flags */ \
5327 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5328 UNDER, /* leading symbol underscore */ \
5329 '/', /* ar_pad_char */ \
5330 15, /* ar_max_namelen */ \
5332 /* Data conversion functions. */ \
5333 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5334 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5335 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5336 /* Header conversion functions. */ \
5337 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5338 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5339 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5340 /* bfd_check_format */ \
5341 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5342 _bfd_dummy_target }, \
5343 /* bfd_set_format */ \
5344 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5345 /* bfd_write_contents */ \
5346 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5349 BFD_JUMP_TABLE_GENERIC (coff), \
5350 BFD_JUMP_TABLE_COPY (coff), \
5351 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5352 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5353 BFD_JUMP_TABLE_SYMBOLS (coff), \
5354 BFD_JUMP_TABLE_RELOCS (coff), \
5355 BFD_JUMP_TABLE_WRITE (coff), \
5356 BFD_JUMP_TABLE_LINK (coff), \
5357 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \