1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright (C) 1990-2014 Free Software Foundation, Inc.
3 Written by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
22 /* Most of this hacked by Steve Chamberlain,
28 BFD supports a number of different flavours of coff format.
29 The major differences between formats are the sizes and
30 alignments of fields in structures on disk, and the occasional
33 Coff in all its varieties is implemented with a few common
34 files and a number of implementation specific files. For
35 example, The 88k bcs coff format is implemented in the file
36 @file{coff-m88k.c}. This file @code{#include}s
37 @file{coff/m88k.h} which defines the external structure of the
38 coff format for the 88k, and @file{coff/internal.h} which
39 defines the internal structure. @file{coff-m88k.c} also
40 defines the relocations used by the 88k format
43 The Intel i960 processor version of coff is implemented in
44 @file{coff-i960.c}. This file has the same structure as
45 @file{coff-m88k.c}, except that it includes @file{coff/i960.h}
46 rather than @file{coff-m88k.h}.
49 Porting to a new version of coff
51 The recommended method is to select from the existing
52 implementations the version of coff which is most like the one
53 you want to use. For example, we'll say that i386 coff is
54 the one you select, and that your coff flavour is called foo.
55 Copy @file{i386coff.c} to @file{foocoff.c}, copy
56 @file{../include/coff/i386.h} to @file{../include/coff/foo.h},
57 and add the lines to @file{targets.c} and @file{Makefile.in}
58 so that your new back end is used. Alter the shapes of the
59 structures in @file{../include/coff/foo.h} so that they match
60 what you need. You will probably also have to add
61 @code{#ifdef}s to the code in @file{coff/internal.h} and
62 @file{coffcode.h} if your version of coff is too wild.
64 You can verify that your new BFD backend works quite simply by
65 building @file{objdump} from the @file{binutils} directory,
66 and making sure that its version of what's going on and your
67 host system's idea (assuming it has the pretty standard coff
68 dump utility, usually called @code{att-dump} or just
69 @code{dump}) are the same. Then clean up your code, and send
70 what you've done to Cygnus. Then your stuff will be in the
71 next release, and you won't have to keep integrating it.
74 How the coff backend works
79 The Coff backend is split into generic routines that are
80 applicable to any Coff target and routines that are specific
81 to a particular target. The target-specific routines are
82 further split into ones which are basically the same for all
83 Coff targets except that they use the external symbol format
84 or use different values for certain constants.
86 The generic routines are in @file{coffgen.c}. These routines
87 work for any Coff target. They use some hooks into the target
88 specific code; the hooks are in a @code{bfd_coff_backend_data}
89 structure, one of which exists for each target.
91 The essentially similar target-specific routines are in
92 @file{coffcode.h}. This header file includes executable C code.
93 The various Coff targets first include the appropriate Coff
94 header file, make any special defines that are needed, and
95 then include @file{coffcode.h}.
97 Some of the Coff targets then also have additional routines in
98 the target source file itself.
100 For example, @file{coff-i960.c} includes
101 @file{coff/internal.h} and @file{coff/i960.h}. It then
102 defines a few constants, such as @code{I960}, and includes
103 @file{coffcode.h}. Since the i960 has complex relocation
104 types, @file{coff-i960.c} also includes some code to
105 manipulate the i960 relocs. This code is not in
106 @file{coffcode.h} because it would not be used by any other
110 Coff long section names
112 In the standard Coff object format, section names are limited to
113 the eight bytes available in the @code{s_name} field of the
114 @code{SCNHDR} section header structure. The format requires the
115 field to be NUL-padded, but not necessarily NUL-terminated, so
116 the longest section names permitted are a full eight characters.
118 The Microsoft PE variants of the Coff object file format add
119 an extension to support the use of long section names. This
120 extension is defined in section 4 of the Microsoft PE/COFF
121 specification (rev 8.1). If a section name is too long to fit
122 into the section header's @code{s_name} field, it is instead
123 placed into the string table, and the @code{s_name} field is
124 filled with a slash ("/") followed by the ASCII decimal
125 representation of the offset of the full name relative to the
128 Note that this implies that the extension can only be used in object
129 files, as executables do not contain a string table. The standard
130 specifies that long section names from objects emitted into executable
131 images are to be truncated.
133 However, as a GNU extension, BFD can generate executable images
134 that contain a string table and long section names. This
135 would appear to be technically valid, as the standard only says
136 that Coff debugging information is deprecated, not forbidden,
137 and in practice it works, although some tools that parse PE files
138 expecting the MS standard format may become confused; @file{PEview} is
141 The functionality is supported in BFD by code implemented under
142 the control of the macro @code{COFF_LONG_SECTION_NAMES}. If not
143 defined, the format does not support long section names in any way.
144 If defined, it is used to initialise a flag,
145 @code{_bfd_coff_long_section_names}, and a hook function pointer,
146 @code{_bfd_coff_set_long_section_names}, in the Coff backend data
147 structure. The flag controls the generation of long section names
148 in output BFDs at runtime; if it is false, as it will be by default
149 when generating an executable image, long section names are truncated;
150 if true, the long section names extension is employed. The hook
151 points to a function that allows the value of the flag to be altered
152 at runtime, on formats that support long section names at all; on
153 other formats it points to a stub that returns an error indication.
155 With input BFDs, the flag is set according to whether any long section
156 names are detected while reading the section headers. For a completely
157 new BFD, the flag is set to the default for the target format. This
158 information can be used by a client of the BFD library when deciding
159 what output format to generate, and means that a BFD that is opened
160 for read and subsequently converted to a writeable BFD and modified
161 in-place will retain whatever format it had on input.
163 If @code{COFF_LONG_SECTION_NAMES} is simply defined (blank), or is
164 defined to the value "1", then long section names are enabled by
165 default; if it is defined to the value zero, they are disabled by
166 default (but still accepted in input BFDs). The header @file{coffcode.h}
167 defines a macro, @code{COFF_DEFAULT_LONG_SECTION_NAMES}, which is
168 used in the backends to initialise the backend data structure fields
169 appropriately; see the comments for further detail.
174 Each flavour of coff supported in BFD has its own header file
175 describing the external layout of the structures. There is also
176 an internal description of the coff layout, in
177 @file{coff/internal.h}. A major function of the
178 coff backend is swapping the bytes and twiddling the bits to
179 translate the external form of the structures into the normal
180 internal form. This is all performed in the
181 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
182 elements are different sizes between different versions of
183 coff; it is the duty of the coff version specific include file
184 to override the definitions of various packing routines in
185 @file{coffcode.h}. E.g., the size of line number entry in coff is
186 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
187 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
188 correct one. No doubt, some day someone will find a version of
189 coff which has a varying field size not catered to at the
190 moment. To port BFD, that person will have to add more @code{#defines}.
191 Three of the bit twiddling routines are exported to
192 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
193 and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol
194 table on its own, but uses BFD to fix things up. More of the
195 bit twiddlers are exported for @code{gas};
196 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
197 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
198 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
199 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
200 of all the symbol table and reloc drudgery itself, thereby
201 saving the internal BFD overhead, but uses BFD to swap things
202 on the way out, making cross ports much safer. Doing so also
203 allows BFD (and thus the linker) to use the same header files
204 as @code{gas}, which makes one avenue to disaster disappear.
209 The simple canonical form for symbols used by BFD is not rich
210 enough to keep all the information available in a coff symbol
211 table. The back end gets around this problem by keeping the original
212 symbol table around, "behind the scenes".
214 When a symbol table is requested (through a call to
215 @code{bfd_canonicalize_symtab}), a request gets through to
216 @code{coff_get_normalized_symtab}. This reads the symbol table from
217 the coff file and swaps all the structures inside into the
218 internal form. It also fixes up all the pointers in the table
219 (represented in the file by offsets from the first symbol in
220 the table) into physical pointers to elements in the new
221 internal table. This involves some work since the meanings of
222 fields change depending upon context: a field that is a
223 pointer to another structure in the symbol table at one moment
224 may be the size in bytes of a structure at the next. Another
225 pass is made over the table. All symbols which mark file names
226 (<<C_FILE>> symbols) are modified so that the internal
227 string points to the value in the auxent (the real filename)
228 rather than the normal text associated with the symbol
231 At this time the symbol names are moved around. Coff stores
232 all symbols less than nine characters long physically
233 within the symbol table; longer strings are kept at the end of
234 the file in the string table. This pass moves all strings
235 into memory and replaces them with pointers to the strings.
237 The symbol table is massaged once again, this time to create
238 the canonical table used by the BFD application. Each symbol
239 is inspected in turn, and a decision made (using the
240 @code{sclass} field) about the various flags to set in the
241 @code{asymbol}. @xref{Symbols}. The generated canonical table
242 shares strings with the hidden internal symbol table.
244 Any linenumbers are read from the coff file too, and attached
245 to the symbols which own the functions the linenumbers belong to.
250 Writing a symbol to a coff file which didn't come from a coff
251 file will lose any debugging information. The @code{asymbol}
252 structure remembers the BFD from which the symbol was taken, and on
253 output the back end makes sure that the same destination target as
254 source target is present.
256 When the symbols have come from a coff file then all the
257 debugging information is preserved.
259 Symbol tables are provided for writing to the back end in a
260 vector of pointers to pointers. This allows applications like
261 the linker to accumulate and output large symbol tables
262 without having to do too much byte copying.
264 This function runs through the provided symbol table and
265 patches each symbol marked as a file place holder
266 (@code{C_FILE}) to point to the next file place holder in the
267 list. It also marks each @code{offset} field in the list with
268 the offset from the first symbol of the current symbol.
270 Another function of this procedure is to turn the canonical
271 value form of BFD into the form used by coff. Internally, BFD
272 expects symbol values to be offsets from a section base; so a
273 symbol physically at 0x120, but in a section starting at
274 0x100, would have the value 0x20. Coff expects symbols to
275 contain their final value, so symbols have their values
276 changed at this point to reflect their sum with their owning
277 section. This transformation uses the
278 <<output_section>> field of the @code{asymbol}'s
279 @code{asection} @xref{Sections}.
281 o <<coff_mangle_symbols>>
283 This routine runs though the provided symbol table and uses
284 the offsets generated by the previous pass and the pointers
285 generated when the symbol table was read in to create the
286 structured hierarchy required by coff. It changes each pointer
287 to a symbol into the index into the symbol table of the asymbol.
289 o <<coff_write_symbols>>
291 This routine runs through the symbol table and patches up the
292 symbols from their internal form into the coff way, calls the
293 bit twiddlers, and writes out the table to the file.
302 The hidden information for an <<asymbol>> is described in a
303 <<combined_entry_type>>:
307 .typedef struct coff_ptr_struct
309 . {* Remembers the offset from the first symbol in the file for
310 . this symbol. Generated by coff_renumber_symbols. *}
311 . unsigned int offset;
313 . {* Should the value of this symbol be renumbered. Used for
314 . XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
315 . unsigned int fix_value : 1;
317 . {* Should the tag field of this symbol be renumbered.
318 . Created by coff_pointerize_aux. *}
319 . unsigned int fix_tag : 1;
321 . {* Should the endidx field of this symbol be renumbered.
322 . Created by coff_pointerize_aux. *}
323 . unsigned int fix_end : 1;
325 . {* Should the x_csect.x_scnlen field be renumbered.
326 . Created by coff_pointerize_aux. *}
327 . unsigned int fix_scnlen : 1;
329 . {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
330 . index into the line number entries. Set by coff_slurp_symbol_table. *}
331 . unsigned int fix_line : 1;
333 . {* The container for the symbol structure as read and translated
337 . union internal_auxent auxent;
338 . struct internal_syment syment;
340 .} combined_entry_type;
343 .{* Each canonical asymbol really looks like this: *}
345 .typedef struct coff_symbol_struct
347 . {* The actual symbol which the rest of BFD works with *}
350 . {* A pointer to the hidden information for this symbol *}
351 . combined_entry_type *native;
353 . {* A pointer to the linenumber information for this symbol *}
354 . struct lineno_cache_entry *lineno;
356 . {* Have the line numbers been relocated yet ? *}
357 . bfd_boolean done_lineno;
362 #include "libiberty.h"
367 #include "coffswap.h"
370 #define STRING_SIZE_SIZE 4
372 #define DOT_DEBUG ".debug"
373 #define DOT_ZDEBUG ".zdebug"
374 #define GNU_LINKONCE_WI ".gnu.linkonce.wi."
375 #define GNU_LINKONCE_WT ".gnu.linkonce.wt."
376 #define DOT_RELOC ".reloc"
378 #if defined (COFF_LONG_SECTION_NAMES)
379 /* Needed to expand the inputs to BLANKOR1TOODD. */
380 #define COFFLONGSECTIONCATHELPER(x,y) x ## y
381 /* If the input macro Y is blank or '1', return an odd number; if it is
382 '0', return an even number. Result undefined in all other cases. */
383 #define BLANKOR1TOODD(y) COFFLONGSECTIONCATHELPER(1,y)
384 /* Defined to numerical 0 or 1 according to whether generation of long
385 section names is disabled or enabled by default. */
386 #define COFF_ENABLE_LONG_SECTION_NAMES (BLANKOR1TOODD(COFF_LONG_SECTION_NAMES) & 1)
387 /* Where long section names are supported, we allow them to be enabled
388 and disabled at runtime, so select an appropriate hook function for
389 _bfd_coff_set_long_section_names. */
390 #define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_allowed
391 #else /* !defined (COFF_LONG_SECTION_NAMES) */
392 /* If long section names are not supported, this stub disallows any
393 attempt to enable them at run-time. */
394 #define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_disallowed
395 #endif /* defined (COFF_LONG_SECTION_NAMES) */
397 /* Define a macro that can be used to initialise both the fields relating
398 to long section names in the backend data struct simultaneously. */
399 #if COFF_ENABLE_LONG_SECTION_NAMES
400 #define COFF_DEFAULT_LONG_SECTION_NAMES (TRUE), COFF_LONG_SECTION_NAMES_SETTER
401 #else /* !COFF_ENABLE_LONG_SECTION_NAMES */
402 #define COFF_DEFAULT_LONG_SECTION_NAMES (FALSE), COFF_LONG_SECTION_NAMES_SETTER
403 #endif /* COFF_ENABLE_LONG_SECTION_NAMES */
405 #if defined (COFF_LONG_SECTION_NAMES)
406 static bfd_boolean bfd_coff_set_long_section_names_allowed
408 #else /* !defined (COFF_LONG_SECTION_NAMES) */
409 static bfd_boolean bfd_coff_set_long_section_names_disallowed
411 #endif /* defined (COFF_LONG_SECTION_NAMES) */
412 static long sec_to_styp_flags
413 (const char *, flagword);
414 static bfd_boolean styp_to_sec_flags
415 (bfd *, void *, const char *, asection *, flagword *);
416 static bfd_boolean coff_bad_format_hook
418 static void coff_set_custom_section_alignment
419 (bfd *, asection *, const struct coff_section_alignment_entry *,
421 static bfd_boolean coff_new_section_hook
423 static bfd_boolean coff_set_arch_mach_hook
425 static bfd_boolean coff_write_relocs
427 static bfd_boolean coff_set_flags
428 (bfd *, unsigned int *, unsigned short *);
429 static bfd_boolean coff_set_arch_mach
430 (bfd *, enum bfd_architecture, unsigned long) ATTRIBUTE_UNUSED;
431 static bfd_boolean coff_compute_section_file_positions
433 static bfd_boolean coff_write_object_contents
434 (bfd *) ATTRIBUTE_UNUSED;
435 static bfd_boolean coff_set_section_contents
436 (bfd *, asection *, const void *, file_ptr, bfd_size_type);
437 static void * buy_and_read
438 (bfd *, file_ptr, bfd_size_type);
439 static bfd_boolean coff_slurp_line_table
441 static bfd_boolean coff_slurp_symbol_table
443 static enum coff_symbol_classification coff_classify_symbol
444 (bfd *, struct internal_syment *);
445 static bfd_boolean coff_slurp_reloc_table
446 (bfd *, asection *, asymbol **);
447 static long coff_canonicalize_reloc
448 (bfd *, asection *, arelent **, asymbol **);
449 #ifndef coff_mkobject_hook
450 static void * coff_mkobject_hook
451 (bfd *, void *, void *);
454 static flagword handle_COMDAT
455 (bfd *, flagword, void *, const char *, asection *);
457 #ifdef COFF_IMAGE_WITH_PE
458 static bfd_boolean coff_read_word
459 (bfd *, unsigned int *);
460 static unsigned int coff_compute_checksum
462 static bfd_boolean coff_apply_checksum
466 static bfd_boolean ticoff0_bad_format_hook
468 static bfd_boolean ticoff1_bad_format_hook
472 /* void warning(); */
474 #if defined (COFF_LONG_SECTION_NAMES)
476 bfd_coff_set_long_section_names_allowed (bfd *abfd, int enable)
478 coff_backend_info (abfd)->_bfd_coff_long_section_names = enable;
481 #else /* !defined (COFF_LONG_SECTION_NAMES) */
483 bfd_coff_set_long_section_names_disallowed (bfd *abfd, int enable)
489 #endif /* defined (COFF_LONG_SECTION_NAMES) */
491 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
492 the incoming SEC_* flags. The inverse of this function is
493 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
494 should probably mirror the changes in styp_to_sec_flags(). */
498 /* Macros for setting debugging flags. */
501 #define STYP_XCOFF_DEBUG STYP_DEBUG
503 #define STYP_XCOFF_DEBUG STYP_INFO
506 #ifdef COFF_ALIGN_IN_S_FLAGS
507 #define STYP_DEBUG_INFO STYP_DSECT
509 #define STYP_DEBUG_INFO STYP_INFO
513 sec_to_styp_flags (const char *sec_name, flagword sec_flags)
517 if (!strcmp (sec_name, _TEXT))
519 styp_flags = STYP_TEXT;
521 else if (!strcmp (sec_name, _DATA))
523 styp_flags = STYP_DATA;
525 else if (!strcmp (sec_name, _BSS))
527 styp_flags = STYP_BSS;
530 else if (!strcmp (sec_name, _COMMENT))
532 styp_flags = STYP_INFO;
533 #endif /* _COMMENT */
536 else if (!strcmp (sec_name, _LIB))
538 styp_flags = STYP_LIB;
542 else if (!strcmp (sec_name, _LIT))
544 styp_flags = STYP_LIT;
547 else if (CONST_STRNEQ (sec_name, DOT_DEBUG)
548 || CONST_STRNEQ (sec_name, DOT_ZDEBUG))
550 /* Handle the XCOFF debug section and DWARF2 debug sections. */
552 styp_flags = STYP_XCOFF_DEBUG;
554 styp_flags = STYP_DEBUG_INFO;
556 else if (CONST_STRNEQ (sec_name, ".stab"))
558 styp_flags = STYP_DEBUG_INFO;
560 #ifdef COFF_LONG_SECTION_NAMES
561 else if (CONST_STRNEQ (sec_name, GNU_LINKONCE_WI)
562 || CONST_STRNEQ (sec_name, GNU_LINKONCE_WT))
564 styp_flags = STYP_DEBUG_INFO;
568 else if (!strcmp (sec_name, _PAD))
570 styp_flags = STYP_PAD;
572 else if (!strcmp (sec_name, _LOADER))
574 styp_flags = STYP_LOADER;
576 else if (!strcmp (sec_name, _EXCEPT))
578 styp_flags = STYP_EXCEPT;
580 else if (!strcmp (sec_name, _TYPCHK))
582 styp_flags = STYP_TYPCHK;
584 else if (sec_flags & SEC_DEBUGGING)
588 for (i = 0; i < XCOFF_DWSECT_NBR_NAMES; i++)
589 if (!strcmp (sec_name, xcoff_dwsect_names[i].name))
591 styp_flags = STYP_DWARF | xcoff_dwsect_names[i].flag;
596 /* Try and figure out what it should be */
597 else if (sec_flags & SEC_CODE)
599 styp_flags = STYP_TEXT;
601 else if (sec_flags & SEC_DATA)
603 styp_flags = STYP_DATA;
605 else if (sec_flags & SEC_READONLY)
607 #ifdef STYP_LIT /* 29k readonly text/data section */
608 styp_flags = STYP_LIT;
610 styp_flags = STYP_TEXT;
611 #endif /* STYP_LIT */
613 else if (sec_flags & SEC_LOAD)
615 styp_flags = STYP_TEXT;
617 else if (sec_flags & SEC_ALLOC)
619 styp_flags = STYP_BSS;
623 if (sec_flags & SEC_TIC54X_CLINK)
624 styp_flags |= STYP_CLINK;
628 if (sec_flags & SEC_TIC54X_BLOCK)
629 styp_flags |= STYP_BLOCK;
633 if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
634 styp_flags |= STYP_NOLOAD;
640 #else /* COFF_WITH_PE */
642 /* The PE version; see above for the general comments. The non-PE
643 case seems to be more guessing, and breaks PE format; specifically,
644 .rdata is readonly, but it sure ain't text. Really, all this
645 should be set up properly in gas (or whatever assembler is in use),
646 and honor whatever objcopy/strip, etc. sent us as input. */
649 sec_to_styp_flags (const char *sec_name, flagword sec_flags)
652 bfd_boolean is_dbg = FALSE;
654 if (CONST_STRNEQ (sec_name, DOT_DEBUG)
655 || CONST_STRNEQ (sec_name, DOT_ZDEBUG)
656 #ifdef COFF_LONG_SECTION_NAMES
657 || CONST_STRNEQ (sec_name, GNU_LINKONCE_WI)
658 || CONST_STRNEQ (sec_name, GNU_LINKONCE_WT)
660 || CONST_STRNEQ (sec_name, ".stab"))
663 /* caution: there are at least three groups of symbols that have
664 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
665 SEC_* are the BFD internal flags, used for generic BFD
666 information. STYP_* are the COFF section flags which appear in
667 COFF files. IMAGE_SCN_* are the PE section flags which appear in
668 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
669 but there are more IMAGE_SCN_* flags. */
671 /* FIXME: There is no gas syntax to specify the debug section flag. */
674 sec_flags &= (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD
675 | SEC_LINK_DUPLICATES_SAME_CONTENTS
676 | SEC_LINK_DUPLICATES_SAME_SIZE);
677 sec_flags |= SEC_DEBUGGING | SEC_READONLY;
683 if ((sec_flags & SEC_CODE) != 0)
684 styp_flags |= IMAGE_SCN_CNT_CODE;
685 if ((sec_flags & (SEC_DATA | SEC_DEBUGGING)) != 0)
686 styp_flags |= IMAGE_SCN_CNT_INITIALIZED_DATA;
687 if ((sec_flags & SEC_ALLOC) != 0 && (sec_flags & SEC_LOAD) == 0)
688 styp_flags |= IMAGE_SCN_CNT_UNINITIALIZED_DATA; /* ==STYP_BSS */
690 /* skip constRUCTOR */
692 if ((sec_flags & SEC_IS_COMMON) != 0)
693 styp_flags |= IMAGE_SCN_LNK_COMDAT;
694 if ((sec_flags & SEC_DEBUGGING) != 0)
695 styp_flags |= IMAGE_SCN_MEM_DISCARDABLE;
696 if ((sec_flags & SEC_EXCLUDE) != 0 && !is_dbg)
697 styp_flags |= IMAGE_SCN_LNK_REMOVE;
698 if ((sec_flags & SEC_NEVER_LOAD) != 0 && !is_dbg)
699 styp_flags |= IMAGE_SCN_LNK_REMOVE;
702 if (sec_flags & SEC_LINK_ONCE)
703 styp_flags |= IMAGE_SCN_LNK_COMDAT;
705 & (SEC_LINK_DUPLICATES_DISCARD | SEC_LINK_DUPLICATES_SAME_CONTENTS
706 | SEC_LINK_DUPLICATES_SAME_SIZE)) != 0)
707 styp_flags |= IMAGE_SCN_LNK_COMDAT;
709 /* skip LINKER_CREATED */
711 if ((sec_flags & SEC_COFF_NOREAD) == 0)
712 styp_flags |= IMAGE_SCN_MEM_READ; /* Invert NOREAD for read. */
713 if ((sec_flags & SEC_READONLY) == 0)
714 styp_flags |= IMAGE_SCN_MEM_WRITE; /* Invert READONLY for write. */
715 if (sec_flags & SEC_CODE)
716 styp_flags |= IMAGE_SCN_MEM_EXECUTE; /* CODE->EXECUTE. */
717 if (sec_flags & SEC_COFF_SHARED)
718 styp_flags |= IMAGE_SCN_MEM_SHARED; /* Shared remains meaningful. */
723 #endif /* COFF_WITH_PE */
725 /* Return a word with SEC_* flags set to represent the incoming STYP_*
726 flags (from scnhdr.s_flags). The inverse of this function is
727 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
728 should probably mirror the changes in sec_to_styp_flags(). */
733 styp_to_sec_flags (bfd *abfd ATTRIBUTE_UNUSED,
736 asection *section ATTRIBUTE_UNUSED,
739 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
740 long styp_flags = internal_s->s_flags;
741 flagword sec_flags = 0;
744 if (styp_flags & STYP_BLOCK)
745 sec_flags |= SEC_TIC54X_BLOCK;
749 if (styp_flags & STYP_CLINK)
750 sec_flags |= SEC_TIC54X_CLINK;
754 if (styp_flags & STYP_NOLOAD)
755 sec_flags |= SEC_NEVER_LOAD;
756 #endif /* STYP_NOLOAD */
758 /* For 386 COFF, at least, an unloadable text or data section is
759 actually a shared library section. */
760 if (styp_flags & STYP_TEXT)
762 if (sec_flags & SEC_NEVER_LOAD)
763 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
765 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
767 else if (styp_flags & STYP_DATA)
769 if (sec_flags & SEC_NEVER_LOAD)
770 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
772 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
774 else if (styp_flags & STYP_BSS)
776 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
777 if (sec_flags & SEC_NEVER_LOAD)
778 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
781 sec_flags |= SEC_ALLOC;
783 else if (styp_flags & STYP_INFO)
785 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
786 defined. coff_compute_section_file_positions uses
787 COFF_PAGE_SIZE to ensure that the low order bits of the
788 section VMA and the file offset match. If we don't know
789 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
790 and demand page loading of the file will fail. */
791 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
792 sec_flags |= SEC_DEBUGGING;
795 else if (styp_flags & STYP_PAD)
798 else if (styp_flags & STYP_EXCEPT)
799 sec_flags |= SEC_LOAD;
800 else if (styp_flags & STYP_LOADER)
801 sec_flags |= SEC_LOAD;
802 else if (styp_flags & STYP_TYPCHK)
803 sec_flags |= SEC_LOAD;
804 else if (styp_flags & STYP_DWARF)
805 sec_flags |= SEC_DEBUGGING;
807 else if (strcmp (name, _TEXT) == 0)
809 if (sec_flags & SEC_NEVER_LOAD)
810 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
812 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
814 else if (strcmp (name, _DATA) == 0)
816 if (sec_flags & SEC_NEVER_LOAD)
817 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
819 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
821 else if (strcmp (name, _BSS) == 0)
823 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
824 if (sec_flags & SEC_NEVER_LOAD)
825 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
828 sec_flags |= SEC_ALLOC;
830 else if (CONST_STRNEQ (name, DOT_DEBUG)
831 || CONST_STRNEQ (name, DOT_ZDEBUG)
833 || strcmp (name, _COMMENT) == 0
835 #ifdef COFF_LONG_SECTION_NAMES
836 || CONST_STRNEQ (name, GNU_LINKONCE_WI)
837 || CONST_STRNEQ (name, GNU_LINKONCE_WT)
839 || CONST_STRNEQ (name, ".stab"))
841 #ifdef COFF_PAGE_SIZE
842 sec_flags |= SEC_DEBUGGING;
846 else if (strcmp (name, _LIB) == 0)
850 else if (strcmp (name, _LIT) == 0)
851 sec_flags = SEC_LOAD | SEC_ALLOC | SEC_READONLY;
854 sec_flags |= SEC_ALLOC | SEC_LOAD;
856 #ifdef STYP_LIT /* A29k readonly text/data section type. */
857 if ((styp_flags & STYP_LIT) == STYP_LIT)
858 sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
859 #endif /* STYP_LIT */
861 #ifdef STYP_OTHER_LOAD /* Other loaded sections. */
862 if (styp_flags & STYP_OTHER_LOAD)
863 sec_flags = (SEC_LOAD | SEC_ALLOC);
864 #endif /* STYP_SDATA */
866 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
867 /* As a GNU extension, if the name begins with .gnu.linkonce, we
868 only link a single copy of the section. This is used to support
869 g++. g++ will emit each template expansion in its own section.
870 The symbols will be defined as weak, so that multiple definitions
871 are permitted. The GNU linker extension is to actually discard
872 all but one of the sections. */
873 if (CONST_STRNEQ (name, ".gnu.linkonce"))
874 sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
877 if (flags_ptr == NULL)
880 * flags_ptr = sec_flags;
884 #else /* COFF_WITH_PE */
887 handle_COMDAT (bfd * abfd,
893 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
894 bfd_byte *esymstart, *esym, *esymend;
896 char *target_name = NULL;
898 sec_flags |= SEC_LINK_ONCE;
900 /* Unfortunately, the PE format stores essential information in
901 the symbol table, of all places. We need to extract that
902 information now, so that objdump and the linker will know how
903 to handle the section without worrying about the symbols. We
904 can't call slurp_symtab, because the linker doesn't want the
907 /* COMDAT sections are special. The first symbol is the section
908 symbol, which tells what kind of COMDAT section it is. The
909 second symbol is the "comdat symbol" - the one with the
910 unique name. GNU uses the section symbol for the unique
911 name; MS uses ".text" for every comdat section. Sigh. - DJ */
913 /* This is not mirrored in sec_to_styp_flags(), but there
914 doesn't seem to be a need to, either, and it would at best be
917 if (! _bfd_coff_get_external_symbols (abfd))
920 esymstart = esym = (bfd_byte *) obj_coff_external_syms (abfd);
921 esymend = esym + obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd);
923 while (esym < esymend)
925 struct internal_syment isym;
926 char buf[SYMNMLEN + 1];
929 bfd_coff_swap_sym_in (abfd, esym, & isym);
931 BFD_ASSERT (sizeof (internal_s->s_name) <= SYMNMLEN);
933 if (isym.n_scnum == section->target_index)
935 /* According to the MSVC documentation, the first
936 TWO entries with the section # are both of
937 interest to us. The first one is the "section
938 symbol" (section name). The second is the comdat
939 symbol name. Here, we've found the first
940 qualifying entry; we distinguish it from the
941 second with a state flag.
943 In the case of gas-generated (at least until that
944 is fixed) .o files, it isn't necessarily the
945 second one. It may be some other later symbol.
947 Since gas also doesn't follow MS conventions and
948 emits the section similar to .text$<name>, where
949 <something> is the name we're looking for, we
950 distinguish the two as follows:
952 If the section name is simply a section name (no
953 $) we presume it's MS-generated, and look at
954 precisely the second symbol for the comdat name.
955 If the section name has a $, we assume it's
956 gas-generated, and look for <something> (whatever
957 follows the $) as the comdat symbol. */
959 /* All 3 branches use this. */
960 symname = _bfd_coff_internal_syment_name (abfd, &isym, buf);
962 /* PR 17512 file: 078-11867-0.004 */
965 _bfd_error_handler (_("%B: unable to load COMDAT section name"), abfd);
973 /* The first time we've seen the symbol. */
974 union internal_auxent aux;
976 /* If it isn't the stuff we're expecting, die;
977 The MS documentation is vague, but it
978 appears that the second entry serves BOTH
979 as the comdat symbol and the defining
980 symbol record (either C_STAT or C_EXT,
981 possibly with an aux entry with debug
982 information if it's a function.) It
983 appears the only way to find the second one
984 is to count. (On Intel, they appear to be
985 adjacent, but on Alpha, they have been
988 Here, we think we've found the first one,
989 but there's some checking we can do to be
992 if (! ((isym.n_sclass == C_STAT
993 || isym.n_sclass == C_EXT)
994 && BTYPE (isym.n_type) == T_NULL
995 && isym.n_value == 0))
998 /* FIXME LATER: MSVC generates section names
999 like .text for comdats. Gas generates
1000 names like .text$foo__Fv (in the case of a
1001 function). See comment above for more. */
1003 if (isym.n_sclass == C_STAT && strcmp (name, symname) != 0)
1004 _bfd_error_handler (_("%B: warning: COMDAT symbol '%s' does not match section name '%s'"),
1005 abfd, symname, name);
1009 /* This is the section symbol. */
1010 bfd_coff_swap_aux_in (abfd, (esym + bfd_coff_symesz (abfd)),
1011 isym.n_type, isym.n_sclass,
1012 0, isym.n_numaux, & aux);
1014 target_name = strchr (name, '$');
1015 if (target_name != NULL)
1023 /* FIXME: Microsoft uses NODUPLICATES and
1024 ASSOCIATIVE, but gnu uses ANY and
1025 SAME_SIZE. Unfortunately, gnu doesn't do
1026 the comdat symbols right. So, until we can
1027 fix it to do the right thing, we are
1028 temporarily disabling comdats for the MS
1029 types (they're used in DLLs and C++, but we
1030 don't support *their* C++ libraries anyway
1033 /* Cygwin does not follow the MS style, and
1034 uses ANY and SAME_SIZE where NODUPLICATES
1035 and ASSOCIATIVE should be used. For
1036 Interix, we just do the right thing up
1039 switch (aux.x_scn.x_comdat)
1041 case IMAGE_COMDAT_SELECT_NODUPLICATES:
1042 #ifdef STRICT_PE_FORMAT
1043 sec_flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
1045 sec_flags &= ~SEC_LINK_ONCE;
1049 case IMAGE_COMDAT_SELECT_ANY:
1050 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
1053 case IMAGE_COMDAT_SELECT_SAME_SIZE:
1054 sec_flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
1057 case IMAGE_COMDAT_SELECT_EXACT_MATCH:
1058 /* Not yet fully implemented ??? */
1059 sec_flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
1062 /* debug$S gets this case; other
1065 /* There may be no symbol... we'll search
1066 the whole table... Is this the right
1067 place to play this game? Or should we do
1068 it when reading it in. */
1069 case IMAGE_COMDAT_SELECT_ASSOCIATIVE:
1070 #ifdef STRICT_PE_FORMAT
1071 /* FIXME: This is not currently implemented. */
1072 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
1074 sec_flags &= ~SEC_LINK_ONCE;
1078 default: /* 0 means "no symbol" */
1079 /* debug$F gets this case; other
1081 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
1088 /* Gas mode: the first matching on partial name. */
1090 #ifndef TARGET_UNDERSCORE
1091 #define TARGET_UNDERSCORE 0
1093 /* Is this the name we're looking for ? */
1094 if (strcmp (target_name,
1095 symname + (TARGET_UNDERSCORE ? 1 : 0)) != 0)
1097 /* Not the name we're looking for */
1098 esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd);
1103 /* MSVC mode: the lexically second symbol (or
1104 drop through from the above). */
1109 /* This must the second symbol with the
1110 section #. It is the actual symbol name.
1111 Intel puts the two adjacent, but Alpha (at
1112 least) spreads them out. */
1114 amt = sizeof (struct coff_comdat_info);
1115 coff_section_data (abfd, section)->comdat
1116 = (struct coff_comdat_info *) bfd_alloc (abfd, amt);
1117 if (coff_section_data (abfd, section)->comdat == NULL)
1120 coff_section_data (abfd, section)->comdat->symbol =
1121 (esym - esymstart) / bfd_coff_symesz (abfd);
1123 amt = strlen (symname) + 1;
1124 newname = (char *) bfd_alloc (abfd, amt);
1125 if (newname == NULL)
1128 strcpy (newname, symname);
1129 coff_section_data (abfd, section)->comdat->name
1137 esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd);
1145 /* The PE version; see above for the general comments.
1147 Since to set the SEC_LINK_ONCE and associated flags, we have to
1148 look at the symbol table anyway, we return the symbol table index
1149 of the symbol being used as the COMDAT symbol. This is admittedly
1150 ugly, but there's really nowhere else that we have access to the
1151 required information. FIXME: Is the COMDAT symbol index used for
1152 any purpose other than objdump? */
1155 styp_to_sec_flags (bfd *abfd,
1159 flagword *flags_ptr)
1161 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
1162 long styp_flags = internal_s->s_flags;
1164 bfd_boolean result = TRUE;
1165 bfd_boolean is_dbg = FALSE;
1167 if (CONST_STRNEQ (name, DOT_DEBUG)
1168 || CONST_STRNEQ (name, DOT_ZDEBUG)
1169 #ifdef COFF_LONG_SECTION_NAMES
1170 || CONST_STRNEQ (name, GNU_LINKONCE_WI)
1171 || CONST_STRNEQ (name, GNU_LINKONCE_WT)
1173 || CONST_STRNEQ (name, ".stab"))
1175 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
1176 sec_flags = SEC_READONLY;
1178 /* If section disallows read, then set the NOREAD flag. */
1179 if ((styp_flags & IMAGE_SCN_MEM_READ) == 0)
1180 sec_flags |= SEC_COFF_NOREAD;
1182 /* Process each flag bit in styp_flags in turn. */
1185 long flag = styp_flags & - styp_flags;
1186 char * unhandled = NULL;
1188 styp_flags &= ~ flag;
1190 /* We infer from the distinct read/write/execute bits the settings
1191 of some of the bfd flags; the actual values, should we need them,
1192 are also in pei_section_data (abfd, section)->pe_flags. */
1197 unhandled = "STYP_DSECT";
1200 unhandled = "STYP_GROUP";
1203 unhandled = "STYP_COPY";
1206 unhandled = "STYP_OVER";
1208 #ifdef SEC_NEVER_LOAD
1210 sec_flags |= SEC_NEVER_LOAD;
1213 case IMAGE_SCN_MEM_READ:
1214 sec_flags &= ~SEC_COFF_NOREAD;
1216 case IMAGE_SCN_TYPE_NO_PAD:
1219 case IMAGE_SCN_LNK_OTHER:
1220 unhandled = "IMAGE_SCN_LNK_OTHER";
1222 case IMAGE_SCN_MEM_NOT_CACHED:
1223 unhandled = "IMAGE_SCN_MEM_NOT_CACHED";
1225 case IMAGE_SCN_MEM_NOT_PAGED:
1226 /* Generate a warning message rather using the 'unhandled'
1227 variable as this will allow some .sys files generate by
1228 other toolchains to be processed. See bugzilla issue 196. */
1229 _bfd_error_handler (_("%B: Warning: Ignoring section flag IMAGE_SCN_MEM_NOT_PAGED in section %s"),
1232 case IMAGE_SCN_MEM_EXECUTE:
1233 sec_flags |= SEC_CODE;
1235 case IMAGE_SCN_MEM_WRITE:
1236 sec_flags &= ~ SEC_READONLY;
1238 case IMAGE_SCN_MEM_DISCARDABLE:
1239 /* The MS PE spec says that debug sections are DISCARDABLE,
1240 but the presence of a DISCARDABLE flag does not necessarily
1241 mean that a given section contains debug information. Thus
1242 we only set the SEC_DEBUGGING flag on sections that we
1243 recognise as containing debug information. */
1246 || strcmp (name, _COMMENT) == 0
1250 sec_flags |= SEC_DEBUGGING | SEC_READONLY;
1253 case IMAGE_SCN_MEM_SHARED:
1254 sec_flags |= SEC_COFF_SHARED;
1256 case IMAGE_SCN_LNK_REMOVE:
1258 sec_flags |= SEC_EXCLUDE;
1260 case IMAGE_SCN_CNT_CODE:
1261 sec_flags |= SEC_CODE | SEC_ALLOC | SEC_LOAD;
1263 case IMAGE_SCN_CNT_INITIALIZED_DATA:
1265 sec_flags |= SEC_DEBUGGING;
1267 sec_flags |= SEC_DATA | SEC_ALLOC | SEC_LOAD;
1269 case IMAGE_SCN_CNT_UNINITIALIZED_DATA:
1270 sec_flags |= SEC_ALLOC;
1272 case IMAGE_SCN_LNK_INFO:
1273 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1274 defined. coff_compute_section_file_positions uses
1275 COFF_PAGE_SIZE to ensure that the low order bits of the
1276 section VMA and the file offset match. If we don't know
1277 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1278 and demand page loading of the file will fail. */
1279 #ifdef COFF_PAGE_SIZE
1280 sec_flags |= SEC_DEBUGGING;
1283 case IMAGE_SCN_LNK_COMDAT:
1284 /* COMDAT gets very special treatment. */
1285 sec_flags = handle_COMDAT (abfd, sec_flags, hdr, name, section);
1288 /* Silently ignore for now. */
1292 /* If the section flag was not handled, report it here. */
1293 if (unhandled != NULL)
1295 (*_bfd_error_handler)
1296 (_("%B (%s): Section flag %s (0x%x) ignored"),
1297 abfd, name, unhandled, flag);
1302 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1303 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1304 only link a single copy of the section. This is used to support
1305 g++. g++ will emit each template expansion in its own section.
1306 The symbols will be defined as weak, so that multiple definitions
1307 are permitted. The GNU linker extension is to actually discard
1308 all but one of the sections. */
1309 if (CONST_STRNEQ (name, ".gnu.linkonce"))
1310 sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1314 * flags_ptr = sec_flags;
1319 #endif /* COFF_WITH_PE */
1321 #define get_index(symbol) ((symbol)->udata.i)
1325 bfd_coff_backend_data
1329 .{* COFF symbol classifications. *}
1331 .enum coff_symbol_classification
1333 . {* Global symbol. *}
1334 . COFF_SYMBOL_GLOBAL,
1335 . {* Common symbol. *}
1336 . COFF_SYMBOL_COMMON,
1337 . {* Undefined symbol. *}
1338 . COFF_SYMBOL_UNDEFINED,
1339 . {* Local symbol. *}
1340 . COFF_SYMBOL_LOCAL,
1341 . {* PE section symbol. *}
1342 . COFF_SYMBOL_PE_SECTION
1345 Special entry points for gdb to swap in coff symbol table parts:
1348 . void (*_bfd_coff_swap_aux_in)
1349 . (bfd *, void *, int, int, int, int, void *);
1351 . void (*_bfd_coff_swap_sym_in)
1352 . (bfd *, void *, void *);
1354 . void (*_bfd_coff_swap_lineno_in)
1355 . (bfd *, void *, void *);
1357 . unsigned int (*_bfd_coff_swap_aux_out)
1358 . (bfd *, void *, int, int, int, int, void *);
1360 . unsigned int (*_bfd_coff_swap_sym_out)
1361 . (bfd *, void *, void *);
1363 . unsigned int (*_bfd_coff_swap_lineno_out)
1364 . (bfd *, void *, void *);
1366 . unsigned int (*_bfd_coff_swap_reloc_out)
1367 . (bfd *, void *, void *);
1369 . unsigned int (*_bfd_coff_swap_filehdr_out)
1370 . (bfd *, void *, void *);
1372 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1373 . (bfd *, void *, void *);
1375 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1376 . (bfd *, void *, void *);
1378 . unsigned int _bfd_filhsz;
1379 . unsigned int _bfd_aoutsz;
1380 . unsigned int _bfd_scnhsz;
1381 . unsigned int _bfd_symesz;
1382 . unsigned int _bfd_auxesz;
1383 . unsigned int _bfd_relsz;
1384 . unsigned int _bfd_linesz;
1385 . unsigned int _bfd_filnmlen;
1386 . bfd_boolean _bfd_coff_long_filenames;
1388 . bfd_boolean _bfd_coff_long_section_names;
1389 . bfd_boolean (*_bfd_coff_set_long_section_names)
1392 . unsigned int _bfd_coff_default_section_alignment_power;
1393 . bfd_boolean _bfd_coff_force_symnames_in_strings;
1394 . unsigned int _bfd_coff_debug_string_prefix_length;
1395 . unsigned int _bfd_coff_max_nscns;
1397 . void (*_bfd_coff_swap_filehdr_in)
1398 . (bfd *, void *, void *);
1400 . void (*_bfd_coff_swap_aouthdr_in)
1401 . (bfd *, void *, void *);
1403 . void (*_bfd_coff_swap_scnhdr_in)
1404 . (bfd *, void *, void *);
1406 . void (*_bfd_coff_swap_reloc_in)
1407 . (bfd *abfd, void *, void *);
1409 . bfd_boolean (*_bfd_coff_bad_format_hook)
1412 . bfd_boolean (*_bfd_coff_set_arch_mach_hook)
1415 . void * (*_bfd_coff_mkobject_hook)
1416 . (bfd *, void *, void *);
1418 . bfd_boolean (*_bfd_styp_to_sec_flags_hook)
1419 . (bfd *, void *, const char *, asection *, flagword *);
1421 . void (*_bfd_set_alignment_hook)
1422 . (bfd *, asection *, void *);
1424 . bfd_boolean (*_bfd_coff_slurp_symbol_table)
1427 . bfd_boolean (*_bfd_coff_symname_in_debug)
1428 . (bfd *, struct internal_syment *);
1430 . bfd_boolean (*_bfd_coff_pointerize_aux_hook)
1431 . (bfd *, combined_entry_type *, combined_entry_type *,
1432 . unsigned int, combined_entry_type *);
1434 . bfd_boolean (*_bfd_coff_print_aux)
1435 . (bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1436 . combined_entry_type *, unsigned int);
1438 . void (*_bfd_coff_reloc16_extra_cases)
1439 . (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1440 . bfd_byte *, unsigned int *, unsigned int *);
1442 . int (*_bfd_coff_reloc16_estimate)
1443 . (bfd *, asection *, arelent *, unsigned int,
1444 . struct bfd_link_info *);
1446 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1447 . (bfd *, struct internal_syment *);
1449 . bfd_boolean (*_bfd_coff_compute_section_file_positions)
1452 . bfd_boolean (*_bfd_coff_start_final_link)
1453 . (bfd *, struct bfd_link_info *);
1455 . bfd_boolean (*_bfd_coff_relocate_section)
1456 . (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1457 . struct internal_reloc *, struct internal_syment *, asection **);
1459 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1460 . (bfd *, asection *, struct internal_reloc *,
1461 . struct coff_link_hash_entry *, struct internal_syment *,
1464 . bfd_boolean (*_bfd_coff_adjust_symndx)
1465 . (bfd *, struct bfd_link_info *, bfd *, asection *,
1466 . struct internal_reloc *, bfd_boolean *);
1468 . bfd_boolean (*_bfd_coff_link_add_one_symbol)
1469 . (struct bfd_link_info *, bfd *, const char *, flagword,
1470 . asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
1471 . struct bfd_link_hash_entry **);
1473 . bfd_boolean (*_bfd_coff_link_output_has_begun)
1474 . (bfd *, struct coff_final_link_info *);
1476 . bfd_boolean (*_bfd_coff_final_link_postscript)
1477 . (bfd *, struct coff_final_link_info *);
1479 . bfd_boolean (*_bfd_coff_print_pdata)
1482 .} bfd_coff_backend_data;
1484 .#define coff_backend_info(abfd) \
1485 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1487 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1488 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1490 .#define bfd_coff_swap_sym_in(a,e,i) \
1491 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1493 .#define bfd_coff_swap_lineno_in(a,e,i) \
1494 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1496 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1497 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1499 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1500 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1502 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1503 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1505 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1506 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1508 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1509 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1511 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1512 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1514 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1515 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1517 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1518 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1519 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1520 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1521 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1522 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1523 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1524 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1525 .#define bfd_coff_long_filenames(abfd) \
1526 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1527 .#define bfd_coff_long_section_names(abfd) \
1528 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1529 .#define bfd_coff_set_long_section_names(abfd, enable) \
1530 . ((coff_backend_info (abfd)->_bfd_coff_set_long_section_names) (abfd, enable))
1531 .#define bfd_coff_default_section_alignment_power(abfd) \
1532 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1533 .#define bfd_coff_max_nscns(abfd) \
1534 . (coff_backend_info (abfd)->_bfd_coff_max_nscns)
1536 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1537 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1539 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1540 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1542 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1543 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1545 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1546 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1548 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1549 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1551 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1552 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1553 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1554 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1555 . (abfd, filehdr, aouthdr))
1557 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1558 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1559 . (abfd, scnhdr, name, section, flags_ptr))
1561 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1562 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1564 .#define bfd_coff_slurp_symbol_table(abfd)\
1565 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1567 .#define bfd_coff_symname_in_debug(abfd, sym)\
1568 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1570 .#define bfd_coff_force_symnames_in_strings(abfd)\
1571 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1573 .#define bfd_coff_debug_string_prefix_length(abfd)\
1574 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1576 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1577 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1578 . (abfd, file, base, symbol, aux, indaux))
1580 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1581 . reloc, data, src_ptr, dst_ptr)\
1582 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1583 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1585 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1586 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1587 . (abfd, section, reloc, shrink, link_info))
1589 .#define bfd_coff_classify_symbol(abfd, sym)\
1590 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1593 .#define bfd_coff_compute_section_file_positions(abfd)\
1594 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1597 .#define bfd_coff_start_final_link(obfd, info)\
1598 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1600 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1601 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1602 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1603 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1604 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1605 . (abfd, sec, rel, h, sym, addendp))
1606 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1607 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1608 . (obfd, info, ibfd, sec, rel, adjustedp))
1609 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1610 . value, string, cp, coll, hashp)\
1611 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1612 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1614 .#define bfd_coff_link_output_has_begun(a,p) \
1615 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p))
1616 .#define bfd_coff_final_link_postscript(a,p) \
1617 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p))
1619 .#define bfd_coff_have_print_pdata(a) \
1620 . (coff_backend_info (a)->_bfd_coff_print_pdata)
1621 .#define bfd_coff_print_pdata(a,p) \
1622 . ((coff_backend_info (a)->_bfd_coff_print_pdata) (a, p))
1624 .{* Macro: Returns true if the bfd is a PE executable as opposed to a
1625 . PE object file. *}
1626 .#define bfd_pei_p(abfd) \
1627 . (CONST_STRNEQ ((abfd)->xvec->name, "pei-"))
1630 /* See whether the magic number matches. */
1633 coff_bad_format_hook (bfd * abfd ATTRIBUTE_UNUSED, void * filehdr)
1635 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1637 if (BADMAG (*internal_f))
1640 /* If the optional header is NULL or not the correct size then
1641 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1642 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1643 optional header is of a different size.
1645 But the mips keeps extra stuff in it's opthdr, so dont check
1648 #if defined(M88) || defined(I960)
1649 if (internal_f->f_opthdr != 0 && bfd_coff_aoutsz (abfd) != internal_f->f_opthdr)
1658 ticoff0_bad_format_hook (bfd *abfd ATTRIBUTE_UNUSED, void * filehdr)
1660 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1662 if (COFF0_BADMAG (*internal_f))
1671 ticoff1_bad_format_hook (bfd *abfd ATTRIBUTE_UNUSED, void * filehdr)
1673 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1675 if (COFF1_BADMAG (*internal_f))
1682 /* Check whether this section uses an alignment other than the
1686 coff_set_custom_section_alignment (bfd *abfd ATTRIBUTE_UNUSED,
1688 const struct coff_section_alignment_entry *alignment_table,
1689 const unsigned int table_size)
1691 const unsigned int default_alignment = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1694 for (i = 0; i < table_size; ++i)
1696 const char *secname = bfd_get_section_name (abfd, section);
1698 if (alignment_table[i].comparison_length == (unsigned int) -1
1699 ? strcmp (alignment_table[i].name, secname) == 0
1700 : strncmp (alignment_table[i].name, secname,
1701 alignment_table[i].comparison_length) == 0)
1704 if (i >= table_size)
1707 if (alignment_table[i].default_alignment_min != COFF_ALIGNMENT_FIELD_EMPTY
1708 && default_alignment < alignment_table[i].default_alignment_min)
1711 if (alignment_table[i].default_alignment_max != COFF_ALIGNMENT_FIELD_EMPTY
1712 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1713 && default_alignment > alignment_table[i].default_alignment_max
1718 section->alignment_power = alignment_table[i].alignment_power;
1721 /* Custom section alignment records. */
1723 static const struct coff_section_alignment_entry
1724 coff_section_alignment_table[] =
1726 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1727 COFF_SECTION_ALIGNMENT_ENTRIES,
1729 /* There must not be any gaps between .stabstr sections. */
1730 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1731 1, COFF_ALIGNMENT_FIELD_EMPTY, 0 },
1732 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1733 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1734 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1735 /* Similarly for the .ctors and .dtors sections. */
1736 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1737 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1738 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1739 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 }
1742 static const unsigned int coff_section_alignment_table_size =
1743 sizeof coff_section_alignment_table / sizeof coff_section_alignment_table[0];
1745 /* Initialize a section structure with information peculiar to this
1746 particular implementation of COFF. */
1749 coff_new_section_hook (bfd * abfd, asection * section)
1751 combined_entry_type *native;
1753 unsigned char sclass = C_STAT;
1755 section->alignment_power = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1758 if (bfd_xcoff_text_align_power (abfd) != 0
1759 && strcmp (bfd_get_section_name (abfd, section), ".text") == 0)
1760 section->alignment_power = bfd_xcoff_text_align_power (abfd);
1761 else if (bfd_xcoff_data_align_power (abfd) != 0
1762 && strcmp (bfd_get_section_name (abfd, section), ".data") == 0)
1763 section->alignment_power = bfd_xcoff_data_align_power (abfd);
1768 for (i = 0; i < XCOFF_DWSECT_NBR_NAMES; i++)
1769 if (strcmp (bfd_get_section_name (abfd, section),
1770 xcoff_dwsect_names[i].name) == 0)
1772 section->alignment_power = 0;
1779 /* Set up the section symbol. */
1780 if (!_bfd_generic_new_section_hook (abfd, section))
1783 /* Allocate aux records for section symbols, to store size and
1786 @@ The 10 is a guess at a plausible maximum number of aux entries
1787 (but shouldn't be a constant). */
1788 amt = sizeof (combined_entry_type) * 10;
1789 native = (combined_entry_type *) bfd_zalloc (abfd, amt);
1793 /* We don't need to set up n_name, n_value, or n_scnum in the native
1794 symbol information, since they'll be overridden by the BFD symbol
1795 anyhow. However, we do need to set the type and storage class,
1796 in case this symbol winds up getting written out. The value 0
1797 for n_numaux is already correct. */
1799 native->u.syment.n_type = T_NULL;
1800 native->u.syment.n_sclass = sclass;
1802 coffsymbol (section->symbol)->native = native;
1804 coff_set_custom_section_alignment (abfd, section,
1805 coff_section_alignment_table,
1806 coff_section_alignment_table_size);
1811 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1813 /* Set the alignment of a BFD section. */
1816 coff_set_alignment_hook (bfd * abfd ATTRIBUTE_UNUSED,
1820 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1824 /* Extract ALIGN from 2**ALIGN stored in section header. */
1825 for (i = 0; i < 32; i++)
1826 if ((1 << i) >= hdr->s_align)
1830 /* TI tools puts the alignment power in bits 8-11. */
1831 i = (hdr->s_flags >> 8) & 0xF ;
1833 #ifdef COFF_DECODE_ALIGNMENT
1834 i = COFF_DECODE_ALIGNMENT(hdr->s_flags);
1836 section->alignment_power = i;
1838 #ifdef coff_set_section_load_page
1839 coff_set_section_load_page (section, hdr->s_page);
1843 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1847 coff_set_alignment_hook (bfd * abfd ATTRIBUTE_UNUSED,
1851 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1853 unsigned int alignment_power_const
1854 = hdr->s_flags & IMAGE_SCN_ALIGN_POWER_BIT_MASK;
1856 switch (alignment_power_const)
1858 case IMAGE_SCN_ALIGN_8192BYTES:
1859 case IMAGE_SCN_ALIGN_4096BYTES:
1860 case IMAGE_SCN_ALIGN_2048BYTES:
1861 case IMAGE_SCN_ALIGN_1024BYTES:
1862 case IMAGE_SCN_ALIGN_512BYTES:
1863 case IMAGE_SCN_ALIGN_256BYTES:
1864 case IMAGE_SCN_ALIGN_128BYTES:
1865 case IMAGE_SCN_ALIGN_64BYTES:
1866 case IMAGE_SCN_ALIGN_32BYTES:
1867 case IMAGE_SCN_ALIGN_16BYTES:
1868 case IMAGE_SCN_ALIGN_8BYTES:
1869 case IMAGE_SCN_ALIGN_4BYTES:
1870 case IMAGE_SCN_ALIGN_2BYTES:
1871 case IMAGE_SCN_ALIGN_1BYTES:
1872 section->alignment_power
1873 = IMAGE_SCN_ALIGN_POWER_NUM (alignment_power_const);
1879 /* In a PE image file, the s_paddr field holds the virtual size of a
1880 section, while the s_size field holds the raw size. We also keep
1881 the original section flag value, since not every bit can be
1882 mapped onto a generic BFD section bit. */
1883 if (coff_section_data (abfd, section) == NULL)
1885 amt = sizeof (struct coff_section_tdata);
1886 section->used_by_bfd = bfd_zalloc (abfd, amt);
1887 if (section->used_by_bfd == NULL)
1888 /* FIXME: Return error. */
1892 if (pei_section_data (abfd, section) == NULL)
1894 amt = sizeof (struct pei_section_tdata);
1895 coff_section_data (abfd, section)->tdata = bfd_zalloc (abfd, amt);
1896 if (coff_section_data (abfd, section)->tdata == NULL)
1897 /* FIXME: Return error. */
1900 pei_section_data (abfd, section)->virt_size = hdr->s_paddr;
1901 pei_section_data (abfd, section)->pe_flags = hdr->s_flags;
1903 section->lma = hdr->s_vaddr;
1905 /* Check for extended relocs. */
1906 if (hdr->s_flags & IMAGE_SCN_LNK_NRELOC_OVFL)
1908 struct external_reloc dst;
1909 struct internal_reloc n;
1910 file_ptr oldpos = bfd_tell (abfd);
1911 bfd_size_type relsz = bfd_coff_relsz (abfd);
1913 if (bfd_seek (abfd, (file_ptr) hdr->s_relptr, 0) != 0)
1915 if (bfd_bread (& dst, relsz, abfd) != relsz)
1918 coff_swap_reloc_in (abfd, &dst, &n);
1919 if (bfd_seek (abfd, oldpos, 0) != 0)
1921 section->reloc_count = hdr->s_nreloc = n.r_vaddr - 1;
1922 section->rel_filepos += relsz;
1924 else if (hdr->s_nreloc == 0xffff)
1925 (*_bfd_error_handler)
1926 ("%s: warning: claims to have 0xffff relocs, without overflow",
1927 bfd_get_filename (abfd));
1930 #undef ELIFALIGN_SET
1932 #else /* ! COFF_WITH_PE */
1935 /* We grossly abuse this function to handle XCOFF overflow headers.
1936 When we see one, we correct the reloc and line number counts in the
1937 real header, and remove the section we just created. */
1940 coff_set_alignment_hook (bfd *abfd, asection *section, void * scnhdr)
1942 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1945 if ((hdr->s_flags & STYP_OVRFLO) == 0)
1948 real_sec = coff_section_from_bfd_index (abfd, (int) hdr->s_nreloc);
1949 if (real_sec == NULL)
1952 real_sec->reloc_count = hdr->s_paddr;
1953 real_sec->lineno_count = hdr->s_vaddr;
1955 if (!bfd_section_removed_from_list (abfd, section))
1957 bfd_section_list_remove (abfd, section);
1958 --abfd->section_count;
1962 #else /* ! RS6000COFF_C */
1964 #define coff_set_alignment_hook \
1965 ((void (*) (bfd *, asection *, void *)) bfd_void)
1967 #endif /* ! RS6000COFF_C */
1968 #endif /* ! COFF_WITH_PE */
1969 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1971 #ifndef coff_mkobject
1974 coff_mkobject (bfd * abfd)
1976 coff_data_type *coff;
1977 bfd_size_type amt = sizeof (coff_data_type);
1979 abfd->tdata.coff_obj_data = bfd_zalloc (abfd, amt);
1980 if (abfd->tdata.coff_obj_data == NULL)
1982 coff = coff_data (abfd);
1983 coff->symbols = NULL;
1984 coff->conversion_table = NULL;
1985 coff->raw_syments = NULL;
1986 coff->relocbase = 0;
1987 coff->local_toc_sym_map = 0;
1989 /* make_abs_section(abfd);*/
1995 /* Create the COFF backend specific information. */
1997 #ifndef coff_mkobject_hook
1999 coff_mkobject_hook (bfd * abfd,
2001 void * aouthdr ATTRIBUTE_UNUSED)
2003 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
2004 coff_data_type *coff;
2006 if (! coff_mkobject (abfd))
2009 coff = coff_data (abfd);
2011 coff->sym_filepos = internal_f->f_symptr;
2013 /* These members communicate important constants about the symbol
2014 table to GDB's symbol-reading code. These `constants'
2015 unfortunately vary among coff implementations... */
2016 coff->local_n_btmask = N_BTMASK;
2017 coff->local_n_btshft = N_BTSHFT;
2018 coff->local_n_tmask = N_TMASK;
2019 coff->local_n_tshift = N_TSHIFT;
2020 coff->local_symesz = bfd_coff_symesz (abfd);
2021 coff->local_auxesz = bfd_coff_auxesz (abfd);
2022 coff->local_linesz = bfd_coff_linesz (abfd);
2024 coff->timestamp = internal_f->f_timdat;
2026 obj_raw_syment_count (abfd) =
2027 obj_conv_table_size (abfd) =
2028 internal_f->f_nsyms;
2031 if ((internal_f->f_flags & F_SHROBJ) != 0)
2032 abfd->flags |= DYNAMIC;
2033 if (aouthdr != NULL && internal_f->f_opthdr >= bfd_coff_aoutsz (abfd))
2035 struct internal_aouthdr *internal_a =
2036 (struct internal_aouthdr *) aouthdr;
2037 struct xcoff_tdata *xcoff;
2039 xcoff = xcoff_data (abfd);
2040 # ifdef U803XTOCMAGIC
2041 xcoff->xcoff64 = internal_f->f_magic == U803XTOCMAGIC;
2045 xcoff->full_aouthdr = TRUE;
2046 xcoff->toc = internal_a->o_toc;
2047 xcoff->sntoc = internal_a->o_sntoc;
2048 xcoff->snentry = internal_a->o_snentry;
2049 bfd_xcoff_text_align_power (abfd) = internal_a->o_algntext;
2050 bfd_xcoff_data_align_power (abfd) = internal_a->o_algndata;
2051 xcoff->modtype = internal_a->o_modtype;
2052 xcoff->cputype = internal_a->o_cputype;
2053 xcoff->maxdata = internal_a->o_maxdata;
2054 xcoff->maxstack = internal_a->o_maxstack;
2059 /* Set the flags field from the COFF header read in. */
2060 if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags))
2065 /* FIXME: I'm not sure this is ever executed, since peicode.h
2066 defines coff_mkobject_hook. */
2067 if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0)
2068 abfd->flags |= HAS_DEBUG;
2071 if ((internal_f->f_flags & F_GO32STUB) != 0)
2072 coff->go32stub = (char *) bfd_alloc (abfd, (bfd_size_type) GO32_STUBSIZE);
2073 if (coff->go32stub != NULL)
2074 memcpy (coff->go32stub, internal_f->go32stub, GO32_STUBSIZE);
2080 /* Determine the machine architecture and type. FIXME: This is target
2081 dependent because the magic numbers are defined in the target
2082 dependent header files. But there is no particular need for this.
2083 If the magic numbers were moved to a separate file, this function
2084 would be target independent and would also be much more successful
2085 at linking together COFF files for different architectures. */
2088 coff_set_arch_mach_hook (bfd *abfd, void * filehdr)
2090 unsigned long machine;
2091 enum bfd_architecture arch;
2092 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
2094 /* Zero selects the default machine for an arch. */
2096 switch (internal_f->f_magic)
2100 arch = bfd_arch_powerpc;
2106 case I386AIXMAGIC: /* Danbury PS/2 AIX C Compiler. */
2107 case LYNXCOFFMAGIC: /* Shadows the m68k Lynx number below, sigh. */
2108 arch = bfd_arch_i386;
2113 arch = bfd_arch_i386;
2114 machine = bfd_mach_x86_64;
2119 arch = bfd_arch_ia64;
2126 arch = bfd_arch_arm;
2127 machine = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
2128 if (machine == bfd_mach_arm_unknown)
2130 switch (internal_f->f_flags & F_ARM_ARCHITECTURE_MASK)
2132 case F_ARM_2: machine = bfd_mach_arm_2; break;
2133 case F_ARM_2a: machine = bfd_mach_arm_2a; break;
2134 case F_ARM_3: machine = bfd_mach_arm_3; break;
2136 case F_ARM_3M: machine = bfd_mach_arm_3M; break;
2137 case F_ARM_4: machine = bfd_mach_arm_4; break;
2138 case F_ARM_4T: machine = bfd_mach_arm_4T; break;
2139 /* The COFF header does not have enough bits available
2140 to cover all the different ARM architectures. So
2141 we interpret F_ARM_5, the highest flag value to mean
2142 "the highest ARM architecture known to BFD" which is
2143 currently the XScale. */
2144 case F_ARM_5: machine = bfd_mach_arm_XScale; break;
2152 #ifdef MC68KBCSMAGIC
2155 #ifdef APOLLOM68KMAGIC
2156 case APOLLOM68KMAGIC:
2158 #ifdef LYNXCOFFMAGIC
2161 arch = bfd_arch_m68k;
2162 machine = bfd_mach_m68020;
2169 arch = bfd_arch_m88k;
2175 arch = bfd_arch_z80;
2176 switch (internal_f->f_flags & F_MACHMASK)
2179 case bfd_mach_z80strict << 12:
2180 case bfd_mach_z80 << 12:
2181 case bfd_mach_z80full << 12:
2182 case bfd_mach_r800 << 12:
2183 machine = ((unsigned)internal_f->f_flags & F_MACHMASK) >> 12;
2192 arch = bfd_arch_z8k;
2193 switch (internal_f->f_flags & F_MACHMASK)
2196 machine = bfd_mach_z8001;
2199 machine = bfd_mach_z8002;
2208 arch = bfd_arch_i860;
2215 arch = bfd_arch_i960;
2216 switch (F_I960TYPE & internal_f->f_flags)
2220 machine = bfd_mach_i960_core;
2223 machine = bfd_mach_i960_kb_sb;
2226 machine = bfd_mach_i960_mc;
2229 machine = bfd_mach_i960_xa;
2232 machine = bfd_mach_i960_ca;
2235 machine = bfd_mach_i960_ka_sa;
2238 machine = bfd_mach_i960_jx;
2241 machine = bfd_mach_i960_hx;
2260 if (xcoff_data (abfd)->cputype != -1)
2261 cputype = xcoff_data (abfd)->cputype & 0xff;
2264 /* We did not get a value from the a.out header. If the
2265 file has not been stripped, we may be able to get the
2266 architecture information from the first symbol, if it
2267 is a .file symbol. */
2268 if (obj_raw_syment_count (abfd) == 0)
2273 struct internal_syment sym;
2274 bfd_size_type amt = bfd_coff_symesz (abfd);
2276 buf = bfd_malloc (amt);
2277 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
2278 || bfd_bread (buf, amt, abfd) != amt)
2283 bfd_coff_swap_sym_in (abfd, buf, & sym);
2284 if (sym.n_sclass == C_FILE)
2285 cputype = sym.n_type & 0xff;
2292 /* FIXME: We don't handle all cases here. */
2297 arch = bfd_xcoff_architecture (abfd);
2298 machine = bfd_xcoff_machine (abfd);
2302 arch = bfd_arch_powerpc;
2303 machine = bfd_mach_ppc_601;
2305 case 2: /* 64 bit PowerPC */
2306 arch = bfd_arch_powerpc;
2307 machine = bfd_mach_ppc_620;
2310 arch = bfd_arch_powerpc;
2311 machine = bfd_mach_ppc;
2314 arch = bfd_arch_rs6000;
2315 machine = bfd_mach_rs6k;
2324 arch = bfd_arch_we32k;
2330 arch = bfd_arch_h8300;
2331 machine = bfd_mach_h8300;
2332 /* !! FIXME this probably isn't the right place for this. */
2333 abfd->flags |= BFD_IS_RELAXABLE;
2339 arch = bfd_arch_h8300;
2340 machine = bfd_mach_h8300h;
2341 /* !! FIXME this probably isn't the right place for this. */
2342 abfd->flags |= BFD_IS_RELAXABLE;
2348 arch = bfd_arch_h8300;
2349 machine = bfd_mach_h8300s;
2350 /* !! FIXME this probably isn't the right place for this. */
2351 abfd->flags |= BFD_IS_RELAXABLE;
2357 arch = bfd_arch_h8300;
2358 machine = bfd_mach_h8300hn;
2359 /* !! FIXME this probably isn't the right place for this. */
2360 abfd->flags |= BFD_IS_RELAXABLE;
2366 arch = bfd_arch_h8300;
2367 machine = bfd_mach_h8300sn;
2368 /* !! FIXME this probably isn't the right place for this. */
2369 abfd->flags |= BFD_IS_RELAXABLE;
2373 #ifdef SH_ARCH_MAGIC_BIG
2374 case SH_ARCH_MAGIC_BIG:
2375 case SH_ARCH_MAGIC_LITTLE:
2377 case SH_ARCH_MAGIC_WINCE:
2383 #ifdef MIPS_ARCH_MAGIC_WINCE
2384 case MIPS_ARCH_MAGIC_WINCE:
2385 arch = bfd_arch_mips;
2391 arch = bfd_arch_h8500;
2397 #ifdef LYNXCOFFMAGIC
2400 arch = bfd_arch_sparc;
2406 arch = bfd_arch_tic30;
2411 #ifdef TICOFF_TARGET_ARCH
2412 /* This TI COFF section should be used by all new TI COFF v0 targets. */
2414 arch = TICOFF_TARGET_ARCH;
2415 machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags);
2421 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */
2422 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */
2425 switch (internal_f->f_target_id)
2429 arch = TICOFF_TARGET_ARCH;
2430 machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags);
2434 arch = bfd_arch_obscure;
2435 (*_bfd_error_handler)
2436 (_("Unrecognized TI COFF target id '0x%x'"),
2437 internal_f->f_target_id);
2443 #ifdef TIC80_ARCH_MAGIC
2444 case TIC80_ARCH_MAGIC:
2445 arch = bfd_arch_tic80;
2451 arch = bfd_arch_mcore;
2457 arch = bfd_arch_w65;
2461 default: /* Unreadable input file type. */
2462 arch = bfd_arch_obscure;
2466 bfd_default_set_arch_mach (abfd, arch, machine);
2470 #ifdef SYMNAME_IN_DEBUG
2473 symname_in_debug_hook (bfd * abfd ATTRIBUTE_UNUSED, struct internal_syment *sym)
2475 return SYMNAME_IN_DEBUG (sym) != 0;
2480 #define symname_in_debug_hook \
2481 (bfd_boolean (*) (bfd *, struct internal_syment *)) bfd_false
2488 #define FORCE_SYMNAMES_IN_STRINGS
2491 /* Handle the csect auxent of a C_EXT, C_AIX_WEAKEXT or C_HIDEXT symbol. */
2494 coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED,
2495 combined_entry_type *table_base,
2496 combined_entry_type *symbol,
2497 unsigned int indaux,
2498 combined_entry_type *aux)
2500 int n_sclass = symbol->u.syment.n_sclass;
2502 if (CSECT_SYM_P (n_sclass)
2503 && indaux + 1 == symbol->u.syment.n_numaux)
2505 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
2507 aux->u.auxent.x_csect.x_scnlen.p =
2508 table_base + aux->u.auxent.x_csect.x_scnlen.l;
2509 aux->fix_scnlen = 1;
2512 /* Return TRUE to indicate that the caller should not do any
2513 further work on this auxent. */
2517 /* Return FALSE to indicate that this auxent should be handled by
2525 /* We don't want to pointerize bal entries. */
2528 coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED,
2529 combined_entry_type *table_base ATTRIBUTE_UNUSED,
2530 combined_entry_type *symbol,
2531 unsigned int indaux,
2532 combined_entry_type *aux ATTRIBUTE_UNUSED)
2534 /* Return TRUE if we don't want to pointerize this aux entry, which
2535 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2537 && (symbol->u.syment.n_sclass == C_LEAFPROC
2538 || symbol->u.syment.n_sclass == C_LEAFSTAT
2539 || symbol->u.syment.n_sclass == C_LEAFEXT));
2544 #define coff_pointerize_aux_hook 0
2547 #endif /* ! RS6000COFF_C */
2549 /* Print an aux entry. This returns TRUE if it has printed it. */
2552 coff_print_aux (bfd *abfd ATTRIBUTE_UNUSED,
2553 FILE *file ATTRIBUTE_UNUSED,
2554 combined_entry_type *table_base ATTRIBUTE_UNUSED,
2555 combined_entry_type *symbol ATTRIBUTE_UNUSED,
2556 combined_entry_type *aux ATTRIBUTE_UNUSED,
2557 unsigned int indaux ATTRIBUTE_UNUSED)
2560 if (CSECT_SYM_P (symbol->u.syment.n_sclass)
2561 && indaux + 1 == symbol->u.syment.n_numaux)
2563 /* This is a csect entry. */
2564 fprintf (file, "AUX ");
2565 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
2567 BFD_ASSERT (! aux->fix_scnlen);
2569 fprintf (file, "val %5lld",
2570 (long long) aux->u.auxent.x_csect.x_scnlen.l);
2572 fprintf (file, "val %5ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
2577 fprintf (file, "indx ");
2578 if (! aux->fix_scnlen)
2580 fprintf (file, "%4lld",
2581 (long long) aux->u.auxent.x_csect.x_scnlen.l);
2583 fprintf (file, "%4ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
2586 fprintf (file, "%4ld",
2587 (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base));
2590 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2591 aux->u.auxent.x_csect.x_parmhash,
2592 (unsigned int) aux->u.auxent.x_csect.x_snhash,
2593 SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp),
2594 SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp),
2595 (unsigned int) aux->u.auxent.x_csect.x_smclas,
2596 aux->u.auxent.x_csect.x_stab,
2597 (unsigned int) aux->u.auxent.x_csect.x_snstab);
2602 /* Return FALSE to indicate that no special action was taken. */
2610 To write relocations, the back end steps though the
2611 canonical relocation table and create an
2612 @code{internal_reloc}. The symbol index to use is removed from
2613 the @code{offset} field in the symbol table supplied. The
2614 address comes directly from the sum of the section base
2615 address and the relocation offset; the type is dug directly
2616 from the howto field. Then the @code{internal_reloc} is
2617 swapped into the shape of an @code{external_reloc} and written
2625 /* AUX's ld wants relocations to be sorted. */
2627 compare_arelent_ptr (const void * x, const void * y)
2629 const arelent **a = (const arelent **) x;
2630 const arelent **b = (const arelent **) y;
2631 bfd_size_type aadr = (*a)->address;
2632 bfd_size_type badr = (*b)->address;
2634 return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
2637 #endif /* TARG_AUX */
2640 coff_write_relocs (bfd * abfd, int first_undef)
2644 for (s = abfd->sections; s != NULL; s = s->next)
2647 struct external_reloc dst;
2654 /* Sort relocations before we write them out. */
2657 amt = s->reloc_count;
2658 amt *= sizeof (arelent *);
2659 p = bfd_malloc (amt);
2660 if (p == NULL && s->reloc_count > 0)
2662 memcpy (p, s->orelocation, (size_t) amt);
2663 qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr);
2667 if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
2671 if (obj_pe (abfd) && s->reloc_count >= 0xffff)
2673 /* Encode real count here as first reloc. */
2674 struct internal_reloc n;
2676 memset (& n, 0, sizeof (n));
2677 /* Add one to count *this* reloc (grr). */
2678 n.r_vaddr = s->reloc_count + 1;
2679 coff_swap_reloc_out (abfd, &n, &dst);
2680 if (bfd_bwrite (& dst, (bfd_size_type) bfd_coff_relsz (abfd),
2681 abfd) != bfd_coff_relsz (abfd))
2686 for (i = 0; i < s->reloc_count; i++)
2688 struct internal_reloc n;
2691 memset (& n, 0, sizeof (n));
2693 /* Now we've renumbered the symbols we know where the
2694 undefined symbols live in the table. Check the reloc
2695 entries for symbols who's output bfd isn't the right one.
2696 This is because the symbol was undefined (which means
2697 that all the pointers are never made to point to the same
2698 place). This is a bad thing,'cause the symbols attached
2699 to the output bfd are indexed, so that the relocation
2700 entries know which symbol index they point to. So we
2701 have to look up the output symbol here. */
2703 if (q->sym_ptr_ptr[0] != NULL && q->sym_ptr_ptr[0]->the_bfd != abfd)
2706 const char *sname = q->sym_ptr_ptr[0]->name;
2707 asymbol **outsyms = abfd->outsymbols;
2709 for (j = first_undef; outsyms[j]; j++)
2711 const char *intable = outsyms[j]->name;
2713 if (strcmp (intable, sname) == 0)
2715 /* Got a hit, so repoint the reloc. */
2716 q->sym_ptr_ptr = outsyms + j;
2722 n.r_vaddr = q->address + s->vma;
2725 /* The 29k const/consth reloc pair is a real kludge. The consth
2726 part doesn't have a symbol; it has an offset. So rebuilt
2728 if (q->howto->type == R_IHCONST)
2729 n.r_symndx = q->addend;
2732 if (q->sym_ptr_ptr && q->sym_ptr_ptr[0] != NULL)
2734 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2735 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q, s))
2737 if ((*q->sym_ptr_ptr)->section == bfd_abs_section_ptr
2738 && ((*q->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0)
2740 /* This is a relocation relative to the absolute symbol. */
2744 n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
2745 /* Check to see if the symbol reloc points to a symbol
2746 we don't have in our symbol table. */
2747 if (n.r_symndx > obj_conv_table_size (abfd))
2749 bfd_set_error (bfd_error_bad_value);
2750 _bfd_error_handler (_("%B: reloc against a non-existant symbol index: %ld"),
2757 #ifdef SWAP_OUT_RELOC_OFFSET
2758 n.r_offset = q->addend;
2762 /* Work out reloc type from what is required. */
2763 SELECT_RELOC (n, q->howto);
2765 n.r_type = q->howto->type;
2767 coff_swap_reloc_out (abfd, &n, &dst);
2769 if (bfd_bwrite (& dst, (bfd_size_type) bfd_coff_relsz (abfd),
2770 abfd) != bfd_coff_relsz (abfd))
2783 /* Set flags and magic number of a coff file from architecture and machine
2784 type. Result is TRUE if we can represent the arch&type, FALSE if not. */
2787 coff_set_flags (bfd * abfd,
2788 unsigned int *magicp ATTRIBUTE_UNUSED,
2789 unsigned short *flagsp ATTRIBUTE_UNUSED)
2791 switch (bfd_get_arch (abfd))
2796 switch (bfd_get_mach (abfd))
2799 case bfd_mach_z80strict:
2801 case bfd_mach_z80full:
2803 *flagsp = bfd_get_mach (abfd) << 12;
2815 switch (bfd_get_mach (abfd))
2817 case bfd_mach_z8001: *flagsp = F_Z8001; break;
2818 case bfd_mach_z8002: *flagsp = F_Z8002; break;
2819 default: return FALSE;
2830 *magicp = I960ROMAGIC;
2832 switch (bfd_get_mach (abfd))
2834 case bfd_mach_i960_core: flags = F_I960CORE; break;
2835 case bfd_mach_i960_kb_sb: flags = F_I960KB; break;
2836 case bfd_mach_i960_mc: flags = F_I960MC; break;
2837 case bfd_mach_i960_xa: flags = F_I960XA; break;
2838 case bfd_mach_i960_ca: flags = F_I960CA; break;
2839 case bfd_mach_i960_ka_sa: flags = F_I960KA; break;
2840 case bfd_mach_i960_jx: flags = F_I960JX; break;
2841 case bfd_mach_i960_hx: flags = F_I960HX; break;
2842 default: return FALSE;
2851 case bfd_arch_tic30:
2852 *magicp = TIC30MAGIC;
2856 #ifdef TICOFF_DEFAULT_MAGIC
2857 case TICOFF_TARGET_ARCH:
2858 /* If there's no indication of which version we want, use the default. */
2860 *magicp = TICOFF_DEFAULT_MAGIC;
2863 /* We may want to output in a different COFF version. */
2864 switch (abfd->xvec->name[4])
2867 *magicp = TICOFF0MAGIC;
2870 *magicp = TICOFF1MAGIC;
2873 *magicp = TICOFF2MAGIC;
2879 TICOFF_TARGET_MACHINE_SET (flagsp, bfd_get_mach (abfd));
2883 #ifdef TIC80_ARCH_MAGIC
2884 case bfd_arch_tic80:
2885 *magicp = TIC80_ARCH_MAGIC;
2892 * magicp = ARMPEMAGIC;
2894 * magicp = ARMMAGIC;
2897 if (APCS_SET (abfd))
2899 if (APCS_26_FLAG (abfd))
2900 * flagsp |= F_APCS26;
2902 if (APCS_FLOAT_FLAG (abfd))
2903 * flagsp |= F_APCS_FLOAT;
2905 if (PIC_FLAG (abfd))
2908 if (INTERWORK_SET (abfd) && INTERWORK_FLAG (abfd))
2909 * flagsp |= F_INTERWORK;
2910 switch (bfd_get_mach (abfd))
2912 case bfd_mach_arm_2: * flagsp |= F_ARM_2; break;
2913 case bfd_mach_arm_2a: * flagsp |= F_ARM_2a; break;
2914 case bfd_mach_arm_3: * flagsp |= F_ARM_3; break;
2915 case bfd_mach_arm_3M: * flagsp |= F_ARM_3M; break;
2916 case bfd_mach_arm_4: * flagsp |= F_ARM_4; break;
2917 case bfd_mach_arm_4T: * flagsp |= F_ARM_4T; break;
2918 case bfd_mach_arm_5: * flagsp |= F_ARM_5; break;
2919 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2920 See also the comment in coff_set_arch_mach_hook(). */
2921 case bfd_mach_arm_5T: * flagsp |= F_ARM_5; break;
2922 case bfd_mach_arm_5TE: * flagsp |= F_ARM_5; break;
2923 case bfd_mach_arm_XScale: * flagsp |= F_ARM_5; break;
2929 case bfd_arch_powerpc:
2934 #if defined(I386MAGIC) || defined(AMD64MAGIC)
2936 #if defined(I386MAGIC)
2937 *magicp = I386MAGIC;
2940 /* Just overwrite the usual value if we're doing Lynx. */
2941 *magicp = LYNXCOFFMAGIC;
2943 #if defined AMD64MAGIC
2944 *magicp = AMD64MAGIC;
2951 *magicp = I860MAGIC;
2957 *magicp = IA64MAGIC;
2963 #ifdef APOLLOM68KMAGIC
2964 *magicp = APOLLO_COFF_VERSION_NUMBER;
2966 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2967 #ifdef NAMES_HAVE_UNDERSCORE
2968 *magicp = MC68KBCSMAGIC;
2970 *magicp = MC68MAGIC;
2974 /* Just overwrite the usual value if we're doing Lynx. */
2975 *magicp = LYNXCOFFMAGIC;
2982 *magicp = MC88OMAGIC;
2987 case bfd_arch_h8300:
2988 switch (bfd_get_mach (abfd))
2990 case bfd_mach_h8300: *magicp = H8300MAGIC; return TRUE;
2991 case bfd_mach_h8300h: *magicp = H8300HMAGIC; return TRUE;
2992 case bfd_mach_h8300s: *magicp = H8300SMAGIC; return TRUE;
2993 case bfd_mach_h8300hn: *magicp = H8300HNMAGIC; return TRUE;
2994 case bfd_mach_h8300sn: *magicp = H8300SNMAGIC; return TRUE;
3000 #ifdef SH_ARCH_MAGIC_BIG
3002 #ifdef COFF_IMAGE_WITH_PE
3003 *magicp = SH_ARCH_MAGIC_WINCE;
3005 if (bfd_big_endian (abfd))
3006 *magicp = SH_ARCH_MAGIC_BIG;
3008 *magicp = SH_ARCH_MAGIC_LITTLE;
3013 #ifdef MIPS_ARCH_MAGIC_WINCE
3015 *magicp = MIPS_ARCH_MAGIC_WINCE;
3020 case bfd_arch_sparc:
3021 *magicp = SPARCMAGIC;
3023 /* Just overwrite the usual value if we're doing Lynx. */
3024 *magicp = LYNXCOFFMAGIC;
3030 case bfd_arch_h8500:
3031 *magicp = H8500MAGIC;
3037 case bfd_arch_we32k:
3038 *magicp = WE32KMAGIC;
3043 case bfd_arch_rs6000:
3045 case bfd_arch_powerpc:
3047 BFD_ASSERT (bfd_get_flavour (abfd) == bfd_target_xcoff_flavour);
3048 *magicp = bfd_xcoff_magic_number (abfd);
3053 case bfd_arch_mcore:
3054 * magicp = MCOREMAGIC;
3064 default: /* Unknown architecture. */
3065 /* Fall through to "return FALSE" below, to avoid
3066 "statement never reached" errors on the one below. */
3074 coff_set_arch_mach (bfd * abfd,
3075 enum bfd_architecture arch,
3076 unsigned long machine)
3079 unsigned short dummy2;
3081 if (! bfd_default_set_arch_mach (abfd, arch, machine))
3084 if (arch != bfd_arch_unknown
3085 && ! coff_set_flags (abfd, &dummy1, &dummy2))
3086 return FALSE; /* We can't represent this type. */
3088 return TRUE; /* We're easy... */
3091 #ifdef COFF_IMAGE_WITH_PE
3093 /* This is used to sort sections by VMA, as required by PE image
3097 sort_by_secaddr (const void * arg1, const void * arg2)
3099 const asection *a = *(const asection **) arg1;
3100 const asection *b = *(const asection **) arg2;
3102 if (a->vma < b->vma)
3104 else if (a->vma > b->vma)
3110 #endif /* COFF_IMAGE_WITH_PE */
3112 /* Calculate the file position for each section. */
3115 #define ALIGN_SECTIONS_IN_FILE
3117 #if defined(TIC80COFF) || defined(TICOFF)
3118 #undef ALIGN_SECTIONS_IN_FILE
3122 coff_compute_section_file_positions (bfd * abfd)
3125 file_ptr sofar = bfd_coff_filhsz (abfd);
3126 bfd_boolean align_adjust;
3127 unsigned int target_index;
3128 #ifdef ALIGN_SECTIONS_IN_FILE
3129 asection *previous = NULL;
3133 #ifdef COFF_IMAGE_WITH_PE
3136 if (coff_data (abfd)->link_info
3137 || (pe_data (abfd) && pe_data (abfd)->pe_opthdr.FileAlignment))
3139 page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
3141 /* If no file alignment has been set, default to one.
3142 This repairs 'ld -r' for arm-wince-pe target. */
3147 page_size = PE_DEF_FILE_ALIGNMENT;
3149 #ifdef COFF_PAGE_SIZE
3150 int page_size = COFF_PAGE_SIZE;
3155 /* On XCOFF, if we have symbols, set up the .debug section. */
3156 if (bfd_get_symcount (abfd) > 0)
3159 bfd_size_type i, symcount;
3163 symcount = bfd_get_symcount (abfd);
3164 for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++)
3166 coff_symbol_type *cf;
3168 cf = coff_symbol_from (abfd, *symp);
3170 && cf->native != NULL
3171 && SYMNAME_IN_DEBUG (&cf->native->u.syment))
3175 len = strlen (bfd_asymbol_name (*symp));
3176 if (len > SYMNMLEN || bfd_coff_force_symnames_in_strings (abfd))
3177 sz += len + 1 + bfd_coff_debug_string_prefix_length (abfd);
3184 dsec = bfd_make_section_old_way (abfd, DOT_DEBUG);
3188 dsec->flags |= SEC_HAS_CONTENTS;
3193 if (bfd_get_start_address (abfd))
3194 /* A start address may have been added to the original file. In this
3195 case it will need an optional header to record it. */
3196 abfd->flags |= EXEC_P;
3198 if (abfd->flags & EXEC_P)
3199 sofar += bfd_coff_aoutsz (abfd);
3201 else if (xcoff_data (abfd)->full_aouthdr)
3202 sofar += bfd_coff_aoutsz (abfd);
3204 sofar += SMALL_AOUTSZ;
3207 sofar += abfd->section_count * bfd_coff_scnhsz (abfd);
3210 /* XCOFF handles overflows in the reloc and line number count fields
3211 by allocating a new section header to hold the correct counts. */
3212 for (current = abfd->sections; current != NULL; current = current->next)
3213 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3214 sofar += bfd_coff_scnhsz (abfd);
3217 #ifdef COFF_IMAGE_WITH_PE
3219 /* PE requires the sections to be in memory order when listed in
3220 the section headers. It also does not like empty loadable
3221 sections. The sections apparently do not have to be in the
3222 right order in the image file itself, but we do need to get the
3223 target_index values right. */
3226 asection **section_list;
3230 #ifdef COFF_PAGE_SIZE
3231 /* Clear D_PAGED if section alignment is smaller than
3233 if (pe_data (abfd)->pe_opthdr.SectionAlignment < COFF_PAGE_SIZE)
3234 abfd->flags &= ~D_PAGED;
3238 for (current = abfd->sections; current != NULL; current = current->next)
3241 /* We allocate an extra cell to simplify the final loop. */
3242 amt = sizeof (struct asection *) * (count + 1);
3243 section_list = (asection **) bfd_malloc (amt);
3244 if (section_list == NULL)
3248 for (current = abfd->sections; current != NULL; current = current->next)
3250 section_list[i] = current;
3253 section_list[i] = NULL;
3255 qsort (section_list, count, sizeof (asection *), sort_by_secaddr);
3257 /* Rethread the linked list into sorted order; at the same time,
3258 assign target_index values. */
3260 abfd->sections = NULL;
3261 abfd->section_last = NULL;
3262 for (i = 0; i < count; i++)
3264 current = section_list[i];
3265 bfd_section_list_append (abfd, current);
3267 /* Later, if the section has zero size, we'll be throwing it
3268 away, so we don't want to number it now. Note that having
3269 a zero size and having real contents are different
3270 concepts: .bss has no contents, but (usually) non-zero
3272 if (current->size == 0)
3274 /* Discard. However, it still might have (valid) symbols
3275 in it, so arbitrarily set it to section 1 (indexing is
3276 1-based here; usually .text). __end__ and other
3277 contents of .endsection really have this happen.
3278 FIXME: This seems somewhat dubious. */
3279 current->target_index = 1;
3282 current->target_index = target_index++;
3285 free (section_list);
3287 #else /* ! COFF_IMAGE_WITH_PE */
3289 /* Set the target_index field. */
3291 for (current = abfd->sections; current != NULL; current = current->next)
3292 current->target_index = target_index++;
3294 #endif /* ! COFF_IMAGE_WITH_PE */
3296 if (target_index >= bfd_coff_max_nscns (abfd))
3298 bfd_set_error (bfd_error_file_too_big);
3299 (*_bfd_error_handler)
3300 (_("%B: too many sections (%d)"), abfd, target_index);
3304 align_adjust = FALSE;
3305 for (current = abfd->sections;
3307 current = current->next)
3309 #ifdef COFF_IMAGE_WITH_PE
3310 /* With PE we have to pad each section to be a multiple of its
3311 page size too, and remember both sizes. */
3312 if (coff_section_data (abfd, current) == NULL)
3314 bfd_size_type amt = sizeof (struct coff_section_tdata);
3316 current->used_by_bfd = bfd_zalloc (abfd, amt);
3317 if (current->used_by_bfd == NULL)
3320 if (pei_section_data (abfd, current) == NULL)
3322 bfd_size_type amt = sizeof (struct pei_section_tdata);
3324 coff_section_data (abfd, current)->tdata = bfd_zalloc (abfd, amt);
3325 if (coff_section_data (abfd, current)->tdata == NULL)
3328 if (pei_section_data (abfd, current)->virt_size == 0)
3329 pei_section_data (abfd, current)->virt_size = current->size;
3332 /* Only deal with sections which have contents. */
3333 if (!(current->flags & SEC_HAS_CONTENTS))
3336 current->rawsize = current->size;
3338 #ifdef COFF_IMAGE_WITH_PE
3339 /* Make sure we skip empty sections in a PE image. */
3340 if (current->size == 0)
3344 /* Align the sections in the file to the same boundary on
3345 which they are aligned in virtual memory. I960 doesn't
3346 do this (FIXME) so we can stay in sync with Intel. 960
3347 doesn't yet page from files... */
3348 #ifdef ALIGN_SECTIONS_IN_FILE
3349 if ((abfd->flags & EXEC_P) != 0)
3351 /* Make sure this section is aligned on the right boundary - by
3352 padding the previous section up if necessary. */
3355 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3358 /* Make sure the file offset and the vma of .text/.data are at the
3359 same page offset, so that the file can be mmap'ed without being
3360 relocated. Failing that, AIX is able to load and execute the
3361 program, but it will be silently relocated (possible as
3362 executables are PIE). But the relocation is slightly costly and
3363 complexify the use of addr2line or gdb. So better to avoid it,
3364 like does the native linker. Usually gnu ld makes sure that
3365 the vma of .text is the file offset so this issue shouldn't
3366 appear unless you are stripping such an executable.
3368 AIX loader checks the text section alignment of (vma - filepos),
3369 and the native linker doesn't try to align the text sections.
3372 0 .text 000054cc 10000128 10000128 00000128 2**5
3373 CONTENTS, ALLOC, LOAD, CODE
3376 if (!strcmp (current->name, _TEXT)
3377 || !strcmp (current->name, _DATA))
3379 bfd_vma align = 4096;
3380 bfd_vma sofar_off = sofar % align;
3381 bfd_vma vma_off = current->vma % align;
3383 if (vma_off > sofar_off)
3384 sofar += vma_off - sofar_off;
3385 else if (vma_off < sofar_off)
3386 sofar += align + vma_off - sofar_off;
3389 if (previous != NULL)
3390 previous->size += sofar - old_sofar;
3395 /* In demand paged files the low order bits of the file offset
3396 must match the low order bits of the virtual address. */
3397 #ifdef COFF_PAGE_SIZE
3398 if ((abfd->flags & D_PAGED) != 0
3399 && (current->flags & SEC_ALLOC) != 0)
3400 sofar += (current->vma - (bfd_vma) sofar) % page_size;
3402 current->filepos = sofar;
3404 #ifdef COFF_IMAGE_WITH_PE
3405 /* Set the padded size. */
3406 current->size = (current->size + page_size - 1) & -page_size;
3409 sofar += current->size;
3411 #ifdef ALIGN_SECTIONS_IN_FILE
3412 /* Make sure that this section is of the right size too. */
3413 if ((abfd->flags & EXEC_P) == 0)
3415 bfd_size_type old_size;
3417 old_size = current->size;
3418 current->size = BFD_ALIGN (current->size,
3419 1 << current->alignment_power);
3420 align_adjust = current->size != old_size;
3421 sofar += current->size - old_size;
3426 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3427 align_adjust = sofar != old_sofar;
3428 current->size += sofar - old_sofar;
3432 #ifdef COFF_IMAGE_WITH_PE
3433 /* For PE we need to make sure we pad out to the aligned
3434 size, in case the caller only writes out data to the
3436 if (pei_section_data (abfd, current)->virt_size < current->size)
3437 align_adjust = TRUE;
3441 /* Force .lib sections to start at zero. The vma is then
3442 incremented in coff_set_section_contents. This is right for
3444 if (strcmp (current->name, _LIB) == 0)
3445 (void) bfd_set_section_vma (abfd, current, 0);
3448 #ifdef ALIGN_SECTIONS_IN_FILE
3453 /* It is now safe to write to the output file. If we needed an
3454 alignment adjustment for the last section, then make sure that
3455 there is a byte at offset sofar. If there are no symbols and no
3456 relocs, then nothing follows the last section. If we don't force
3457 the last byte out, then the file may appear to be truncated. */
3463 if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0
3464 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
3468 /* Make sure the relocations are aligned. We don't need to make
3469 sure that this byte exists, because it will only matter if there
3470 really are relocs. */
3471 sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER);
3473 obj_relocbase (abfd) = sofar;
3474 abfd->output_has_begun = TRUE;
3479 #ifdef COFF_IMAGE_WITH_PE
3481 static unsigned int pelength;
3482 static unsigned int peheader;
3485 coff_read_word (bfd *abfd, unsigned int *value)
3490 status = bfd_bread (b, (bfd_size_type) 2, abfd);
3498 *value = (unsigned int) b[0];
3500 *value = (unsigned int) (b[0] + (b[1] << 8));
3502 pelength += (unsigned int) status;
3508 coff_compute_checksum (bfd *abfd)
3510 bfd_boolean more_data;
3517 filepos = (file_ptr) 0;
3521 if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
3524 more_data = coff_read_word (abfd, &value);
3526 total = 0xffff & (total + (total >> 0x10));
3531 return (0xffff & (total + (total >> 0x10)));
3535 coff_apply_checksum (bfd *abfd)
3537 unsigned int computed;
3538 unsigned int checksum = 0;
3540 if (bfd_seek (abfd, 0x3c, SEEK_SET) != 0)
3543 if (!coff_read_word (abfd, &peheader))
3546 if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
3550 bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
3552 if (bfd_seek (abfd, peheader, SEEK_SET) != 0)
3555 computed = coff_compute_checksum (abfd);
3557 checksum = computed + pelength;
3559 if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
3562 bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
3567 #endif /* COFF_IMAGE_WITH_PE */
3570 coff_write_object_contents (bfd * abfd)
3573 bfd_boolean hasrelocs = FALSE;
3574 bfd_boolean haslinno = FALSE;
3575 #ifdef COFF_IMAGE_WITH_PE
3576 bfd_boolean hasdebug = FALSE;
3579 file_ptr reloc_base;
3580 file_ptr lineno_base;
3582 unsigned long reloc_size = 0, reloc_count = 0;
3583 unsigned long lnno_size = 0;
3584 bfd_boolean long_section_names;
3585 asection *text_sec = NULL;
3586 asection *data_sec = NULL;
3587 asection *bss_sec = NULL;
3588 struct internal_filehdr internal_f;
3589 struct internal_aouthdr internal_a;
3590 #ifdef COFF_LONG_SECTION_NAMES
3591 size_t string_size = STRING_SIZE_SIZE;
3594 bfd_set_error (bfd_error_system_call);
3596 /* Make a pass through the symbol table to count line number entries and
3597 put them into the correct asections. */
3598 lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd);
3600 if (! abfd->output_has_begun)
3602 if (! coff_compute_section_file_positions (abfd))
3606 reloc_base = obj_relocbase (abfd);
3608 /* Work out the size of the reloc and linno areas. */
3610 for (current = abfd->sections; current != NULL; current =
3614 /* We store the actual reloc count in the first reloc's addr. */
3615 if (obj_pe (abfd) && current->reloc_count >= 0xffff)
3618 reloc_count += current->reloc_count;
3621 reloc_size = reloc_count * bfd_coff_relsz (abfd);
3623 lineno_base = reloc_base + reloc_size;
3624 sym_base = lineno_base + lnno_size;
3626 /* Indicate in each section->line_filepos its actual file address. */
3627 for (current = abfd->sections; current != NULL; current =
3630 if (current->lineno_count)
3632 current->line_filepos = lineno_base;
3633 current->moving_line_filepos = lineno_base;
3634 lineno_base += current->lineno_count * bfd_coff_linesz (abfd);
3637 current->line_filepos = 0;
3639 if (current->reloc_count)
3641 current->rel_filepos = reloc_base;
3642 reloc_base += current->reloc_count * bfd_coff_relsz (abfd);
3644 /* Extra reloc to hold real count. */
3645 if (obj_pe (abfd) && current->reloc_count >= 0xffff)
3646 reloc_base += bfd_coff_relsz (abfd);
3650 current->rel_filepos = 0;
3653 /* Write section headers to the file. */
3654 internal_f.f_nscns = 0;
3656 if ((abfd->flags & EXEC_P) != 0)
3657 scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
3660 scn_base = bfd_coff_filhsz (abfd);
3663 if (xcoff_data (abfd)->full_aouthdr)
3664 scn_base += bfd_coff_aoutsz (abfd);
3666 scn_base += SMALL_AOUTSZ;
3671 if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
3674 long_section_names = FALSE;
3675 for (current = abfd->sections;
3677 current = current->next)
3679 struct internal_scnhdr section;
3680 #ifdef COFF_IMAGE_WITH_PE
3681 bfd_boolean is_reloc_section = FALSE;
3683 if (strcmp (current->name, DOT_RELOC) == 0)
3685 is_reloc_section = TRUE;
3687 pe_data (abfd)->has_reloc_section = 1;
3691 internal_f.f_nscns++;
3693 strncpy (section.s_name, current->name, SCNNMLEN);
3695 #ifdef COFF_LONG_SECTION_NAMES
3696 /* Handle long section names as in PE. This must be compatible
3697 with the code in coff_write_symbols and _bfd_coff_final_link. */
3698 if (bfd_coff_long_section_names (abfd))
3702 len = strlen (current->name);
3705 /* The s_name field is defined to be NUL-padded but need not be
3706 NUL-terminated. We use a temporary buffer so that we can still
3707 sprintf all eight chars without splatting a terminating NUL
3708 over the first byte of the following member (s_paddr). */
3709 char s_name_buf[SCNNMLEN + 1];
3711 /* An inherent limitation of the /nnnnnnn notation used to indicate
3712 the offset of the long name in the string table is that we
3713 cannot address entries beyone the ten million byte boundary. */
3714 if (string_size >= 10000000)
3716 bfd_set_error (bfd_error_file_too_big);
3717 (*_bfd_error_handler)
3718 (_("%B: section %s: string table overflow at offset %ld"),
3719 abfd, current->name, string_size);
3723 /* snprintf not strictly necessary now we've verified the value
3724 has less than eight ASCII digits, but never mind. */
3725 snprintf (s_name_buf, SCNNMLEN + 1, "/%lu", (unsigned long) string_size);
3726 /* Then strncpy takes care of any padding for us. */
3727 strncpy (section.s_name, s_name_buf, SCNNMLEN);
3728 string_size += len + 1;
3729 long_section_names = TRUE;
3735 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3736 Ian Taylor <ian@cygnus.com>. */
3737 if (strcmp (current->name, _LIB) == 0)
3738 section.s_vaddr = 0;
3741 section.s_vaddr = current->vma;
3742 section.s_paddr = current->lma;
3743 section.s_size = current->size;
3744 #ifdef coff_get_section_load_page
3745 section.s_page = coff_get_section_load_page (current);
3751 section.s_paddr = 0;
3753 #ifdef COFF_IMAGE_WITH_PE
3754 /* Reminder: s_paddr holds the virtual size of the section. */
3755 if (coff_section_data (abfd, current) != NULL
3756 && pei_section_data (abfd, current) != NULL)
3757 section.s_paddr = pei_section_data (abfd, current)->virt_size;
3759 section.s_paddr = 0;
3762 /* If this section has no size or is unloadable then the scnptr
3764 if (current->size == 0
3765 || (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
3766 section.s_scnptr = 0;
3768 section.s_scnptr = current->filepos;
3770 section.s_relptr = current->rel_filepos;
3771 section.s_lnnoptr = current->line_filepos;
3772 section.s_nreloc = current->reloc_count;
3773 section.s_nlnno = current->lineno_count;
3774 #ifndef COFF_IMAGE_WITH_PE
3775 /* In PEI, relocs come in the .reloc section. */
3776 if (current->reloc_count != 0)
3779 if (current->lineno_count != 0)
3781 #ifdef COFF_IMAGE_WITH_PE
3782 if ((current->flags & SEC_DEBUGGING) != 0
3783 && ! is_reloc_section)
3789 /* Indicate the use of an XCOFF overflow section header. */
3790 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3792 section.s_nreloc = 0xffff;
3793 section.s_nlnno = 0xffff;
3798 section.s_flags = sec_to_styp_flags (current->name, current->flags);
3800 if (!strcmp (current->name, _TEXT))
3802 else if (!strcmp (current->name, _DATA))
3804 else if (!strcmp (current->name, _BSS))
3808 section.s_align = (current->alignment_power
3809 ? 1 << current->alignment_power
3813 /* TI COFF puts the alignment power in bits 8-11 of the flags. */
3814 section.s_flags |= (current->alignment_power & 0xF) << 8;
3816 #ifdef COFF_ENCODE_ALIGNMENT
3817 COFF_ENCODE_ALIGNMENT(section, current->alignment_power);
3820 #ifdef COFF_IMAGE_WITH_PE
3821 /* Suppress output of the sections if they are null. ld
3822 includes the bss and data sections even if there is no size
3823 assigned to them. NT loader doesn't like it if these section
3824 headers are included if the sections themselves are not
3825 needed. See also coff_compute_section_file_positions. */
3826 if (section.s_size == 0)
3827 internal_f.f_nscns--;
3832 bfd_size_type amt = bfd_coff_scnhsz (abfd);
3834 if (coff_swap_scnhdr_out (abfd, §ion, &buff) == 0
3835 || bfd_bwrite (& buff, amt, abfd) != amt)
3840 /* PE stores COMDAT section information in the symbol table. If
3841 this section is supposed to have some COMDAT info, track down
3842 the symbol in the symbol table and modify it. */
3843 if ((current->flags & SEC_LINK_ONCE) != 0)
3845 unsigned int i, count;
3847 coff_symbol_type *csym = NULL;
3851 count = bfd_get_symcount (abfd);
3852 for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++)
3854 if ((*psym)->section != current)
3857 /* Remember the location of the first symbol in this
3859 if (psymsec == NULL)
3862 /* See if this is the section symbol. */
3863 if (strcmp ((*psym)->name, current->name) == 0)
3865 csym = coff_symbol_from (abfd, *psym);
3867 || csym->native == NULL
3868 || csym->native->u.syment.n_numaux < 1
3869 || csym->native->u.syment.n_sclass != C_STAT
3870 || csym->native->u.syment.n_type != T_NULL)
3873 /* Here *PSYM is the section symbol for CURRENT. */
3880 Note that we might not if we're converting the file from
3881 some other object file format. */
3884 combined_entry_type *aux;
3886 /* We don't touch the x_checksum field. The
3887 x_associated field is not currently supported. */
3889 aux = csym->native + 1;
3890 switch (current->flags & SEC_LINK_DUPLICATES)
3892 case SEC_LINK_DUPLICATES_DISCARD:
3893 aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY;
3896 case SEC_LINK_DUPLICATES_ONE_ONLY:
3897 aux->u.auxent.x_scn.x_comdat =
3898 IMAGE_COMDAT_SELECT_NODUPLICATES;
3901 case SEC_LINK_DUPLICATES_SAME_SIZE:
3902 aux->u.auxent.x_scn.x_comdat =
3903 IMAGE_COMDAT_SELECT_SAME_SIZE;
3906 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
3907 aux->u.auxent.x_scn.x_comdat =
3908 IMAGE_COMDAT_SELECT_EXACT_MATCH;
3912 /* The COMDAT symbol must be the first symbol from this
3913 section in the symbol table. In order to make this
3914 work, we move the COMDAT symbol before the first
3915 symbol we found in the search above. It's OK to
3916 rearrange the symbol table at this point, because
3917 coff_renumber_symbols is going to rearrange it
3918 further and fix up all the aux entries. */
3919 if (psym != psymsec)
3925 for (pcopy = psym; pcopy > psymsec; pcopy--)
3926 pcopy[0] = pcopy[-1];
3931 #endif /* COFF_WITH_PE */
3936 /* XCOFF handles overflows in the reloc and line number count fields
3937 by creating a new section header to hold the correct values. */
3938 for (current = abfd->sections; current != NULL; current = current->next)
3940 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3942 struct internal_scnhdr scnhdr;
3946 internal_f.f_nscns++;
3947 memcpy (scnhdr.s_name, ".ovrflo", 8);
3948 scnhdr.s_paddr = current->reloc_count;
3949 scnhdr.s_vaddr = current->lineno_count;
3951 scnhdr.s_scnptr = 0;
3952 scnhdr.s_relptr = current->rel_filepos;
3953 scnhdr.s_lnnoptr = current->line_filepos;
3954 scnhdr.s_nreloc = current->target_index;
3955 scnhdr.s_nlnno = current->target_index;
3956 scnhdr.s_flags = STYP_OVRFLO;
3957 amt = bfd_coff_scnhsz (abfd);
3958 if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
3959 || bfd_bwrite (& buff, amt, abfd) != amt)
3966 /* OK, now set up the filehdr... */
3968 /* Don't include the internal abs section in the section count */
3970 /* We will NOT put a fucking timestamp in the header here. Every time you
3971 put it back, I will come in and take it out again. I'm sorry. This
3972 field does not belong here. We fill it with a 0 so it compares the
3973 same but is not a reasonable time. -- gnu@cygnus.com */
3974 internal_f.f_timdat = 0;
3975 internal_f.f_flags = 0;
3977 if (abfd->flags & EXEC_P)
3978 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3981 internal_f.f_opthdr = 0;
3984 if (xcoff_data (abfd)->full_aouthdr)
3985 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3987 internal_f.f_opthdr = SMALL_AOUTSZ;
3993 internal_f.f_flags |= F_RELFLG;
3995 internal_f.f_flags |= F_LNNO;
3996 if (abfd->flags & EXEC_P)
3997 internal_f.f_flags |= F_EXEC;
3998 #ifdef COFF_IMAGE_WITH_PE
4000 internal_f.f_flags |= IMAGE_FILE_DEBUG_STRIPPED;
4001 if (pe_data (abfd)->real_flags & IMAGE_FILE_LARGE_ADDRESS_AWARE)
4002 internal_f.f_flags |= IMAGE_FILE_LARGE_ADDRESS_AWARE;
4005 #ifndef COFF_WITH_pex64
4007 internal_f.f_flags |= IMAGE_FILE_32BIT_MACHINE;
4009 if (bfd_little_endian (abfd))
4010 internal_f.f_flags |= F_AR32WR;
4012 internal_f.f_flags |= F_AR32W;
4017 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
4018 but it doesn't hurt to set it internally. */
4019 internal_f.f_target_id = TI_TARGET_ID;
4021 #ifdef TIC80_TARGET_ID
4022 internal_f.f_target_id = TIC80_TARGET_ID;
4025 /* FIXME, should do something about the other byte orders and
4029 if ((abfd->flags & DYNAMIC) != 0)
4030 internal_f.f_flags |= F_SHROBJ;
4031 if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
4032 internal_f.f_flags |= F_DYNLOAD;
4035 /* Set up architecture-dependent stuff. */
4037 unsigned int magic = 0;
4038 unsigned short flags = 0;
4040 coff_set_flags (abfd, &magic, &flags);
4041 internal_f.f_magic = magic;
4042 internal_f.f_flags |= flags;
4043 /* ...and the "opt"hdr... */
4045 #ifdef TICOFF_AOUT_MAGIC
4046 internal_a.magic = TICOFF_AOUT_MAGIC;
4047 #define __A_MAGIC_SET__
4050 internal_a.magic = TIC80_ARCH_MAGIC;
4051 #define __A_MAGIC_SET__
4054 /* FIXME: What are the a.out magic numbers for the i860? */
4055 internal_a.magic = 0;
4056 #define __A_MAGIC_SET__
4059 internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
4060 #define __A_MAGIC_SET__
4063 #define __A_MAGIC_SET__
4064 internal_a.magic = PAGEMAGICBCS;
4068 #define __A_MAGIC_SET__
4069 internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
4072 #if defined(M68) || defined(WE32K) || defined(M68K)
4073 #define __A_MAGIC_SET__
4075 internal_a.magic = LYNXCOFFMAGIC;
4077 #if defined(TARG_AUX)
4078 internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED :
4079 abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED :
4080 PAGEMAGICEXECSWAPPED);
4082 #if defined (PAGEMAGICPEXECPAGED)
4083 internal_a.magic = PAGEMAGICPEXECPAGED;
4085 #endif /* TARG_AUX */
4087 #endif /* M68 || WE32K || M68K */
4090 #define __A_MAGIC_SET__
4091 internal_a.magic = ZMAGIC;
4095 #define __A_MAGIC_SET__
4096 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
4099 #if defined MCORE_PE
4100 #define __A_MAGIC_SET__
4101 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
4105 #define __A_MAGIC_SET__
4107 internal_a.magic = LYNXCOFFMAGIC;
4109 internal_a.magic = IMAGE_NT_OPTIONAL_HDR64_MAGIC;
4111 internal_a.magic = ZMAGIC;
4116 #define __A_MAGIC_SET__
4117 internal_a.magic = PE32PMAGIC;
4121 #define __A_MAGIC_SET__
4123 internal_a.magic = LYNXCOFFMAGIC;
4128 #define __A_MAGIC_SET__
4129 internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
4130 (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
4131 RS6K_AOUTHDR_OMAGIC;
4134 #if defined(SH) && defined(COFF_WITH_PE)
4135 #define __A_MAGIC_SET__
4136 internal_a.magic = SH_PE_MAGIC;
4139 #if defined(MIPS) && defined(COFF_WITH_PE)
4140 #define __A_MAGIC_SET__
4141 internal_a.magic = MIPS_PE_MAGIC;
4144 #ifndef __A_MAGIC_SET__
4145 #include "Your aouthdr magic number is not being set!"
4147 #undef __A_MAGIC_SET__
4151 /* FIXME: Does anybody ever set this to another value? */
4152 internal_a.vstamp = 0;
4154 /* Now should write relocs, strings, syms. */
4155 obj_sym_filepos (abfd) = sym_base;
4157 if (bfd_get_symcount (abfd) != 0)
4161 if (!coff_renumber_symbols (abfd, &firstundef))
4163 coff_mangle_symbols (abfd);
4164 if (! coff_write_symbols (abfd))
4166 if (! coff_write_linenumbers (abfd))
4168 if (! coff_write_relocs (abfd, firstundef))
4171 #ifdef COFF_LONG_SECTION_NAMES
4172 else if (long_section_names && ! obj_coff_strings_written (abfd))
4174 /* If we have long section names we have to write out the string
4175 table even if there are no symbols. */
4176 if (! coff_write_symbols (abfd))
4180 #ifdef COFF_IMAGE_WITH_PE
4182 else if ((abfd->flags & EXEC_P) != 0)
4186 /* PowerPC PE appears to require that all executable files be
4187 rounded up to the page size. */
4190 (file_ptr) BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1,
4192 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
4198 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
4199 backend linker, and obj_raw_syment_count is not valid until after
4200 coff_write_symbols is called. */
4201 if (obj_raw_syment_count (abfd) != 0)
4203 internal_f.f_symptr = sym_base;
4205 /* AIX appears to require that F_RELFLG not be set if there are
4206 local symbols but no relocations. */
4207 internal_f.f_flags &=~ F_RELFLG;
4212 if (long_section_names)
4213 internal_f.f_symptr = sym_base;
4215 internal_f.f_symptr = 0;
4216 internal_f.f_flags |= F_LSYMS;
4221 internal_a.tsize = text_sec->size;
4222 internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
4226 internal_a.dsize = data_sec->size;
4227 internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
4231 internal_a.bsize = bss_sec->size;
4232 if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
4233 internal_a.data_start = bss_sec->vma;
4236 internal_a.entry = bfd_get_start_address (abfd);
4237 internal_f.f_nsyms = obj_raw_syment_count (abfd);
4240 if (xcoff_data (abfd)->full_aouthdr)
4243 asection *loader_sec;
4245 internal_a.vstamp = 1;
4247 internal_a.o_snentry = xcoff_data (abfd)->snentry;
4248 if (internal_a.o_snentry == 0)
4249 internal_a.entry = (bfd_vma) -1;
4251 if (text_sec != NULL)
4253 internal_a.o_sntext = text_sec->target_index;
4254 internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
4258 internal_a.o_sntext = 0;
4259 internal_a.o_algntext = 0;
4261 if (data_sec != NULL)
4263 internal_a.o_sndata = data_sec->target_index;
4264 internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
4268 internal_a.o_sndata = 0;
4269 internal_a.o_algndata = 0;
4271 loader_sec = bfd_get_section_by_name (abfd, ".loader");
4272 if (loader_sec != NULL)
4273 internal_a.o_snloader = loader_sec->target_index;
4275 internal_a.o_snloader = 0;
4276 if (bss_sec != NULL)
4277 internal_a.o_snbss = bss_sec->target_index;
4279 internal_a.o_snbss = 0;
4281 toc = xcoff_data (abfd)->toc;
4282 internal_a.o_toc = toc;
4283 internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
4285 internal_a.o_modtype = xcoff_data (abfd)->modtype;
4286 if (xcoff_data (abfd)->cputype != -1)
4287 internal_a.o_cputype = xcoff_data (abfd)->cputype;
4290 switch (bfd_get_arch (abfd))
4292 case bfd_arch_rs6000:
4293 internal_a.o_cputype = 4;
4295 case bfd_arch_powerpc:
4296 if (bfd_get_mach (abfd) == bfd_mach_ppc)
4297 internal_a.o_cputype = 3;
4299 internal_a.o_cputype = 1;
4305 internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
4306 internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
4312 /* After object contents are finalized so we can compute a reasonable hash,
4313 but before header is written so we can update it to point to debug directory. */
4314 struct pe_tdata *pe = pe_data (abfd);
4316 if (pe->build_id.after_write_object_contents != NULL)
4317 (*pe->build_id.after_write_object_contents) (abfd);
4321 /* Now write header. */
4322 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
4327 bfd_size_type amount = bfd_coff_filhsz (abfd);
4329 buff = (char *) bfd_malloc (amount);
4333 bfd_coff_swap_filehdr_out (abfd, & internal_f, buff);
4334 amount = bfd_bwrite (buff, amount, abfd);
4338 if (amount != bfd_coff_filhsz (abfd))
4342 if (abfd->flags & EXEC_P)
4344 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4345 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4347 bfd_size_type amount = bfd_coff_aoutsz (abfd);
4349 buff = (char *) bfd_malloc (amount);
4353 coff_swap_aouthdr_out (abfd, & internal_a, buff);
4354 amount = bfd_bwrite (buff, amount, abfd);
4358 if (amount != bfd_coff_aoutsz (abfd))
4361 #ifdef COFF_IMAGE_WITH_PE
4362 if (! coff_apply_checksum (abfd))
4372 /* XCOFF seems to always write at least a small a.out header. */
4373 coff_swap_aouthdr_out (abfd, & internal_a, & buff);
4374 if (xcoff_data (abfd)->full_aouthdr)
4375 size = bfd_coff_aoutsz (abfd);
4377 size = SMALL_AOUTSZ;
4378 if (bfd_bwrite (& buff, (bfd_size_type) size, abfd) != size)
4387 coff_set_section_contents (bfd * abfd,
4389 const void * location,
4391 bfd_size_type count)
4393 if (! abfd->output_has_begun) /* Set by bfd.c handler. */
4395 if (! coff_compute_section_file_positions (abfd))
4399 #if defined(_LIB) && !defined(TARG_AUX)
4400 /* The physical address field of a .lib section is used to hold the
4401 number of shared libraries in the section. This code counts the
4402 number of sections being written, and increments the lma field
4405 I have found no documentation on the contents of this section.
4406 Experimentation indicates that the section contains zero or more
4407 records, each of which has the following structure:
4409 - a (four byte) word holding the length of this record, in words,
4410 - a word that always seems to be set to "2",
4411 - the path to a shared library, null-terminated and then padded
4412 to a whole word boundary.
4414 bfd_assert calls have been added to alert if an attempt is made
4415 to write a section which doesn't follow these assumptions. The
4416 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4417 <robertl@arnet.com> (Thanks!).
4419 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4420 if (strcmp (section->name, _LIB) == 0)
4422 bfd_byte *rec, *recend;
4424 rec = (bfd_byte *) location;
4425 recend = rec + count;
4426 while (rec < recend)
4429 rec += bfd_get_32 (abfd, rec) * 4;
4432 BFD_ASSERT (rec == recend);
4436 /* Don't write out bss sections - one way to do this is to
4437 see if the filepos has not been set. */
4438 if (section->filepos == 0)
4441 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
4447 return bfd_bwrite (location, count, abfd) == count;
4451 buy_and_read (bfd *abfd, file_ptr where, bfd_size_type size)
4453 void * area = bfd_alloc (abfd, size);
4457 if (bfd_seek (abfd, where, SEEK_SET) != 0
4458 || bfd_bread (area, size, abfd) != size)
4467 Creating the linenumber table is done by reading in the entire
4468 coff linenumber table, and creating another table for internal use.
4470 A coff linenumber table is structured so that each function
4471 is marked as having a line number of 0. Each line within the
4472 function is an offset from the first line in the function. The
4473 base of the line number information for the table is stored in
4474 the symbol associated with the function.
4476 Note: The PE format uses line number 0 for a flag indicating a
4479 The information is copied from the external to the internal
4480 table, and each symbol which marks a function is marked by
4483 How does this work ?
4487 coff_sort_func_alent (const void * arg1, const void * arg2)
4489 const alent *al1 = *(const alent **) arg1;
4490 const alent *al2 = *(const alent **) arg2;
4491 const coff_symbol_type *s1 = (const coff_symbol_type *) (al1->u.sym);
4492 const coff_symbol_type *s2 = (const coff_symbol_type *) (al2->u.sym);
4494 if (s1 == NULL || s2 == NULL)
4496 if (s1->symbol.value < s2->symbol.value)
4498 else if (s1->symbol.value > s2->symbol.value)
4505 coff_slurp_line_table (bfd *abfd, asection *asect)
4507 LINENO *native_lineno;
4508 alent *lineno_cache;
4510 unsigned int counter;
4512 bfd_vma prev_offset = 0;
4514 unsigned int nbr_func;
4516 bfd_boolean have_func;
4518 BFD_ASSERT (asect->lineno == NULL);
4520 amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
4521 lineno_cache = (alent *) bfd_alloc (abfd, amt);
4522 if (lineno_cache == NULL)
4525 amt = (bfd_size_type) bfd_coff_linesz (abfd) * asect->lineno_count;
4526 native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos, amt);
4527 if (native_lineno == NULL)
4529 (*_bfd_error_handler)
4530 (_("%B: warning: line number table read failed"), abfd);
4531 bfd_release (abfd, lineno_cache);
4535 cache_ptr = lineno_cache;
4536 asect->lineno = lineno_cache;
4537 src = native_lineno;
4541 for (counter = 0; counter < asect->lineno_count; counter++, src++)
4543 struct internal_lineno dst;
4545 bfd_coff_swap_lineno_in (abfd, src, &dst);
4546 cache_ptr->line_number = dst.l_lnno;
4547 /* Appease memory checkers that get all excited about
4548 uninitialised memory when copying alents if u.offset is
4549 larger than u.sym. (64-bit BFD on 32-bit host.) */
4550 memset (&cache_ptr->u, 0, sizeof (cache_ptr->u));
4552 if (cache_ptr->line_number == 0)
4555 coff_symbol_type *sym;
4558 symndx = dst.l_addr.l_symndx;
4559 if (symndx >= obj_raw_syment_count (abfd))
4561 (*_bfd_error_handler)
4562 (_("%B: warning: illegal symbol index 0x%lx in line number entry %d"),
4563 abfd, (long) symndx, counter);
4567 /* FIXME: We should not be casting between ints and
4568 pointers like this. */
4569 sym = ((coff_symbol_type *)
4570 ((symndx + obj_raw_syments (abfd))
4571 ->u.syment._n._n_n._n_zeroes));
4573 /* PR 17512 file: 078-10659-0.004 */
4574 if (sym < obj_symbols (abfd)
4575 || sym >= obj_symbols (abfd) + obj_raw_syment_count (abfd))
4577 (*_bfd_error_handler)
4578 (_("%B: warning: illegal symbol in line number entry %d"),
4585 cache_ptr->u.sym = (asymbol *) sym;
4586 if (sym->lineno != NULL)
4587 (*_bfd_error_handler)
4588 (_("%B: warning: duplicate line number information for `%s'"),
4589 abfd, bfd_asymbol_name (&sym->symbol));
4591 sym->lineno = cache_ptr;
4592 if (sym->symbol.value < prev_offset)
4594 prev_offset = sym->symbol.value;
4596 else if (!have_func)
4597 /* Drop line information that has no associated function.
4598 PR 17521: file: 078-10659-0.004. */
4601 cache_ptr->u.offset = (dst.l_addr.l_paddr
4602 - bfd_section_vma (abfd, asect));
4606 asect->lineno_count = cache_ptr - lineno_cache;
4607 memset (cache_ptr, 0, sizeof (*cache_ptr));
4608 bfd_release (abfd, native_lineno);
4610 /* On some systems (eg AIX5.3) the lineno table may not be sorted. */
4613 /* Sort the table. */
4615 alent *n_lineno_cache;
4617 /* Create a table of functions. */
4618 func_table = (alent **) bfd_alloc (abfd, nbr_func * sizeof (alent *));
4619 if (func_table != NULL)
4621 alent **p = func_table;
4624 for (i = 0; i < asect->lineno_count; i++)
4625 if (lineno_cache[i].line_number == 0)
4626 *p++ = &lineno_cache[i];
4628 /* Sort by functions. */
4629 qsort (func_table, nbr_func, sizeof (alent *), coff_sort_func_alent);
4631 /* Create the new sorted table. */
4632 amt = (bfd_size_type) asect->lineno_count * sizeof (alent);
4633 n_lineno_cache = (alent *) bfd_alloc (abfd, amt);
4634 if (n_lineno_cache != NULL)
4636 alent *n_cache_ptr = n_lineno_cache;
4638 for (i = 0; i < nbr_func; i++)
4640 coff_symbol_type *sym;
4641 alent *old_ptr = func_table[i];
4643 /* Update the function entry. */
4644 sym = (coff_symbol_type *) old_ptr->u.sym;
4645 /* PR binutils/17512: Point the lineno to where
4646 this entry will be after the memcpy below. */
4647 sym->lineno = lineno_cache + (n_cache_ptr - n_lineno_cache);
4648 /* Copy the function and line number entries. */
4650 *n_cache_ptr++ = *old_ptr++;
4651 while (old_ptr->line_number != 0);
4653 memcpy (lineno_cache, n_lineno_cache, amt);
4655 bfd_release (abfd, func_table);
4662 /* Slurp in the symbol table, converting it to generic form. Note
4663 that if coff_relocate_section is defined, the linker will read
4664 symbols via coff_link_add_symbols, rather than via this routine. */
4667 coff_slurp_symbol_table (bfd * abfd)
4669 combined_entry_type *native_symbols;
4670 coff_symbol_type *cached_area;
4671 unsigned int *table_ptr;
4673 unsigned int number_of_symbols = 0;
4675 if (obj_symbols (abfd))
4678 /* Read in the symbol table. */
4679 if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
4682 /* Allocate enough room for all the symbols in cached form. */
4683 amt = obj_raw_syment_count (abfd);
4684 amt *= sizeof (coff_symbol_type);
4685 cached_area = (coff_symbol_type *) bfd_alloc (abfd, amt);
4686 if (cached_area == NULL)
4689 amt = obj_raw_syment_count (abfd);
4690 amt *= sizeof (unsigned int);
4691 table_ptr = (unsigned int *) bfd_zalloc (abfd, amt);
4693 if (table_ptr == NULL)
4697 coff_symbol_type *dst = cached_area;
4698 unsigned int last_native_index = obj_raw_syment_count (abfd);
4699 unsigned int this_index = 0;
4701 while (this_index < last_native_index)
4703 combined_entry_type *src = native_symbols + this_index;
4704 table_ptr[this_index] = number_of_symbols;
4706 dst->symbol.the_bfd = abfd;
4707 dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
4708 /* We use the native name field to point to the cached field. */
4709 src->u.syment._n._n_n._n_zeroes = (bfd_hostptr_t) dst;
4710 dst->symbol.section = coff_section_from_bfd_index (abfd,
4711 src->u.syment.n_scnum);
4712 dst->symbol.flags = 0;
4713 dst->done_lineno = FALSE;
4715 switch (src->u.syment.n_sclass)
4719 /* Fall through to next case. */
4726 case C_THUMBEXTFUNC:
4732 case C_SYSTEM: /* System Wide variable. */
4735 /* In PE, 0x68 (104) denotes a section symbol. */
4737 /* In PE, 0x69 (105) denotes a weak external symbol. */
4740 switch (coff_classify_symbol (abfd, &src->u.syment))
4742 case COFF_SYMBOL_GLOBAL:
4743 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
4744 #if defined COFF_WITH_PE
4745 /* PE sets the symbol to a value relative to the
4746 start of the section. */
4747 dst->symbol.value = src->u.syment.n_value;
4749 dst->symbol.value = (src->u.syment.n_value
4750 - dst->symbol.section->vma);
4752 if (ISFCN ((src->u.syment.n_type)))
4753 /* A function ext does not go at the end of a
4755 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4758 case COFF_SYMBOL_COMMON:
4759 dst->symbol.section = bfd_com_section_ptr;
4760 dst->symbol.value = src->u.syment.n_value;
4763 case COFF_SYMBOL_UNDEFINED:
4764 dst->symbol.section = bfd_und_section_ptr;
4765 dst->symbol.value = 0;
4768 case COFF_SYMBOL_PE_SECTION:
4769 dst->symbol.flags |= BSF_EXPORT | BSF_SECTION_SYM;
4770 dst->symbol.value = 0;
4773 case COFF_SYMBOL_LOCAL:
4774 dst->symbol.flags = BSF_LOCAL;
4775 #if defined COFF_WITH_PE
4776 /* PE sets the symbol to a value relative to the
4777 start of the section. */
4778 dst->symbol.value = src->u.syment.n_value;
4780 dst->symbol.value = (src->u.syment.n_value
4781 - dst->symbol.section->vma);
4783 if (ISFCN ((src->u.syment.n_type)))
4784 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4789 /* A symbol with a csect entry should not go at the end. */
4790 if (src->u.syment.n_numaux > 0)
4791 dst->symbol.flags |= BSF_NOT_AT_END;
4795 if (src->u.syment.n_sclass == C_NT_WEAK)
4796 dst->symbol.flags |= BSF_WEAK;
4798 if (src->u.syment.n_sclass == C_SECTION
4799 && src->u.syment.n_scnum > 0)
4800 dst->symbol.flags = BSF_LOCAL;
4802 if (src->u.syment.n_sclass == C_WEAKEXT)
4803 dst->symbol.flags |= BSF_WEAK;
4807 case C_STAT: /* Static. */
4809 case C_LEAFSTAT: /* Static leaf procedure. */
4812 case C_THUMBSTAT: /* Thumb static. */
4813 case C_THUMBLABEL: /* Thumb label. */
4814 case C_THUMBSTATFUNC:/* Thumb static function. */
4817 case C_DWARF: /* A label in a dwarf section. */
4818 case C_INFO: /* A label in a comment section. */
4820 case C_LABEL: /* Label. */
4821 if (src->u.syment.n_scnum == N_DEBUG)
4822 dst->symbol.flags = BSF_DEBUGGING;
4824 dst->symbol.flags = BSF_LOCAL;
4826 /* Base the value as an index from the base of the
4827 section, if there is one. */
4828 if (dst->symbol.section)
4830 #if defined COFF_WITH_PE
4831 /* PE sets the symbol to a value relative to the
4832 start of the section. */
4833 dst->symbol.value = src->u.syment.n_value;
4835 dst->symbol.value = (src->u.syment.n_value
4836 - dst->symbol.section->vma);
4840 dst->symbol.value = src->u.syment.n_value;
4843 case C_MOS: /* Member of structure. */
4844 case C_EOS: /* End of structure. */
4845 case C_REGPARM: /* Register parameter. */
4846 case C_REG: /* register variable. */
4847 /* C_AUTOARG conflicts with TI COFF C_UEXT. */
4848 #if !defined (TIC80COFF) && !defined (TICOFF)
4850 case C_AUTOARG: /* 960-specific storage class. */
4853 case C_TPDEF: /* Type definition. */
4855 case C_AUTO: /* Automatic variable. */
4856 case C_FIELD: /* Bit field. */
4857 case C_ENTAG: /* Enumeration tag. */
4858 case C_MOE: /* Member of enumeration. */
4859 case C_MOU: /* Member of union. */
4860 case C_UNTAG: /* Union tag. */
4861 dst->symbol.flags = BSF_DEBUGGING;
4862 dst->symbol.value = (src->u.syment.n_value);
4865 case C_FILE: /* File name. */
4866 case C_STRTAG: /* Structure tag. */
4883 dst->symbol.flags = BSF_DEBUGGING;
4884 dst->symbol.value = (src->u.syment.n_value);
4888 case C_BINCL: /* Beginning of include file. */
4889 case C_EINCL: /* Ending of include file. */
4890 /* The value is actually a pointer into the line numbers
4891 of the file. We locate the line number entry, and
4892 set the section to the section which contains it, and
4893 the value to the index in that section. */
4897 dst->symbol.flags = BSF_DEBUGGING;
4898 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4899 if (sec->line_filepos <= (file_ptr) src->u.syment.n_value
4900 && ((file_ptr) (sec->line_filepos
4901 + sec->lineno_count * bfd_coff_linesz (abfd))
4902 > (file_ptr) src->u.syment.n_value))
4905 dst->symbol.value = 0;
4908 dst->symbol.section = sec;
4909 dst->symbol.value = ((src->u.syment.n_value
4910 - sec->line_filepos)
4911 / bfd_coff_linesz (abfd));
4918 dst->symbol.flags = BSF_DEBUGGING;
4920 /* The value is actually a symbol index. Save a pointer
4921 to the symbol instead of the index. FIXME: This
4922 should use a union. */
4923 src->u.syment.n_value =
4924 (long) (intptr_t) (native_symbols + src->u.syment.n_value);
4925 dst->symbol.value = src->u.syment.n_value;
4930 case C_BLOCK: /* ".bb" or ".eb". */
4931 case C_FCN: /* ".bf" or ".ef" (or PE ".lf"). */
4932 case C_EFCN: /* Physical end of function. */
4933 #if defined COFF_WITH_PE
4934 /* PE sets the symbol to a value relative to the start
4936 dst->symbol.value = src->u.syment.n_value;
4937 if (strcmp (dst->symbol.name, ".bf") != 0)
4939 /* PE uses funny values for .ef and .lf; don't
4941 dst->symbol.flags = BSF_DEBUGGING;
4944 dst->symbol.flags = BSF_DEBUGGING | BSF_DEBUGGING_RELOC;
4946 /* Base the value as an index from the base of the
4948 dst->symbol.flags = BSF_LOCAL;
4949 dst->symbol.value = (src->u.syment.n_value
4950 - dst->symbol.section->vma);
4954 case C_STATLAB: /* Static load time label. */
4955 dst->symbol.value = src->u.syment.n_value;
4956 dst->symbol.flags = BSF_GLOBAL;
4960 /* PE DLLs sometimes have zeroed out symbols for some
4961 reason. Just ignore them without a warning. */
4962 if (src->u.syment.n_type == 0
4963 && src->u.syment.n_value == 0
4964 && src->u.syment.n_scnum == 0)
4967 /* XCOFF specific: deleted entry. */
4968 if (src->u.syment.n_value == C_NULL_VALUE)
4972 case C_EXTDEF: /* External definition. */
4973 case C_ULABEL: /* Undefined label. */
4974 case C_USTATIC: /* Undefined static. */
4975 #ifndef COFF_WITH_PE
4976 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4977 class to represent a section symbol. */
4978 case C_LINE: /* line # reformatted as symbol table entry. */
4979 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4980 case C_ALIAS: /* Duplicate tag. */
4982 /* New storage classes for TI COFF. */
4983 #if defined(TIC80COFF) || defined(TICOFF)
4984 case C_UEXT: /* Tentative external definition. */
4986 case C_EXTLAB: /* External load time label. */
4987 case C_HIDDEN: /* Ext symbol in dmert public lib. */
4989 (*_bfd_error_handler)
4990 (_("%B: Unrecognized storage class %d for %s symbol `%s'"),
4991 abfd, src->u.syment.n_sclass,
4992 dst->symbol.section->name, dst->symbol.name);
4993 dst->symbol.flags = BSF_DEBUGGING;
4994 dst->symbol.value = (src->u.syment.n_value);
5000 dst->symbol.udata.i = 0;
5002 this_index += (src->u.syment.n_numaux) + 1;
5004 number_of_symbols++;
5008 obj_symbols (abfd) = cached_area;
5009 obj_raw_syments (abfd) = native_symbols;
5011 bfd_get_symcount (abfd) = number_of_symbols;
5012 obj_convert (abfd) = table_ptr;
5013 /* Slurp the line tables for each section too. */
5020 coff_slurp_line_table (abfd, p);
5028 /* Classify a COFF symbol. A couple of targets have globally visible
5029 symbols which are not class C_EXT, and this handles those. It also
5030 recognizes some special PE cases. */
5032 static enum coff_symbol_classification
5033 coff_classify_symbol (bfd *abfd,
5034 struct internal_syment *syment)
5036 /* FIXME: This partially duplicates the switch in
5037 coff_slurp_symbol_table. */
5038 switch (syment->n_sclass)
5047 case C_THUMBEXTFUNC:
5055 if (syment->n_scnum == 0)
5057 if (syment->n_value == 0)
5058 return COFF_SYMBOL_UNDEFINED;
5060 return COFF_SYMBOL_COMMON;
5062 return COFF_SYMBOL_GLOBAL;
5069 if (syment->n_sclass == C_STAT)
5071 if (syment->n_scnum == 0)
5072 /* The Microsoft compiler sometimes generates these if a
5073 small static function is inlined every time it is used.
5074 The function is discarded, but the symbol table entry
5076 return COFF_SYMBOL_LOCAL;
5078 #ifdef STRICT_PE_FORMAT
5079 /* This is correct for Microsoft generated objects, but it
5080 breaks gas generated objects. */
5081 if (syment->n_value == 0)
5085 char buf[SYMNMLEN + 1];
5087 name = _bfd_coff_internal_syment_name (abfd, syment, buf)
5088 sec = coff_section_from_bfd_index (abfd, syment->n_scnum);
5089 if (sec != NULL && name != NULL
5090 && (strcmp (bfd_get_section_name (abfd, sec), name) == 0))
5091 return COFF_SYMBOL_PE_SECTION;
5095 return COFF_SYMBOL_LOCAL;
5098 if (syment->n_sclass == C_SECTION)
5100 /* In some cases in a DLL generated by the Microsoft linker, the
5101 n_value field will contain garbage. FIXME: This should
5102 probably be handled by the swapping function instead. */
5103 syment->n_value = 0;
5104 if (syment->n_scnum == 0)
5105 return COFF_SYMBOL_UNDEFINED;
5106 return COFF_SYMBOL_PE_SECTION;
5108 #endif /* COFF_WITH_PE */
5110 /* If it is not a global symbol, we presume it is a local symbol. */
5111 if (syment->n_scnum == 0)
5113 char buf[SYMNMLEN + 1];
5115 (*_bfd_error_handler)
5116 (_("warning: %B: local symbol `%s' has no section"),
5117 abfd, _bfd_coff_internal_syment_name (abfd, syment, buf));
5120 return COFF_SYMBOL_LOCAL;
5127 Coff relocations are easily transformed into the internal BFD form
5130 Reading a coff relocation table is done in the following stages:
5132 o Read the entire coff relocation table into memory.
5134 o Process each relocation in turn; first swap it from the
5135 external to the internal form.
5137 o Turn the symbol referenced in the relocation's symbol index
5138 into a pointer into the canonical symbol table.
5139 This table is the same as the one returned by a call to
5140 @code{bfd_canonicalize_symtab}. The back end will call that
5141 routine and save the result if a canonicalization hasn't been done.
5143 o The reloc index is turned into a pointer to a howto
5144 structure, in a back end specific way. For instance, the 386
5145 and 960 use the @code{r_type} to directly produce an index
5146 into a howto table vector; the 88k subtracts a number from the
5147 @code{r_type} field and creates an addend field.
5151 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
5153 coff_symbol_type *coffsym = NULL; \
5155 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
5156 coffsym = (obj_symbols (abfd) \
5157 + (cache_ptr->sym_ptr_ptr - symbols)); \
5159 coffsym = coff_symbol_from (abfd, ptr); \
5160 if (coffsym != NULL \
5161 && coffsym->native->u.syment.n_scnum == 0) \
5162 cache_ptr->addend = 0; \
5163 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
5164 && ptr->section != NULL) \
5165 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
5167 cache_ptr->addend = 0; \
5172 coff_slurp_reloc_table (bfd * abfd, sec_ptr asect, asymbol ** symbols)
5174 RELOC *native_relocs;
5175 arelent *reloc_cache;
5180 if (asect->relocation)
5182 if (asect->reloc_count == 0)
5184 if (asect->flags & SEC_CONSTRUCTOR)
5186 if (!coff_slurp_symbol_table (abfd))
5189 amt = (bfd_size_type) bfd_coff_relsz (abfd) * asect->reloc_count;
5190 native_relocs = (RELOC *) buy_and_read (abfd, asect->rel_filepos, amt);
5191 amt = (bfd_size_type) asect->reloc_count * sizeof (arelent);
5192 reloc_cache = (arelent *) bfd_alloc (abfd, amt);
5194 if (reloc_cache == NULL || native_relocs == NULL)
5197 for (idx = 0; idx < asect->reloc_count; idx++)
5199 struct internal_reloc dst;
5200 struct external_reloc *src;
5201 #ifndef RELOC_PROCESSING
5205 cache_ptr = reloc_cache + idx;
5206 src = native_relocs + idx;
5209 coff_swap_reloc_in (abfd, src, &dst);
5211 #ifdef RELOC_PROCESSING
5212 RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
5214 cache_ptr->address = dst.r_vaddr;
5216 if (dst.r_symndx != -1)
5218 if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd))
5220 (*_bfd_error_handler)
5221 (_("%B: warning: illegal symbol index %ld in relocs"),
5222 abfd, (long) dst.r_symndx);
5223 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
5228 cache_ptr->sym_ptr_ptr = (symbols
5229 + obj_convert (abfd)[dst.r_symndx]);
5230 ptr = *(cache_ptr->sym_ptr_ptr);
5235 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
5239 /* The symbols definitions that we have read in have been
5240 relocated as if their sections started at 0. But the offsets
5241 refering to the symbols in the raw data have not been
5242 modified, so we have to have a negative addend to compensate.
5244 Note that symbols which used to be common must be left alone. */
5246 /* Calculate any reloc addend by looking at the symbol. */
5247 CALC_ADDEND (abfd, ptr, dst, cache_ptr);
5250 cache_ptr->address -= asect->vma;
5251 /* !! cache_ptr->section = NULL;*/
5253 /* Fill in the cache_ptr->howto field from dst.r_type. */
5254 RTYPE2HOWTO (cache_ptr, &dst);
5255 #endif /* RELOC_PROCESSING */
5257 if (cache_ptr->howto == NULL)
5259 (*_bfd_error_handler)
5260 (_("%B: illegal relocation type %d at address 0x%lx"),
5261 abfd, dst.r_type, (long) dst.r_vaddr);
5262 bfd_set_error (bfd_error_bad_value);
5267 asect->relocation = reloc_cache;
5271 #ifndef coff_rtype_to_howto
5274 /* Get the howto structure for a reloc. This is only used if the file
5275 including this one defines coff_relocate_section to be
5276 _bfd_coff_generic_relocate_section, so it is OK if it does not
5277 always work. It is the responsibility of the including file to
5278 make sure it is reasonable if it is needed. */
5280 static reloc_howto_type *
5281 coff_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
5282 asection *sec ATTRIBUTE_UNUSED,
5283 struct internal_reloc *rel,
5284 struct coff_link_hash_entry *h ATTRIBUTE_UNUSED,
5285 struct internal_syment *sym ATTRIBUTE_UNUSED,
5286 bfd_vma *addendp ATTRIBUTE_UNUSED)
5290 genrel.howto = NULL;
5291 RTYPE2HOWTO (&genrel, rel);
5292 return genrel.howto;
5295 #else /* ! defined (RTYPE2HOWTO) */
5297 #define coff_rtype_to_howto NULL
5299 #endif /* ! defined (RTYPE2HOWTO) */
5300 #endif /* ! defined (coff_rtype_to_howto) */
5302 /* This is stupid. This function should be a boolean predicate. */
5305 coff_canonicalize_reloc (bfd * abfd,
5310 arelent *tblptr = section->relocation;
5311 unsigned int count = 0;
5313 if (section->flags & SEC_CONSTRUCTOR)
5315 /* This section has relocs made up by us, they are not in the
5316 file, so take them out of their chain and place them into
5317 the data area provided. */
5318 arelent_chain *chain = section->constructor_chain;
5320 for (count = 0; count < section->reloc_count; count++)
5322 *relptr++ = &chain->relent;
5323 chain = chain->next;
5328 if (! coff_slurp_reloc_table (abfd, section, symbols))
5331 tblptr = section->relocation;
5333 for (; count++ < section->reloc_count;)
5334 *relptr++ = tblptr++;
5337 return section->reloc_count;
5340 #ifndef coff_reloc16_estimate
5341 #define coff_reloc16_estimate dummy_reloc16_estimate
5344 dummy_reloc16_estimate (bfd *abfd ATTRIBUTE_UNUSED,
5345 asection *input_section ATTRIBUTE_UNUSED,
5346 arelent *reloc ATTRIBUTE_UNUSED,
5347 unsigned int shrink ATTRIBUTE_UNUSED,
5348 struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
5356 #ifndef coff_reloc16_extra_cases
5358 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5360 /* This works even if abort is not declared in any header file. */
5363 dummy_reloc16_extra_cases (bfd *abfd ATTRIBUTE_UNUSED,
5364 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
5365 struct bfd_link_order *link_order ATTRIBUTE_UNUSED,
5366 arelent *reloc ATTRIBUTE_UNUSED,
5367 bfd_byte *data ATTRIBUTE_UNUSED,
5368 unsigned int *src_ptr ATTRIBUTE_UNUSED,
5369 unsigned int *dst_ptr ATTRIBUTE_UNUSED)
5375 /* If coff_relocate_section is defined, we can use the optimized COFF
5376 backend linker. Otherwise we must continue to use the old linker. */
5378 #ifdef coff_relocate_section
5380 #ifndef coff_bfd_link_hash_table_create
5381 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5383 #ifndef coff_bfd_link_add_symbols
5384 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5386 #ifndef coff_bfd_final_link
5387 #define coff_bfd_final_link _bfd_coff_final_link
5390 #else /* ! defined (coff_relocate_section) */
5392 #define coff_relocate_section NULL
5393 #ifndef coff_bfd_link_hash_table_create
5394 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5396 #ifndef coff_bfd_link_add_symbols
5397 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5399 #define coff_bfd_final_link _bfd_generic_final_link
5401 #endif /* ! defined (coff_relocate_section) */
5403 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5404 #define coff_bfd_copy_link_hash_symbol_type \
5405 _bfd_generic_copy_link_hash_symbol_type
5406 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5408 #ifndef coff_start_final_link
5409 #define coff_start_final_link NULL
5412 #ifndef coff_adjust_symndx
5413 #define coff_adjust_symndx NULL
5416 #ifndef coff_link_add_one_symbol
5417 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5420 #ifndef coff_link_output_has_begun
5423 coff_link_output_has_begun (bfd * abfd,
5424 struct coff_final_link_info * info ATTRIBUTE_UNUSED)
5426 return abfd->output_has_begun;
5430 #ifndef coff_final_link_postscript
5433 coff_final_link_postscript (bfd * abfd ATTRIBUTE_UNUSED,
5434 struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED)
5440 #ifndef coff_SWAP_aux_in
5441 #define coff_SWAP_aux_in coff_swap_aux_in
5443 #ifndef coff_SWAP_sym_in
5444 #define coff_SWAP_sym_in coff_swap_sym_in
5446 #ifndef coff_SWAP_lineno_in
5447 #define coff_SWAP_lineno_in coff_swap_lineno_in
5449 #ifndef coff_SWAP_aux_out
5450 #define coff_SWAP_aux_out coff_swap_aux_out
5452 #ifndef coff_SWAP_sym_out
5453 #define coff_SWAP_sym_out coff_swap_sym_out
5455 #ifndef coff_SWAP_lineno_out
5456 #define coff_SWAP_lineno_out coff_swap_lineno_out
5458 #ifndef coff_SWAP_reloc_out
5459 #define coff_SWAP_reloc_out coff_swap_reloc_out
5461 #ifndef coff_SWAP_filehdr_out
5462 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5464 #ifndef coff_SWAP_aouthdr_out
5465 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5467 #ifndef coff_SWAP_scnhdr_out
5468 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5470 #ifndef coff_SWAP_reloc_in
5471 #define coff_SWAP_reloc_in coff_swap_reloc_in
5473 #ifndef coff_SWAP_filehdr_in
5474 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5476 #ifndef coff_SWAP_aouthdr_in
5477 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5479 #ifndef coff_SWAP_scnhdr_in
5480 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5483 static bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED =
5485 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5486 coff_SWAP_aux_out, coff_SWAP_sym_out,
5487 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5488 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5489 coff_SWAP_scnhdr_out,
5490 FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
5491 #ifdef COFF_LONG_FILENAMES
5496 COFF_DEFAULT_LONG_SECTION_NAMES,
5497 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5498 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5503 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5509 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5510 coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
5511 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5512 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5513 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5514 coff_classify_symbol, coff_compute_section_file_positions,
5515 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5516 coff_adjust_symndx, coff_link_add_one_symbol,
5517 coff_link_output_has_begun, coff_final_link_postscript,
5522 /* COFF0 differs in file/section header size and relocation entry size. */
5524 static bfd_coff_backend_data ticoff0_swap_table =
5526 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5527 coff_SWAP_aux_out, coff_SWAP_sym_out,
5528 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5529 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5530 coff_SWAP_scnhdr_out,
5531 FILHSZ_V0, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ_V0, LINESZ, FILNMLEN,
5532 #ifdef COFF_LONG_FILENAMES
5537 COFF_DEFAULT_LONG_SECTION_NAMES,
5538 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5539 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5544 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5550 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5551 coff_SWAP_reloc_in, ticoff0_bad_format_hook, coff_set_arch_mach_hook,
5552 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5553 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5554 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5555 coff_classify_symbol, coff_compute_section_file_positions,
5556 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5557 coff_adjust_symndx, coff_link_add_one_symbol,
5558 coff_link_output_has_begun, coff_final_link_postscript,
5564 /* COFF1 differs in section header size. */
5566 static bfd_coff_backend_data ticoff1_swap_table =
5568 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5569 coff_SWAP_aux_out, coff_SWAP_sym_out,
5570 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5571 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5572 coff_SWAP_scnhdr_out,
5573 FILHSZ, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
5574 #ifdef COFF_LONG_FILENAMES
5579 COFF_DEFAULT_LONG_SECTION_NAMES,
5580 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5581 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5586 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5592 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5593 coff_SWAP_reloc_in, ticoff1_bad_format_hook, coff_set_arch_mach_hook,
5594 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5595 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5596 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5597 coff_classify_symbol, coff_compute_section_file_positions,
5598 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5599 coff_adjust_symndx, coff_link_add_one_symbol,
5600 coff_link_output_has_begun, coff_final_link_postscript,
5601 bfd_pe_print_pdata /* huh */
5605 #ifdef COFF_WITH_PE_BIGOBJ
5606 /* The UUID for bigobj files. */
5608 static const char header_bigobj_classid[16] =
5610 0xC7, 0xA1, 0xBA, 0xD1,
5614 0xFA, 0xF6, 0x6A, 0xA4, 0xDC, 0xB8
5617 /* Swap routines. */
5620 coff_bigobj_swap_filehdr_in (bfd * abfd, void * src, void * dst)
5622 struct external_ANON_OBJECT_HEADER_BIGOBJ *filehdr_src =
5623 (struct external_ANON_OBJECT_HEADER_BIGOBJ *) src;
5624 struct internal_filehdr *filehdr_dst = (struct internal_filehdr *) dst;
5626 filehdr_dst->f_magic = H_GET_16 (abfd, filehdr_src->Machine);
5627 filehdr_dst->f_nscns = H_GET_32 (abfd, filehdr_src->NumberOfSections);
5628 filehdr_dst->f_timdat = H_GET_32 (abfd, filehdr_src->TimeDateStamp);
5629 filehdr_dst->f_symptr =
5630 GET_FILEHDR_SYMPTR (abfd, filehdr_src->PointerToSymbolTable);
5631 filehdr_dst->f_nsyms = H_GET_32 (abfd, filehdr_src->NumberOfSymbols);
5632 filehdr_dst->f_opthdr = 0;
5633 filehdr_dst->f_flags = 0;
5635 /* Check other magic numbers. */
5636 if (H_GET_16 (abfd, filehdr_src->Sig1) != IMAGE_FILE_MACHINE_UNKNOWN
5637 || H_GET_16 (abfd, filehdr_src->Sig2) != 0xffff
5638 || H_GET_16 (abfd, filehdr_src->Version) != 2
5639 || memcmp (filehdr_src->ClassID, header_bigobj_classid, 16) != 0)
5640 filehdr_dst->f_opthdr = 0xffff;
5642 /* Note that CLR metadata are ignored. */
5646 coff_bigobj_swap_filehdr_out (bfd *abfd, void * in, void * out)
5648 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
5649 struct external_ANON_OBJECT_HEADER_BIGOBJ *filehdr_out =
5650 (struct external_ANON_OBJECT_HEADER_BIGOBJ *) out;
5652 memset (filehdr_out, 0, sizeof (*filehdr_out));
5654 H_PUT_16 (abfd, IMAGE_FILE_MACHINE_UNKNOWN, filehdr_out->Sig1);
5655 H_PUT_16 (abfd, 0xffff, filehdr_out->Sig2);
5656 H_PUT_16 (abfd, 2, filehdr_out->Version);
5657 memcpy (filehdr_out->ClassID, header_bigobj_classid, 16);
5658 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->Machine);
5659 H_PUT_32 (abfd, filehdr_in->f_nscns, filehdr_out->NumberOfSections);
5660 H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->TimeDateStamp);
5661 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
5662 filehdr_out->PointerToSymbolTable);
5663 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->NumberOfSymbols);
5665 return bfd_coff_filhsz (abfd);
5669 coff_bigobj_swap_sym_in (bfd * abfd, void * ext1, void * in1)
5671 SYMENT_BIGOBJ *ext = (SYMENT_BIGOBJ *) ext1;
5672 struct internal_syment *in = (struct internal_syment *) in1;
5674 if (ext->e.e_name[0] == 0)
5676 in->_n._n_n._n_zeroes = 0;
5677 in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset);
5681 #if SYMNMLEN != E_SYMNMLEN
5682 #error we need to cope with truncating or extending SYMNMLEN
5684 memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN);
5688 in->n_value = H_GET_32 (abfd, ext->e_value);
5689 in->n_scnum = H_GET_32 (abfd, ext->e_scnum);
5690 in->n_type = H_GET_16 (abfd, ext->e_type);
5691 in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
5692 in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
5696 coff_bigobj_swap_sym_out (bfd * abfd, void * inp, void * extp)
5698 struct internal_syment *in = (struct internal_syment *) inp;
5699 SYMENT_BIGOBJ *ext = (SYMENT_BIGOBJ *) extp;
5701 if (in->_n._n_name[0] == 0)
5703 H_PUT_32 (abfd, 0, ext->e.e.e_zeroes);
5704 H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset);
5708 #if SYMNMLEN != E_SYMNMLEN
5709 #error we need to cope with truncating or extending SYMNMLEN
5711 memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN);
5715 H_PUT_32 (abfd, in->n_value, ext->e_value);
5716 H_PUT_32 (abfd, in->n_scnum, ext->e_scnum);
5718 H_PUT_16 (abfd, in->n_type, ext->e_type);
5719 H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
5720 H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
5722 return SYMESZ_BIGOBJ;
5726 coff_bigobj_swap_aux_in (bfd *abfd,
5734 AUXENT_BIGOBJ *ext = (AUXENT_BIGOBJ *) ext1;
5735 union internal_auxent *in = (union internal_auxent *) in1;
5743 memcpy (in->x_file.x_fname, ext->File.Name,
5744 numaux * sizeof (AUXENT_BIGOBJ));
5747 memcpy (in->x_file.x_fname, ext->File.Name, sizeof (ext->File.Name));
5755 in->x_scn.x_scnlen = H_GET_32 (abfd, ext->Section.Length);
5756 in->x_scn.x_nreloc =
5757 H_GET_16 (abfd, ext->Section.NumberOfRelocations);
5758 in->x_scn.x_nlinno =
5759 H_GET_16 (abfd, ext->Section.NumberOfLinenumbers);
5760 in->x_scn.x_checksum = H_GET_32 (abfd, ext->Section.Checksum);
5761 in->x_scn.x_associated = H_GET_16 (abfd, ext->Section.Number)
5762 | (H_GET_16 (abfd, ext->Section.HighNumber) << 16);
5763 in->x_scn.x_comdat = H_GET_8 (abfd, ext->Section.Selection);
5769 in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->Sym.WeakDefaultSymIndex);
5770 /* Characteristics is ignored. */
5776 coff_bigobj_swap_aux_out (bfd * abfd,
5780 int indx ATTRIBUTE_UNUSED,
5781 int numaux ATTRIBUTE_UNUSED,
5784 union internal_auxent * in = (union internal_auxent *) inp;
5785 AUXENT_BIGOBJ *ext = (AUXENT_BIGOBJ *) extp;
5787 memset (ext, 0, AUXESZ);
5792 memcpy (ext->File.Name, in->x_file.x_fname, sizeof (ext->File.Name));
5801 H_PUT_32 (abfd, in->x_scn.x_scnlen, ext->Section.Length);
5802 H_PUT_16 (abfd, in->x_scn.x_nreloc,
5803 ext->Section.NumberOfRelocations);
5804 H_PUT_16 (abfd, in->x_scn.x_nlinno,
5805 ext->Section.NumberOfLinenumbers);
5806 H_PUT_32 (abfd, in->x_scn.x_checksum, ext->Section.Checksum);
5807 H_PUT_16 (abfd, in->x_scn.x_associated & 0xffff,
5808 ext->Section.Number);
5809 H_PUT_16 (abfd, (in->x_scn.x_associated >> 16),
5810 ext->Section.HighNumber);
5811 H_PUT_8 (abfd, in->x_scn.x_comdat, ext->Section.Selection);
5817 H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->Sym.WeakDefaultSymIndex);
5818 H_PUT_32 (abfd, 1, ext->Sym.WeakSearchType);
5823 static bfd_coff_backend_data bigobj_swap_table =
5825 coff_bigobj_swap_aux_in, coff_bigobj_swap_sym_in, coff_SWAP_lineno_in,
5826 coff_bigobj_swap_aux_out, coff_bigobj_swap_sym_out,
5827 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5828 coff_bigobj_swap_filehdr_out, coff_SWAP_aouthdr_out,
5829 coff_SWAP_scnhdr_out,
5830 FILHSZ_BIGOBJ, AOUTSZ, SCNHSZ, SYMESZ_BIGOBJ, AUXESZ_BIGOBJ,
5831 RELSZ, LINESZ, FILNMLEN_BIGOBJ,
5833 COFF_DEFAULT_LONG_SECTION_NAMES,
5834 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5838 coff_bigobj_swap_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5839 coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
5840 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5841 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5842 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5843 coff_classify_symbol, coff_compute_section_file_positions,
5844 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5845 coff_adjust_symndx, coff_link_add_one_symbol,
5846 coff_link_output_has_begun, coff_final_link_postscript,
5847 bfd_pe_print_pdata /* huh */
5850 #endif /* COFF_WITH_PE_BIGOBJ */
5852 #ifndef coff_close_and_cleanup
5853 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5856 #ifndef coff_bfd_free_cached_info
5857 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5860 #ifndef coff_get_section_contents
5861 #define coff_get_section_contents _bfd_generic_get_section_contents
5864 #ifndef coff_bfd_copy_private_symbol_data
5865 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5868 #ifndef coff_bfd_copy_private_header_data
5869 #define coff_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
5872 #ifndef coff_bfd_copy_private_section_data
5873 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5876 #ifndef coff_bfd_copy_private_bfd_data
5877 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5880 #ifndef coff_bfd_merge_private_bfd_data
5881 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5884 #ifndef coff_bfd_set_private_flags
5885 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5888 #ifndef coff_bfd_print_private_bfd_data
5889 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5892 #ifndef coff_bfd_is_local_label_name
5893 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5896 #ifndef coff_bfd_is_target_special_symbol
5897 #define coff_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
5900 #ifndef coff_read_minisymbols
5901 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5904 #ifndef coff_minisymbol_to_symbol
5905 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5908 /* The reloc lookup routine must be supplied by each individual COFF
5910 #ifndef coff_bfd_reloc_type_lookup
5911 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5913 #ifndef coff_bfd_reloc_name_lookup
5914 #define coff_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5917 #ifndef coff_bfd_get_relocated_section_contents
5918 #define coff_bfd_get_relocated_section_contents \
5919 bfd_generic_get_relocated_section_contents
5922 #ifndef coff_bfd_relax_section
5923 #define coff_bfd_relax_section bfd_generic_relax_section
5926 #ifndef coff_bfd_gc_sections
5927 #define coff_bfd_gc_sections bfd_generic_gc_sections
5930 #ifndef coff_bfd_lookup_section_flags
5931 #define coff_bfd_lookup_section_flags bfd_generic_lookup_section_flags
5934 #ifndef coff_bfd_merge_sections
5935 #define coff_bfd_merge_sections bfd_generic_merge_sections
5938 #ifndef coff_bfd_is_group_section
5939 #define coff_bfd_is_group_section bfd_generic_is_group_section
5942 #ifndef coff_bfd_discard_group
5943 #define coff_bfd_discard_group bfd_generic_discard_group
5946 #ifndef coff_section_already_linked
5947 #define coff_section_already_linked \
5948 _bfd_coff_section_already_linked
5951 #ifndef coff_bfd_define_common_symbol
5952 #define coff_bfd_define_common_symbol bfd_generic_define_common_symbol
5955 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5956 const bfd_target VAR = \
5959 bfd_target_coff_flavour, \
5960 BFD_ENDIAN_BIG, /* Data byte order is big. */ \
5961 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5962 /* object flags */ \
5963 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5964 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5965 /* section flags */ \
5966 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5967 UNDER, /* Leading symbol underscore. */ \
5968 '/', /* AR_pad_char. */ \
5969 15, /* AR_max_namelen. */ \
5970 0, /* match priority. */ \
5972 /* Data conversion functions. */ \
5973 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5974 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5975 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5977 /* Header conversion functions. */ \
5978 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5979 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5980 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5982 /* bfd_check_format. */ \
5983 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5984 _bfd_dummy_target }, \
5985 /* bfd_set_format. */ \
5986 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5987 /* bfd_write_contents. */ \
5988 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5991 BFD_JUMP_TABLE_GENERIC (coff), \
5992 BFD_JUMP_TABLE_COPY (coff), \
5993 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5994 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5995 BFD_JUMP_TABLE_SYMBOLS (coff), \
5996 BFD_JUMP_TABLE_RELOCS (coff), \
5997 BFD_JUMP_TABLE_WRITE (coff), \
5998 BFD_JUMP_TABLE_LINK (coff), \
5999 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
6006 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
6007 const bfd_target VAR = \
6010 bfd_target_coff_flavour, \
6011 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
6012 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
6013 /* object flags */ \
6014 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
6015 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
6016 /* section flags */ \
6017 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
6018 UNDER, /* Leading symbol underscore. */ \
6019 '/', /* AR_pad_char. */ \
6020 15, /* AR_max_namelen. */ \
6021 0, /* match priority. */ \
6023 /* Data conversion functions. */ \
6024 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
6025 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
6026 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
6028 /* Header conversion functions. */ \
6029 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
6030 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
6031 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
6033 /* bfd_check_format. */ \
6034 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
6035 _bfd_dummy_target }, \
6036 /* bfd_set_format. */ \
6037 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
6038 /* bfd_write_contents. */ \
6039 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
6042 BFD_JUMP_TABLE_GENERIC (coff), \
6043 BFD_JUMP_TABLE_COPY (coff), \
6044 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
6045 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
6046 BFD_JUMP_TABLE_SYMBOLS (coff), \
6047 BFD_JUMP_TABLE_RELOCS (coff), \
6048 BFD_JUMP_TABLE_WRITE (coff), \
6049 BFD_JUMP_TABLE_LINK (coff), \
6050 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
6057 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
6058 const bfd_target VAR = \
6061 bfd_target_coff_flavour, \
6062 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
6063 BFD_ENDIAN_LITTLE, /* Header byte order is little. */ \
6064 /* object flags */ \
6065 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
6066 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
6067 /* section flags */ \
6068 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
6069 UNDER, /* Leading symbol underscore. */ \
6070 '/', /* AR_pad_char. */ \
6071 15, /* AR_max_namelen. */ \
6072 0, /* match priority. */ \
6074 /* Data conversion functions. */ \
6075 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
6076 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
6077 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
6078 /* Header conversion functions. */ \
6079 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
6080 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
6081 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
6082 /* bfd_check_format. */ \
6083 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
6084 _bfd_dummy_target }, \
6085 /* bfd_set_format. */ \
6086 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
6087 /* bfd_write_contents. */ \
6088 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
6091 BFD_JUMP_TABLE_GENERIC (coff), \
6092 BFD_JUMP_TABLE_COPY (coff), \
6093 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
6094 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
6095 BFD_JUMP_TABLE_SYMBOLS (coff), \
6096 BFD_JUMP_TABLE_RELOCS (coff), \
6097 BFD_JUMP_TABLE_WRITE (coff), \
6098 BFD_JUMP_TABLE_LINK (coff), \
6099 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \