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 if (sizeof (internal_s
->s_name
) > SYMNMLEN
)
933 /* This case implies that the matching
934 symbol name will be in the string table. */
938 if (isym
.n_scnum
== section
->target_index
)
940 /* According to the MSVC documentation, the first
941 TWO entries with the section # are both of
942 interest to us. The first one is the "section
943 symbol" (section name). The second is the comdat
944 symbol name. Here, we've found the first
945 qualifying entry; we distinguish it from the
946 second with a state flag.
948 In the case of gas-generated (at least until that
949 is fixed) .o files, it isn't necessarily the
950 second one. It may be some other later symbol.
952 Since gas also doesn't follow MS conventions and
953 emits the section similar to .text$<name>, where
954 <something> is the name we're looking for, we
955 distinguish the two as follows:
957 If the section name is simply a section name (no
958 $) we presume it's MS-generated, and look at
959 precisely the second symbol for the comdat name.
960 If the section name has a $, we assume it's
961 gas-generated, and look for <something> (whatever
962 follows the $) as the comdat symbol. */
964 /* All 3 branches use this. */
965 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
, buf
);
974 /* The first time we've seen the symbol. */
975 union internal_auxent aux
;
977 /* If it isn't the stuff we're expecting, die;
978 The MS documentation is vague, but it
979 appears that the second entry serves BOTH
980 as the comdat symbol and the defining
981 symbol record (either C_STAT or C_EXT,
982 possibly with an aux entry with debug
983 information if it's a function.) It
984 appears the only way to find the second one
985 is to count. (On Intel, they appear to be
986 adjacent, but on Alpha, they have been
989 Here, we think we've found the first one,
990 but there's some checking we can do to be
993 if (! ((isym
.n_sclass
== C_STAT
994 || isym
.n_sclass
== C_EXT
)
995 && BTYPE (isym
.n_type
) == T_NULL
996 && isym
.n_value
== 0))
999 /* FIXME LATER: MSVC generates section names
1000 like .text for comdats. Gas generates
1001 names like .text$foo__Fv (in the case of a
1002 function). See comment above for more. */
1004 if (isym
.n_sclass
== C_STAT
&& strcmp (name
, symname
) != 0)
1005 _bfd_error_handler (_("%B: warning: COMDAT symbol '%s' does not match section name '%s'"),
1006 abfd
, symname
, name
);
1010 /* This is the section symbol. */
1011 bfd_coff_swap_aux_in (abfd
, (esym
+ bfd_coff_symesz (abfd
)),
1012 isym
.n_type
, isym
.n_sclass
,
1013 0, isym
.n_numaux
, & aux
);
1015 target_name
= strchr (name
, '$');
1016 if (target_name
!= NULL
)
1024 /* FIXME: Microsoft uses NODUPLICATES and
1025 ASSOCIATIVE, but gnu uses ANY and
1026 SAME_SIZE. Unfortunately, gnu doesn't do
1027 the comdat symbols right. So, until we can
1028 fix it to do the right thing, we are
1029 temporarily disabling comdats for the MS
1030 types (they're used in DLLs and C++, but we
1031 don't support *their* C++ libraries anyway
1034 /* Cygwin does not follow the MS style, and
1035 uses ANY and SAME_SIZE where NODUPLICATES
1036 and ASSOCIATIVE should be used. For
1037 Interix, we just do the right thing up
1040 switch (aux
.x_scn
.x_comdat
)
1042 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
1043 #ifdef STRICT_PE_FORMAT
1044 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
1046 sec_flags
&= ~SEC_LINK_ONCE
;
1050 case IMAGE_COMDAT_SELECT_ANY
:
1051 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1054 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
1055 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
1058 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
1059 /* Not yet fully implemented ??? */
1060 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
1063 /* debug$S gets this case; other
1066 /* There may be no symbol... we'll search
1067 the whole table... Is this the right
1068 place to play this game? Or should we do
1069 it when reading it in. */
1070 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
1071 #ifdef STRICT_PE_FORMAT
1072 /* FIXME: This is not currently implemented. */
1073 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1075 sec_flags
&= ~SEC_LINK_ONCE
;
1079 default: /* 0 means "no symbol" */
1080 /* debug$F gets this case; other
1082 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1089 /* Gas mode: the first matching on partial name. */
1091 #ifndef TARGET_UNDERSCORE
1092 #define TARGET_UNDERSCORE 0
1094 /* Is this the name we're looking for ? */
1095 if (strcmp (target_name
,
1096 symname
+ (TARGET_UNDERSCORE
? 1 : 0)) != 0)
1098 /* Not the name we're looking for */
1099 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1104 /* MSVC mode: the lexically second symbol (or
1105 drop through from the above). */
1110 /* This must the second symbol with the
1111 section #. It is the actual symbol name.
1112 Intel puts the two adjacent, but Alpha (at
1113 least) spreads them out. */
1115 amt
= sizeof (struct coff_comdat_info
);
1116 coff_section_data (abfd
, section
)->comdat
1117 = (struct coff_comdat_info
*) bfd_alloc (abfd
, amt
);
1118 if (coff_section_data (abfd
, section
)->comdat
== NULL
)
1121 coff_section_data (abfd
, section
)->comdat
->symbol
=
1122 (esym
- esymstart
) / bfd_coff_symesz (abfd
);
1124 amt
= strlen (symname
) + 1;
1125 newname
= (char *) bfd_alloc (abfd
, amt
);
1126 if (newname
== NULL
)
1129 strcpy (newname
, symname
);
1130 coff_section_data (abfd
, section
)->comdat
->name
1138 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1146 /* The PE version; see above for the general comments.
1148 Since to set the SEC_LINK_ONCE and associated flags, we have to
1149 look at the symbol table anyway, we return the symbol table index
1150 of the symbol being used as the COMDAT symbol. This is admittedly
1151 ugly, but there's really nowhere else that we have access to the
1152 required information. FIXME: Is the COMDAT symbol index used for
1153 any purpose other than objdump? */
1156 styp_to_sec_flags (bfd
*abfd
,
1160 flagword
*flags_ptr
)
1162 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
1163 long styp_flags
= internal_s
->s_flags
;
1165 bfd_boolean result
= TRUE
;
1166 bfd_boolean is_dbg
= FALSE
;
1168 if (CONST_STRNEQ (name
, DOT_DEBUG
)
1169 || CONST_STRNEQ (name
, DOT_ZDEBUG
)
1170 #ifdef COFF_LONG_SECTION_NAMES
1171 || CONST_STRNEQ (name
, GNU_LINKONCE_WI
)
1172 || CONST_STRNEQ (name
, GNU_LINKONCE_WT
)
1174 || CONST_STRNEQ (name
, ".stab"))
1176 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
1177 sec_flags
= SEC_READONLY
;
1179 /* If section disallows read, then set the NOREAD flag. */
1180 if ((styp_flags
& IMAGE_SCN_MEM_READ
) == 0)
1181 sec_flags
|= SEC_COFF_NOREAD
;
1183 /* Process each flag bit in styp_flags in turn. */
1186 long flag
= styp_flags
& - styp_flags
;
1187 char * unhandled
= NULL
;
1189 styp_flags
&= ~ flag
;
1191 /* We infer from the distinct read/write/execute bits the settings
1192 of some of the bfd flags; the actual values, should we need them,
1193 are also in pei_section_data (abfd, section)->pe_flags. */
1198 unhandled
= "STYP_DSECT";
1201 unhandled
= "STYP_GROUP";
1204 unhandled
= "STYP_COPY";
1207 unhandled
= "STYP_OVER";
1209 #ifdef SEC_NEVER_LOAD
1211 sec_flags
|= SEC_NEVER_LOAD
;
1214 case IMAGE_SCN_MEM_READ
:
1215 sec_flags
&= ~SEC_COFF_NOREAD
;
1217 case IMAGE_SCN_TYPE_NO_PAD
:
1220 case IMAGE_SCN_LNK_OTHER
:
1221 unhandled
= "IMAGE_SCN_LNK_OTHER";
1223 case IMAGE_SCN_MEM_NOT_CACHED
:
1224 unhandled
= "IMAGE_SCN_MEM_NOT_CACHED";
1226 case IMAGE_SCN_MEM_NOT_PAGED
:
1227 /* Generate a warning message rather using the 'unhandled'
1228 variable as this will allow some .sys files generate by
1229 other toolchains to be processed. See bugzilla issue 196. */
1230 _bfd_error_handler (_("%B: Warning: Ignoring section flag IMAGE_SCN_MEM_NOT_PAGED in section %s"),
1233 case IMAGE_SCN_MEM_EXECUTE
:
1234 sec_flags
|= SEC_CODE
;
1236 case IMAGE_SCN_MEM_WRITE
:
1237 sec_flags
&= ~ SEC_READONLY
;
1239 case IMAGE_SCN_MEM_DISCARDABLE
:
1240 /* The MS PE spec says that debug sections are DISCARDABLE,
1241 but the presence of a DISCARDABLE flag does not necessarily
1242 mean that a given section contains debug information. Thus
1243 we only set the SEC_DEBUGGING flag on sections that we
1244 recognise as containing debug information. */
1247 || strcmp (name
, _COMMENT
) == 0
1251 sec_flags
|= SEC_DEBUGGING
| SEC_READONLY
;
1254 case IMAGE_SCN_MEM_SHARED
:
1255 sec_flags
|= SEC_COFF_SHARED
;
1257 case IMAGE_SCN_LNK_REMOVE
:
1259 sec_flags
|= SEC_EXCLUDE
;
1261 case IMAGE_SCN_CNT_CODE
:
1262 sec_flags
|= SEC_CODE
| SEC_ALLOC
| SEC_LOAD
;
1264 case IMAGE_SCN_CNT_INITIALIZED_DATA
:
1266 sec_flags
|= SEC_DEBUGGING
;
1268 sec_flags
|= SEC_DATA
| SEC_ALLOC
| SEC_LOAD
;
1270 case IMAGE_SCN_CNT_UNINITIALIZED_DATA
:
1271 sec_flags
|= SEC_ALLOC
;
1273 case IMAGE_SCN_LNK_INFO
:
1274 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1275 defined. coff_compute_section_file_positions uses
1276 COFF_PAGE_SIZE to ensure that the low order bits of the
1277 section VMA and the file offset match. If we don't know
1278 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1279 and demand page loading of the file will fail. */
1280 #ifdef COFF_PAGE_SIZE
1281 sec_flags
|= SEC_DEBUGGING
;
1284 case IMAGE_SCN_LNK_COMDAT
:
1285 /* COMDAT gets very special treatment. */
1286 sec_flags
= handle_COMDAT (abfd
, sec_flags
, hdr
, name
, section
);
1289 /* Silently ignore for now. */
1293 /* If the section flag was not handled, report it here. */
1294 if (unhandled
!= NULL
)
1296 (*_bfd_error_handler
)
1297 (_("%B (%s): Section flag %s (0x%x) ignored"),
1298 abfd
, name
, unhandled
, flag
);
1303 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1304 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1305 only link a single copy of the section. This is used to support
1306 g++. g++ will emit each template expansion in its own section.
1307 The symbols will be defined as weak, so that multiple definitions
1308 are permitted. The GNU linker extension is to actually discard
1309 all but one of the sections. */
1310 if (CONST_STRNEQ (name
, ".gnu.linkonce"))
1311 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1315 * flags_ptr
= sec_flags
;
1320 #endif /* COFF_WITH_PE */
1322 #define get_index(symbol) ((symbol)->udata.i)
1326 bfd_coff_backend_data
1330 .{* COFF symbol classifications. *}
1332 .enum coff_symbol_classification
1334 . {* Global symbol. *}
1335 . COFF_SYMBOL_GLOBAL,
1336 . {* Common symbol. *}
1337 . COFF_SYMBOL_COMMON,
1338 . {* Undefined symbol. *}
1339 . COFF_SYMBOL_UNDEFINED,
1340 . {* Local symbol. *}
1341 . COFF_SYMBOL_LOCAL,
1342 . {* PE section symbol. *}
1343 . COFF_SYMBOL_PE_SECTION
1346 Special entry points for gdb to swap in coff symbol table parts:
1349 . void (*_bfd_coff_swap_aux_in)
1350 . (bfd *, void *, int, int, int, int, void *);
1352 . void (*_bfd_coff_swap_sym_in)
1353 . (bfd *, void *, void *);
1355 . void (*_bfd_coff_swap_lineno_in)
1356 . (bfd *, void *, void *);
1358 . unsigned int (*_bfd_coff_swap_aux_out)
1359 . (bfd *, void *, int, int, int, int, void *);
1361 . unsigned int (*_bfd_coff_swap_sym_out)
1362 . (bfd *, void *, void *);
1364 . unsigned int (*_bfd_coff_swap_lineno_out)
1365 . (bfd *, void *, void *);
1367 . unsigned int (*_bfd_coff_swap_reloc_out)
1368 . (bfd *, void *, void *);
1370 . unsigned int (*_bfd_coff_swap_filehdr_out)
1371 . (bfd *, void *, void *);
1373 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1374 . (bfd *, void *, void *);
1376 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1377 . (bfd *, void *, void *);
1379 . unsigned int _bfd_filhsz;
1380 . unsigned int _bfd_aoutsz;
1381 . unsigned int _bfd_scnhsz;
1382 . unsigned int _bfd_symesz;
1383 . unsigned int _bfd_auxesz;
1384 . unsigned int _bfd_relsz;
1385 . unsigned int _bfd_linesz;
1386 . unsigned int _bfd_filnmlen;
1387 . bfd_boolean _bfd_coff_long_filenames;
1389 . bfd_boolean _bfd_coff_long_section_names;
1390 . bfd_boolean (*_bfd_coff_set_long_section_names)
1393 . unsigned int _bfd_coff_default_section_alignment_power;
1394 . bfd_boolean _bfd_coff_force_symnames_in_strings;
1395 . unsigned int _bfd_coff_debug_string_prefix_length;
1396 . unsigned int _bfd_coff_max_nscns;
1398 . void (*_bfd_coff_swap_filehdr_in)
1399 . (bfd *, void *, void *);
1401 . void (*_bfd_coff_swap_aouthdr_in)
1402 . (bfd *, void *, void *);
1404 . void (*_bfd_coff_swap_scnhdr_in)
1405 . (bfd *, void *, void *);
1407 . void (*_bfd_coff_swap_reloc_in)
1408 . (bfd *abfd, void *, void *);
1410 . bfd_boolean (*_bfd_coff_bad_format_hook)
1413 . bfd_boolean (*_bfd_coff_set_arch_mach_hook)
1416 . void * (*_bfd_coff_mkobject_hook)
1417 . (bfd *, void *, void *);
1419 . bfd_boolean (*_bfd_styp_to_sec_flags_hook)
1420 . (bfd *, void *, const char *, asection *, flagword *);
1422 . void (*_bfd_set_alignment_hook)
1423 . (bfd *, asection *, void *);
1425 . bfd_boolean (*_bfd_coff_slurp_symbol_table)
1428 . bfd_boolean (*_bfd_coff_symname_in_debug)
1429 . (bfd *, struct internal_syment *);
1431 . bfd_boolean (*_bfd_coff_pointerize_aux_hook)
1432 . (bfd *, combined_entry_type *, combined_entry_type *,
1433 . unsigned int, combined_entry_type *);
1435 . bfd_boolean (*_bfd_coff_print_aux)
1436 . (bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1437 . combined_entry_type *, unsigned int);
1439 . void (*_bfd_coff_reloc16_extra_cases)
1440 . (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1441 . bfd_byte *, unsigned int *, unsigned int *);
1443 . int (*_bfd_coff_reloc16_estimate)
1444 . (bfd *, asection *, arelent *, unsigned int,
1445 . struct bfd_link_info *);
1447 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1448 . (bfd *, struct internal_syment *);
1450 . bfd_boolean (*_bfd_coff_compute_section_file_positions)
1453 . bfd_boolean (*_bfd_coff_start_final_link)
1454 . (bfd *, struct bfd_link_info *);
1456 . bfd_boolean (*_bfd_coff_relocate_section)
1457 . (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1458 . struct internal_reloc *, struct internal_syment *, asection **);
1460 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1461 . (bfd *, asection *, struct internal_reloc *,
1462 . struct coff_link_hash_entry *, struct internal_syment *,
1465 . bfd_boolean (*_bfd_coff_adjust_symndx)
1466 . (bfd *, struct bfd_link_info *, bfd *, asection *,
1467 . struct internal_reloc *, bfd_boolean *);
1469 . bfd_boolean (*_bfd_coff_link_add_one_symbol)
1470 . (struct bfd_link_info *, bfd *, const char *, flagword,
1471 . asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
1472 . struct bfd_link_hash_entry **);
1474 . bfd_boolean (*_bfd_coff_link_output_has_begun)
1475 . (bfd *, struct coff_final_link_info *);
1477 . bfd_boolean (*_bfd_coff_final_link_postscript)
1478 . (bfd *, struct coff_final_link_info *);
1480 . bfd_boolean (*_bfd_coff_print_pdata)
1483 .} bfd_coff_backend_data;
1485 .#define coff_backend_info(abfd) \
1486 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1488 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1489 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1491 .#define bfd_coff_swap_sym_in(a,e,i) \
1492 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1494 .#define bfd_coff_swap_lineno_in(a,e,i) \
1495 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1497 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1498 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1500 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1501 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1503 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1504 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1506 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1507 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1509 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1510 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1512 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1513 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1515 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1516 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1518 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1519 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1520 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1521 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1522 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1523 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1524 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1525 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1526 .#define bfd_coff_long_filenames(abfd) \
1527 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1528 .#define bfd_coff_long_section_names(abfd) \
1529 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1530 .#define bfd_coff_set_long_section_names(abfd, enable) \
1531 . ((coff_backend_info (abfd)->_bfd_coff_set_long_section_names) (abfd, enable))
1532 .#define bfd_coff_default_section_alignment_power(abfd) \
1533 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1534 .#define bfd_coff_max_nscns(abfd) \
1535 . (coff_backend_info (abfd)->_bfd_coff_max_nscns)
1537 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1538 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1540 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1541 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1543 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1544 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1546 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1547 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1549 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1550 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1552 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1553 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1554 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1555 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1556 . (abfd, filehdr, aouthdr))
1558 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1559 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1560 . (abfd, scnhdr, name, section, flags_ptr))
1562 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1563 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1565 .#define bfd_coff_slurp_symbol_table(abfd)\
1566 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1568 .#define bfd_coff_symname_in_debug(abfd, sym)\
1569 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1571 .#define bfd_coff_force_symnames_in_strings(abfd)\
1572 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1574 .#define bfd_coff_debug_string_prefix_length(abfd)\
1575 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1577 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1578 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1579 . (abfd, file, base, symbol, aux, indaux))
1581 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1582 . reloc, data, src_ptr, dst_ptr)\
1583 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1584 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1586 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1587 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1588 . (abfd, section, reloc, shrink, link_info))
1590 .#define bfd_coff_classify_symbol(abfd, sym)\
1591 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1594 .#define bfd_coff_compute_section_file_positions(abfd)\
1595 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1598 .#define bfd_coff_start_final_link(obfd, info)\
1599 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1601 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1602 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1603 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1604 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1605 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1606 . (abfd, sec, rel, h, sym, addendp))
1607 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1608 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1609 . (obfd, info, ibfd, sec, rel, adjustedp))
1610 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1611 . value, string, cp, coll, hashp)\
1612 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1613 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1615 .#define bfd_coff_link_output_has_begun(a,p) \
1616 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p))
1617 .#define bfd_coff_final_link_postscript(a,p) \
1618 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p))
1620 .#define bfd_coff_have_print_pdata(a) \
1621 . (coff_backend_info (a)->_bfd_coff_print_pdata)
1622 .#define bfd_coff_print_pdata(a,p) \
1623 . ((coff_backend_info (a)->_bfd_coff_print_pdata) (a, p))
1625 .{* Macro: Returns true if the bfd is a PE executable as opposed to a
1626 . PE object file. *}
1627 .#define bfd_pei_p(abfd) \
1628 . (CONST_STRNEQ ((abfd)->xvec->name, "pei-"))
1631 /* See whether the magic number matches. */
1634 coff_bad_format_hook (bfd
* abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1636 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1638 if (BADMAG (*internal_f
))
1641 /* If the optional header is NULL or not the correct size then
1642 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1643 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1644 optional header is of a different size.
1646 But the mips keeps extra stuff in it's opthdr, so dont check
1649 #if defined(M88) || defined(I960)
1650 if (internal_f
->f_opthdr
!= 0 && bfd_coff_aoutsz (abfd
) != internal_f
->f_opthdr
)
1659 ticoff0_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1661 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1663 if (COFF0_BADMAG (*internal_f
))
1672 ticoff1_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1674 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1676 if (COFF1_BADMAG (*internal_f
))
1683 /* Check whether this section uses an alignment other than the
1687 coff_set_custom_section_alignment (bfd
*abfd ATTRIBUTE_UNUSED
,
1689 const struct coff_section_alignment_entry
*alignment_table
,
1690 const unsigned int table_size
)
1692 const unsigned int default_alignment
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1695 for (i
= 0; i
< table_size
; ++i
)
1697 const char *secname
= bfd_get_section_name (abfd
, section
);
1699 if (alignment_table
[i
].comparison_length
== (unsigned int) -1
1700 ? strcmp (alignment_table
[i
].name
, secname
) == 0
1701 : strncmp (alignment_table
[i
].name
, secname
,
1702 alignment_table
[i
].comparison_length
) == 0)
1705 if (i
>= table_size
)
1708 if (alignment_table
[i
].default_alignment_min
!= COFF_ALIGNMENT_FIELD_EMPTY
1709 && default_alignment
< alignment_table
[i
].default_alignment_min
)
1712 if (alignment_table
[i
].default_alignment_max
!= COFF_ALIGNMENT_FIELD_EMPTY
1713 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1714 && default_alignment
> alignment_table
[i
].default_alignment_max
1719 section
->alignment_power
= alignment_table
[i
].alignment_power
;
1722 /* Custom section alignment records. */
1724 static const struct coff_section_alignment_entry
1725 coff_section_alignment_table
[] =
1727 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1728 COFF_SECTION_ALIGNMENT_ENTRIES
,
1730 /* There must not be any gaps between .stabstr sections. */
1731 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1732 1, COFF_ALIGNMENT_FIELD_EMPTY
, 0 },
1733 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1734 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1735 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1736 /* Similarly for the .ctors and .dtors sections. */
1737 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1738 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1739 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1740 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 }
1743 static const unsigned int coff_section_alignment_table_size
=
1744 sizeof coff_section_alignment_table
/ sizeof coff_section_alignment_table
[0];
1746 /* Initialize a section structure with information peculiar to this
1747 particular implementation of COFF. */
1750 coff_new_section_hook (bfd
* abfd
, asection
* section
)
1752 combined_entry_type
*native
;
1754 unsigned char sclass
= C_STAT
;
1756 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1759 if (bfd_xcoff_text_align_power (abfd
) != 0
1760 && strcmp (bfd_get_section_name (abfd
, section
), ".text") == 0)
1761 section
->alignment_power
= bfd_xcoff_text_align_power (abfd
);
1762 else if (bfd_xcoff_data_align_power (abfd
) != 0
1763 && strcmp (bfd_get_section_name (abfd
, section
), ".data") == 0)
1764 section
->alignment_power
= bfd_xcoff_data_align_power (abfd
);
1769 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
1770 if (strcmp (bfd_get_section_name (abfd
, section
),
1771 xcoff_dwsect_names
[i
].name
) == 0)
1773 section
->alignment_power
= 0;
1780 /* Set up the section symbol. */
1781 if (!_bfd_generic_new_section_hook (abfd
, section
))
1784 /* Allocate aux records for section symbols, to store size and
1787 @@ The 10 is a guess at a plausible maximum number of aux entries
1788 (but shouldn't be a constant). */
1789 amt
= sizeof (combined_entry_type
) * 10;
1790 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
1794 /* We don't need to set up n_name, n_value, or n_scnum in the native
1795 symbol information, since they'll be overridden by the BFD symbol
1796 anyhow. However, we do need to set the type and storage class,
1797 in case this symbol winds up getting written out. The value 0
1798 for n_numaux is already correct. */
1800 native
->u
.syment
.n_type
= T_NULL
;
1801 native
->u
.syment
.n_sclass
= sclass
;
1803 coffsymbol (section
->symbol
)->native
= native
;
1805 coff_set_custom_section_alignment (abfd
, section
,
1806 coff_section_alignment_table
,
1807 coff_section_alignment_table_size
);
1812 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1814 /* Set the alignment of a BFD section. */
1817 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1821 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1825 /* Extract ALIGN from 2**ALIGN stored in section header. */
1826 for (i
= 0; i
< 32; i
++)
1827 if ((1 << i
) >= hdr
->s_align
)
1831 /* TI tools puts the alignment power in bits 8-11. */
1832 i
= (hdr
->s_flags
>> 8) & 0xF ;
1834 #ifdef COFF_DECODE_ALIGNMENT
1835 i
= COFF_DECODE_ALIGNMENT(hdr
->s_flags
);
1837 section
->alignment_power
= i
;
1839 #ifdef coff_set_section_load_page
1840 coff_set_section_load_page (section
, hdr
->s_page
);
1844 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1848 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1852 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1854 unsigned int alignment_power_const
1855 = hdr
->s_flags
& IMAGE_SCN_ALIGN_POWER_BIT_MASK
;
1857 switch (alignment_power_const
)
1859 case IMAGE_SCN_ALIGN_8192BYTES
:
1860 case IMAGE_SCN_ALIGN_4096BYTES
:
1861 case IMAGE_SCN_ALIGN_2048BYTES
:
1862 case IMAGE_SCN_ALIGN_1024BYTES
:
1863 case IMAGE_SCN_ALIGN_512BYTES
:
1864 case IMAGE_SCN_ALIGN_256BYTES
:
1865 case IMAGE_SCN_ALIGN_128BYTES
:
1866 case IMAGE_SCN_ALIGN_64BYTES
:
1867 case IMAGE_SCN_ALIGN_32BYTES
:
1868 case IMAGE_SCN_ALIGN_16BYTES
:
1869 case IMAGE_SCN_ALIGN_8BYTES
:
1870 case IMAGE_SCN_ALIGN_4BYTES
:
1871 case IMAGE_SCN_ALIGN_2BYTES
:
1872 case IMAGE_SCN_ALIGN_1BYTES
:
1873 section
->alignment_power
1874 = IMAGE_SCN_ALIGN_POWER_NUM (alignment_power_const
);
1880 /* In a PE image file, the s_paddr field holds the virtual size of a
1881 section, while the s_size field holds the raw size. We also keep
1882 the original section flag value, since not every bit can be
1883 mapped onto a generic BFD section bit. */
1884 if (coff_section_data (abfd
, section
) == NULL
)
1886 amt
= sizeof (struct coff_section_tdata
);
1887 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
1888 if (section
->used_by_bfd
== NULL
)
1889 /* FIXME: Return error. */
1893 if (pei_section_data (abfd
, section
) == NULL
)
1895 amt
= sizeof (struct pei_section_tdata
);
1896 coff_section_data (abfd
, section
)->tdata
= bfd_zalloc (abfd
, amt
);
1897 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1898 /* FIXME: Return error. */
1901 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1902 pei_section_data (abfd
, section
)->pe_flags
= hdr
->s_flags
;
1904 section
->lma
= hdr
->s_vaddr
;
1906 /* Check for extended relocs. */
1907 if (hdr
->s_flags
& IMAGE_SCN_LNK_NRELOC_OVFL
)
1909 struct external_reloc dst
;
1910 struct internal_reloc n
;
1911 file_ptr oldpos
= bfd_tell (abfd
);
1912 bfd_size_type relsz
= bfd_coff_relsz (abfd
);
1914 if (bfd_seek (abfd
, (file_ptr
) hdr
->s_relptr
, 0) != 0)
1916 if (bfd_bread (& dst
, relsz
, abfd
) != relsz
)
1919 coff_swap_reloc_in (abfd
, &dst
, &n
);
1920 if (bfd_seek (abfd
, oldpos
, 0) != 0)
1922 section
->reloc_count
= hdr
->s_nreloc
= n
.r_vaddr
- 1;
1923 section
->rel_filepos
+= relsz
;
1925 else if (hdr
->s_nreloc
== 0xffff)
1926 (*_bfd_error_handler
)
1927 ("%s: warning: claims to have 0xffff relocs, without overflow",
1928 bfd_get_filename (abfd
));
1931 #undef ELIFALIGN_SET
1933 #else /* ! COFF_WITH_PE */
1936 /* We grossly abuse this function to handle XCOFF overflow headers.
1937 When we see one, we correct the reloc and line number counts in the
1938 real header, and remove the section we just created. */
1941 coff_set_alignment_hook (bfd
*abfd
, asection
*section
, void * scnhdr
)
1943 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1946 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1949 real_sec
= coff_section_from_bfd_index (abfd
, (int) hdr
->s_nreloc
);
1950 if (real_sec
== NULL
)
1953 real_sec
->reloc_count
= hdr
->s_paddr
;
1954 real_sec
->lineno_count
= hdr
->s_vaddr
;
1956 if (!bfd_section_removed_from_list (abfd
, section
))
1958 bfd_section_list_remove (abfd
, section
);
1959 --abfd
->section_count
;
1963 #else /* ! RS6000COFF_C */
1965 #define coff_set_alignment_hook \
1966 ((void (*) (bfd *, asection *, void *)) bfd_void)
1968 #endif /* ! RS6000COFF_C */
1969 #endif /* ! COFF_WITH_PE */
1970 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1972 #ifndef coff_mkobject
1975 coff_mkobject (bfd
* abfd
)
1977 coff_data_type
*coff
;
1978 bfd_size_type amt
= sizeof (coff_data_type
);
1980 abfd
->tdata
.coff_obj_data
= bfd_zalloc (abfd
, amt
);
1981 if (abfd
->tdata
.coff_obj_data
== NULL
)
1983 coff
= coff_data (abfd
);
1984 coff
->symbols
= NULL
;
1985 coff
->conversion_table
= NULL
;
1986 coff
->raw_syments
= NULL
;
1987 coff
->relocbase
= 0;
1988 coff
->local_toc_sym_map
= 0;
1990 /* make_abs_section(abfd);*/
1996 /* Create the COFF backend specific information. */
1998 #ifndef coff_mkobject_hook
2000 coff_mkobject_hook (bfd
* abfd
,
2002 void * aouthdr ATTRIBUTE_UNUSED
)
2004 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
2005 coff_data_type
*coff
;
2007 if (! coff_mkobject (abfd
))
2010 coff
= coff_data (abfd
);
2012 coff
->sym_filepos
= internal_f
->f_symptr
;
2014 /* These members communicate important constants about the symbol
2015 table to GDB's symbol-reading code. These `constants'
2016 unfortunately vary among coff implementations... */
2017 coff
->local_n_btmask
= N_BTMASK
;
2018 coff
->local_n_btshft
= N_BTSHFT
;
2019 coff
->local_n_tmask
= N_TMASK
;
2020 coff
->local_n_tshift
= N_TSHIFT
;
2021 coff
->local_symesz
= bfd_coff_symesz (abfd
);
2022 coff
->local_auxesz
= bfd_coff_auxesz (abfd
);
2023 coff
->local_linesz
= bfd_coff_linesz (abfd
);
2025 coff
->timestamp
= internal_f
->f_timdat
;
2027 obj_raw_syment_count (abfd
) =
2028 obj_conv_table_size (abfd
) =
2029 internal_f
->f_nsyms
;
2032 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
2033 abfd
->flags
|= DYNAMIC
;
2034 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= bfd_coff_aoutsz (abfd
))
2036 struct internal_aouthdr
*internal_a
=
2037 (struct internal_aouthdr
*) aouthdr
;
2038 struct xcoff_tdata
*xcoff
;
2040 xcoff
= xcoff_data (abfd
);
2041 # ifdef U803XTOCMAGIC
2042 xcoff
->xcoff64
= internal_f
->f_magic
== U803XTOCMAGIC
;
2046 xcoff
->full_aouthdr
= TRUE
;
2047 xcoff
->toc
= internal_a
->o_toc
;
2048 xcoff
->sntoc
= internal_a
->o_sntoc
;
2049 xcoff
->snentry
= internal_a
->o_snentry
;
2050 bfd_xcoff_text_align_power (abfd
) = internal_a
->o_algntext
;
2051 bfd_xcoff_data_align_power (abfd
) = internal_a
->o_algndata
;
2052 xcoff
->modtype
= internal_a
->o_modtype
;
2053 xcoff
->cputype
= internal_a
->o_cputype
;
2054 xcoff
->maxdata
= internal_a
->o_maxdata
;
2055 xcoff
->maxstack
= internal_a
->o_maxstack
;
2060 /* Set the flags field from the COFF header read in. */
2061 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
2066 /* FIXME: I'm not sure this is ever executed, since peicode.h
2067 defines coff_mkobject_hook. */
2068 if ((internal_f
->f_flags
& IMAGE_FILE_DEBUG_STRIPPED
) == 0)
2069 abfd
->flags
|= HAS_DEBUG
;
2072 if ((internal_f
->f_flags
& F_GO32STUB
) != 0)
2073 coff
->go32stub
= (char *) bfd_alloc (abfd
, (bfd_size_type
) GO32_STUBSIZE
);
2074 if (coff
->go32stub
!= NULL
)
2075 memcpy (coff
->go32stub
, internal_f
->go32stub
, GO32_STUBSIZE
);
2081 /* Determine the machine architecture and type. FIXME: This is target
2082 dependent because the magic numbers are defined in the target
2083 dependent header files. But there is no particular need for this.
2084 If the magic numbers were moved to a separate file, this function
2085 would be target independent and would also be much more successful
2086 at linking together COFF files for different architectures. */
2089 coff_set_arch_mach_hook (bfd
*abfd
, void * filehdr
)
2091 unsigned long machine
;
2092 enum bfd_architecture arch
;
2093 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
2095 /* Zero selects the default machine for an arch. */
2097 switch (internal_f
->f_magic
)
2099 #ifdef OR32_MAGIC_BIG
2100 case OR32_MAGIC_BIG
:
2101 case OR32_MAGIC_LITTLE
:
2102 arch
= bfd_arch_or32
;
2107 arch
= bfd_arch_powerpc
;
2113 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler. */
2114 case LYNXCOFFMAGIC
: /* Shadows the m68k Lynx number below, sigh. */
2115 arch
= bfd_arch_i386
;
2120 arch
= bfd_arch_i386
;
2121 machine
= bfd_mach_x86_64
;
2126 arch
= bfd_arch_ia64
;
2133 arch
= bfd_arch_arm
;
2134 machine
= bfd_arm_get_mach_from_notes (abfd
, ARM_NOTE_SECTION
);
2135 if (machine
== bfd_mach_arm_unknown
)
2137 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
2139 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
2140 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
2141 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
2143 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
2144 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
2145 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
2146 /* The COFF header does not have enough bits available
2147 to cover all the different ARM architectures. So
2148 we interpret F_ARM_5, the highest flag value to mean
2149 "the highest ARM architecture known to BFD" which is
2150 currently the XScale. */
2151 case F_ARM_5
: machine
= bfd_mach_arm_XScale
; break;
2159 #ifdef MC68KBCSMAGIC
2162 #ifdef APOLLOM68KMAGIC
2163 case APOLLOM68KMAGIC
:
2165 #ifdef LYNXCOFFMAGIC
2168 arch
= bfd_arch_m68k
;
2169 machine
= bfd_mach_m68020
;
2176 arch
= bfd_arch_m88k
;
2182 arch
= bfd_arch_z80
;
2183 switch (internal_f
->f_flags
& F_MACHMASK
)
2186 case bfd_mach_z80strict
<< 12:
2187 case bfd_mach_z80
<< 12:
2188 case bfd_mach_z80full
<< 12:
2189 case bfd_mach_r800
<< 12:
2190 machine
= ((unsigned)internal_f
->f_flags
& F_MACHMASK
) >> 12;
2199 arch
= bfd_arch_z8k
;
2200 switch (internal_f
->f_flags
& F_MACHMASK
)
2203 machine
= bfd_mach_z8001
;
2206 machine
= bfd_mach_z8002
;
2215 arch
= bfd_arch_i860
;
2222 arch
= bfd_arch_i960
;
2223 switch (F_I960TYPE
& internal_f
->f_flags
)
2227 machine
= bfd_mach_i960_core
;
2230 machine
= bfd_mach_i960_kb_sb
;
2233 machine
= bfd_mach_i960_mc
;
2236 machine
= bfd_mach_i960_xa
;
2239 machine
= bfd_mach_i960_ca
;
2242 machine
= bfd_mach_i960_ka_sa
;
2245 machine
= bfd_mach_i960_jx
;
2248 machine
= bfd_mach_i960_hx
;
2267 if (xcoff_data (abfd
)->cputype
!= -1)
2268 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
2271 /* We did not get a value from the a.out header. If the
2272 file has not been stripped, we may be able to get the
2273 architecture information from the first symbol, if it
2274 is a .file symbol. */
2275 if (obj_raw_syment_count (abfd
) == 0)
2280 struct internal_syment sym
;
2281 bfd_size_type amt
= bfd_coff_symesz (abfd
);
2283 buf
= bfd_malloc (amt
);
2284 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
2285 || bfd_bread (buf
, amt
, abfd
) != amt
)
2290 bfd_coff_swap_sym_in (abfd
, buf
, & sym
);
2291 if (sym
.n_sclass
== C_FILE
)
2292 cputype
= sym
.n_type
& 0xff;
2299 /* FIXME: We don't handle all cases here. */
2304 arch
= bfd_xcoff_architecture (abfd
);
2305 machine
= bfd_xcoff_machine (abfd
);
2309 arch
= bfd_arch_powerpc
;
2310 machine
= bfd_mach_ppc_601
;
2312 case 2: /* 64 bit PowerPC */
2313 arch
= bfd_arch_powerpc
;
2314 machine
= bfd_mach_ppc_620
;
2317 arch
= bfd_arch_powerpc
;
2318 machine
= bfd_mach_ppc
;
2321 arch
= bfd_arch_rs6000
;
2322 machine
= bfd_mach_rs6k
;
2331 arch
= bfd_arch_we32k
;
2337 arch
= bfd_arch_h8300
;
2338 machine
= bfd_mach_h8300
;
2339 /* !! FIXME this probably isn't the right place for this. */
2340 abfd
->flags
|= BFD_IS_RELAXABLE
;
2346 arch
= bfd_arch_h8300
;
2347 machine
= bfd_mach_h8300h
;
2348 /* !! FIXME this probably isn't the right place for this. */
2349 abfd
->flags
|= BFD_IS_RELAXABLE
;
2355 arch
= bfd_arch_h8300
;
2356 machine
= bfd_mach_h8300s
;
2357 /* !! FIXME this probably isn't the right place for this. */
2358 abfd
->flags
|= BFD_IS_RELAXABLE
;
2364 arch
= bfd_arch_h8300
;
2365 machine
= bfd_mach_h8300hn
;
2366 /* !! FIXME this probably isn't the right place for this. */
2367 abfd
->flags
|= BFD_IS_RELAXABLE
;
2373 arch
= bfd_arch_h8300
;
2374 machine
= bfd_mach_h8300sn
;
2375 /* !! FIXME this probably isn't the right place for this. */
2376 abfd
->flags
|= BFD_IS_RELAXABLE
;
2380 #ifdef SH_ARCH_MAGIC_BIG
2381 case SH_ARCH_MAGIC_BIG
:
2382 case SH_ARCH_MAGIC_LITTLE
:
2384 case SH_ARCH_MAGIC_WINCE
:
2390 #ifdef MIPS_ARCH_MAGIC_WINCE
2391 case MIPS_ARCH_MAGIC_WINCE
:
2392 arch
= bfd_arch_mips
;
2398 arch
= bfd_arch_h8500
;
2404 #ifdef LYNXCOFFMAGIC
2407 arch
= bfd_arch_sparc
;
2413 arch
= bfd_arch_tic30
;
2418 #ifdef TICOFF_TARGET_ARCH
2419 /* This TI COFF section should be used by all new TI COFF v0 targets. */
2421 arch
= TICOFF_TARGET_ARCH
;
2422 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2428 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */
2429 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */
2432 switch (internal_f
->f_target_id
)
2436 arch
= TICOFF_TARGET_ARCH
;
2437 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2441 arch
= bfd_arch_obscure
;
2442 (*_bfd_error_handler
)
2443 (_("Unrecognized TI COFF target id '0x%x'"),
2444 internal_f
->f_target_id
);
2450 #ifdef TIC80_ARCH_MAGIC
2451 case TIC80_ARCH_MAGIC
:
2452 arch
= bfd_arch_tic80
;
2458 arch
= bfd_arch_mcore
;
2464 arch
= bfd_arch_w65
;
2468 default: /* Unreadable input file type. */
2469 arch
= bfd_arch_obscure
;
2473 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2477 #ifdef SYMNAME_IN_DEBUG
2480 symname_in_debug_hook (bfd
* abfd ATTRIBUTE_UNUSED
, struct internal_syment
*sym
)
2482 return SYMNAME_IN_DEBUG (sym
) != 0;
2487 #define symname_in_debug_hook \
2488 (bfd_boolean (*) (bfd *, struct internal_syment *)) bfd_false
2495 #define FORCE_SYMNAMES_IN_STRINGS
2498 /* Handle the csect auxent of a C_EXT, C_AIX_WEAKEXT or C_HIDEXT symbol. */
2501 coff_pointerize_aux_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2502 combined_entry_type
*table_base
,
2503 combined_entry_type
*symbol
,
2504 unsigned int indaux
,
2505 combined_entry_type
*aux
)
2507 int n_sclass
= symbol
->u
.syment
.n_sclass
;
2509 if (CSECT_SYM_P (n_sclass
)
2510 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2512 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2514 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2515 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2516 aux
->fix_scnlen
= 1;
2519 /* Return TRUE to indicate that the caller should not do any
2520 further work on this auxent. */
2524 /* Return FALSE to indicate that this auxent should be handled by
2532 /* We don't want to pointerize bal entries. */
2535 coff_pointerize_aux_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2536 combined_entry_type
*table_base ATTRIBUTE_UNUSED
,
2537 combined_entry_type
*symbol
,
2538 unsigned int indaux
,
2539 combined_entry_type
*aux ATTRIBUTE_UNUSED
)
2541 /* Return TRUE if we don't want to pointerize this aux entry, which
2542 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2544 && (symbol
->u
.syment
.n_sclass
== C_LEAFPROC
2545 || symbol
->u
.syment
.n_sclass
== C_LEAFSTAT
2546 || symbol
->u
.syment
.n_sclass
== C_LEAFEXT
));
2551 #define coff_pointerize_aux_hook 0
2554 #endif /* ! RS6000COFF_C */
2556 /* Print an aux entry. This returns TRUE if it has printed it. */
2559 coff_print_aux (bfd
*abfd ATTRIBUTE_UNUSED
,
2560 FILE *file ATTRIBUTE_UNUSED
,
2561 combined_entry_type
*table_base ATTRIBUTE_UNUSED
,
2562 combined_entry_type
*symbol ATTRIBUTE_UNUSED
,
2563 combined_entry_type
*aux ATTRIBUTE_UNUSED
,
2564 unsigned int indaux ATTRIBUTE_UNUSED
)
2567 if (CSECT_SYM_P (symbol
->u
.syment
.n_sclass
)
2568 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2570 /* This is a csect entry. */
2571 fprintf (file
, "AUX ");
2572 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2574 BFD_ASSERT (! aux
->fix_scnlen
);
2576 fprintf (file
, "val %5lld",
2577 (long long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2579 fprintf (file
, "val %5ld", (long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2584 fprintf (file
, "indx ");
2585 if (! aux
->fix_scnlen
)
2587 fprintf (file
, "%4lld",
2588 (long long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2590 fprintf (file
, "%4ld", (long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2593 fprintf (file
, "%4ld",
2594 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2597 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2598 aux
->u
.auxent
.x_csect
.x_parmhash
,
2599 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2600 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2601 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2602 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2603 aux
->u
.auxent
.x_csect
.x_stab
,
2604 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2609 /* Return FALSE to indicate that no special action was taken. */
2617 To write relocations, the back end steps though the
2618 canonical relocation table and create an
2619 @code{internal_reloc}. The symbol index to use is removed from
2620 the @code{offset} field in the symbol table supplied. The
2621 address comes directly from the sum of the section base
2622 address and the relocation offset; the type is dug directly
2623 from the howto field. Then the @code{internal_reloc} is
2624 swapped into the shape of an @code{external_reloc} and written
2632 /* AUX's ld wants relocations to be sorted. */
2634 compare_arelent_ptr (const void * x
, const void * y
)
2636 const arelent
**a
= (const arelent
**) x
;
2637 const arelent
**b
= (const arelent
**) y
;
2638 bfd_size_type aadr
= (*a
)->address
;
2639 bfd_size_type badr
= (*b
)->address
;
2641 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2644 #endif /* TARG_AUX */
2647 coff_write_relocs (bfd
* abfd
, int first_undef
)
2651 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2654 struct external_reloc dst
;
2661 /* Sort relocations before we write them out. */
2664 amt
= s
->reloc_count
;
2665 amt
*= sizeof (arelent
*);
2666 p
= bfd_malloc (amt
);
2667 if (p
== NULL
&& s
->reloc_count
> 0)
2669 memcpy (p
, s
->orelocation
, (size_t) amt
);
2670 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2674 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2678 if (obj_pe (abfd
) && s
->reloc_count
>= 0xffff)
2680 /* Encode real count here as first reloc. */
2681 struct internal_reloc n
;
2683 memset (& n
, 0, sizeof (n
));
2684 /* Add one to count *this* reloc (grr). */
2685 n
.r_vaddr
= s
->reloc_count
+ 1;
2686 coff_swap_reloc_out (abfd
, &n
, &dst
);
2687 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2688 abfd
) != bfd_coff_relsz (abfd
))
2693 for (i
= 0; i
< s
->reloc_count
; i
++)
2695 struct internal_reloc n
;
2698 memset (& n
, 0, sizeof (n
));
2700 /* Now we've renumbered the symbols we know where the
2701 undefined symbols live in the table. Check the reloc
2702 entries for symbols who's output bfd isn't the right one.
2703 This is because the symbol was undefined (which means
2704 that all the pointers are never made to point to the same
2705 place). This is a bad thing,'cause the symbols attached
2706 to the output bfd are indexed, so that the relocation
2707 entries know which symbol index they point to. So we
2708 have to look up the output symbol here. */
2710 if (q
->sym_ptr_ptr
[0] != NULL
&& q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2713 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2714 asymbol
**outsyms
= abfd
->outsymbols
;
2716 for (j
= first_undef
; outsyms
[j
]; j
++)
2718 const char *intable
= outsyms
[j
]->name
;
2720 if (strcmp (intable
, sname
) == 0)
2722 /* Got a hit, so repoint the reloc. */
2723 q
->sym_ptr_ptr
= outsyms
+ j
;
2729 n
.r_vaddr
= q
->address
+ s
->vma
;
2732 /* The 29k const/consth reloc pair is a real kludge. The consth
2733 part doesn't have a symbol; it has an offset. So rebuilt
2735 if (q
->howto
->type
== R_IHCONST
)
2736 n
.r_symndx
= q
->addend
;
2739 if (q
->sym_ptr_ptr
&& q
->sym_ptr_ptr
[0] != NULL
)
2741 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2742 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
, s
))
2744 if ((*q
->sym_ptr_ptr
)->section
== bfd_abs_section_ptr
2745 && ((*q
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) != 0)
2747 /* This is a relocation relative to the absolute symbol. */
2751 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2752 /* Check to see if the symbol reloc points to a symbol
2753 we don't have in our symbol table. */
2754 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2756 bfd_set_error (bfd_error_bad_value
);
2757 _bfd_error_handler (_("%B: reloc against a non-existant symbol index: %ld"),
2764 #ifdef SWAP_OUT_RELOC_OFFSET
2765 n
.r_offset
= q
->addend
;
2769 /* Work out reloc type from what is required. */
2770 SELECT_RELOC (n
, q
->howto
);
2772 n
.r_type
= q
->howto
->type
;
2774 coff_swap_reloc_out (abfd
, &n
, &dst
);
2776 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2777 abfd
) != bfd_coff_relsz (abfd
))
2790 /* Set flags and magic number of a coff file from architecture and machine
2791 type. Result is TRUE if we can represent the arch&type, FALSE if not. */
2794 coff_set_flags (bfd
* abfd
,
2795 unsigned int *magicp ATTRIBUTE_UNUSED
,
2796 unsigned short *flagsp ATTRIBUTE_UNUSED
)
2798 switch (bfd_get_arch (abfd
))
2803 switch (bfd_get_mach (abfd
))
2806 case bfd_mach_z80strict
:
2808 case bfd_mach_z80full
:
2810 *flagsp
= bfd_get_mach (abfd
) << 12;
2822 switch (bfd_get_mach (abfd
))
2824 case bfd_mach_z8001
: *flagsp
= F_Z8001
; break;
2825 case bfd_mach_z8002
: *flagsp
= F_Z8002
; break;
2826 default: return FALSE
;
2837 *magicp
= I960ROMAGIC
;
2839 switch (bfd_get_mach (abfd
))
2841 case bfd_mach_i960_core
: flags
= F_I960CORE
; break;
2842 case bfd_mach_i960_kb_sb
: flags
= F_I960KB
; break;
2843 case bfd_mach_i960_mc
: flags
= F_I960MC
; break;
2844 case bfd_mach_i960_xa
: flags
= F_I960XA
; break;
2845 case bfd_mach_i960_ca
: flags
= F_I960CA
; break;
2846 case bfd_mach_i960_ka_sa
: flags
= F_I960KA
; break;
2847 case bfd_mach_i960_jx
: flags
= F_I960JX
; break;
2848 case bfd_mach_i960_hx
: flags
= F_I960HX
; break;
2849 default: return FALSE
;
2858 case bfd_arch_tic30
:
2859 *magicp
= TIC30MAGIC
;
2863 #ifdef TICOFF_DEFAULT_MAGIC
2864 case TICOFF_TARGET_ARCH
:
2865 /* If there's no indication of which version we want, use the default. */
2867 *magicp
= TICOFF_DEFAULT_MAGIC
;
2870 /* We may want to output in a different COFF version. */
2871 switch (abfd
->xvec
->name
[4])
2874 *magicp
= TICOFF0MAGIC
;
2877 *magicp
= TICOFF1MAGIC
;
2880 *magicp
= TICOFF2MAGIC
;
2886 TICOFF_TARGET_MACHINE_SET (flagsp
, bfd_get_mach (abfd
));
2890 #ifdef TIC80_ARCH_MAGIC
2891 case bfd_arch_tic80
:
2892 *magicp
= TIC80_ARCH_MAGIC
;
2899 * magicp
= ARMPEMAGIC
;
2901 * magicp
= ARMMAGIC
;
2904 if (APCS_SET (abfd
))
2906 if (APCS_26_FLAG (abfd
))
2907 * flagsp
|= F_APCS26
;
2909 if (APCS_FLOAT_FLAG (abfd
))
2910 * flagsp
|= F_APCS_FLOAT
;
2912 if (PIC_FLAG (abfd
))
2915 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2916 * flagsp
|= F_INTERWORK
;
2917 switch (bfd_get_mach (abfd
))
2919 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2920 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2921 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2922 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2923 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2924 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2925 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2926 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2927 See also the comment in coff_set_arch_mach_hook(). */
2928 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break;
2929 case bfd_mach_arm_5TE
: * flagsp
|= F_ARM_5
; break;
2930 case bfd_mach_arm_XScale
: * flagsp
|= F_ARM_5
; break;
2936 case bfd_arch_powerpc
:
2941 #if defined(I386MAGIC) || defined(AMD64MAGIC)
2943 #if defined(I386MAGIC)
2944 *magicp
= I386MAGIC
;
2947 /* Just overwrite the usual value if we're doing Lynx. */
2948 *magicp
= LYNXCOFFMAGIC
;
2950 #if defined AMD64MAGIC
2951 *magicp
= AMD64MAGIC
;
2958 *magicp
= I860MAGIC
;
2964 *magicp
= IA64MAGIC
;
2970 #ifdef APOLLOM68KMAGIC
2971 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
2973 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2974 #ifdef NAMES_HAVE_UNDERSCORE
2975 *magicp
= MC68KBCSMAGIC
;
2977 *magicp
= MC68MAGIC
;
2981 /* Just overwrite the usual value if we're doing Lynx. */
2982 *magicp
= LYNXCOFFMAGIC
;
2989 *magicp
= MC88OMAGIC
;
2994 case bfd_arch_h8300
:
2995 switch (bfd_get_mach (abfd
))
2997 case bfd_mach_h8300
: *magicp
= H8300MAGIC
; return TRUE
;
2998 case bfd_mach_h8300h
: *magicp
= H8300HMAGIC
; return TRUE
;
2999 case bfd_mach_h8300s
: *magicp
= H8300SMAGIC
; return TRUE
;
3000 case bfd_mach_h8300hn
: *magicp
= H8300HNMAGIC
; return TRUE
;
3001 case bfd_mach_h8300sn
: *magicp
= H8300SNMAGIC
; return TRUE
;
3007 #ifdef SH_ARCH_MAGIC_BIG
3009 #ifdef COFF_IMAGE_WITH_PE
3010 *magicp
= SH_ARCH_MAGIC_WINCE
;
3012 if (bfd_big_endian (abfd
))
3013 *magicp
= SH_ARCH_MAGIC_BIG
;
3015 *magicp
= SH_ARCH_MAGIC_LITTLE
;
3020 #ifdef MIPS_ARCH_MAGIC_WINCE
3022 *magicp
= MIPS_ARCH_MAGIC_WINCE
;
3027 case bfd_arch_sparc
:
3028 *magicp
= SPARCMAGIC
;
3030 /* Just overwrite the usual value if we're doing Lynx. */
3031 *magicp
= LYNXCOFFMAGIC
;
3037 case bfd_arch_h8500
:
3038 *magicp
= H8500MAGIC
;
3044 case bfd_arch_we32k
:
3045 *magicp
= WE32KMAGIC
;
3050 case bfd_arch_rs6000
:
3052 case bfd_arch_powerpc
:
3054 BFD_ASSERT (bfd_get_flavour (abfd
) == bfd_target_xcoff_flavour
);
3055 *magicp
= bfd_xcoff_magic_number (abfd
);
3060 case bfd_arch_mcore
:
3061 * magicp
= MCOREMAGIC
;
3071 #ifdef OR32_MAGIC_BIG
3073 if (bfd_big_endian (abfd
))
3074 * magicp
= OR32_MAGIC_BIG
;
3076 * magicp
= OR32_MAGIC_LITTLE
;
3080 default: /* Unknown architecture. */
3081 /* Fall through to "return FALSE" below, to avoid
3082 "statement never reached" errors on the one below. */
3090 coff_set_arch_mach (bfd
* abfd
,
3091 enum bfd_architecture arch
,
3092 unsigned long machine
)
3095 unsigned short dummy2
;
3097 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
3100 if (arch
!= bfd_arch_unknown
3101 && ! coff_set_flags (abfd
, &dummy1
, &dummy2
))
3102 return FALSE
; /* We can't represent this type. */
3104 return TRUE
; /* We're easy... */
3107 #ifdef COFF_IMAGE_WITH_PE
3109 /* This is used to sort sections by VMA, as required by PE image
3113 sort_by_secaddr (const void * arg1
, const void * arg2
)
3115 const asection
*a
= *(const asection
**) arg1
;
3116 const asection
*b
= *(const asection
**) arg2
;
3118 if (a
->vma
< b
->vma
)
3120 else if (a
->vma
> b
->vma
)
3126 #endif /* COFF_IMAGE_WITH_PE */
3128 /* Calculate the file position for each section. */
3131 #define ALIGN_SECTIONS_IN_FILE
3133 #if defined(TIC80COFF) || defined(TICOFF)
3134 #undef ALIGN_SECTIONS_IN_FILE
3138 coff_compute_section_file_positions (bfd
* abfd
)
3141 file_ptr sofar
= bfd_coff_filhsz (abfd
);
3142 bfd_boolean align_adjust
;
3143 unsigned int target_index
;
3144 #ifdef ALIGN_SECTIONS_IN_FILE
3145 asection
*previous
= NULL
;
3149 #ifdef COFF_IMAGE_WITH_PE
3152 if (coff_data (abfd
)->link_info
)
3154 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
3156 /* If no file alignment has been set, default to one.
3157 This repairs 'ld -r' for arm-wince-pe target. */
3162 page_size
= PE_DEF_FILE_ALIGNMENT
;
3164 #ifdef COFF_PAGE_SIZE
3165 int page_size
= COFF_PAGE_SIZE
;
3170 /* On XCOFF, if we have symbols, set up the .debug section. */
3171 if (bfd_get_symcount (abfd
) > 0)
3174 bfd_size_type i
, symcount
;
3178 symcount
= bfd_get_symcount (abfd
);
3179 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
3181 coff_symbol_type
*cf
;
3183 cf
= coff_symbol_from (abfd
, *symp
);
3185 && cf
->native
!= NULL
3186 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
3190 len
= strlen (bfd_asymbol_name (*symp
));
3191 if (len
> SYMNMLEN
|| bfd_coff_force_symnames_in_strings (abfd
))
3192 sz
+= len
+ 1 + bfd_coff_debug_string_prefix_length (abfd
);
3199 dsec
= bfd_make_section_old_way (abfd
, DOT_DEBUG
);
3203 dsec
->flags
|= SEC_HAS_CONTENTS
;
3208 if (bfd_get_start_address (abfd
))
3209 /* A start address may have been added to the original file. In this
3210 case it will need an optional header to record it. */
3211 abfd
->flags
|= EXEC_P
;
3213 if (abfd
->flags
& EXEC_P
)
3214 sofar
+= bfd_coff_aoutsz (abfd
);
3216 else if (xcoff_data (abfd
)->full_aouthdr
)
3217 sofar
+= bfd_coff_aoutsz (abfd
);
3219 sofar
+= SMALL_AOUTSZ
;
3222 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
3225 /* XCOFF handles overflows in the reloc and line number count fields
3226 by allocating a new section header to hold the correct counts. */
3227 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3228 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3229 sofar
+= bfd_coff_scnhsz (abfd
);
3232 #ifdef COFF_IMAGE_WITH_PE
3234 /* PE requires the sections to be in memory order when listed in
3235 the section headers. It also does not like empty loadable
3236 sections. The sections apparently do not have to be in the
3237 right order in the image file itself, but we do need to get the
3238 target_index values right. */
3241 asection
**section_list
;
3245 #ifdef COFF_PAGE_SIZE
3246 /* Clear D_PAGED if section alignment is smaller than
3248 if (pe_data (abfd
)->pe_opthdr
.SectionAlignment
< COFF_PAGE_SIZE
)
3249 abfd
->flags
&= ~D_PAGED
;
3253 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3256 /* We allocate an extra cell to simplify the final loop. */
3257 amt
= sizeof (struct asection
*) * (count
+ 1);
3258 section_list
= (asection
**) bfd_malloc (amt
);
3259 if (section_list
== NULL
)
3263 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3265 section_list
[i
] = current
;
3268 section_list
[i
] = NULL
;
3270 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
3272 /* Rethread the linked list into sorted order; at the same time,
3273 assign target_index values. */
3275 abfd
->sections
= NULL
;
3276 abfd
->section_last
= NULL
;
3277 for (i
= 0; i
< count
; i
++)
3279 current
= section_list
[i
];
3280 bfd_section_list_append (abfd
, current
);
3282 /* Later, if the section has zero size, we'll be throwing it
3283 away, so we don't want to number it now. Note that having
3284 a zero size and having real contents are different
3285 concepts: .bss has no contents, but (usually) non-zero
3287 if (current
->size
== 0)
3289 /* Discard. However, it still might have (valid) symbols
3290 in it, so arbitrarily set it to section 1 (indexing is
3291 1-based here; usually .text). __end__ and other
3292 contents of .endsection really have this happen.
3293 FIXME: This seems somewhat dubious. */
3294 current
->target_index
= 1;
3297 current
->target_index
= target_index
++;
3300 free (section_list
);
3302 #else /* ! COFF_IMAGE_WITH_PE */
3304 /* Set the target_index field. */
3306 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3307 current
->target_index
= target_index
++;
3309 #endif /* ! COFF_IMAGE_WITH_PE */
3311 if (target_index
>= bfd_coff_max_nscns (abfd
))
3313 bfd_set_error (bfd_error_file_too_big
);
3314 (*_bfd_error_handler
)
3315 (_("%B: too many sections (%d)"), abfd
, target_index
);
3319 align_adjust
= FALSE
;
3320 for (current
= abfd
->sections
;
3322 current
= current
->next
)
3324 #ifdef COFF_IMAGE_WITH_PE
3325 /* With PE we have to pad each section to be a multiple of its
3326 page size too, and remember both sizes. */
3327 if (coff_section_data (abfd
, current
) == NULL
)
3329 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
3331 current
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
3332 if (current
->used_by_bfd
== NULL
)
3335 if (pei_section_data (abfd
, current
) == NULL
)
3337 bfd_size_type amt
= sizeof (struct pei_section_tdata
);
3339 coff_section_data (abfd
, current
)->tdata
= bfd_zalloc (abfd
, amt
);
3340 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
3343 if (pei_section_data (abfd
, current
)->virt_size
== 0)
3344 pei_section_data (abfd
, current
)->virt_size
= current
->size
;
3347 /* Only deal with sections which have contents. */
3348 if (!(current
->flags
& SEC_HAS_CONTENTS
))
3351 current
->rawsize
= current
->size
;
3353 #ifdef COFF_IMAGE_WITH_PE
3354 /* Make sure we skip empty sections in a PE image. */
3355 if (current
->size
== 0)
3359 /* Align the sections in the file to the same boundary on
3360 which they are aligned in virtual memory. I960 doesn't
3361 do this (FIXME) so we can stay in sync with Intel. 960
3362 doesn't yet page from files... */
3363 #ifdef ALIGN_SECTIONS_IN_FILE
3364 if ((abfd
->flags
& EXEC_P
) != 0)
3366 /* Make sure this section is aligned on the right boundary - by
3367 padding the previous section up if necessary. */
3370 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3373 /* Make sure the file offset and the vma of .text/.data are at the
3374 same page offset, so that the file can be mmap'ed without being
3375 relocated. Failing that, AIX is able to load and execute the
3376 program, but it will be silently relocated (possible as
3377 executables are PIE). But the relocation is slightly costly and
3378 complexify the use of addr2line or gdb. So better to avoid it,
3379 like does the native linker. Usually gnu ld makes sure that
3380 the vma of .text is the file offset so this issue shouldn't
3381 appear unless you are stripping such an executable.
3383 AIX loader checks the text section alignment of (vma - filepos),
3384 and the native linker doesn't try to align the text sections.
3387 0 .text 000054cc 10000128 10000128 00000128 2**5
3388 CONTENTS, ALLOC, LOAD, CODE
3391 if (!strcmp (current
->name
, _TEXT
)
3392 || !strcmp (current
->name
, _DATA
))
3394 bfd_vma align
= 4096;
3395 bfd_vma sofar_off
= sofar
% align
;
3396 bfd_vma vma_off
= current
->vma
% align
;
3398 if (vma_off
> sofar_off
)
3399 sofar
+= vma_off
- sofar_off
;
3400 else if (vma_off
< sofar_off
)
3401 sofar
+= align
+ vma_off
- sofar_off
;
3404 if (previous
!= NULL
)
3405 previous
->size
+= sofar
- old_sofar
;
3410 /* In demand paged files the low order bits of the file offset
3411 must match the low order bits of the virtual address. */
3412 #ifdef COFF_PAGE_SIZE
3413 if ((abfd
->flags
& D_PAGED
) != 0
3414 && (current
->flags
& SEC_ALLOC
) != 0)
3415 sofar
+= (current
->vma
- (bfd_vma
) sofar
) % page_size
;
3417 current
->filepos
= sofar
;
3419 #ifdef COFF_IMAGE_WITH_PE
3420 /* Set the padded size. */
3421 current
->size
= (current
->size
+ page_size
- 1) & -page_size
;
3424 sofar
+= current
->size
;
3426 #ifdef ALIGN_SECTIONS_IN_FILE
3427 /* Make sure that this section is of the right size too. */
3428 if ((abfd
->flags
& EXEC_P
) == 0)
3430 bfd_size_type old_size
;
3432 old_size
= current
->size
;
3433 current
->size
= BFD_ALIGN (current
->size
,
3434 1 << current
->alignment_power
);
3435 align_adjust
= current
->size
!= old_size
;
3436 sofar
+= current
->size
- old_size
;
3441 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3442 align_adjust
= sofar
!= old_sofar
;
3443 current
->size
+= sofar
- old_sofar
;
3447 #ifdef COFF_IMAGE_WITH_PE
3448 /* For PE we need to make sure we pad out to the aligned
3449 size, in case the caller only writes out data to the
3451 if (pei_section_data (abfd
, current
)->virt_size
< current
->size
)
3452 align_adjust
= TRUE
;
3456 /* Force .lib sections to start at zero. The vma is then
3457 incremented in coff_set_section_contents. This is right for
3459 if (strcmp (current
->name
, _LIB
) == 0)
3460 (void) bfd_set_section_vma (abfd
, current
, 0);
3463 #ifdef ALIGN_SECTIONS_IN_FILE
3468 /* It is now safe to write to the output file. If we needed an
3469 alignment adjustment for the last section, then make sure that
3470 there is a byte at offset sofar. If there are no symbols and no
3471 relocs, then nothing follows the last section. If we don't force
3472 the last byte out, then the file may appear to be truncated. */
3478 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
3479 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3483 /* Make sure the relocations are aligned. We don't need to make
3484 sure that this byte exists, because it will only matter if there
3485 really are relocs. */
3486 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
3488 obj_relocbase (abfd
) = sofar
;
3489 abfd
->output_has_begun
= TRUE
;
3494 #ifdef COFF_IMAGE_WITH_PE
3496 static unsigned int pelength
;
3497 static unsigned int peheader
;
3500 coff_read_word (bfd
*abfd
, unsigned int *value
)
3505 status
= bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3513 *value
= (unsigned int) b
[0];
3515 *value
= (unsigned int) (b
[0] + (b
[1] << 8));
3517 pelength
+= (unsigned int) status
;
3523 coff_compute_checksum (bfd
*abfd
)
3525 bfd_boolean more_data
;
3532 filepos
= (file_ptr
) 0;
3536 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
3539 more_data
= coff_read_word (abfd
, &value
);
3541 total
= 0xffff & (total
+ (total
>> 0x10));
3546 return (0xffff & (total
+ (total
>> 0x10)));
3550 coff_apply_checksum (bfd
*abfd
)
3552 unsigned int computed
;
3553 unsigned int checksum
= 0;
3555 if (bfd_seek (abfd
, 0x3c, SEEK_SET
) != 0)
3558 if (!coff_read_word (abfd
, &peheader
))
3561 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3565 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3567 if (bfd_seek (abfd
, peheader
, SEEK_SET
) != 0)
3570 computed
= coff_compute_checksum (abfd
);
3572 checksum
= computed
+ pelength
;
3574 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3577 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3582 #endif /* COFF_IMAGE_WITH_PE */
3585 coff_write_object_contents (bfd
* abfd
)
3588 bfd_boolean hasrelocs
= FALSE
;
3589 bfd_boolean haslinno
= FALSE
;
3590 #ifdef COFF_IMAGE_WITH_PE
3591 bfd_boolean hasdebug
= FALSE
;
3594 file_ptr reloc_base
;
3595 file_ptr lineno_base
;
3597 unsigned long reloc_size
= 0, reloc_count
= 0;
3598 unsigned long lnno_size
= 0;
3599 bfd_boolean long_section_names
;
3600 asection
*text_sec
= NULL
;
3601 asection
*data_sec
= NULL
;
3602 asection
*bss_sec
= NULL
;
3603 struct internal_filehdr internal_f
;
3604 struct internal_aouthdr internal_a
;
3605 #ifdef COFF_LONG_SECTION_NAMES
3606 size_t string_size
= STRING_SIZE_SIZE
;
3609 bfd_set_error (bfd_error_system_call
);
3611 /* Make a pass through the symbol table to count line number entries and
3612 put them into the correct asections. */
3613 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3615 if (! abfd
->output_has_begun
)
3617 if (! coff_compute_section_file_positions (abfd
))
3621 reloc_base
= obj_relocbase (abfd
);
3623 /* Work out the size of the reloc and linno areas. */
3625 for (current
= abfd
->sections
; current
!= NULL
; current
=
3629 /* We store the actual reloc count in the first reloc's addr. */
3630 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3633 reloc_count
+= current
->reloc_count
;
3636 reloc_size
= reloc_count
* bfd_coff_relsz (abfd
);
3638 lineno_base
= reloc_base
+ reloc_size
;
3639 sym_base
= lineno_base
+ lnno_size
;
3641 /* Indicate in each section->line_filepos its actual file address. */
3642 for (current
= abfd
->sections
; current
!= NULL
; current
=
3645 if (current
->lineno_count
)
3647 current
->line_filepos
= lineno_base
;
3648 current
->moving_line_filepos
= lineno_base
;
3649 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3652 current
->line_filepos
= 0;
3654 if (current
->reloc_count
)
3656 current
->rel_filepos
= reloc_base
;
3657 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3659 /* Extra reloc to hold real count. */
3660 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3661 reloc_base
+= bfd_coff_relsz (abfd
);
3665 current
->rel_filepos
= 0;
3668 /* Write section headers to the file. */
3669 internal_f
.f_nscns
= 0;
3671 if ((abfd
->flags
& EXEC_P
) != 0)
3672 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3675 scn_base
= bfd_coff_filhsz (abfd
);
3678 if (xcoff_data (abfd
)->full_aouthdr
)
3679 scn_base
+= bfd_coff_aoutsz (abfd
);
3681 scn_base
+= SMALL_AOUTSZ
;
3686 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3689 long_section_names
= FALSE
;
3690 for (current
= abfd
->sections
;
3692 current
= current
->next
)
3694 struct internal_scnhdr section
;
3695 #ifdef COFF_IMAGE_WITH_PE
3696 bfd_boolean is_reloc_section
= FALSE
;
3698 if (strcmp (current
->name
, DOT_RELOC
) == 0)
3700 is_reloc_section
= TRUE
;
3702 pe_data (abfd
)->has_reloc_section
= 1;
3706 internal_f
.f_nscns
++;
3708 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3710 #ifdef COFF_LONG_SECTION_NAMES
3711 /* Handle long section names as in PE. This must be compatible
3712 with the code in coff_write_symbols and _bfd_coff_final_link. */
3713 if (bfd_coff_long_section_names (abfd
))
3717 len
= strlen (current
->name
);
3720 /* The s_name field is defined to be NUL-padded but need not be
3721 NUL-terminated. We use a temporary buffer so that we can still
3722 sprintf all eight chars without splatting a terminating NUL
3723 over the first byte of the following member (s_paddr). */
3724 char s_name_buf
[SCNNMLEN
+ 1];
3726 /* An inherent limitation of the /nnnnnnn notation used to indicate
3727 the offset of the long name in the string table is that we
3728 cannot address entries beyone the ten million byte boundary. */
3729 if (string_size
>= 10000000)
3731 bfd_set_error (bfd_error_file_too_big
);
3732 (*_bfd_error_handler
)
3733 (_("%B: section %s: string table overflow at offset %ld"),
3734 abfd
, current
->name
, string_size
);
3738 /* snprintf not strictly necessary now we've verified the value
3739 has less than eight ASCII digits, but never mind. */
3740 snprintf (s_name_buf
, SCNNMLEN
+ 1, "/%lu", (unsigned long) string_size
);
3741 /* Then strncpy takes care of any padding for us. */
3742 strncpy (section
.s_name
, s_name_buf
, SCNNMLEN
);
3743 string_size
+= len
+ 1;
3744 long_section_names
= TRUE
;
3750 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3751 Ian Taylor <ian@cygnus.com>. */
3752 if (strcmp (current
->name
, _LIB
) == 0)
3753 section
.s_vaddr
= 0;
3756 section
.s_vaddr
= current
->vma
;
3757 section
.s_paddr
= current
->lma
;
3758 section
.s_size
= current
->size
;
3759 #ifdef coff_get_section_load_page
3760 section
.s_page
= coff_get_section_load_page (current
);
3766 section
.s_paddr
= 0;
3768 #ifdef COFF_IMAGE_WITH_PE
3769 /* Reminder: s_paddr holds the virtual size of the section. */
3770 if (coff_section_data (abfd
, current
) != NULL
3771 && pei_section_data (abfd
, current
) != NULL
)
3772 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3774 section
.s_paddr
= 0;
3777 /* If this section has no size or is unloadable then the scnptr
3779 if (current
->size
== 0
3780 || (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3781 section
.s_scnptr
= 0;
3783 section
.s_scnptr
= current
->filepos
;
3785 section
.s_relptr
= current
->rel_filepos
;
3786 section
.s_lnnoptr
= current
->line_filepos
;
3787 section
.s_nreloc
= current
->reloc_count
;
3788 section
.s_nlnno
= current
->lineno_count
;
3789 #ifndef COFF_IMAGE_WITH_PE
3790 /* In PEI, relocs come in the .reloc section. */
3791 if (current
->reloc_count
!= 0)
3794 if (current
->lineno_count
!= 0)
3796 #ifdef COFF_IMAGE_WITH_PE
3797 if ((current
->flags
& SEC_DEBUGGING
) != 0
3798 && ! is_reloc_section
)
3804 /* Indicate the use of an XCOFF overflow section header. */
3805 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3807 section
.s_nreloc
= 0xffff;
3808 section
.s_nlnno
= 0xffff;
3813 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3815 if (!strcmp (current
->name
, _TEXT
))
3817 else if (!strcmp (current
->name
, _DATA
))
3819 else if (!strcmp (current
->name
, _BSS
))
3823 section
.s_align
= (current
->alignment_power
3824 ? 1 << current
->alignment_power
3828 /* TI COFF puts the alignment power in bits 8-11 of the flags. */
3829 section
.s_flags
|= (current
->alignment_power
& 0xF) << 8;
3831 #ifdef COFF_ENCODE_ALIGNMENT
3832 COFF_ENCODE_ALIGNMENT(section
, current
->alignment_power
);
3835 #ifdef COFF_IMAGE_WITH_PE
3836 /* Suppress output of the sections if they are null. ld
3837 includes the bss and data sections even if there is no size
3838 assigned to them. NT loader doesn't like it if these section
3839 headers are included if the sections themselves are not
3840 needed. See also coff_compute_section_file_positions. */
3841 if (section
.s_size
== 0)
3842 internal_f
.f_nscns
--;
3847 bfd_size_type amt
= bfd_coff_scnhsz (abfd
);
3849 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3850 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3855 /* PE stores COMDAT section information in the symbol table. If
3856 this section is supposed to have some COMDAT info, track down
3857 the symbol in the symbol table and modify it. */
3858 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3860 unsigned int i
, count
;
3862 coff_symbol_type
*csym
= NULL
;
3866 count
= bfd_get_symcount (abfd
);
3867 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3869 if ((*psym
)->section
!= current
)
3872 /* Remember the location of the first symbol in this
3874 if (psymsec
== NULL
)
3877 /* See if this is the section symbol. */
3878 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3880 csym
= coff_symbol_from (abfd
, *psym
);
3882 || csym
->native
== NULL
3883 || csym
->native
->u
.syment
.n_numaux
< 1
3884 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3885 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3888 /* Here *PSYM is the section symbol for CURRENT. */
3895 Note that we might not if we're converting the file from
3896 some other object file format. */
3899 combined_entry_type
*aux
;
3901 /* We don't touch the x_checksum field. The
3902 x_associated field is not currently supported. */
3904 aux
= csym
->native
+ 1;
3905 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3907 case SEC_LINK_DUPLICATES_DISCARD
:
3908 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3911 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3912 aux
->u
.auxent
.x_scn
.x_comdat
=
3913 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3916 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3917 aux
->u
.auxent
.x_scn
.x_comdat
=
3918 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3921 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3922 aux
->u
.auxent
.x_scn
.x_comdat
=
3923 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3927 /* The COMDAT symbol must be the first symbol from this
3928 section in the symbol table. In order to make this
3929 work, we move the COMDAT symbol before the first
3930 symbol we found in the search above. It's OK to
3931 rearrange the symbol table at this point, because
3932 coff_renumber_symbols is going to rearrange it
3933 further and fix up all the aux entries. */
3934 if (psym
!= psymsec
)
3940 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3941 pcopy
[0] = pcopy
[-1];
3946 #endif /* COFF_WITH_PE */
3951 /* XCOFF handles overflows in the reloc and line number count fields
3952 by creating a new section header to hold the correct values. */
3953 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3955 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3957 struct internal_scnhdr scnhdr
;
3961 internal_f
.f_nscns
++;
3962 memcpy (scnhdr
.s_name
, ".ovrflo", 8);
3963 scnhdr
.s_paddr
= current
->reloc_count
;
3964 scnhdr
.s_vaddr
= current
->lineno_count
;
3966 scnhdr
.s_scnptr
= 0;
3967 scnhdr
.s_relptr
= current
->rel_filepos
;
3968 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3969 scnhdr
.s_nreloc
= current
->target_index
;
3970 scnhdr
.s_nlnno
= current
->target_index
;
3971 scnhdr
.s_flags
= STYP_OVRFLO
;
3972 amt
= bfd_coff_scnhsz (abfd
);
3973 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3974 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3981 /* OK, now set up the filehdr... */
3983 /* Don't include the internal abs section in the section count */
3985 /* We will NOT put a fucking timestamp in the header here. Every time you
3986 put it back, I will come in and take it out again. I'm sorry. This
3987 field does not belong here. We fill it with a 0 so it compares the
3988 same but is not a reasonable time. -- gnu@cygnus.com */
3989 internal_f
.f_timdat
= 0;
3990 internal_f
.f_flags
= 0;
3992 if (abfd
->flags
& EXEC_P
)
3993 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3996 internal_f
.f_opthdr
= 0;
3999 if (xcoff_data (abfd
)->full_aouthdr
)
4000 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
4002 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
4008 internal_f
.f_flags
|= F_RELFLG
;
4010 internal_f
.f_flags
|= F_LNNO
;
4011 if (abfd
->flags
& EXEC_P
)
4012 internal_f
.f_flags
|= F_EXEC
;
4013 #ifdef COFF_IMAGE_WITH_PE
4015 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
4016 if (pe_data (abfd
)->real_flags
& IMAGE_FILE_LARGE_ADDRESS_AWARE
)
4017 internal_f
.f_flags
|= IMAGE_FILE_LARGE_ADDRESS_AWARE
;
4020 #ifndef COFF_WITH_pex64
4022 internal_f
.f_flags
|= IMAGE_FILE_32BIT_MACHINE
;
4024 if (bfd_little_endian (abfd
))
4025 internal_f
.f_flags
|= F_AR32WR
;
4027 internal_f
.f_flags
|= F_AR32W
;
4032 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
4033 but it doesn't hurt to set it internally. */
4034 internal_f
.f_target_id
= TI_TARGET_ID
;
4036 #ifdef TIC80_TARGET_ID
4037 internal_f
.f_target_id
= TIC80_TARGET_ID
;
4040 /* FIXME, should do something about the other byte orders and
4044 if ((abfd
->flags
& DYNAMIC
) != 0)
4045 internal_f
.f_flags
|= F_SHROBJ
;
4046 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
4047 internal_f
.f_flags
|= F_DYNLOAD
;
4050 memset (&internal_a
, 0, sizeof internal_a
);
4052 /* Set up architecture-dependent stuff. */
4054 unsigned int magic
= 0;
4055 unsigned short flags
= 0;
4057 coff_set_flags (abfd
, &magic
, &flags
);
4058 internal_f
.f_magic
= magic
;
4059 internal_f
.f_flags
|= flags
;
4060 /* ...and the "opt"hdr... */
4062 #ifdef TICOFF_AOUT_MAGIC
4063 internal_a
.magic
= TICOFF_AOUT_MAGIC
;
4064 #define __A_MAGIC_SET__
4067 internal_a
.magic
= TIC80_ARCH_MAGIC
;
4068 #define __A_MAGIC_SET__
4071 /* FIXME: What are the a.out magic numbers for the i860? */
4072 internal_a
.magic
= 0;
4073 #define __A_MAGIC_SET__
4076 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
4077 #define __A_MAGIC_SET__
4080 #define __A_MAGIC_SET__
4081 internal_a
.magic
= PAGEMAGICBCS
;
4085 #define __A_MAGIC_SET__
4086 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
4089 #if defined(M68) || defined(WE32K) || defined(M68K)
4090 #define __A_MAGIC_SET__
4092 internal_a
.magic
= LYNXCOFFMAGIC
;
4094 #if defined(TARG_AUX)
4095 internal_a
.magic
= (abfd
->flags
& D_PAGED
? PAGEMAGICPEXECPAGED
:
4096 abfd
->flags
& WP_TEXT
? PAGEMAGICPEXECSWAPPED
:
4097 PAGEMAGICEXECSWAPPED
);
4099 #if defined (PAGEMAGICPEXECPAGED)
4100 internal_a
.magic
= PAGEMAGICPEXECPAGED
;
4102 #endif /* TARG_AUX */
4104 #endif /* M68 || WE32K || M68K */
4107 #define __A_MAGIC_SET__
4108 internal_a
.magic
= ZMAGIC
;
4112 #define __A_MAGIC_SET__
4113 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
4116 #if defined MCORE_PE
4117 #define __A_MAGIC_SET__
4118 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
4122 #define __A_MAGIC_SET__
4124 internal_a
.magic
= LYNXCOFFMAGIC
;
4126 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR64_MAGIC
;
4128 internal_a
.magic
= ZMAGIC
;
4133 #define __A_MAGIC_SET__
4134 internal_a
.magic
= PE32PMAGIC
;
4138 #define __A_MAGIC_SET__
4140 internal_a
.magic
= LYNXCOFFMAGIC
;
4145 #define __A_MAGIC_SET__
4146 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
4147 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
4148 RS6K_AOUTHDR_OMAGIC
;
4151 #if defined(SH) && defined(COFF_WITH_PE)
4152 #define __A_MAGIC_SET__
4153 internal_a
.magic
= SH_PE_MAGIC
;
4156 #if defined(MIPS) && defined(COFF_WITH_PE)
4157 #define __A_MAGIC_SET__
4158 internal_a
.magic
= MIPS_PE_MAGIC
;
4162 #define __A_MAGIC_SET__
4163 internal_a
.magic
= NMAGIC
; /* Assume separate i/d. */
4166 #ifndef __A_MAGIC_SET__
4167 #include "Your aouthdr magic number is not being set!"
4169 #undef __A_MAGIC_SET__
4173 /* FIXME: Does anybody ever set this to another value? */
4174 internal_a
.vstamp
= 0;
4176 /* Now should write relocs, strings, syms. */
4177 obj_sym_filepos (abfd
) = sym_base
;
4179 if (bfd_get_symcount (abfd
) != 0)
4183 if (!coff_renumber_symbols (abfd
, &firstundef
))
4185 coff_mangle_symbols (abfd
);
4186 if (! coff_write_symbols (abfd
))
4188 if (! coff_write_linenumbers (abfd
))
4190 if (! coff_write_relocs (abfd
, firstundef
))
4193 #ifdef COFF_LONG_SECTION_NAMES
4194 else if (long_section_names
&& ! obj_coff_strings_written (abfd
))
4196 /* If we have long section names we have to write out the string
4197 table even if there are no symbols. */
4198 if (! coff_write_symbols (abfd
))
4202 #ifdef COFF_IMAGE_WITH_PE
4204 else if ((abfd
->flags
& EXEC_P
) != 0)
4208 /* PowerPC PE appears to require that all executable files be
4209 rounded up to the page size. */
4212 (file_ptr
) BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
4214 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
4220 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
4221 backend linker, and obj_raw_syment_count is not valid until after
4222 coff_write_symbols is called. */
4223 if (obj_raw_syment_count (abfd
) != 0)
4225 internal_f
.f_symptr
= sym_base
;
4227 /* AIX appears to require that F_RELFLG not be set if there are
4228 local symbols but no relocations. */
4229 internal_f
.f_flags
&=~ F_RELFLG
;
4234 if (long_section_names
)
4235 internal_f
.f_symptr
= sym_base
;
4237 internal_f
.f_symptr
= 0;
4238 internal_f
.f_flags
|= F_LSYMS
;
4243 internal_a
.tsize
= text_sec
->size
;
4244 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
4248 internal_a
.dsize
= data_sec
->size
;
4249 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
4253 internal_a
.bsize
= bss_sec
->size
;
4254 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
4255 internal_a
.data_start
= bss_sec
->vma
;
4258 internal_a
.entry
= bfd_get_start_address (abfd
);
4259 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
4262 if (xcoff_data (abfd
)->full_aouthdr
)
4265 asection
*loader_sec
;
4267 internal_a
.vstamp
= 1;
4269 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
4270 if (internal_a
.o_snentry
== 0)
4271 internal_a
.entry
= (bfd_vma
) -1;
4273 if (text_sec
!= NULL
)
4275 internal_a
.o_sntext
= text_sec
->target_index
;
4276 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
4280 internal_a
.o_sntext
= 0;
4281 internal_a
.o_algntext
= 0;
4283 if (data_sec
!= NULL
)
4285 internal_a
.o_sndata
= data_sec
->target_index
;
4286 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
4290 internal_a
.o_sndata
= 0;
4291 internal_a
.o_algndata
= 0;
4293 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
4294 if (loader_sec
!= NULL
)
4295 internal_a
.o_snloader
= loader_sec
->target_index
;
4297 internal_a
.o_snloader
= 0;
4298 if (bss_sec
!= NULL
)
4299 internal_a
.o_snbss
= bss_sec
->target_index
;
4301 internal_a
.o_snbss
= 0;
4303 toc
= xcoff_data (abfd
)->toc
;
4304 internal_a
.o_toc
= toc
;
4305 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
4307 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
4308 if (xcoff_data (abfd
)->cputype
!= -1)
4309 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
4312 switch (bfd_get_arch (abfd
))
4314 case bfd_arch_rs6000
:
4315 internal_a
.o_cputype
= 4;
4317 case bfd_arch_powerpc
:
4318 if (bfd_get_mach (abfd
) == bfd_mach_ppc
)
4319 internal_a
.o_cputype
= 3;
4321 internal_a
.o_cputype
= 1;
4327 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
4328 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
4334 /* After object contents are finalized so we can compute a reasonable hash,
4335 but before header is written so we can update it to point to debug directory. */
4336 struct pe_tdata
*pe
= pe_data (abfd
);
4338 if (pe
->build_id
.after_write_object_contents
!= NULL
)
4339 (*pe
->build_id
.after_write_object_contents
) (abfd
);
4343 /* Now write header. */
4344 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
4349 bfd_size_type amount
= bfd_coff_filhsz (abfd
);
4351 buff
= (char *) bfd_malloc (amount
);
4355 bfd_coff_swap_filehdr_out (abfd
, & internal_f
, buff
);
4356 amount
= bfd_bwrite (buff
, amount
, abfd
);
4360 if (amount
!= bfd_coff_filhsz (abfd
))
4364 if (abfd
->flags
& EXEC_P
)
4366 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4367 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4369 bfd_size_type amount
= bfd_coff_aoutsz (abfd
);
4371 buff
= (char *) bfd_malloc (amount
);
4375 coff_swap_aouthdr_out (abfd
, & internal_a
, buff
);
4376 amount
= bfd_bwrite (buff
, amount
, abfd
);
4380 if (amount
!= bfd_coff_aoutsz (abfd
))
4383 #ifdef COFF_IMAGE_WITH_PE
4384 if (! coff_apply_checksum (abfd
))
4394 /* XCOFF seems to always write at least a small a.out header. */
4395 coff_swap_aouthdr_out (abfd
, & internal_a
, & buff
);
4396 if (xcoff_data (abfd
)->full_aouthdr
)
4397 size
= bfd_coff_aoutsz (abfd
);
4399 size
= SMALL_AOUTSZ
;
4400 if (bfd_bwrite (& buff
, (bfd_size_type
) size
, abfd
) != size
)
4409 coff_set_section_contents (bfd
* abfd
,
4411 const void * location
,
4413 bfd_size_type count
)
4415 if (! abfd
->output_has_begun
) /* Set by bfd.c handler. */
4417 if (! coff_compute_section_file_positions (abfd
))
4421 #if defined(_LIB) && !defined(TARG_AUX)
4422 /* The physical address field of a .lib section is used to hold the
4423 number of shared libraries in the section. This code counts the
4424 number of sections being written, and increments the lma field
4427 I have found no documentation on the contents of this section.
4428 Experimentation indicates that the section contains zero or more
4429 records, each of which has the following structure:
4431 - a (four byte) word holding the length of this record, in words,
4432 - a word that always seems to be set to "2",
4433 - the path to a shared library, null-terminated and then padded
4434 to a whole word boundary.
4436 bfd_assert calls have been added to alert if an attempt is made
4437 to write a section which doesn't follow these assumptions. The
4438 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4439 <robertl@arnet.com> (Thanks!).
4441 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4442 if (strcmp (section
->name
, _LIB
) == 0)
4444 bfd_byte
*rec
, *recend
;
4446 rec
= (bfd_byte
*) location
;
4447 recend
= rec
+ count
;
4448 while (rec
< recend
)
4451 rec
+= bfd_get_32 (abfd
, rec
) * 4;
4454 BFD_ASSERT (rec
== recend
);
4458 /* Don't write out bss sections - one way to do this is to
4459 see if the filepos has not been set. */
4460 if (section
->filepos
== 0)
4463 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0)
4469 return bfd_bwrite (location
, count
, abfd
) == count
;
4473 buy_and_read (bfd
*abfd
, file_ptr where
, bfd_size_type size
)
4475 void * area
= bfd_alloc (abfd
, size
);
4479 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0
4480 || bfd_bread (area
, size
, abfd
) != size
)
4489 Creating the linenumber table is done by reading in the entire
4490 coff linenumber table, and creating another table for internal use.
4492 A coff linenumber table is structured so that each function
4493 is marked as having a line number of 0. Each line within the
4494 function is an offset from the first line in the function. The
4495 base of the line number information for the table is stored in
4496 the symbol associated with the function.
4498 Note: The PE format uses line number 0 for a flag indicating a
4501 The information is copied from the external to the internal
4502 table, and each symbol which marks a function is marked by
4505 How does this work ?
4509 coff_sort_func_alent (const void * arg1
, const void * arg2
)
4511 const alent
*al1
= *(const alent
**) arg1
;
4512 const alent
*al2
= *(const alent
**) arg2
;
4513 const coff_symbol_type
*s1
= (const coff_symbol_type
*) (al1
->u
.sym
);
4514 const coff_symbol_type
*s2
= (const coff_symbol_type
*) (al2
->u
.sym
);
4516 if (s1
->symbol
.value
< s2
->symbol
.value
)
4518 else if (s1
->symbol
.value
> s2
->symbol
.value
)
4525 coff_slurp_line_table (bfd
*abfd
, asection
*asect
)
4527 LINENO
*native_lineno
;
4528 alent
*lineno_cache
;
4530 unsigned int counter
;
4532 bfd_vma prev_offset
= 0;
4534 unsigned int nbr_func
;
4537 BFD_ASSERT (asect
->lineno
== NULL
);
4539 amt
= ((bfd_size_type
) asect
->lineno_count
+ 1) * sizeof (alent
);
4540 lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
);
4541 if (lineno_cache
== NULL
)
4544 amt
= (bfd_size_type
) bfd_coff_linesz (abfd
) * asect
->lineno_count
;
4545 native_lineno
= (LINENO
*) buy_and_read (abfd
, asect
->line_filepos
, amt
);
4546 if (native_lineno
== NULL
)
4548 (*_bfd_error_handler
)
4549 (_("%B: warning: line number table read failed"), abfd
);
4550 bfd_release (abfd
, lineno_cache
);
4554 cache_ptr
= lineno_cache
;
4555 asect
->lineno
= lineno_cache
;
4556 src
= native_lineno
;
4559 for (counter
= 0; counter
< asect
->lineno_count
; counter
++)
4561 struct internal_lineno dst
;
4563 bfd_coff_swap_lineno_in (abfd
, src
, &dst
);
4564 cache_ptr
->line_number
= dst
.l_lnno
;
4566 if (cache_ptr
->line_number
== 0)
4569 bfd_signed_vma symndx
;
4570 coff_symbol_type
*sym
;
4574 symndx
= dst
.l_addr
.l_symndx
;
4576 || (bfd_vma
) symndx
>= obj_raw_syment_count (abfd
))
4578 (*_bfd_error_handler
)
4579 (_("%B: warning: illegal symbol index %ld in line numbers"),
4580 abfd
, (long) symndx
);
4585 /* FIXME: We should not be casting between ints and
4586 pointers like this. */
4587 sym
= ((coff_symbol_type
*)
4588 ((symndx
+ obj_raw_syments (abfd
))
4589 ->u
.syment
._n
._n_n
._n_zeroes
));
4590 cache_ptr
->u
.sym
= (asymbol
*) sym
;
4591 if (sym
->lineno
!= NULL
&& ! warned
)
4592 (*_bfd_error_handler
)
4593 (_("%B: warning: duplicate line number information for `%s'"),
4594 abfd
, bfd_asymbol_name (&sym
->symbol
));
4596 sym
->lineno
= cache_ptr
;
4597 if (sym
->symbol
.value
< prev_offset
)
4599 prev_offset
= sym
->symbol
.value
;
4602 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
4603 - bfd_section_vma (abfd
, asect
);
4608 cache_ptr
->line_number
= 0;
4609 bfd_release (abfd
, native_lineno
);
4611 /* On some systems (eg AIX5.3) the lineno table may not be sorted. */
4614 /* Sort the table. */
4616 alent
*n_lineno_cache
;
4618 /* Create a table of functions. */
4619 func_table
= (alent
**) bfd_alloc (abfd
, nbr_func
* sizeof (alent
*));
4620 if (func_table
!= NULL
)
4622 alent
**p
= func_table
;
4625 for (i
= 0; i
< counter
; i
++)
4626 if (lineno_cache
[i
].line_number
== 0)
4627 *p
++ = &lineno_cache
[i
];
4629 /* Sort by functions. */
4630 qsort (func_table
, nbr_func
, sizeof (alent
*), coff_sort_func_alent
);
4632 /* Create the new sorted table. */
4633 amt
= ((bfd_size_type
) asect
->lineno_count
+ 1) * sizeof (alent
);
4634 n_lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
);
4635 if (n_lineno_cache
!= NULL
)
4637 alent
*n_cache_ptr
= n_lineno_cache
;
4639 for (i
= 0; i
< nbr_func
; i
++)
4641 coff_symbol_type
*sym
;
4642 alent
*old_ptr
= func_table
[i
];
4644 /* Copy the function entry and update it. */
4645 *n_cache_ptr
= *old_ptr
;
4646 sym
= (coff_symbol_type
*)n_cache_ptr
->u
.sym
;
4647 sym
->lineno
= n_cache_ptr
;
4651 /* Copy the line number entries. */
4652 while (old_ptr
->line_number
!= 0)
4653 *n_cache_ptr
++ = *old_ptr
++;
4655 n_cache_ptr
->line_number
= 0;
4656 memcpy (lineno_cache
, n_lineno_cache
, amt
);
4658 bfd_release (abfd
, func_table
);
4665 /* Slurp in the symbol table, converting it to generic form. Note
4666 that if coff_relocate_section is defined, the linker will read
4667 symbols via coff_link_add_symbols, rather than via this routine. */
4670 coff_slurp_symbol_table (bfd
* abfd
)
4672 combined_entry_type
*native_symbols
;
4673 coff_symbol_type
*cached_area
;
4674 unsigned int *table_ptr
;
4676 unsigned int number_of_symbols
= 0;
4678 if (obj_symbols (abfd
))
4681 /* Read in the symbol table. */
4682 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4685 /* Allocate enough room for all the symbols in cached form. */
4686 amt
= obj_raw_syment_count (abfd
);
4687 amt
*= sizeof (coff_symbol_type
);
4688 cached_area
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
4689 if (cached_area
== NULL
)
4692 amt
= obj_raw_syment_count (abfd
);
4693 amt
*= sizeof (unsigned int);
4694 table_ptr
= (unsigned int *) bfd_alloc (abfd
, amt
);
4696 if (table_ptr
== NULL
)
4700 coff_symbol_type
*dst
= cached_area
;
4701 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4702 unsigned int this_index
= 0;
4704 while (this_index
< last_native_index
)
4706 combined_entry_type
*src
= native_symbols
+ this_index
;
4707 table_ptr
[this_index
] = number_of_symbols
;
4708 dst
->symbol
.the_bfd
= abfd
;
4710 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4711 /* We use the native name field to point to the cached field. */
4712 src
->u
.syment
._n
._n_n
._n_zeroes
= (bfd_hostptr_t
) dst
;
4713 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4714 src
->u
.syment
.n_scnum
);
4715 dst
->symbol
.flags
= 0;
4716 dst
->done_lineno
= FALSE
;
4718 switch (src
->u
.syment
.n_sclass
)
4722 /* Fall through to next case. */
4729 case C_THUMBEXTFUNC
:
4735 case C_SYSTEM
: /* System Wide variable. */
4738 /* In PE, 0x68 (104) denotes a section symbol. */
4740 /* In PE, 0x69 (105) denotes a weak external symbol. */
4743 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4745 case COFF_SYMBOL_GLOBAL
:
4746 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4747 #if defined COFF_WITH_PE
4748 /* PE sets the symbol to a value relative to the
4749 start of the section. */
4750 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4752 dst
->symbol
.value
= (src
->u
.syment
.n_value
4753 - dst
->symbol
.section
->vma
);
4755 if (ISFCN ((src
->u
.syment
.n_type
)))
4756 /* A function ext does not go at the end of a
4758 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4761 case COFF_SYMBOL_COMMON
:
4762 dst
->symbol
.section
= bfd_com_section_ptr
;
4763 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4766 case COFF_SYMBOL_UNDEFINED
:
4767 dst
->symbol
.section
= bfd_und_section_ptr
;
4768 dst
->symbol
.value
= 0;
4771 case COFF_SYMBOL_PE_SECTION
:
4772 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4773 dst
->symbol
.value
= 0;
4776 case COFF_SYMBOL_LOCAL
:
4777 dst
->symbol
.flags
= BSF_LOCAL
;
4778 #if defined COFF_WITH_PE
4779 /* PE sets the symbol to a value relative to the
4780 start of the section. */
4781 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4783 dst
->symbol
.value
= (src
->u
.syment
.n_value
4784 - dst
->symbol
.section
->vma
);
4786 if (ISFCN ((src
->u
.syment
.n_type
)))
4787 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4792 /* A symbol with a csect entry should not go at the end. */
4793 if (src
->u
.syment
.n_numaux
> 0)
4794 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4798 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4799 dst
->symbol
.flags
|= BSF_WEAK
;
4801 if (src
->u
.syment
.n_sclass
== C_SECTION
4802 && src
->u
.syment
.n_scnum
> 0)
4803 dst
->symbol
.flags
= BSF_LOCAL
;
4805 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
)
4806 dst
->symbol
.flags
|= BSF_WEAK
;
4810 case C_STAT
: /* Static. */
4812 case C_LEAFSTAT
: /* Static leaf procedure. */
4815 case C_THUMBSTAT
: /* Thumb static. */
4816 case C_THUMBLABEL
: /* Thumb label. */
4817 case C_THUMBSTATFUNC
:/* Thumb static function. */
4820 case C_DWARF
: /* A label in a dwarf section. */
4821 case C_INFO
: /* A label in a comment section. */
4823 case C_LABEL
: /* Label. */
4824 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4825 dst
->symbol
.flags
= BSF_DEBUGGING
;
4827 dst
->symbol
.flags
= BSF_LOCAL
;
4829 /* Base the value as an index from the base of the
4830 section, if there is one. */
4831 if (dst
->symbol
.section
)
4833 #if defined COFF_WITH_PE
4834 /* PE sets the symbol to a value relative to the
4835 start of the section. */
4836 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4838 dst
->symbol
.value
= (src
->u
.syment
.n_value
4839 - dst
->symbol
.section
->vma
);
4843 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4846 case C_MOS
: /* Member of structure. */
4847 case C_EOS
: /* End of structure. */
4848 case C_REGPARM
: /* Register parameter. */
4849 case C_REG
: /* register variable. */
4850 /* C_AUTOARG conflicts with TI COFF C_UEXT. */
4851 #if !defined (TIC80COFF) && !defined (TICOFF)
4853 case C_AUTOARG
: /* 960-specific storage class. */
4856 case C_TPDEF
: /* Type definition. */
4858 case C_AUTO
: /* Automatic variable. */
4859 case C_FIELD
: /* Bit field. */
4860 case C_ENTAG
: /* Enumeration tag. */
4861 case C_MOE
: /* Member of enumeration. */
4862 case C_MOU
: /* Member of union. */
4863 case C_UNTAG
: /* Union tag. */
4864 dst
->symbol
.flags
= BSF_DEBUGGING
;
4865 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4868 case C_FILE
: /* File name. */
4869 case C_STRTAG
: /* Structure tag. */
4886 dst
->symbol
.flags
= BSF_DEBUGGING
;
4887 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4891 case C_BINCL
: /* Beginning of include file. */
4892 case C_EINCL
: /* Ending of include file. */
4893 /* The value is actually a pointer into the line numbers
4894 of the file. We locate the line number entry, and
4895 set the section to the section which contains it, and
4896 the value to the index in that section. */
4900 dst
->symbol
.flags
= BSF_DEBUGGING
;
4901 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4902 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4903 && ((file_ptr
) (sec
->line_filepos
4904 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4905 > (file_ptr
) src
->u
.syment
.n_value
))
4908 dst
->symbol
.value
= 0;
4911 dst
->symbol
.section
= sec
;
4912 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4913 - sec
->line_filepos
)
4914 / bfd_coff_linesz (abfd
));
4921 dst
->symbol
.flags
= BSF_DEBUGGING
;
4923 /* The value is actually a symbol index. Save a pointer
4924 to the symbol instead of the index. FIXME: This
4925 should use a union. */
4926 src
->u
.syment
.n_value
=
4927 (long) (intptr_t) (native_symbols
+ src
->u
.syment
.n_value
);
4928 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4933 case C_BLOCK
: /* ".bb" or ".eb". */
4934 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf"). */
4935 case C_EFCN
: /* Physical end of function. */
4936 #if defined COFF_WITH_PE
4937 /* PE sets the symbol to a value relative to the start
4939 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4940 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4942 /* PE uses funny values for .ef and .lf; don't
4944 dst
->symbol
.flags
= BSF_DEBUGGING
;
4947 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4949 /* Base the value as an index from the base of the
4951 dst
->symbol
.flags
= BSF_LOCAL
;
4952 dst
->symbol
.value
= (src
->u
.syment
.n_value
4953 - dst
->symbol
.section
->vma
);
4957 case C_STATLAB
: /* Static load time label. */
4958 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4959 dst
->symbol
.flags
= BSF_GLOBAL
;
4963 /* PE DLLs sometimes have zeroed out symbols for some
4964 reason. Just ignore them without a warning. */
4965 if (src
->u
.syment
.n_type
== 0
4966 && src
->u
.syment
.n_value
== 0
4967 && src
->u
.syment
.n_scnum
== 0)
4970 /* XCOFF specific: deleted entry. */
4971 if (src
->u
.syment
.n_value
== C_NULL_VALUE
)
4975 case C_EXTDEF
: /* External definition. */
4976 case C_ULABEL
: /* Undefined label. */
4977 case C_USTATIC
: /* Undefined static. */
4978 #ifndef COFF_WITH_PE
4979 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4980 class to represent a section symbol. */
4981 case C_LINE
: /* line # reformatted as symbol table entry. */
4982 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4983 case C_ALIAS
: /* Duplicate tag. */
4985 /* New storage classes for TI COFF. */
4986 #if defined(TIC80COFF) || defined(TICOFF)
4987 case C_UEXT
: /* Tentative external definition. */
4989 case C_EXTLAB
: /* External load time label. */
4990 case C_HIDDEN
: /* Ext symbol in dmert public lib. */
4992 (*_bfd_error_handler
)
4993 (_("%B: Unrecognized storage class %d for %s symbol `%s'"),
4994 abfd
, src
->u
.syment
.n_sclass
,
4995 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4996 dst
->symbol
.flags
= BSF_DEBUGGING
;
4997 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
5003 dst
->symbol
.udata
.i
= 0;
5005 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
5007 number_of_symbols
++;
5011 obj_symbols (abfd
) = cached_area
;
5012 obj_raw_syments (abfd
) = native_symbols
;
5014 bfd_get_symcount (abfd
) = number_of_symbols
;
5015 obj_convert (abfd
) = table_ptr
;
5016 /* Slurp the line tables for each section too. */
5023 coff_slurp_line_table (abfd
, p
);
5031 /* Classify a COFF symbol. A couple of targets have globally visible
5032 symbols which are not class C_EXT, and this handles those. It also
5033 recognizes some special PE cases. */
5035 static enum coff_symbol_classification
5036 coff_classify_symbol (bfd
*abfd
,
5037 struct internal_syment
*syment
)
5039 /* FIXME: This partially duplicates the switch in
5040 coff_slurp_symbol_table. */
5041 switch (syment
->n_sclass
)
5050 case C_THUMBEXTFUNC
:
5058 if (syment
->n_scnum
== 0)
5060 if (syment
->n_value
== 0)
5061 return COFF_SYMBOL_UNDEFINED
;
5063 return COFF_SYMBOL_COMMON
;
5065 return COFF_SYMBOL_GLOBAL
;
5072 if (syment
->n_sclass
== C_STAT
)
5074 if (syment
->n_scnum
== 0)
5075 /* The Microsoft compiler sometimes generates these if a
5076 small static function is inlined every time it is used.
5077 The function is discarded, but the symbol table entry
5079 return COFF_SYMBOL_LOCAL
;
5081 #ifdef STRICT_PE_FORMAT
5082 /* This is correct for Microsoft generated objects, but it
5083 breaks gas generated objects. */
5084 if (syment
->n_value
== 0)
5087 char buf
[SYMNMLEN
+ 1];
5089 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
5091 && (strcmp (bfd_get_section_name (abfd
, sec
),
5092 _bfd_coff_internal_syment_name (abfd
, syment
, buf
))
5094 return COFF_SYMBOL_PE_SECTION
;
5098 return COFF_SYMBOL_LOCAL
;
5101 if (syment
->n_sclass
== C_SECTION
)
5103 /* In some cases in a DLL generated by the Microsoft linker, the
5104 n_value field will contain garbage. FIXME: This should
5105 probably be handled by the swapping function instead. */
5106 syment
->n_value
= 0;
5107 if (syment
->n_scnum
== 0)
5108 return COFF_SYMBOL_UNDEFINED
;
5109 return COFF_SYMBOL_PE_SECTION
;
5111 #endif /* COFF_WITH_PE */
5113 /* If it is not a global symbol, we presume it is a local symbol. */
5114 if (syment
->n_scnum
== 0)
5116 char buf
[SYMNMLEN
+ 1];
5118 (*_bfd_error_handler
)
5119 (_("warning: %B: local symbol `%s' has no section"),
5120 abfd
, _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
5123 return COFF_SYMBOL_LOCAL
;
5130 Coff relocations are easily transformed into the internal BFD form
5133 Reading a coff relocation table is done in the following stages:
5135 o Read the entire coff relocation table into memory.
5137 o Process each relocation in turn; first swap it from the
5138 external to the internal form.
5140 o Turn the symbol referenced in the relocation's symbol index
5141 into a pointer into the canonical symbol table.
5142 This table is the same as the one returned by a call to
5143 @code{bfd_canonicalize_symtab}. The back end will call that
5144 routine and save the result if a canonicalization hasn't been done.
5146 o The reloc index is turned into a pointer to a howto
5147 structure, in a back end specific way. For instance, the 386
5148 and 960 use the @code{r_type} to directly produce an index
5149 into a howto table vector; the 88k subtracts a number from the
5150 @code{r_type} field and creates an addend field.
5154 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
5156 coff_symbol_type *coffsym = NULL; \
5158 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
5159 coffsym = (obj_symbols (abfd) \
5160 + (cache_ptr->sym_ptr_ptr - symbols)); \
5162 coffsym = coff_symbol_from (abfd, ptr); \
5163 if (coffsym != NULL \
5164 && coffsym->native->u.syment.n_scnum == 0) \
5165 cache_ptr->addend = 0; \
5166 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
5167 && ptr->section != NULL) \
5168 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
5170 cache_ptr->addend = 0; \
5175 coff_slurp_reloc_table (bfd
* abfd
, sec_ptr asect
, asymbol
** symbols
)
5177 RELOC
*native_relocs
;
5178 arelent
*reloc_cache
;
5183 if (asect
->relocation
)
5185 if (asect
->reloc_count
== 0)
5187 if (asect
->flags
& SEC_CONSTRUCTOR
)
5189 if (!coff_slurp_symbol_table (abfd
))
5192 amt
= (bfd_size_type
) bfd_coff_relsz (abfd
) * asect
->reloc_count
;
5193 native_relocs
= (RELOC
*) buy_and_read (abfd
, asect
->rel_filepos
, amt
);
5194 amt
= (bfd_size_type
) asect
->reloc_count
* sizeof (arelent
);
5195 reloc_cache
= (arelent
*) bfd_alloc (abfd
, amt
);
5197 if (reloc_cache
== NULL
|| native_relocs
== NULL
)
5200 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
5202 struct internal_reloc dst
;
5203 struct external_reloc
*src
;
5204 #ifndef RELOC_PROCESSING
5208 cache_ptr
= reloc_cache
+ idx
;
5209 src
= native_relocs
+ idx
;
5212 coff_swap_reloc_in (abfd
, src
, &dst
);
5214 #ifdef RELOC_PROCESSING
5215 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
5217 cache_ptr
->address
= dst
.r_vaddr
;
5219 if (dst
.r_symndx
!= -1)
5221 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
5223 (*_bfd_error_handler
)
5224 (_("%B: warning: illegal symbol index %ld in relocs"),
5225 abfd
, (long) dst
.r_symndx
);
5226 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5231 cache_ptr
->sym_ptr_ptr
= (symbols
5232 + obj_convert (abfd
)[dst
.r_symndx
]);
5233 ptr
= *(cache_ptr
->sym_ptr_ptr
);
5238 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5242 /* The symbols definitions that we have read in have been
5243 relocated as if their sections started at 0. But the offsets
5244 refering to the symbols in the raw data have not been
5245 modified, so we have to have a negative addend to compensate.
5247 Note that symbols which used to be common must be left alone. */
5249 /* Calculate any reloc addend by looking at the symbol. */
5250 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
5253 cache_ptr
->address
-= asect
->vma
;
5254 /* !! cache_ptr->section = NULL;*/
5256 /* Fill in the cache_ptr->howto field from dst.r_type. */
5257 RTYPE2HOWTO (cache_ptr
, &dst
);
5258 #endif /* RELOC_PROCESSING */
5260 if (cache_ptr
->howto
== NULL
)
5262 (*_bfd_error_handler
)
5263 (_("%B: illegal relocation type %d at address 0x%lx"),
5264 abfd
, dst
.r_type
, (long) dst
.r_vaddr
);
5265 bfd_set_error (bfd_error_bad_value
);
5270 asect
->relocation
= reloc_cache
;
5274 #ifndef coff_rtype_to_howto
5277 /* Get the howto structure for a reloc. This is only used if the file
5278 including this one defines coff_relocate_section to be
5279 _bfd_coff_generic_relocate_section, so it is OK if it does not
5280 always work. It is the responsibility of the including file to
5281 make sure it is reasonable if it is needed. */
5283 static reloc_howto_type
*
5284 coff_rtype_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
5285 asection
*sec ATTRIBUTE_UNUSED
,
5286 struct internal_reloc
*rel
,
5287 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
,
5288 struct internal_syment
*sym ATTRIBUTE_UNUSED
,
5289 bfd_vma
*addendp ATTRIBUTE_UNUSED
)
5293 genrel
.howto
= NULL
;
5294 RTYPE2HOWTO (&genrel
, rel
);
5295 return genrel
.howto
;
5298 #else /* ! defined (RTYPE2HOWTO) */
5300 #define coff_rtype_to_howto NULL
5302 #endif /* ! defined (RTYPE2HOWTO) */
5303 #endif /* ! defined (coff_rtype_to_howto) */
5305 /* This is stupid. This function should be a boolean predicate. */
5308 coff_canonicalize_reloc (bfd
* abfd
,
5313 arelent
*tblptr
= section
->relocation
;
5314 unsigned int count
= 0;
5316 if (section
->flags
& SEC_CONSTRUCTOR
)
5318 /* This section has relocs made up by us, they are not in the
5319 file, so take them out of their chain and place them into
5320 the data area provided. */
5321 arelent_chain
*chain
= section
->constructor_chain
;
5323 for (count
= 0; count
< section
->reloc_count
; count
++)
5325 *relptr
++ = &chain
->relent
;
5326 chain
= chain
->next
;
5331 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
5334 tblptr
= section
->relocation
;
5336 for (; count
++ < section
->reloc_count
;)
5337 *relptr
++ = tblptr
++;
5340 return section
->reloc_count
;
5343 #ifndef coff_reloc16_estimate
5344 #define coff_reloc16_estimate dummy_reloc16_estimate
5347 dummy_reloc16_estimate (bfd
*abfd ATTRIBUTE_UNUSED
,
5348 asection
*input_section ATTRIBUTE_UNUSED
,
5349 arelent
*reloc ATTRIBUTE_UNUSED
,
5350 unsigned int shrink ATTRIBUTE_UNUSED
,
5351 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
)
5359 #ifndef coff_reloc16_extra_cases
5361 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5363 /* This works even if abort is not declared in any header file. */
5366 dummy_reloc16_extra_cases (bfd
*abfd ATTRIBUTE_UNUSED
,
5367 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
5368 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
,
5369 arelent
*reloc ATTRIBUTE_UNUSED
,
5370 bfd_byte
*data ATTRIBUTE_UNUSED
,
5371 unsigned int *src_ptr ATTRIBUTE_UNUSED
,
5372 unsigned int *dst_ptr ATTRIBUTE_UNUSED
)
5378 #ifndef coff_bfd_link_hash_table_free
5379 #define coff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
5382 /* If coff_relocate_section is defined, we can use the optimized COFF
5383 backend linker. Otherwise we must continue to use the old linker. */
5385 #ifdef coff_relocate_section
5387 #ifndef coff_bfd_link_hash_table_create
5388 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5390 #ifndef coff_bfd_link_add_symbols
5391 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5393 #ifndef coff_bfd_final_link
5394 #define coff_bfd_final_link _bfd_coff_final_link
5397 #else /* ! defined (coff_relocate_section) */
5399 #define coff_relocate_section NULL
5400 #ifndef coff_bfd_link_hash_table_create
5401 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5403 #ifndef coff_bfd_link_add_symbols
5404 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5406 #define coff_bfd_final_link _bfd_generic_final_link
5408 #endif /* ! defined (coff_relocate_section) */
5410 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5411 #define coff_bfd_copy_link_hash_symbol_type \
5412 _bfd_generic_copy_link_hash_symbol_type
5413 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5415 #ifndef coff_start_final_link
5416 #define coff_start_final_link NULL
5419 #ifndef coff_adjust_symndx
5420 #define coff_adjust_symndx NULL
5423 #ifndef coff_link_add_one_symbol
5424 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5427 #ifndef coff_link_output_has_begun
5430 coff_link_output_has_begun (bfd
* abfd
,
5431 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
)
5433 return abfd
->output_has_begun
;
5437 #ifndef coff_final_link_postscript
5440 coff_final_link_postscript (bfd
* abfd ATTRIBUTE_UNUSED
,
5441 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
)
5447 #ifndef coff_SWAP_aux_in
5448 #define coff_SWAP_aux_in coff_swap_aux_in
5450 #ifndef coff_SWAP_sym_in
5451 #define coff_SWAP_sym_in coff_swap_sym_in
5453 #ifndef coff_SWAP_lineno_in
5454 #define coff_SWAP_lineno_in coff_swap_lineno_in
5456 #ifndef coff_SWAP_aux_out
5457 #define coff_SWAP_aux_out coff_swap_aux_out
5459 #ifndef coff_SWAP_sym_out
5460 #define coff_SWAP_sym_out coff_swap_sym_out
5462 #ifndef coff_SWAP_lineno_out
5463 #define coff_SWAP_lineno_out coff_swap_lineno_out
5465 #ifndef coff_SWAP_reloc_out
5466 #define coff_SWAP_reloc_out coff_swap_reloc_out
5468 #ifndef coff_SWAP_filehdr_out
5469 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5471 #ifndef coff_SWAP_aouthdr_out
5472 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5474 #ifndef coff_SWAP_scnhdr_out
5475 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5477 #ifndef coff_SWAP_reloc_in
5478 #define coff_SWAP_reloc_in coff_swap_reloc_in
5480 #ifndef coff_SWAP_filehdr_in
5481 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5483 #ifndef coff_SWAP_aouthdr_in
5484 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5486 #ifndef coff_SWAP_scnhdr_in
5487 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5490 static bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED
=
5492 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5493 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5494 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5495 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5496 coff_SWAP_scnhdr_out
,
5497 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5498 #ifdef COFF_LONG_FILENAMES
5503 COFF_DEFAULT_LONG_SECTION_NAMES
,
5504 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5505 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5510 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5516 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5517 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5518 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5519 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5520 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5521 coff_classify_symbol
, coff_compute_section_file_positions
,
5522 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5523 coff_adjust_symndx
, coff_link_add_one_symbol
,
5524 coff_link_output_has_begun
, coff_final_link_postscript
,
5529 /* COFF0 differs in file/section header size and relocation entry size. */
5531 static bfd_coff_backend_data ticoff0_swap_table
=
5533 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5534 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5535 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5536 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5537 coff_SWAP_scnhdr_out
,
5538 FILHSZ_V0
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ_V0
, LINESZ
, FILNMLEN
,
5539 #ifdef COFF_LONG_FILENAMES
5544 COFF_DEFAULT_LONG_SECTION_NAMES
,
5545 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5546 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5551 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5557 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5558 coff_SWAP_reloc_in
, ticoff0_bad_format_hook
, coff_set_arch_mach_hook
,
5559 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5560 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5561 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5562 coff_classify_symbol
, coff_compute_section_file_positions
,
5563 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5564 coff_adjust_symndx
, coff_link_add_one_symbol
,
5565 coff_link_output_has_begun
, coff_final_link_postscript
,
5571 /* COFF1 differs in section header size. */
5573 static bfd_coff_backend_data ticoff1_swap_table
=
5575 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5576 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5577 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5578 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5579 coff_SWAP_scnhdr_out
,
5580 FILHSZ
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5581 #ifdef COFF_LONG_FILENAMES
5586 COFF_DEFAULT_LONG_SECTION_NAMES
,
5587 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5588 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5593 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5599 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5600 coff_SWAP_reloc_in
, ticoff1_bad_format_hook
, coff_set_arch_mach_hook
,
5601 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5602 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5603 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5604 coff_classify_symbol
, coff_compute_section_file_positions
,
5605 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5606 coff_adjust_symndx
, coff_link_add_one_symbol
,
5607 coff_link_output_has_begun
, coff_final_link_postscript
,
5608 bfd_pe_print_pdata
/* huh */
5612 #ifdef COFF_WITH_PE_BIGOBJ
5613 /* The UUID for bigobj files. */
5615 static const char header_bigobj_classid
[16] =
5617 0xC7, 0xA1, 0xBA, 0xD1,
5621 0xFA, 0xF6, 0x6A, 0xA4, 0xDC, 0xB8
5624 /* Swap routines. */
5627 coff_bigobj_swap_filehdr_in (bfd
* abfd
, void * src
, void * dst
)
5629 struct external_ANON_OBJECT_HEADER_BIGOBJ
*filehdr_src
=
5630 (struct external_ANON_OBJECT_HEADER_BIGOBJ
*) src
;
5631 struct internal_filehdr
*filehdr_dst
= (struct internal_filehdr
*) dst
;
5633 filehdr_dst
->f_magic
= H_GET_16 (abfd
, filehdr_src
->Machine
);
5634 filehdr_dst
->f_nscns
= H_GET_32 (abfd
, filehdr_src
->NumberOfSections
);
5635 filehdr_dst
->f_timdat
= H_GET_32 (abfd
, filehdr_src
->TimeDateStamp
);
5636 filehdr_dst
->f_symptr
=
5637 GET_FILEHDR_SYMPTR (abfd
, filehdr_src
->PointerToSymbolTable
);
5638 filehdr_dst
->f_nsyms
= H_GET_32 (abfd
, filehdr_src
->NumberOfSymbols
);
5639 filehdr_dst
->f_opthdr
= 0;
5640 filehdr_dst
->f_flags
= 0;
5642 /* Check other magic numbers. */
5643 if (H_GET_16 (abfd
, filehdr_src
->Sig1
) != IMAGE_FILE_MACHINE_UNKNOWN
5644 || H_GET_16 (abfd
, filehdr_src
->Sig2
) != 0xffff
5645 || H_GET_16 (abfd
, filehdr_src
->Version
) != 2
5646 || memcmp (filehdr_src
->ClassID
, header_bigobj_classid
, 16) != 0)
5647 filehdr_dst
->f_opthdr
= 0xffff;
5649 /* Note that CLR metadata are ignored. */
5653 coff_bigobj_swap_filehdr_out (bfd
*abfd
, void * in
, void * out
)
5655 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
5656 struct external_ANON_OBJECT_HEADER_BIGOBJ
*filehdr_out
=
5657 (struct external_ANON_OBJECT_HEADER_BIGOBJ
*) out
;
5659 memset (filehdr_out
, 0, sizeof (*filehdr_out
));
5661 H_PUT_16 (abfd
, IMAGE_FILE_MACHINE_UNKNOWN
, filehdr_out
->Sig1
);
5662 H_PUT_16 (abfd
, 0xffff, filehdr_out
->Sig2
);
5663 H_PUT_16 (abfd
, 2, filehdr_out
->Version
);
5664 memcpy (filehdr_out
->ClassID
, header_bigobj_classid
, 16);
5665 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->Machine
);
5666 H_PUT_32 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->NumberOfSections
);
5667 H_PUT_32 (abfd
, filehdr_in
->f_timdat
, filehdr_out
->TimeDateStamp
);
5668 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
,
5669 filehdr_out
->PointerToSymbolTable
);
5670 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->NumberOfSymbols
);
5672 return bfd_coff_filhsz (abfd
);
5676 coff_bigobj_swap_sym_in (bfd
* abfd
, void * ext1
, void * in1
)
5678 SYMENT_BIGOBJ
*ext
= (SYMENT_BIGOBJ
*) ext1
;
5679 struct internal_syment
*in
= (struct internal_syment
*) in1
;
5681 if (ext
->e
.e_name
[0] == 0)
5683 in
->_n
._n_n
._n_zeroes
= 0;
5684 in
->_n
._n_n
._n_offset
= H_GET_32 (abfd
, ext
->e
.e
.e_offset
);
5688 #if SYMNMLEN != E_SYMNMLEN
5689 #error we need to cope with truncating or extending SYMNMLEN
5691 memcpy (in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
5695 in
->n_value
= H_GET_32 (abfd
, ext
->e_value
);
5696 in
->n_scnum
= H_GET_32 (abfd
, ext
->e_scnum
);
5697 in
->n_type
= H_GET_16 (abfd
, ext
->e_type
);
5698 in
->n_sclass
= H_GET_8 (abfd
, ext
->e_sclass
);
5699 in
->n_numaux
= H_GET_8 (abfd
, ext
->e_numaux
);
5703 coff_bigobj_swap_sym_out (bfd
* abfd
, void * inp
, void * extp
)
5705 struct internal_syment
*in
= (struct internal_syment
*) inp
;
5706 SYMENT_BIGOBJ
*ext
= (SYMENT_BIGOBJ
*) extp
;
5708 if (in
->_n
._n_name
[0] == 0)
5710 H_PUT_32 (abfd
, 0, ext
->e
.e
.e_zeroes
);
5711 H_PUT_32 (abfd
, in
->_n
._n_n
._n_offset
, ext
->e
.e
.e_offset
);
5715 #if SYMNMLEN != E_SYMNMLEN
5716 #error we need to cope with truncating or extending SYMNMLEN
5718 memcpy (ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
5722 H_PUT_32 (abfd
, in
->n_value
, ext
->e_value
);
5723 H_PUT_32 (abfd
, in
->n_scnum
, ext
->e_scnum
);
5725 H_PUT_16 (abfd
, in
->n_type
, ext
->e_type
);
5726 H_PUT_8 (abfd
, in
->n_sclass
, ext
->e_sclass
);
5727 H_PUT_8 (abfd
, in
->n_numaux
, ext
->e_numaux
);
5729 return SYMESZ_BIGOBJ
;
5733 coff_bigobj_swap_aux_in (bfd
*abfd
,
5741 AUXENT_BIGOBJ
*ext
= (AUXENT_BIGOBJ
*) ext1
;
5742 union internal_auxent
*in
= (union internal_auxent
*) in1
;
5750 memcpy (in
->x_file
.x_fname
, ext
->File
.Name
,
5751 numaux
* sizeof (AUXENT_BIGOBJ
));
5754 memcpy (in
->x_file
.x_fname
, ext
->File
.Name
, sizeof (ext
->File
.Name
));
5762 in
->x_scn
.x_scnlen
= H_GET_32 (abfd
, ext
->Section
.Length
);
5763 in
->x_scn
.x_nreloc
=
5764 H_GET_16 (abfd
, ext
->Section
.NumberOfRelocations
);
5765 in
->x_scn
.x_nlinno
=
5766 H_GET_16 (abfd
, ext
->Section
.NumberOfLinenumbers
);
5767 in
->x_scn
.x_checksum
= H_GET_32 (abfd
, ext
->Section
.Checksum
);
5768 in
->x_scn
.x_associated
= H_GET_16 (abfd
, ext
->Section
.Number
)
5769 | (H_GET_16 (abfd
, ext
->Section
.HighNumber
) << 16);
5770 in
->x_scn
.x_comdat
= H_GET_8 (abfd
, ext
->Section
.Selection
);
5776 in
->x_sym
.x_tagndx
.l
= H_GET_32 (abfd
, ext
->Sym
.WeakDefaultSymIndex
);
5777 /* Characteristics is ignored. */
5783 coff_bigobj_swap_aux_out (bfd
* abfd
,
5787 int indx ATTRIBUTE_UNUSED
,
5788 int numaux ATTRIBUTE_UNUSED
,
5791 union internal_auxent
* in
= (union internal_auxent
*) inp
;
5792 AUXENT_BIGOBJ
*ext
= (AUXENT_BIGOBJ
*) extp
;
5794 memset (ext
, 0, AUXESZ
);
5799 memcpy (ext
->File
.Name
, in
->x_file
.x_fname
, sizeof (ext
->File
.Name
));
5808 H_PUT_32 (abfd
, in
->x_scn
.x_scnlen
, ext
->Section
.Length
);
5809 H_PUT_16 (abfd
, in
->x_scn
.x_nreloc
,
5810 ext
->Section
.NumberOfRelocations
);
5811 H_PUT_16 (abfd
, in
->x_scn
.x_nlinno
,
5812 ext
->Section
.NumberOfLinenumbers
);
5813 H_PUT_32 (abfd
, in
->x_scn
.x_checksum
, ext
->Section
.Checksum
);
5814 H_PUT_16 (abfd
, in
->x_scn
.x_associated
& 0xffff,
5815 ext
->Section
.Number
);
5816 H_PUT_16 (abfd
, (in
->x_scn
.x_associated
>> 16),
5817 ext
->Section
.HighNumber
);
5818 H_PUT_8 (abfd
, in
->x_scn
.x_comdat
, ext
->Section
.Selection
);
5824 H_PUT_32 (abfd
, in
->x_sym
.x_tagndx
.l
, ext
->Sym
.WeakDefaultSymIndex
);
5825 H_PUT_32 (abfd
, 1, ext
->Sym
.WeakSearchType
);
5830 static bfd_coff_backend_data bigobj_swap_table
=
5832 coff_bigobj_swap_aux_in
, coff_bigobj_swap_sym_in
, coff_SWAP_lineno_in
,
5833 coff_bigobj_swap_aux_out
, coff_bigobj_swap_sym_out
,
5834 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5835 coff_bigobj_swap_filehdr_out
, coff_SWAP_aouthdr_out
,
5836 coff_SWAP_scnhdr_out
,
5837 FILHSZ_BIGOBJ
, AOUTSZ
, SCNHSZ
, SYMESZ_BIGOBJ
, AUXESZ_BIGOBJ
,
5838 RELSZ
, LINESZ
, FILNMLEN_BIGOBJ
,
5840 COFF_DEFAULT_LONG_SECTION_NAMES
,
5841 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5845 coff_bigobj_swap_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5846 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5847 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5848 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5849 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5850 coff_classify_symbol
, coff_compute_section_file_positions
,
5851 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5852 coff_adjust_symndx
, coff_link_add_one_symbol
,
5853 coff_link_output_has_begun
, coff_final_link_postscript
,
5854 bfd_pe_print_pdata
/* huh */
5857 #endif /* COFF_WITH_PE_BIGOBJ */
5859 #ifndef coff_close_and_cleanup
5860 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5863 #ifndef coff_bfd_free_cached_info
5864 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5867 #ifndef coff_get_section_contents
5868 #define coff_get_section_contents _bfd_generic_get_section_contents
5871 #ifndef coff_bfd_copy_private_symbol_data
5872 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5875 #ifndef coff_bfd_copy_private_header_data
5876 #define coff_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
5879 #ifndef coff_bfd_copy_private_section_data
5880 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5883 #ifndef coff_bfd_copy_private_bfd_data
5884 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5887 #ifndef coff_bfd_merge_private_bfd_data
5888 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5891 #ifndef coff_bfd_set_private_flags
5892 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5895 #ifndef coff_bfd_print_private_bfd_data
5896 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5899 #ifndef coff_bfd_is_local_label_name
5900 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5903 #ifndef coff_bfd_is_target_special_symbol
5904 #define coff_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
5907 #ifndef coff_read_minisymbols
5908 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5911 #ifndef coff_minisymbol_to_symbol
5912 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5915 /* The reloc lookup routine must be supplied by each individual COFF
5917 #ifndef coff_bfd_reloc_type_lookup
5918 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5920 #ifndef coff_bfd_reloc_name_lookup
5921 #define coff_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5924 #ifndef coff_bfd_get_relocated_section_contents
5925 #define coff_bfd_get_relocated_section_contents \
5926 bfd_generic_get_relocated_section_contents
5929 #ifndef coff_bfd_relax_section
5930 #define coff_bfd_relax_section bfd_generic_relax_section
5933 #ifndef coff_bfd_gc_sections
5934 #define coff_bfd_gc_sections bfd_generic_gc_sections
5937 #ifndef coff_bfd_lookup_section_flags
5938 #define coff_bfd_lookup_section_flags bfd_generic_lookup_section_flags
5941 #ifndef coff_bfd_merge_sections
5942 #define coff_bfd_merge_sections bfd_generic_merge_sections
5945 #ifndef coff_bfd_is_group_section
5946 #define coff_bfd_is_group_section bfd_generic_is_group_section
5949 #ifndef coff_bfd_discard_group
5950 #define coff_bfd_discard_group bfd_generic_discard_group
5953 #ifndef coff_section_already_linked
5954 #define coff_section_already_linked \
5955 _bfd_coff_section_already_linked
5958 #ifndef coff_bfd_define_common_symbol
5959 #define coff_bfd_define_common_symbol bfd_generic_define_common_symbol
5962 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5963 const bfd_target VAR = \
5966 bfd_target_coff_flavour, \
5967 BFD_ENDIAN_BIG, /* Data byte order is big. */ \
5968 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5969 /* object flags */ \
5970 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5971 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5972 /* section flags */ \
5973 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5974 UNDER, /* Leading symbol underscore. */ \
5975 '/', /* AR_pad_char. */ \
5976 15, /* AR_max_namelen. */ \
5977 0, /* match priority. */ \
5979 /* Data conversion functions. */ \
5980 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5981 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5982 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5984 /* Header conversion functions. */ \
5985 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5986 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5987 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5989 /* bfd_check_format. */ \
5990 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5991 _bfd_dummy_target }, \
5992 /* bfd_set_format. */ \
5993 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5994 /* bfd_write_contents. */ \
5995 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5998 BFD_JUMP_TABLE_GENERIC (coff), \
5999 BFD_JUMP_TABLE_COPY (coff), \
6000 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
6001 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
6002 BFD_JUMP_TABLE_SYMBOLS (coff), \
6003 BFD_JUMP_TABLE_RELOCS (coff), \
6004 BFD_JUMP_TABLE_WRITE (coff), \
6005 BFD_JUMP_TABLE_LINK (coff), \
6006 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
6013 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
6014 const bfd_target VAR = \
6017 bfd_target_coff_flavour, \
6018 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
6019 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
6020 /* object flags */ \
6021 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
6022 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
6023 /* section flags */ \
6024 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
6025 UNDER, /* Leading symbol underscore. */ \
6026 '/', /* AR_pad_char. */ \
6027 15, /* AR_max_namelen. */ \
6028 0, /* match priority. */ \
6030 /* Data conversion functions. */ \
6031 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
6032 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
6033 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
6035 /* Header conversion functions. */ \
6036 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
6037 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
6038 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
6040 /* bfd_check_format. */ \
6041 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
6042 _bfd_dummy_target }, \
6043 /* bfd_set_format. */ \
6044 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
6045 /* bfd_write_contents. */ \
6046 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
6049 BFD_JUMP_TABLE_GENERIC (coff), \
6050 BFD_JUMP_TABLE_COPY (coff), \
6051 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
6052 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
6053 BFD_JUMP_TABLE_SYMBOLS (coff), \
6054 BFD_JUMP_TABLE_RELOCS (coff), \
6055 BFD_JUMP_TABLE_WRITE (coff), \
6056 BFD_JUMP_TABLE_LINK (coff), \
6057 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
6064 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
6065 const bfd_target VAR = \
6068 bfd_target_coff_flavour, \
6069 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
6070 BFD_ENDIAN_LITTLE, /* Header byte order is little. */ \
6071 /* object flags */ \
6072 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
6073 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
6074 /* section flags */ \
6075 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
6076 UNDER, /* Leading symbol underscore. */ \
6077 '/', /* AR_pad_char. */ \
6078 15, /* AR_max_namelen. */ \
6079 0, /* match priority. */ \
6081 /* Data conversion functions. */ \
6082 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
6083 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
6084 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
6085 /* Header conversion functions. */ \
6086 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
6087 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
6088 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
6089 /* bfd_check_format. */ \
6090 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
6091 _bfd_dummy_target }, \
6092 /* bfd_set_format. */ \
6093 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
6094 /* bfd_write_contents. */ \
6095 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
6098 BFD_JUMP_TABLE_GENERIC (coff), \
6099 BFD_JUMP_TABLE_COPY (coff), \
6100 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
6101 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
6102 BFD_JUMP_TABLE_SYMBOLS (coff), \
6103 BFD_JUMP_TABLE_RELOCS (coff), \
6104 BFD_JUMP_TABLE_WRITE (coff), \
6105 BFD_JUMP_TABLE_LINK (coff), \
6106 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \