1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright (C) 1990-2019 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 i386 coff format is implemented in the file
36 @file{coff-i386.c}. This file @code{#include}s
37 @file{coff/i386.h} which defines the external structure of the
38 coff format for the i386, and @file{coff/internal.h} which
39 defines the internal structure. @file{coff-i386.c} also
40 defines the relocations used by the i386 coff format
44 Porting to a new version of coff
46 The recommended method is to select from the existing
47 implementations the version of coff which is most like the one
48 you want to use. For example, we'll say that i386 coff is
49 the one you select, and that your coff flavour is called foo.
50 Copy @file{i386coff.c} to @file{foocoff.c}, copy
51 @file{../include/coff/i386.h} to @file{../include/coff/foo.h},
52 and add the lines to @file{targets.c} and @file{Makefile.in}
53 so that your new back end is used. Alter the shapes of the
54 structures in @file{../include/coff/foo.h} so that they match
55 what you need. You will probably also have to add
56 @code{#ifdef}s to the code in @file{coff/internal.h} and
57 @file{coffcode.h} if your version of coff is too wild.
59 You can verify that your new BFD backend works quite simply by
60 building @file{objdump} from the @file{binutils} directory,
61 and making sure that its version of what's going on and your
62 host system's idea (assuming it has the pretty standard coff
63 dump utility, usually called @code{att-dump} or just
64 @code{dump}) are the same. Then clean up your code, and send
65 what you've done to Cygnus. Then your stuff will be in the
66 next release, and you won't have to keep integrating it.
69 How the coff backend works
74 The Coff backend is split into generic routines that are
75 applicable to any Coff target and routines that are specific
76 to a particular target. The target-specific routines are
77 further split into ones which are basically the same for all
78 Coff targets except that they use the external symbol format
79 or use different values for certain constants.
81 The generic routines are in @file{coffgen.c}. These routines
82 work for any Coff target. They use some hooks into the target
83 specific code; the hooks are in a @code{bfd_coff_backend_data}
84 structure, one of which exists for each target.
86 The essentially similar target-specific routines are in
87 @file{coffcode.h}. This header file includes executable C code.
88 The various Coff targets first include the appropriate Coff
89 header file, make any special defines that are needed, and
90 then include @file{coffcode.h}.
92 Some of the Coff targets then also have additional routines in
93 the target source file itself.
96 Coff long section names
98 In the standard Coff object format, section names are limited to
99 the eight bytes available in the @code{s_name} field of the
100 @code{SCNHDR} section header structure. The format requires the
101 field to be NUL-padded, but not necessarily NUL-terminated, so
102 the longest section names permitted are a full eight characters.
104 The Microsoft PE variants of the Coff object file format add
105 an extension to support the use of long section names. This
106 extension is defined in section 4 of the Microsoft PE/COFF
107 specification (rev 8.1). If a section name is too long to fit
108 into the section header's @code{s_name} field, it is instead
109 placed into the string table, and the @code{s_name} field is
110 filled with a slash ("/") followed by the ASCII decimal
111 representation of the offset of the full name relative to the
114 Note that this implies that the extension can only be used in object
115 files, as executables do not contain a string table. The standard
116 specifies that long section names from objects emitted into executable
117 images are to be truncated.
119 However, as a GNU extension, BFD can generate executable images
120 that contain a string table and long section names. This
121 would appear to be technically valid, as the standard only says
122 that Coff debugging information is deprecated, not forbidden,
123 and in practice it works, although some tools that parse PE files
124 expecting the MS standard format may become confused; @file{PEview} is
127 The functionality is supported in BFD by code implemented under
128 the control of the macro @code{COFF_LONG_SECTION_NAMES}. If not
129 defined, the format does not support long section names in any way.
130 If defined, it is used to initialise a flag,
131 @code{_bfd_coff_long_section_names}, and a hook function pointer,
132 @code{_bfd_coff_set_long_section_names}, in the Coff backend data
133 structure. The flag controls the generation of long section names
134 in output BFDs at runtime; if it is false, as it will be by default
135 when generating an executable image, long section names are truncated;
136 if true, the long section names extension is employed. The hook
137 points to a function that allows the value of the flag to be altered
138 at runtime, on formats that support long section names at all; on
139 other formats it points to a stub that returns an error indication.
141 With input BFDs, the flag is set according to whether any long section
142 names are detected while reading the section headers. For a completely
143 new BFD, the flag is set to the default for the target format. This
144 information can be used by a client of the BFD library when deciding
145 what output format to generate, and means that a BFD that is opened
146 for read and subsequently converted to a writeable BFD and modified
147 in-place will retain whatever format it had on input.
149 If @code{COFF_LONG_SECTION_NAMES} is simply defined (blank), or is
150 defined to the value "1", then long section names are enabled by
151 default; if it is defined to the value zero, they are disabled by
152 default (but still accepted in input BFDs). The header @file{coffcode.h}
153 defines a macro, @code{COFF_DEFAULT_LONG_SECTION_NAMES}, which is
154 used in the backends to initialise the backend data structure fields
155 appropriately; see the comments for further detail.
160 Each flavour of coff supported in BFD has its own header file
161 describing the external layout of the structures. There is also
162 an internal description of the coff layout, in
163 @file{coff/internal.h}. A major function of the
164 coff backend is swapping the bytes and twiddling the bits to
165 translate the external form of the structures into the normal
166 internal form. This is all performed in the
167 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
168 elements are different sizes between different versions of
169 coff; it is the duty of the coff version specific include file
170 to override the definitions of various packing routines in
171 @file{coffcode.h}. E.g., the size of line number entry in coff is
172 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
173 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
174 correct one. No doubt, some day someone will find a version of
175 coff which has a varying field size not catered to at the
176 moment. To port BFD, that person will have to add more @code{#defines}.
177 Three of the bit twiddling routines are exported to
178 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
179 and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol
180 table on its own, but uses BFD to fix things up. More of the
181 bit twiddlers are exported for @code{gas};
182 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
183 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
184 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
185 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
186 of all the symbol table and reloc drudgery itself, thereby
187 saving the internal BFD overhead, but uses BFD to swap things
188 on the way out, making cross ports much safer. Doing so also
189 allows BFD (and thus the linker) to use the same header files
190 as @code{gas}, which makes one avenue to disaster disappear.
195 The simple canonical form for symbols used by BFD is not rich
196 enough to keep all the information available in a coff symbol
197 table. The back end gets around this problem by keeping the original
198 symbol table around, "behind the scenes".
200 When a symbol table is requested (through a call to
201 @code{bfd_canonicalize_symtab}), a request gets through to
202 @code{coff_get_normalized_symtab}. This reads the symbol table from
203 the coff file and swaps all the structures inside into the
204 internal form. It also fixes up all the pointers in the table
205 (represented in the file by offsets from the first symbol in
206 the table) into physical pointers to elements in the new
207 internal table. This involves some work since the meanings of
208 fields change depending upon context: a field that is a
209 pointer to another structure in the symbol table at one moment
210 may be the size in bytes of a structure at the next. Another
211 pass is made over the table. All symbols which mark file names
212 (<<C_FILE>> symbols) are modified so that the internal
213 string points to the value in the auxent (the real filename)
214 rather than the normal text associated with the symbol
217 At this time the symbol names are moved around. Coff stores
218 all symbols less than nine characters long physically
219 within the symbol table; longer strings are kept at the end of
220 the file in the string table. This pass moves all strings
221 into memory and replaces them with pointers to the strings.
223 The symbol table is massaged once again, this time to create
224 the canonical table used by the BFD application. Each symbol
225 is inspected in turn, and a decision made (using the
226 @code{sclass} field) about the various flags to set in the
227 @code{asymbol}. @xref{Symbols}. The generated canonical table
228 shares strings with the hidden internal symbol table.
230 Any linenumbers are read from the coff file too, and attached
231 to the symbols which own the functions the linenumbers belong to.
236 Writing a symbol to a coff file which didn't come from a coff
237 file will lose any debugging information. The @code{asymbol}
238 structure remembers the BFD from which the symbol was taken, and on
239 output the back end makes sure that the same destination target as
240 source target is present.
242 When the symbols have come from a coff file then all the
243 debugging information is preserved.
245 Symbol tables are provided for writing to the back end in a
246 vector of pointers to pointers. This allows applications like
247 the linker to accumulate and output large symbol tables
248 without having to do too much byte copying.
250 This function runs through the provided symbol table and
251 patches each symbol marked as a file place holder
252 (@code{C_FILE}) to point to the next file place holder in the
253 list. It also marks each @code{offset} field in the list with
254 the offset from the first symbol of the current symbol.
256 Another function of this procedure is to turn the canonical
257 value form of BFD into the form used by coff. Internally, BFD
258 expects symbol values to be offsets from a section base; so a
259 symbol physically at 0x120, but in a section starting at
260 0x100, would have the value 0x20. Coff expects symbols to
261 contain their final value, so symbols have their values
262 changed at this point to reflect their sum with their owning
263 section. This transformation uses the
264 <<output_section>> field of the @code{asymbol}'s
265 @code{asection} @xref{Sections}.
267 o <<coff_mangle_symbols>>
269 This routine runs though the provided symbol table and uses
270 the offsets generated by the previous pass and the pointers
271 generated when the symbol table was read in to create the
272 structured hierarchy required by coff. It changes each pointer
273 to a symbol into the index into the symbol table of the asymbol.
275 o <<coff_write_symbols>>
277 This routine runs through the symbol table and patches up the
278 symbols from their internal form into the coff way, calls the
279 bit twiddlers, and writes out the table to the file.
288 The hidden information for an <<asymbol>> is described in a
289 <<combined_entry_type>>:
293 .typedef struct coff_ptr_struct
295 . {* Remembers the offset from the first symbol in the file for
296 . this symbol. Generated by coff_renumber_symbols. *}
297 . unsigned int offset;
299 . {* Should the value of this symbol be renumbered. Used for
300 . XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
301 . unsigned int fix_value : 1;
303 . {* Should the tag field of this symbol be renumbered.
304 . Created by coff_pointerize_aux. *}
305 . unsigned int fix_tag : 1;
307 . {* Should the endidx field of this symbol be renumbered.
308 . Created by coff_pointerize_aux. *}
309 . unsigned int fix_end : 1;
311 . {* Should the x_csect.x_scnlen field be renumbered.
312 . Created by coff_pointerize_aux. *}
313 . unsigned int fix_scnlen : 1;
315 . {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
316 . index into the line number entries. Set by coff_slurp_symbol_table. *}
317 . unsigned int fix_line : 1;
319 . {* The container for the symbol structure as read and translated
323 . union internal_auxent auxent;
324 . struct internal_syment syment;
327 . {* Selector for the union above. *}
328 . bfd_boolean is_sym;
329 .} combined_entry_type;
332 .{* Each canonical asymbol really looks like this: *}
334 .typedef struct coff_symbol_struct
336 . {* The actual symbol which the rest of BFD works with *}
339 . {* A pointer to the hidden information for this symbol *}
340 . combined_entry_type *native;
342 . {* A pointer to the linenumber information for this symbol *}
343 . struct lineno_cache_entry *lineno;
345 . {* Have the line numbers been relocated yet ? *}
346 . bfd_boolean done_lineno;
351 #include "libiberty.h"
356 #include "coffswap.h"
359 #define STRING_SIZE_SIZE 4
361 #define DOT_DEBUG ".debug"
362 #define DOT_ZDEBUG ".zdebug"
363 #define GNU_LINKONCE_WI ".gnu.linkonce.wi."
364 #define GNU_LINKONCE_WT ".gnu.linkonce.wt."
365 #define DOT_RELOC ".reloc"
367 #if defined (COFF_LONG_SECTION_NAMES)
368 /* Needed to expand the inputs to BLANKOR1TOODD. */
369 #define COFFLONGSECTIONCATHELPER(x,y) x ## y
370 /* If the input macro Y is blank or '1', return an odd number; if it is
371 '0', return an even number. Result undefined in all other cases. */
372 #define BLANKOR1TOODD(y) COFFLONGSECTIONCATHELPER(1,y)
373 /* Defined to numerical 0 or 1 according to whether generation of long
374 section names is disabled or enabled by default. */
375 #define COFF_ENABLE_LONG_SECTION_NAMES (BLANKOR1TOODD(COFF_LONG_SECTION_NAMES) & 1)
376 /* Where long section names are supported, we allow them to be enabled
377 and disabled at runtime, so select an appropriate hook function for
378 _bfd_coff_set_long_section_names. */
379 #define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_allowed
380 #else /* !defined (COFF_LONG_SECTION_NAMES) */
381 /* If long section names are not supported, this stub disallows any
382 attempt to enable them at run-time. */
383 #define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_disallowed
384 #endif /* defined (COFF_LONG_SECTION_NAMES) */
386 /* Define a macro that can be used to initialise both the fields relating
387 to long section names in the backend data struct simultaneously. */
388 #if COFF_ENABLE_LONG_SECTION_NAMES
389 #define COFF_DEFAULT_LONG_SECTION_NAMES (TRUE), COFF_LONG_SECTION_NAMES_SETTER
390 #else /* !COFF_ENABLE_LONG_SECTION_NAMES */
391 #define COFF_DEFAULT_LONG_SECTION_NAMES (FALSE), COFF_LONG_SECTION_NAMES_SETTER
392 #endif /* COFF_ENABLE_LONG_SECTION_NAMES */
394 #if defined (COFF_LONG_SECTION_NAMES)
395 static bfd_boolean bfd_coff_set_long_section_names_allowed
397 #else /* !defined (COFF_LONG_SECTION_NAMES) */
398 static bfd_boolean bfd_coff_set_long_section_names_disallowed
400 #endif /* defined (COFF_LONG_SECTION_NAMES) */
401 static long sec_to_styp_flags
402 (const char *, flagword
);
403 static bfd_boolean styp_to_sec_flags
404 (bfd
*, void *, const char *, asection
*, flagword
*);
405 static bfd_boolean coff_bad_format_hook
407 static void coff_set_custom_section_alignment
408 (bfd
*, asection
*, const struct coff_section_alignment_entry
*,
410 static bfd_boolean coff_new_section_hook
412 static bfd_boolean coff_set_arch_mach_hook
414 static bfd_boolean coff_write_relocs
416 static bfd_boolean coff_set_flags
417 (bfd
*, unsigned int *, unsigned short *);
418 static bfd_boolean coff_set_arch_mach
419 (bfd
*, enum bfd_architecture
, unsigned long) ATTRIBUTE_UNUSED
;
420 static bfd_boolean coff_compute_section_file_positions
422 static bfd_boolean coff_write_object_contents
423 (bfd
*) ATTRIBUTE_UNUSED
;
424 static bfd_boolean coff_set_section_contents
425 (bfd
*, asection
*, const void *, file_ptr
, bfd_size_type
);
426 static bfd_boolean coff_slurp_line_table
428 static bfd_boolean coff_slurp_symbol_table
430 static enum coff_symbol_classification coff_classify_symbol
431 (bfd
*, struct internal_syment
*);
432 static bfd_boolean coff_slurp_reloc_table
433 (bfd
*, asection
*, asymbol
**);
434 static long coff_canonicalize_reloc
435 (bfd
*, asection
*, arelent
**, asymbol
**);
436 #ifndef coff_mkobject_hook
437 static void * coff_mkobject_hook
438 (bfd
*, void *, void *);
441 static flagword handle_COMDAT
442 (bfd
*, flagword
, void *, const char *, asection
*);
444 #ifdef COFF_IMAGE_WITH_PE
445 static bfd_boolean coff_read_word
446 (bfd
*, unsigned int *);
447 static unsigned int coff_compute_checksum
449 static bfd_boolean coff_apply_checksum
453 static bfd_boolean ticoff0_bad_format_hook
455 static bfd_boolean ticoff1_bad_format_hook
459 /* void warning(); */
461 #if defined (COFF_LONG_SECTION_NAMES)
463 bfd_coff_set_long_section_names_allowed (bfd
*abfd
, int enable
)
465 coff_backend_info (abfd
)->_bfd_coff_long_section_names
= enable
;
468 #else /* !defined (COFF_LONG_SECTION_NAMES) */
470 bfd_coff_set_long_section_names_disallowed (bfd
*abfd
, int enable
)
476 #endif /* defined (COFF_LONG_SECTION_NAMES) */
478 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
479 the incoming SEC_* flags. The inverse of this function is
480 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
481 should probably mirror the changes in styp_to_sec_flags(). */
485 /* Macros for setting debugging flags. */
488 #define STYP_XCOFF_DEBUG STYP_DEBUG
490 #define STYP_XCOFF_DEBUG STYP_INFO
493 #ifdef COFF_ALIGN_IN_S_FLAGS
494 #define STYP_DEBUG_INFO STYP_DSECT
496 #define STYP_DEBUG_INFO STYP_INFO
500 sec_to_styp_flags (const char *sec_name
, flagword sec_flags
)
504 if (!strcmp (sec_name
, _TEXT
))
506 styp_flags
= STYP_TEXT
;
508 else if (!strcmp (sec_name
, _DATA
))
510 styp_flags
= STYP_DATA
;
512 else if (!strcmp (sec_name
, _BSS
))
514 styp_flags
= STYP_BSS
;
517 else if (!strcmp (sec_name
, _COMMENT
))
519 styp_flags
= STYP_INFO
;
520 #endif /* _COMMENT */
523 else if (!strcmp (sec_name
, _LIB
))
525 styp_flags
= STYP_LIB
;
529 else if (!strcmp (sec_name
, _LIT
))
531 styp_flags
= STYP_LIT
;
534 else if (CONST_STRNEQ (sec_name
, DOT_DEBUG
)
535 || CONST_STRNEQ (sec_name
, DOT_ZDEBUG
))
537 /* Handle the XCOFF debug section and DWARF2 debug sections. */
539 styp_flags
= STYP_XCOFF_DEBUG
;
541 styp_flags
= STYP_DEBUG_INFO
;
543 else if (CONST_STRNEQ (sec_name
, ".stab"))
545 styp_flags
= STYP_DEBUG_INFO
;
547 #ifdef COFF_LONG_SECTION_NAMES
548 else if (CONST_STRNEQ (sec_name
, GNU_LINKONCE_WI
)
549 || CONST_STRNEQ (sec_name
, GNU_LINKONCE_WT
))
551 styp_flags
= STYP_DEBUG_INFO
;
555 else if (!strcmp (sec_name
, _PAD
))
557 styp_flags
= STYP_PAD
;
559 else if (!strcmp (sec_name
, _LOADER
))
561 styp_flags
= STYP_LOADER
;
563 else if (!strcmp (sec_name
, _EXCEPT
))
565 styp_flags
= STYP_EXCEPT
;
567 else if (!strcmp (sec_name
, _TYPCHK
))
569 styp_flags
= STYP_TYPCHK
;
571 else if (sec_flags
& SEC_DEBUGGING
)
575 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
576 if (!strcmp (sec_name
, xcoff_dwsect_names
[i
].name
))
578 styp_flags
= STYP_DWARF
| xcoff_dwsect_names
[i
].flag
;
583 /* Try and figure out what it should be */
584 else if (sec_flags
& SEC_CODE
)
586 styp_flags
= STYP_TEXT
;
588 else if (sec_flags
& SEC_DATA
)
590 styp_flags
= STYP_DATA
;
592 else if (sec_flags
& SEC_READONLY
)
594 #ifdef STYP_LIT /* 29k readonly text/data section */
595 styp_flags
= STYP_LIT
;
597 styp_flags
= STYP_TEXT
;
598 #endif /* STYP_LIT */
600 else if (sec_flags
& SEC_LOAD
)
602 styp_flags
= STYP_TEXT
;
604 else if (sec_flags
& SEC_ALLOC
)
606 styp_flags
= STYP_BSS
;
610 if (sec_flags
& SEC_TIC54X_CLINK
)
611 styp_flags
|= STYP_CLINK
;
615 if (sec_flags
& SEC_TIC54X_BLOCK
)
616 styp_flags
|= STYP_BLOCK
;
620 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
621 styp_flags
|= STYP_NOLOAD
;
627 #else /* COFF_WITH_PE */
629 /* The PE version; see above for the general comments. The non-PE
630 case seems to be more guessing, and breaks PE format; specifically,
631 .rdata is readonly, but it sure ain't text. Really, all this
632 should be set up properly in gas (or whatever assembler is in use),
633 and honor whatever objcopy/strip, etc. sent us as input. */
636 sec_to_styp_flags (const char *sec_name
, flagword sec_flags
)
639 bfd_boolean is_dbg
= FALSE
;
641 if (CONST_STRNEQ (sec_name
, DOT_DEBUG
)
642 || CONST_STRNEQ (sec_name
, DOT_ZDEBUG
)
643 #ifdef COFF_LONG_SECTION_NAMES
644 || CONST_STRNEQ (sec_name
, GNU_LINKONCE_WI
)
645 || CONST_STRNEQ (sec_name
, GNU_LINKONCE_WT
)
647 || CONST_STRNEQ (sec_name
, ".stab"))
650 /* caution: there are at least three groups of symbols that have
651 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
652 SEC_* are the BFD internal flags, used for generic BFD
653 information. STYP_* are the COFF section flags which appear in
654 COFF files. IMAGE_SCN_* are the PE section flags which appear in
655 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
656 but there are more IMAGE_SCN_* flags. */
658 /* FIXME: There is no gas syntax to specify the debug section flag. */
661 sec_flags
&= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
662 | SEC_LINK_DUPLICATES_SAME_CONTENTS
663 | SEC_LINK_DUPLICATES_SAME_SIZE
);
664 sec_flags
|= SEC_DEBUGGING
| SEC_READONLY
;
670 if ((sec_flags
& SEC_CODE
) != 0)
671 styp_flags
|= IMAGE_SCN_CNT_CODE
;
672 if ((sec_flags
& (SEC_DATA
| SEC_DEBUGGING
)) != 0)
673 styp_flags
|= IMAGE_SCN_CNT_INITIALIZED_DATA
;
674 if ((sec_flags
& SEC_ALLOC
) != 0 && (sec_flags
& SEC_LOAD
) == 0)
675 styp_flags
|= IMAGE_SCN_CNT_UNINITIALIZED_DATA
; /* ==STYP_BSS */
677 /* skip constRUCTOR */
679 if ((sec_flags
& SEC_IS_COMMON
) != 0)
680 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
681 if ((sec_flags
& SEC_DEBUGGING
) != 0)
682 styp_flags
|= IMAGE_SCN_MEM_DISCARDABLE
;
683 if ((sec_flags
& SEC_EXCLUDE
) != 0 && !is_dbg
)
684 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
685 if ((sec_flags
& SEC_NEVER_LOAD
) != 0 && !is_dbg
)
686 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
689 if (sec_flags
& SEC_LINK_ONCE
)
690 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
692 & (SEC_LINK_DUPLICATES_DISCARD
| SEC_LINK_DUPLICATES_SAME_CONTENTS
693 | SEC_LINK_DUPLICATES_SAME_SIZE
)) != 0)
694 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
696 /* skip LINKER_CREATED */
698 if ((sec_flags
& SEC_COFF_NOREAD
) == 0)
699 styp_flags
|= IMAGE_SCN_MEM_READ
; /* Invert NOREAD for read. */
700 if ((sec_flags
& SEC_READONLY
) == 0)
701 styp_flags
|= IMAGE_SCN_MEM_WRITE
; /* Invert READONLY for write. */
702 if (sec_flags
& SEC_CODE
)
703 styp_flags
|= IMAGE_SCN_MEM_EXECUTE
; /* CODE->EXECUTE. */
704 if (sec_flags
& SEC_COFF_SHARED
)
705 styp_flags
|= IMAGE_SCN_MEM_SHARED
; /* Shared remains meaningful. */
710 #endif /* COFF_WITH_PE */
712 /* Return a word with SEC_* flags set to represent the incoming STYP_*
713 flags (from scnhdr.s_flags). The inverse of this function is
714 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
715 should probably mirror the changes in sec_to_styp_flags(). */
720 styp_to_sec_flags (bfd
*abfd ATTRIBUTE_UNUSED
,
723 asection
*section ATTRIBUTE_UNUSED
,
726 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
727 long styp_flags
= internal_s
->s_flags
;
728 flagword sec_flags
= 0;
731 if (styp_flags
& STYP_BLOCK
)
732 sec_flags
|= SEC_TIC54X_BLOCK
;
736 if (styp_flags
& STYP_CLINK
)
737 sec_flags
|= SEC_TIC54X_CLINK
;
741 if (styp_flags
& STYP_NOLOAD
)
742 sec_flags
|= SEC_NEVER_LOAD
;
743 #endif /* STYP_NOLOAD */
745 /* For 386 COFF, at least, an unloadable text or data section is
746 actually a shared library section. */
747 if (styp_flags
& STYP_TEXT
)
749 if (sec_flags
& SEC_NEVER_LOAD
)
750 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
752 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
754 else if (styp_flags
& STYP_DATA
)
756 if (sec_flags
& SEC_NEVER_LOAD
)
757 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
759 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
761 else if (styp_flags
& STYP_BSS
)
763 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
764 if (sec_flags
& SEC_NEVER_LOAD
)
765 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
768 sec_flags
|= SEC_ALLOC
;
770 else if (styp_flags
& STYP_INFO
)
772 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
773 defined. coff_compute_section_file_positions uses
774 COFF_PAGE_SIZE to ensure that the low order bits of the
775 section VMA and the file offset match. If we don't know
776 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
777 and demand page loading of the file will fail. */
778 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
779 sec_flags
|= SEC_DEBUGGING
;
782 else if (styp_flags
& STYP_PAD
)
785 else if (styp_flags
& STYP_EXCEPT
)
786 sec_flags
|= SEC_LOAD
;
787 else if (styp_flags
& STYP_LOADER
)
788 sec_flags
|= SEC_LOAD
;
789 else if (styp_flags
& STYP_TYPCHK
)
790 sec_flags
|= SEC_LOAD
;
791 else if (styp_flags
& STYP_DWARF
)
792 sec_flags
|= SEC_DEBUGGING
;
794 else if (strcmp (name
, _TEXT
) == 0)
796 if (sec_flags
& SEC_NEVER_LOAD
)
797 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
799 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
801 else if (strcmp (name
, _DATA
) == 0)
803 if (sec_flags
& SEC_NEVER_LOAD
)
804 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
806 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
808 else if (strcmp (name
, _BSS
) == 0)
810 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
811 if (sec_flags
& SEC_NEVER_LOAD
)
812 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
815 sec_flags
|= SEC_ALLOC
;
817 else if (CONST_STRNEQ (name
, DOT_DEBUG
)
818 || CONST_STRNEQ (name
, DOT_ZDEBUG
)
820 || strcmp (name
, _COMMENT
) == 0
822 #ifdef COFF_LONG_SECTION_NAMES
823 || CONST_STRNEQ (name
, GNU_LINKONCE_WI
)
824 || CONST_STRNEQ (name
, GNU_LINKONCE_WT
)
826 || CONST_STRNEQ (name
, ".stab"))
828 #ifdef COFF_PAGE_SIZE
829 sec_flags
|= SEC_DEBUGGING
;
833 else if (strcmp (name
, _LIB
) == 0)
837 else if (strcmp (name
, _LIT
) == 0)
838 sec_flags
= SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
841 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
843 #ifdef STYP_LIT /* A29k readonly text/data section type. */
844 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
845 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
846 #endif /* STYP_LIT */
848 #ifdef STYP_OTHER_LOAD /* Other loaded sections. */
849 if (styp_flags
& STYP_OTHER_LOAD
)
850 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
851 #endif /* STYP_SDATA */
853 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
854 /* As a GNU extension, if the name begins with .gnu.linkonce, we
855 only link a single copy of the section. This is used to support
856 g++. g++ will emit each template expansion in its own section.
857 The symbols will be defined as weak, so that multiple definitions
858 are permitted. The GNU linker extension is to actually discard
859 all but one of the sections. */
860 if (CONST_STRNEQ (name
, ".gnu.linkonce"))
861 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
864 if (flags_ptr
== NULL
)
867 * flags_ptr
= sec_flags
;
871 #else /* COFF_WITH_PE */
874 handle_COMDAT (bfd
* abfd
,
880 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
881 bfd_byte
*esymstart
, *esym
, *esymend
;
883 char *target_name
= NULL
;
885 sec_flags
|= SEC_LINK_ONCE
;
887 /* Unfortunately, the PE format stores essential information in
888 the symbol table, of all places. We need to extract that
889 information now, so that objdump and the linker will know how
890 to handle the section without worrying about the symbols. We
891 can't call slurp_symtab, because the linker doesn't want the
894 /* COMDAT sections are special. The first symbol is the section
895 symbol, which tells what kind of COMDAT section it is. The
896 second symbol is the "comdat symbol" - the one with the
897 unique name. GNU uses the section symbol for the unique
898 name; MS uses ".text" for every comdat section. Sigh. - DJ */
900 /* This is not mirrored in sec_to_styp_flags(), but there
901 doesn't seem to be a need to, either, and it would at best be
904 if (! _bfd_coff_get_external_symbols (abfd
))
907 esymstart
= esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
908 esymend
= esym
+ obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
910 while (esym
< esymend
)
912 struct internal_syment isym
;
913 char buf
[SYMNMLEN
+ 1];
916 bfd_coff_swap_sym_in (abfd
, esym
, & isym
);
918 BFD_ASSERT (sizeof (internal_s
->s_name
) <= SYMNMLEN
);
920 if (isym
.n_scnum
== section
->target_index
)
922 /* According to the MSVC documentation, the first
923 TWO entries with the section # are both of
924 interest to us. The first one is the "section
925 symbol" (section name). The second is the comdat
926 symbol name. Here, we've found the first
927 qualifying entry; we distinguish it from the
928 second with a state flag.
930 In the case of gas-generated (at least until that
931 is fixed) .o files, it isn't necessarily the
932 second one. It may be some other later symbol.
934 Since gas also doesn't follow MS conventions and
935 emits the section similar to .text$<name>, where
936 <something> is the name we're looking for, we
937 distinguish the two as follows:
939 If the section name is simply a section name (no
940 $) we presume it's MS-generated, and look at
941 precisely the second symbol for the comdat name.
942 If the section name has a $, we assume it's
943 gas-generated, and look for <something> (whatever
944 follows the $) as the comdat symbol. */
946 /* All 3 branches use this. */
947 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
, buf
);
949 /* PR 17512 file: 078-11867-0.004 */
952 _bfd_error_handler (_("%pB: unable to load COMDAT section name"),
961 /* The first time we've seen the symbol. */
962 union internal_auxent aux
;
964 /* If it isn't the stuff we're expecting, die;
965 The MS documentation is vague, but it
966 appears that the second entry serves BOTH
967 as the comdat symbol and the defining
968 symbol record (either C_STAT or C_EXT,
969 possibly with an aux entry with debug
970 information if it's a function.) It
971 appears the only way to find the second one
972 is to count. (On Intel, they appear to be
973 adjacent, but on Alpha, they have been
976 Here, we think we've found the first one,
977 but there's some checking we can do to be
980 if (! ((isym
.n_sclass
== C_STAT
981 || isym
.n_sclass
== C_EXT
)
982 && BTYPE (isym
.n_type
) == T_NULL
983 && isym
.n_value
== 0))
985 /* Malformed input files can trigger this test.
987 _bfd_error_handler (_("%pB: error: unexpected symbol '%s' in COMDAT section"),
992 /* FIXME LATER: MSVC generates section names
993 like .text for comdats. Gas generates
994 names like .text$foo__Fv (in the case of a
995 function). See comment above for more. */
997 if (isym
.n_sclass
== C_STAT
&& strcmp (name
, symname
) != 0)
998 /* xgettext:c-format */
999 _bfd_error_handler (_("%pB: warning: COMDAT symbol '%s'"
1000 " does not match section name '%s'"),
1001 abfd
, symname
, name
);
1005 /* PR 17512: file: e2cfe54f. */
1006 if (esym
+ bfd_coff_symesz (abfd
) >= esymend
)
1008 /* xgettext:c-format */
1009 _bfd_error_handler (_("%pB: warning: no symbol for"
1010 " section '%s' found"),
1014 /* This is the section symbol. */
1015 bfd_coff_swap_aux_in (abfd
, (esym
+ bfd_coff_symesz (abfd
)),
1016 isym
.n_type
, isym
.n_sclass
,
1017 0, isym
.n_numaux
, & aux
);
1019 target_name
= strchr (name
, '$');
1020 if (target_name
!= NULL
)
1028 /* FIXME: Microsoft uses NODUPLICATES and
1029 ASSOCIATIVE, but gnu uses ANY and
1030 SAME_SIZE. Unfortunately, gnu doesn't do
1031 the comdat symbols right. So, until we can
1032 fix it to do the right thing, we are
1033 temporarily disabling comdats for the MS
1034 types (they're used in DLLs and C++, but we
1035 don't support *their* C++ libraries anyway
1038 /* Cygwin does not follow the MS style, and
1039 uses ANY and SAME_SIZE where NODUPLICATES
1040 and ASSOCIATIVE should be used. For
1041 Interix, we just do the right thing up
1044 switch (aux
.x_scn
.x_comdat
)
1046 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
1047 #ifdef STRICT_PE_FORMAT
1048 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
1050 sec_flags
&= ~SEC_LINK_ONCE
;
1054 case IMAGE_COMDAT_SELECT_ANY
:
1055 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1058 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
1059 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
1062 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
1063 /* Not yet fully implemented ??? */
1064 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
1067 /* debug$S gets this case; other
1070 /* There may be no symbol... we'll search
1071 the whole table... Is this the right
1072 place to play this game? Or should we do
1073 it when reading it in. */
1074 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
1075 #ifdef STRICT_PE_FORMAT
1076 /* FIXME: This is not currently implemented. */
1077 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1079 sec_flags
&= ~SEC_LINK_ONCE
;
1083 default: /* 0 means "no symbol" */
1084 /* debug$F gets this case; other
1086 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1093 /* Gas mode: the first matching on partial name. */
1095 #ifndef TARGET_UNDERSCORE
1096 #define TARGET_UNDERSCORE 0
1098 /* Is this the name we're looking for ? */
1099 if (strcmp (target_name
,
1100 symname
+ (TARGET_UNDERSCORE
? 1 : 0)) != 0)
1102 /* Not the name we're looking for */
1103 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1108 /* MSVC mode: the lexically second symbol (or
1109 drop through from the above). */
1114 /* This must the second symbol with the
1115 section #. It is the actual symbol name.
1116 Intel puts the two adjacent, but Alpha (at
1117 least) spreads them out. */
1119 amt
= sizeof (struct coff_comdat_info
);
1120 coff_section_data (abfd
, section
)->comdat
1121 = (struct coff_comdat_info
*) bfd_alloc (abfd
, amt
);
1122 if (coff_section_data (abfd
, section
)->comdat
== NULL
)
1125 coff_section_data (abfd
, section
)->comdat
->symbol
=
1126 (esym
- esymstart
) / bfd_coff_symesz (abfd
);
1128 amt
= strlen (symname
) + 1;
1129 newname
= (char *) bfd_alloc (abfd
, amt
);
1130 if (newname
== NULL
)
1133 strcpy (newname
, symname
);
1134 coff_section_data (abfd
, section
)->comdat
->name
1142 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1150 /* The PE version; see above for the general comments.
1152 Since to set the SEC_LINK_ONCE and associated flags, we have to
1153 look at the symbol table anyway, we return the symbol table index
1154 of the symbol being used as the COMDAT symbol. This is admittedly
1155 ugly, but there's really nowhere else that we have access to the
1156 required information. FIXME: Is the COMDAT symbol index used for
1157 any purpose other than objdump? */
1160 styp_to_sec_flags (bfd
*abfd
,
1164 flagword
*flags_ptr
)
1166 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
1167 unsigned long styp_flags
= internal_s
->s_flags
;
1169 bfd_boolean result
= TRUE
;
1170 bfd_boolean is_dbg
= FALSE
;
1172 if (CONST_STRNEQ (name
, DOT_DEBUG
)
1173 || CONST_STRNEQ (name
, DOT_ZDEBUG
)
1174 #ifdef COFF_LONG_SECTION_NAMES
1175 || CONST_STRNEQ (name
, GNU_LINKONCE_WI
)
1176 || CONST_STRNEQ (name
, GNU_LINKONCE_WT
)
1177 /* FIXME: These definitions ought to be in a header file. */
1178 #define GNU_DEBUGLINK ".gnu_debuglink"
1179 #define GNU_DEBUGALTLINK ".gnu_debugaltlink"
1180 || CONST_STRNEQ (name
, GNU_DEBUGLINK
)
1181 || CONST_STRNEQ (name
, GNU_DEBUGALTLINK
)
1183 || CONST_STRNEQ (name
, ".stab"))
1185 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
1186 sec_flags
= SEC_READONLY
;
1188 /* If section disallows read, then set the NOREAD flag. */
1189 if ((styp_flags
& IMAGE_SCN_MEM_READ
) == 0)
1190 sec_flags
|= SEC_COFF_NOREAD
;
1192 /* Process each flag bit in styp_flags in turn. */
1195 unsigned long flag
= styp_flags
& - styp_flags
;
1196 char * unhandled
= NULL
;
1198 styp_flags
&= ~ flag
;
1200 /* We infer from the distinct read/write/execute bits the settings
1201 of some of the bfd flags; the actual values, should we need them,
1202 are also in pei_section_data (abfd, section)->pe_flags. */
1207 unhandled
= "STYP_DSECT";
1210 unhandled
= "STYP_GROUP";
1213 unhandled
= "STYP_COPY";
1216 unhandled
= "STYP_OVER";
1218 #ifdef SEC_NEVER_LOAD
1220 sec_flags
|= SEC_NEVER_LOAD
;
1223 case IMAGE_SCN_MEM_READ
:
1224 sec_flags
&= ~SEC_COFF_NOREAD
;
1226 case IMAGE_SCN_TYPE_NO_PAD
:
1229 case IMAGE_SCN_LNK_OTHER
:
1230 unhandled
= "IMAGE_SCN_LNK_OTHER";
1232 case IMAGE_SCN_MEM_NOT_CACHED
:
1233 unhandled
= "IMAGE_SCN_MEM_NOT_CACHED";
1235 case IMAGE_SCN_MEM_NOT_PAGED
:
1236 /* Generate a warning message rather using the 'unhandled'
1237 variable as this will allow some .sys files generate by
1238 other toolchains to be processed. See bugzilla issue 196. */
1239 /* xgettext:c-format */
1240 _bfd_error_handler (_("%pB: warning: ignoring section flag"
1241 " %s in section %s"),
1242 abfd
, "IMAGE_SCN_MEM_NOT_PAGED", name
);
1244 case IMAGE_SCN_MEM_EXECUTE
:
1245 sec_flags
|= SEC_CODE
;
1247 case IMAGE_SCN_MEM_WRITE
:
1248 sec_flags
&= ~ SEC_READONLY
;
1250 case IMAGE_SCN_MEM_DISCARDABLE
:
1251 /* The MS PE spec says that debug sections are DISCARDABLE,
1252 but the presence of a DISCARDABLE flag does not necessarily
1253 mean that a given section contains debug information. Thus
1254 we only set the SEC_DEBUGGING flag on sections that we
1255 recognise as containing debug information. */
1258 || strcmp (name
, _COMMENT
) == 0
1262 sec_flags
|= SEC_DEBUGGING
| SEC_READONLY
;
1265 case IMAGE_SCN_MEM_SHARED
:
1266 sec_flags
|= SEC_COFF_SHARED
;
1268 case IMAGE_SCN_LNK_REMOVE
:
1270 sec_flags
|= SEC_EXCLUDE
;
1272 case IMAGE_SCN_CNT_CODE
:
1273 sec_flags
|= SEC_CODE
| SEC_ALLOC
| SEC_LOAD
;
1275 case IMAGE_SCN_CNT_INITIALIZED_DATA
:
1277 sec_flags
|= SEC_DEBUGGING
;
1279 sec_flags
|= SEC_DATA
| SEC_ALLOC
| SEC_LOAD
;
1281 case IMAGE_SCN_CNT_UNINITIALIZED_DATA
:
1282 sec_flags
|= SEC_ALLOC
;
1284 case IMAGE_SCN_LNK_INFO
:
1285 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1286 defined. coff_compute_section_file_positions uses
1287 COFF_PAGE_SIZE to ensure that the low order bits of the
1288 section VMA and the file offset match. If we don't know
1289 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1290 and demand page loading of the file will fail. */
1291 #ifdef COFF_PAGE_SIZE
1292 sec_flags
|= SEC_DEBUGGING
;
1295 case IMAGE_SCN_LNK_COMDAT
:
1296 /* COMDAT gets very special treatment. */
1297 sec_flags
= handle_COMDAT (abfd
, sec_flags
, hdr
, name
, section
);
1300 /* Silently ignore for now. */
1304 /* If the section flag was not handled, report it here. */
1305 if (unhandled
!= NULL
)
1308 /* xgettext:c-format */
1309 (_("%pB (%s): section flag %s (%#lx) ignored"),
1310 abfd
, name
, unhandled
, flag
);
1315 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1316 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1317 only link a single copy of the section. This is used to support
1318 g++. g++ will emit each template expansion in its own section.
1319 The symbols will be defined as weak, so that multiple definitions
1320 are permitted. The GNU linker extension is to actually discard
1321 all but one of the sections. */
1322 if (CONST_STRNEQ (name
, ".gnu.linkonce"))
1323 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1327 * flags_ptr
= sec_flags
;
1332 #endif /* COFF_WITH_PE */
1334 #define get_index(symbol) ((symbol)->udata.i)
1338 bfd_coff_backend_data
1342 .{* COFF symbol classifications. *}
1344 .enum coff_symbol_classification
1346 . {* Global symbol. *}
1347 . COFF_SYMBOL_GLOBAL,
1348 . {* Common symbol. *}
1349 . COFF_SYMBOL_COMMON,
1350 . {* Undefined symbol. *}
1351 . COFF_SYMBOL_UNDEFINED,
1352 . {* Local symbol. *}
1353 . COFF_SYMBOL_LOCAL,
1354 . {* PE section symbol. *}
1355 . COFF_SYMBOL_PE_SECTION
1358 .typedef asection * (*coff_gc_mark_hook_fn)
1359 . (asection *, struct bfd_link_info *, struct internal_reloc *,
1360 . struct coff_link_hash_entry *, struct internal_syment *);
1362 Special entry points for gdb to swap in coff symbol table parts:
1365 . void (*_bfd_coff_swap_aux_in)
1366 . (bfd *, void *, int, int, int, int, void *);
1368 . void (*_bfd_coff_swap_sym_in)
1369 . (bfd *, void *, void *);
1371 . void (*_bfd_coff_swap_lineno_in)
1372 . (bfd *, void *, void *);
1374 . unsigned int (*_bfd_coff_swap_aux_out)
1375 . (bfd *, void *, int, int, int, int, void *);
1377 . unsigned int (*_bfd_coff_swap_sym_out)
1378 . (bfd *, void *, void *);
1380 . unsigned int (*_bfd_coff_swap_lineno_out)
1381 . (bfd *, void *, void *);
1383 . unsigned int (*_bfd_coff_swap_reloc_out)
1384 . (bfd *, void *, void *);
1386 . unsigned int (*_bfd_coff_swap_filehdr_out)
1387 . (bfd *, void *, void *);
1389 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1390 . (bfd *, void *, void *);
1392 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1393 . (bfd *, void *, void *);
1395 . unsigned int _bfd_filhsz;
1396 . unsigned int _bfd_aoutsz;
1397 . unsigned int _bfd_scnhsz;
1398 . unsigned int _bfd_symesz;
1399 . unsigned int _bfd_auxesz;
1400 . unsigned int _bfd_relsz;
1401 . unsigned int _bfd_linesz;
1402 . unsigned int _bfd_filnmlen;
1403 . bfd_boolean _bfd_coff_long_filenames;
1405 . bfd_boolean _bfd_coff_long_section_names;
1406 . bfd_boolean (*_bfd_coff_set_long_section_names)
1409 . unsigned int _bfd_coff_default_section_alignment_power;
1410 . bfd_boolean _bfd_coff_force_symnames_in_strings;
1411 . unsigned int _bfd_coff_debug_string_prefix_length;
1412 . unsigned int _bfd_coff_max_nscns;
1414 . void (*_bfd_coff_swap_filehdr_in)
1415 . (bfd *, void *, void *);
1417 . void (*_bfd_coff_swap_aouthdr_in)
1418 . (bfd *, void *, void *);
1420 . void (*_bfd_coff_swap_scnhdr_in)
1421 . (bfd *, void *, void *);
1423 . void (*_bfd_coff_swap_reloc_in)
1424 . (bfd *abfd, void *, void *);
1426 . bfd_boolean (*_bfd_coff_bad_format_hook)
1429 . bfd_boolean (*_bfd_coff_set_arch_mach_hook)
1432 . void * (*_bfd_coff_mkobject_hook)
1433 . (bfd *, void *, void *);
1435 . bfd_boolean (*_bfd_styp_to_sec_flags_hook)
1436 . (bfd *, void *, const char *, asection *, flagword *);
1438 . void (*_bfd_set_alignment_hook)
1439 . (bfd *, asection *, void *);
1441 . bfd_boolean (*_bfd_coff_slurp_symbol_table)
1444 . bfd_boolean (*_bfd_coff_symname_in_debug)
1445 . (bfd *, struct internal_syment *);
1447 . bfd_boolean (*_bfd_coff_pointerize_aux_hook)
1448 . (bfd *, combined_entry_type *, combined_entry_type *,
1449 . unsigned int, combined_entry_type *);
1451 . bfd_boolean (*_bfd_coff_print_aux)
1452 . (bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1453 . combined_entry_type *, unsigned int);
1455 . void (*_bfd_coff_reloc16_extra_cases)
1456 . (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1457 . bfd_byte *, unsigned int *, unsigned int *);
1459 . int (*_bfd_coff_reloc16_estimate)
1460 . (bfd *, asection *, arelent *, unsigned int,
1461 . struct bfd_link_info *);
1463 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1464 . (bfd *, struct internal_syment *);
1466 . bfd_boolean (*_bfd_coff_compute_section_file_positions)
1469 . bfd_boolean (*_bfd_coff_start_final_link)
1470 . (bfd *, struct bfd_link_info *);
1472 . bfd_boolean (*_bfd_coff_relocate_section)
1473 . (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1474 . struct internal_reloc *, struct internal_syment *, asection **);
1476 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1477 . (bfd *, asection *, struct internal_reloc *,
1478 . struct coff_link_hash_entry *, struct internal_syment *, bfd_vma *);
1480 . bfd_boolean (*_bfd_coff_adjust_symndx)
1481 . (bfd *, struct bfd_link_info *, bfd *, asection *,
1482 . struct internal_reloc *, bfd_boolean *);
1484 . bfd_boolean (*_bfd_coff_link_add_one_symbol)
1485 . (struct bfd_link_info *, bfd *, const char *, flagword,
1486 . asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
1487 . struct bfd_link_hash_entry **);
1489 . bfd_boolean (*_bfd_coff_link_output_has_begun)
1490 . (bfd *, struct coff_final_link_info *);
1492 . bfd_boolean (*_bfd_coff_final_link_postscript)
1493 . (bfd *, struct coff_final_link_info *);
1495 . bfd_boolean (*_bfd_coff_print_pdata)
1498 .} bfd_coff_backend_data;
1500 .#define coff_backend_info(abfd) \
1501 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1503 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1504 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1506 .#define bfd_coff_swap_sym_in(a,e,i) \
1507 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1509 .#define bfd_coff_swap_lineno_in(a,e,i) \
1510 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1512 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1513 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1515 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1516 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1518 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1519 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1521 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1522 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1524 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1525 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1527 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1528 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1530 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1531 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1533 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1534 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1535 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1536 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1537 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1538 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1539 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1540 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1541 .#define bfd_coff_long_filenames(abfd) \
1542 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1543 .#define bfd_coff_long_section_names(abfd) \
1544 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1545 .#define bfd_coff_set_long_section_names(abfd, enable) \
1546 . ((coff_backend_info (abfd)->_bfd_coff_set_long_section_names) (abfd, enable))
1547 .#define bfd_coff_default_section_alignment_power(abfd) \
1548 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1549 .#define bfd_coff_max_nscns(abfd) \
1550 . (coff_backend_info (abfd)->_bfd_coff_max_nscns)
1552 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1553 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1555 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1556 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1558 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1559 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1561 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1562 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1564 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1565 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1567 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1568 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1569 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1570 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1571 . (abfd, filehdr, aouthdr))
1573 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1574 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1575 . (abfd, scnhdr, name, section, flags_ptr))
1577 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1578 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1580 .#define bfd_coff_slurp_symbol_table(abfd)\
1581 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1583 .#define bfd_coff_symname_in_debug(abfd, sym)\
1584 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1586 .#define bfd_coff_force_symnames_in_strings(abfd)\
1587 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1589 .#define bfd_coff_debug_string_prefix_length(abfd)\
1590 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1592 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1593 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1594 . (abfd, file, base, symbol, aux, indaux))
1596 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1597 . reloc, data, src_ptr, dst_ptr)\
1598 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1599 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1601 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1602 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1603 . (abfd, section, reloc, shrink, link_info))
1605 .#define bfd_coff_classify_symbol(abfd, sym)\
1606 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1609 .#define bfd_coff_compute_section_file_positions(abfd)\
1610 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1613 .#define bfd_coff_start_final_link(obfd, info)\
1614 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1616 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1617 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1618 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1619 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1620 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1621 . (abfd, sec, rel, h, sym, addendp))
1622 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1623 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1624 . (obfd, info, ibfd, sec, rel, adjustedp))
1625 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1626 . value, string, cp, coll, hashp)\
1627 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1628 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1630 .#define bfd_coff_link_output_has_begun(a,p) \
1631 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p))
1632 .#define bfd_coff_final_link_postscript(a,p) \
1633 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p))
1635 .#define bfd_coff_have_print_pdata(a) \
1636 . (coff_backend_info (a)->_bfd_coff_print_pdata)
1637 .#define bfd_coff_print_pdata(a,p) \
1638 . ((coff_backend_info (a)->_bfd_coff_print_pdata) (a, p))
1640 .{* Macro: Returns true if the bfd is a PE executable as opposed to a
1641 . PE object file. *}
1642 .#define bfd_pei_p(abfd) \
1643 . (CONST_STRNEQ ((abfd)->xvec->name, "pei-"))
1646 /* See whether the magic number matches. */
1649 coff_bad_format_hook (bfd
* abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1651 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1653 if (BADMAG (*internal_f
))
1661 ticoff0_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1663 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1665 if (COFF0_BADMAG (*internal_f
))
1674 ticoff1_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1676 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1678 if (COFF1_BADMAG (*internal_f
))
1685 /* Check whether this section uses an alignment other than the
1689 coff_set_custom_section_alignment (bfd
*abfd ATTRIBUTE_UNUSED
,
1691 const struct coff_section_alignment_entry
*alignment_table
,
1692 const unsigned int table_size
)
1694 const unsigned int default_alignment
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1697 for (i
= 0; i
< table_size
; ++i
)
1699 const char *secname
= bfd_section_name (section
);
1701 if (alignment_table
[i
].comparison_length
== (unsigned int) -1
1702 ? strcmp (alignment_table
[i
].name
, secname
) == 0
1703 : strncmp (alignment_table
[i
].name
, secname
,
1704 alignment_table
[i
].comparison_length
) == 0)
1707 if (i
>= table_size
)
1710 if (alignment_table
[i
].default_alignment_min
!= COFF_ALIGNMENT_FIELD_EMPTY
1711 && default_alignment
< alignment_table
[i
].default_alignment_min
)
1714 if (alignment_table
[i
].default_alignment_max
!= COFF_ALIGNMENT_FIELD_EMPTY
1715 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1716 && default_alignment
> alignment_table
[i
].default_alignment_max
1721 section
->alignment_power
= alignment_table
[i
].alignment_power
;
1724 /* Custom section alignment records. */
1726 static const struct coff_section_alignment_entry
1727 coff_section_alignment_table
[] =
1729 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1730 COFF_SECTION_ALIGNMENT_ENTRIES
,
1732 /* There must not be any gaps between .stabstr sections. */
1733 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1734 1, COFF_ALIGNMENT_FIELD_EMPTY
, 0 },
1735 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1736 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1737 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1738 /* Similarly for the .ctors and .dtors sections. */
1739 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1740 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1741 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1742 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 }
1745 static const unsigned int coff_section_alignment_table_size
=
1746 sizeof coff_section_alignment_table
/ sizeof coff_section_alignment_table
[0];
1748 /* Initialize a section structure with information peculiar to this
1749 particular implementation of COFF. */
1752 coff_new_section_hook (bfd
* abfd
, asection
* section
)
1754 combined_entry_type
*native
;
1756 unsigned char sclass
= C_STAT
;
1758 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1761 if (bfd_xcoff_text_align_power (abfd
) != 0
1762 && strcmp (bfd_section_name (section
), ".text") == 0)
1763 section
->alignment_power
= bfd_xcoff_text_align_power (abfd
);
1764 else if (bfd_xcoff_data_align_power (abfd
) != 0
1765 && strcmp (bfd_section_name (section
), ".data") == 0)
1766 section
->alignment_power
= bfd_xcoff_data_align_power (abfd
);
1771 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
1772 if (strcmp (bfd_section_name (section
),
1773 xcoff_dwsect_names
[i
].name
) == 0)
1775 section
->alignment_power
= 0;
1782 /* Set up the section symbol. */
1783 if (!_bfd_generic_new_section_hook (abfd
, section
))
1786 /* Allocate aux records for section symbols, to store size and
1789 @@ The 10 is a guess at a plausible maximum number of aux entries
1790 (but shouldn't be a constant). */
1791 amt
= sizeof (combined_entry_type
) * 10;
1792 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
1796 /* We don't need to set up n_name, n_value, or n_scnum in the native
1797 symbol information, since they'll be overridden by the BFD symbol
1798 anyhow. However, we do need to set the type and storage class,
1799 in case this symbol winds up getting written out. The value 0
1800 for n_numaux is already correct. */
1802 native
->is_sym
= TRUE
;
1803 native
->u
.syment
.n_type
= T_NULL
;
1804 native
->u
.syment
.n_sclass
= sclass
;
1806 coffsymbol (section
->symbol
)->native
= native
;
1808 coff_set_custom_section_alignment (abfd
, section
,
1809 coff_section_alignment_table
,
1810 coff_section_alignment_table_size
);
1815 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1817 /* Set the alignment of a BFD section. */
1820 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1824 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1827 #ifdef COFF_DECODE_ALIGNMENT
1828 i
= COFF_DECODE_ALIGNMENT(hdr
->s_flags
);
1830 section
->alignment_power
= i
;
1832 #ifdef coff_set_section_load_page
1833 coff_set_section_load_page (section
, hdr
->s_page
);
1837 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1841 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1845 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1847 unsigned int alignment_power_const
1848 = hdr
->s_flags
& IMAGE_SCN_ALIGN_POWER_BIT_MASK
;
1850 switch (alignment_power_const
)
1852 case IMAGE_SCN_ALIGN_8192BYTES
:
1853 case IMAGE_SCN_ALIGN_4096BYTES
:
1854 case IMAGE_SCN_ALIGN_2048BYTES
:
1855 case IMAGE_SCN_ALIGN_1024BYTES
:
1856 case IMAGE_SCN_ALIGN_512BYTES
:
1857 case IMAGE_SCN_ALIGN_256BYTES
:
1858 case IMAGE_SCN_ALIGN_128BYTES
:
1859 case IMAGE_SCN_ALIGN_64BYTES
:
1860 case IMAGE_SCN_ALIGN_32BYTES
:
1861 case IMAGE_SCN_ALIGN_16BYTES
:
1862 case IMAGE_SCN_ALIGN_8BYTES
:
1863 case IMAGE_SCN_ALIGN_4BYTES
:
1864 case IMAGE_SCN_ALIGN_2BYTES
:
1865 case IMAGE_SCN_ALIGN_1BYTES
:
1866 section
->alignment_power
1867 = IMAGE_SCN_ALIGN_POWER_NUM (alignment_power_const
);
1873 /* In a PE image file, the s_paddr field holds the virtual size of a
1874 section, while the s_size field holds the raw size. We also keep
1875 the original section flag value, since not every bit can be
1876 mapped onto a generic BFD section bit. */
1877 if (coff_section_data (abfd
, section
) == NULL
)
1879 amt
= sizeof (struct coff_section_tdata
);
1880 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
1881 if (section
->used_by_bfd
== NULL
)
1882 /* FIXME: Return error. */
1886 if (pei_section_data (abfd
, section
) == NULL
)
1888 amt
= sizeof (struct pei_section_tdata
);
1889 coff_section_data (abfd
, section
)->tdata
= bfd_zalloc (abfd
, amt
);
1890 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1891 /* FIXME: Return error. */
1894 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1895 pei_section_data (abfd
, section
)->pe_flags
= hdr
->s_flags
;
1897 section
->lma
= hdr
->s_vaddr
;
1899 /* Check for extended relocs. */
1900 if (hdr
->s_flags
& IMAGE_SCN_LNK_NRELOC_OVFL
)
1902 struct external_reloc dst
;
1903 struct internal_reloc n
;
1904 file_ptr oldpos
= bfd_tell (abfd
);
1905 bfd_size_type relsz
= bfd_coff_relsz (abfd
);
1907 if (bfd_seek (abfd
, (file_ptr
) hdr
->s_relptr
, 0) != 0)
1909 if (bfd_bread (& dst
, relsz
, abfd
) != relsz
)
1912 coff_swap_reloc_in (abfd
, &dst
, &n
);
1913 if (bfd_seek (abfd
, oldpos
, 0) != 0)
1915 section
->reloc_count
= hdr
->s_nreloc
= n
.r_vaddr
- 1;
1916 section
->rel_filepos
+= relsz
;
1918 else if (hdr
->s_nreloc
== 0xffff)
1920 (_("%pB: warning: claims to have 0xffff relocs, without overflow"),
1924 #undef ELIFALIGN_SET
1926 #else /* ! COFF_WITH_PE */
1929 /* We grossly abuse this function to handle XCOFF overflow headers.
1930 When we see one, we correct the reloc and line number counts in the
1931 real header, and remove the section we just created. */
1934 coff_set_alignment_hook (bfd
*abfd
, asection
*section
, void * scnhdr
)
1936 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1939 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1942 real_sec
= coff_section_from_bfd_index (abfd
, (int) hdr
->s_nreloc
);
1943 if (real_sec
== NULL
)
1946 real_sec
->reloc_count
= hdr
->s_paddr
;
1947 real_sec
->lineno_count
= hdr
->s_vaddr
;
1949 if (!bfd_section_removed_from_list (abfd
, section
))
1951 bfd_section_list_remove (abfd
, section
);
1952 --abfd
->section_count
;
1956 #else /* ! RS6000COFF_C */
1959 coff_set_alignment_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
1960 asection
*section ATTRIBUTE_UNUSED
,
1961 void *scnhdr ATTRIBUTE_UNUSED
)
1965 #endif /* ! RS6000COFF_C */
1966 #endif /* ! COFF_WITH_PE */
1967 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1969 #ifndef coff_mkobject
1972 coff_mkobject (bfd
* abfd
)
1974 coff_data_type
*coff
;
1975 bfd_size_type amt
= sizeof (coff_data_type
);
1977 abfd
->tdata
.coff_obj_data
= bfd_zalloc (abfd
, amt
);
1978 if (abfd
->tdata
.coff_obj_data
== NULL
)
1980 coff
= coff_data (abfd
);
1981 coff
->symbols
= NULL
;
1982 coff
->conversion_table
= NULL
;
1983 coff
->raw_syments
= NULL
;
1984 coff
->relocbase
= 0;
1985 coff
->local_toc_sym_map
= 0;
1987 /* make_abs_section(abfd);*/
1993 /* Create the COFF backend specific information. */
1995 #ifndef coff_mkobject_hook
1997 coff_mkobject_hook (bfd
* abfd
,
1999 void * aouthdr ATTRIBUTE_UNUSED
)
2001 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
2002 coff_data_type
*coff
;
2004 if (! coff_mkobject (abfd
))
2007 coff
= coff_data (abfd
);
2009 coff
->sym_filepos
= internal_f
->f_symptr
;
2011 /* These members communicate important constants about the symbol
2012 table to GDB's symbol-reading code. These `constants'
2013 unfortunately vary among coff implementations... */
2014 coff
->local_n_btmask
= N_BTMASK
;
2015 coff
->local_n_btshft
= N_BTSHFT
;
2016 coff
->local_n_tmask
= N_TMASK
;
2017 coff
->local_n_tshift
= N_TSHIFT
;
2018 coff
->local_symesz
= bfd_coff_symesz (abfd
);
2019 coff
->local_auxesz
= bfd_coff_auxesz (abfd
);
2020 coff
->local_linesz
= bfd_coff_linesz (abfd
);
2022 coff
->timestamp
= internal_f
->f_timdat
;
2024 obj_raw_syment_count (abfd
) =
2025 obj_conv_table_size (abfd
) =
2026 internal_f
->f_nsyms
;
2029 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
2030 abfd
->flags
|= DYNAMIC
;
2031 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= bfd_coff_aoutsz (abfd
))
2033 struct internal_aouthdr
*internal_a
=
2034 (struct internal_aouthdr
*) aouthdr
;
2035 struct xcoff_tdata
*xcoff
;
2037 xcoff
= xcoff_data (abfd
);
2038 # ifdef U803XTOCMAGIC
2039 xcoff
->xcoff64
= internal_f
->f_magic
== U803XTOCMAGIC
;
2043 xcoff
->full_aouthdr
= TRUE
;
2044 xcoff
->toc
= internal_a
->o_toc
;
2045 xcoff
->sntoc
= internal_a
->o_sntoc
;
2046 xcoff
->snentry
= internal_a
->o_snentry
;
2047 bfd_xcoff_text_align_power (abfd
) = internal_a
->o_algntext
;
2048 bfd_xcoff_data_align_power (abfd
) = internal_a
->o_algndata
;
2049 xcoff
->modtype
= internal_a
->o_modtype
;
2050 xcoff
->cputype
= internal_a
->o_cputype
;
2051 xcoff
->maxdata
= internal_a
->o_maxdata
;
2052 xcoff
->maxstack
= internal_a
->o_maxstack
;
2057 /* Set the flags field from the COFF header read in. */
2058 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
2063 /* FIXME: I'm not sure this is ever executed, since peicode.h
2064 defines coff_mkobject_hook. */
2065 if ((internal_f
->f_flags
& IMAGE_FILE_DEBUG_STRIPPED
) == 0)
2066 abfd
->flags
|= HAS_DEBUG
;
2069 if ((internal_f
->f_flags
& F_GO32STUB
) != 0)
2071 coff
->go32stub
= (char *) bfd_alloc (abfd
, (bfd_size_type
) GO32_STUBSIZE
);
2072 if (coff
->go32stub
== NULL
)
2075 if (coff
->go32stub
!= NULL
)
2076 memcpy (coff
->go32stub
, internal_f
->go32stub
, GO32_STUBSIZE
);
2082 /* Determine the machine architecture and type. FIXME: This is target
2083 dependent because the magic numbers are defined in the target
2084 dependent header files. But there is no particular need for this.
2085 If the magic numbers were moved to a separate file, this function
2086 would be target independent and would also be much more successful
2087 at linking together COFF files for different architectures. */
2090 coff_set_arch_mach_hook (bfd
*abfd
, void * filehdr
)
2092 unsigned long machine
;
2093 enum bfd_architecture arch
;
2094 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
2096 /* Zero selects the default machine for an arch. */
2098 switch (internal_f
->f_magic
)
2102 arch
= bfd_arch_powerpc
;
2108 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler. */
2110 case I386_APPLE_MAGIC
:
2111 case I386_FREEBSD_MAGIC
:
2112 case I386_LINUX_MAGIC
:
2113 case I386_NETBSD_MAGIC
:
2114 arch
= bfd_arch_i386
;
2119 case AMD64_APPLE_MAGIC
:
2120 case AMD64_FREEBSD_MAGIC
:
2121 case AMD64_LINUX_MAGIC
:
2122 case AMD64_NETBSD_MAGIC
:
2123 arch
= bfd_arch_i386
;
2124 machine
= bfd_mach_x86_64
;
2129 arch
= bfd_arch_ia64
;
2136 arch
= bfd_arch_arm
;
2137 machine
= bfd_arm_get_mach_from_notes (abfd
, ARM_NOTE_SECTION
);
2138 if (machine
== bfd_mach_arm_unknown
)
2140 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
2142 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
2143 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
2144 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
2146 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
2147 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
2148 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
2149 /* The COFF header does not have enough bits available
2150 to cover all the different ARM architectures. So
2151 we interpret F_ARM_5, the highest flag value to mean
2152 "the highest ARM architecture known to BFD" which is
2153 currently the XScale. */
2154 case F_ARM_5
: machine
= bfd_mach_arm_XScale
; break;
2161 arch
= bfd_arch_z80
;
2162 switch (internal_f
->f_flags
& F_MACHMASK
)
2165 case bfd_mach_z80strict
<< 12:
2166 case bfd_mach_z80
<< 12:
2167 case bfd_mach_z80full
<< 12:
2168 case bfd_mach_r800
<< 12:
2169 machine
= ((unsigned)internal_f
->f_flags
& F_MACHMASK
) >> 12;
2178 arch
= bfd_arch_z8k
;
2179 switch (internal_f
->f_flags
& F_MACHMASK
)
2182 machine
= bfd_mach_z8001
;
2185 machine
= bfd_mach_z8002
;
2205 if (xcoff_data (abfd
)->cputype
!= -1)
2206 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
2209 /* We did not get a value from the a.out header. If the
2210 file has not been stripped, we may be able to get the
2211 architecture information from the first symbol, if it
2212 is a .file symbol. */
2213 if (obj_raw_syment_count (abfd
) == 0)
2218 struct internal_syment sym
;
2219 bfd_size_type amt
= bfd_coff_symesz (abfd
);
2221 buf
= bfd_malloc (amt
);
2224 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
2225 || bfd_bread (buf
, amt
, abfd
) != amt
)
2230 bfd_coff_swap_sym_in (abfd
, buf
, & sym
);
2231 if (sym
.n_sclass
== C_FILE
)
2232 cputype
= sym
.n_type
& 0xff;
2239 /* FIXME: We don't handle all cases here. */
2244 arch
= bfd_xcoff_architecture (abfd
);
2245 machine
= bfd_xcoff_machine (abfd
);
2249 arch
= bfd_arch_powerpc
;
2250 machine
= bfd_mach_ppc_601
;
2252 case 2: /* 64 bit PowerPC */
2253 arch
= bfd_arch_powerpc
;
2254 machine
= bfd_mach_ppc_620
;
2257 arch
= bfd_arch_powerpc
;
2258 machine
= bfd_mach_ppc
;
2261 arch
= bfd_arch_rs6000
;
2262 machine
= bfd_mach_rs6k
;
2269 #ifdef SH_ARCH_MAGIC_BIG
2270 case SH_ARCH_MAGIC_BIG
:
2271 case SH_ARCH_MAGIC_LITTLE
:
2273 case SH_ARCH_MAGIC_WINCE
:
2279 #ifdef MIPS_ARCH_MAGIC_WINCE
2280 case MIPS_ARCH_MAGIC_WINCE
:
2281 arch
= bfd_arch_mips
;
2287 #ifdef LYNXCOFFMAGIC
2290 arch
= bfd_arch_sparc
;
2296 arch
= bfd_arch_tic30
;
2301 #ifdef TICOFF_TARGET_ARCH
2302 /* This TI COFF section should be used by all new TI COFF v0 targets. */
2304 arch
= TICOFF_TARGET_ARCH
;
2305 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2311 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */
2312 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */
2315 switch (internal_f
->f_target_id
)
2319 arch
= TICOFF_TARGET_ARCH
;
2320 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2324 arch
= bfd_arch_obscure
;
2326 (_("unrecognized TI COFF target id '0x%x'"),
2327 internal_f
->f_target_id
);
2333 #ifdef TIC80_ARCH_MAGIC
2334 case TIC80_ARCH_MAGIC
:
2335 arch
= bfd_arch_tic80
;
2341 arch
= bfd_arch_mcore
;
2345 default: /* Unreadable input file type. */
2346 arch
= bfd_arch_obscure
;
2350 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2355 symname_in_debug_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2356 struct internal_syment
*sym ATTRIBUTE_UNUSED
)
2358 #ifdef SYMNAME_IN_DEBUG
2359 return SYMNAME_IN_DEBUG (sym
) != 0;
2368 #define FORCE_SYMNAMES_IN_STRINGS
2371 /* Handle the csect auxent of a C_EXT, C_AIX_WEAKEXT or C_HIDEXT symbol. */
2374 coff_pointerize_aux_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2375 combined_entry_type
*table_base
,
2376 combined_entry_type
*symbol
,
2377 unsigned int indaux
,
2378 combined_entry_type
*aux
)
2380 BFD_ASSERT (symbol
->is_sym
);
2381 int n_sclass
= symbol
->u
.syment
.n_sclass
;
2383 if (CSECT_SYM_P (n_sclass
)
2384 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2386 BFD_ASSERT (! aux
->is_sym
);
2387 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2389 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2390 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2391 aux
->fix_scnlen
= 1;
2394 /* Return TRUE to indicate that the caller should not do any
2395 further work on this auxent. */
2399 /* Return FALSE to indicate that this auxent should be handled by
2405 #define coff_pointerize_aux_hook 0
2406 #endif /* ! RS6000COFF_C */
2408 /* Print an aux entry. This returns TRUE if it has printed it. */
2411 coff_print_aux (bfd
*abfd ATTRIBUTE_UNUSED
,
2412 FILE *file ATTRIBUTE_UNUSED
,
2413 combined_entry_type
*table_base ATTRIBUTE_UNUSED
,
2414 combined_entry_type
*symbol ATTRIBUTE_UNUSED
,
2415 combined_entry_type
*aux ATTRIBUTE_UNUSED
,
2416 unsigned int indaux ATTRIBUTE_UNUSED
)
2418 BFD_ASSERT (symbol
->is_sym
);
2419 BFD_ASSERT (! aux
->is_sym
);
2421 if (CSECT_SYM_P (symbol
->u
.syment
.n_sclass
)
2422 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2424 /* This is a csect entry. */
2425 fprintf (file
, "AUX ");
2426 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2428 BFD_ASSERT (! aux
->fix_scnlen
);
2429 fprintf (file
, "val %5" BFD_VMA_FMT
"d",
2430 aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2434 fprintf (file
, "indx ");
2435 if (! aux
->fix_scnlen
)
2436 fprintf (file
, "%4" BFD_VMA_FMT
"d",
2437 aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2439 fprintf (file
, "%4ld",
2440 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2443 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2444 aux
->u
.auxent
.x_csect
.x_parmhash
,
2445 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2446 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2447 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2448 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2449 aux
->u
.auxent
.x_csect
.x_stab
,
2450 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2455 /* Return FALSE to indicate that no special action was taken. */
2463 To write relocations, the back end steps though the
2464 canonical relocation table and create an
2465 @code{internal_reloc}. The symbol index to use is removed from
2466 the @code{offset} field in the symbol table supplied. The
2467 address comes directly from the sum of the section base
2468 address and the relocation offset; the type is dug directly
2469 from the howto field. Then the @code{internal_reloc} is
2470 swapped into the shape of an @code{external_reloc} and written
2478 /* AUX's ld wants relocations to be sorted. */
2480 compare_arelent_ptr (const void * x
, const void * y
)
2482 const arelent
**a
= (const arelent
**) x
;
2483 const arelent
**b
= (const arelent
**) y
;
2484 bfd_size_type aadr
= (*a
)->address
;
2485 bfd_size_type badr
= (*b
)->address
;
2487 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2490 #endif /* TARG_AUX */
2493 coff_write_relocs (bfd
* abfd
, int first_undef
)
2497 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2500 struct external_reloc dst
;
2507 /* Sort relocations before we write them out. */
2510 amt
= s
->reloc_count
;
2511 amt
*= sizeof (arelent
*);
2512 p
= bfd_malloc (amt
);
2515 if (s
->reloc_count
> 0)
2520 memcpy (p
, s
->orelocation
, (size_t) amt
);
2521 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2526 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2530 if (obj_pe (abfd
) && s
->reloc_count
>= 0xffff)
2532 /* Encode real count here as first reloc. */
2533 struct internal_reloc n
;
2535 memset (& n
, 0, sizeof (n
));
2536 /* Add one to count *this* reloc (grr). */
2537 n
.r_vaddr
= s
->reloc_count
+ 1;
2538 coff_swap_reloc_out (abfd
, &n
, &dst
);
2539 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2540 abfd
) != bfd_coff_relsz (abfd
))
2545 for (i
= 0; i
< s
->reloc_count
; i
++)
2547 struct internal_reloc n
;
2550 memset (& n
, 0, sizeof (n
));
2552 /* Now we've renumbered the symbols we know where the
2553 undefined symbols live in the table. Check the reloc
2554 entries for symbols who's output bfd isn't the right one.
2555 This is because the symbol was undefined (which means
2556 that all the pointers are never made to point to the same
2557 place). This is a bad thing,'cause the symbols attached
2558 to the output bfd are indexed, so that the relocation
2559 entries know which symbol index they point to. So we
2560 have to look up the output symbol here. */
2562 if (q
->sym_ptr_ptr
[0] != NULL
&& q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2565 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2566 asymbol
**outsyms
= abfd
->outsymbols
;
2568 for (j
= first_undef
; outsyms
[j
]; j
++)
2570 const char *intable
= outsyms
[j
]->name
;
2572 if (strcmp (intable
, sname
) == 0)
2574 /* Got a hit, so repoint the reloc. */
2575 q
->sym_ptr_ptr
= outsyms
+ j
;
2581 n
.r_vaddr
= q
->address
+ s
->vma
;
2584 /* The 29k const/consth reloc pair is a real kludge. The consth
2585 part doesn't have a symbol; it has an offset. So rebuilt
2587 if (q
->howto
->type
== R_IHCONST
)
2588 n
.r_symndx
= q
->addend
;
2591 if (q
->sym_ptr_ptr
&& q
->sym_ptr_ptr
[0] != NULL
)
2593 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2594 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
, s
))
2596 if ((*q
->sym_ptr_ptr
)->section
== bfd_abs_section_ptr
2597 && ((*q
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) != 0)
2599 /* This is a relocation relative to the absolute symbol. */
2603 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2604 /* Check to see if the symbol reloc points to a symbol
2605 we don't have in our symbol table. */
2606 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2608 bfd_set_error (bfd_error_bad_value
);
2609 /* xgettext:c-format */
2610 _bfd_error_handler (_("%pB: reloc against a non-existent"
2611 " symbol index: %ld"),
2618 #ifdef SWAP_OUT_RELOC_OFFSET
2619 n
.r_offset
= q
->addend
;
2623 /* Work out reloc type from what is required. */
2624 SELECT_RELOC (n
, q
->howto
);
2626 n
.r_type
= q
->howto
->type
;
2628 coff_swap_reloc_out (abfd
, &n
, &dst
);
2630 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2631 abfd
) != bfd_coff_relsz (abfd
))
2644 /* Set flags and magic number of a coff file from architecture and machine
2645 type. Result is TRUE if we can represent the arch&type, FALSE if not. */
2648 coff_set_flags (bfd
* abfd
,
2649 unsigned int *magicp ATTRIBUTE_UNUSED
,
2650 unsigned short *flagsp ATTRIBUTE_UNUSED
)
2652 switch (bfd_get_arch (abfd
))
2657 switch (bfd_get_mach (abfd
))
2660 case bfd_mach_z80strict
:
2662 case bfd_mach_z80full
:
2664 *flagsp
= bfd_get_mach (abfd
) << 12;
2676 switch (bfd_get_mach (abfd
))
2678 case bfd_mach_z8001
: *flagsp
= F_Z8001
; break;
2679 case bfd_mach_z8002
: *flagsp
= F_Z8002
; break;
2680 default: return FALSE
;
2686 case bfd_arch_tic30
:
2687 *magicp
= TIC30MAGIC
;
2691 #ifdef TICOFF_DEFAULT_MAGIC
2692 case TICOFF_TARGET_ARCH
:
2693 /* If there's no indication of which version we want, use the default. */
2695 *magicp
= TICOFF_DEFAULT_MAGIC
;
2698 /* We may want to output in a different COFF version. */
2699 switch (abfd
->xvec
->name
[4])
2702 *magicp
= TICOFF0MAGIC
;
2705 *magicp
= TICOFF1MAGIC
;
2708 *magicp
= TICOFF2MAGIC
;
2714 TICOFF_TARGET_MACHINE_SET (flagsp
, bfd_get_mach (abfd
));
2718 #ifdef TIC80_ARCH_MAGIC
2719 case bfd_arch_tic80
:
2720 *magicp
= TIC80_ARCH_MAGIC
;
2727 * magicp
= ARMPEMAGIC
;
2729 * magicp
= ARMMAGIC
;
2732 if (APCS_SET (abfd
))
2734 if (APCS_26_FLAG (abfd
))
2735 * flagsp
|= F_APCS26
;
2737 if (APCS_FLOAT_FLAG (abfd
))
2738 * flagsp
|= F_APCS_FLOAT
;
2740 if (PIC_FLAG (abfd
))
2743 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2744 * flagsp
|= F_INTERWORK
;
2745 switch (bfd_get_mach (abfd
))
2747 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2748 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2749 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2750 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2751 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2752 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2753 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2754 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2755 See also the comment in coff_set_arch_mach_hook(). */
2756 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break;
2757 case bfd_mach_arm_5TE
: * flagsp
|= F_ARM_5
; break;
2758 case bfd_mach_arm_XScale
: * flagsp
|= F_ARM_5
; break;
2764 case bfd_arch_powerpc
:
2769 #if defined(I386MAGIC) || defined(AMD64MAGIC)
2771 #if defined(I386MAGIC)
2772 *magicp
= I386MAGIC
;
2775 /* Just overwrite the usual value if we're doing Lynx. */
2776 *magicp
= LYNXCOFFMAGIC
;
2778 #if defined AMD64MAGIC
2779 *magicp
= AMD64MAGIC
;
2786 *magicp
= IA64MAGIC
;
2790 #ifdef SH_ARCH_MAGIC_BIG
2792 #ifdef COFF_IMAGE_WITH_PE
2793 *magicp
= SH_ARCH_MAGIC_WINCE
;
2795 if (bfd_big_endian (abfd
))
2796 *magicp
= SH_ARCH_MAGIC_BIG
;
2798 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2803 #ifdef MIPS_ARCH_MAGIC_WINCE
2805 *magicp
= MIPS_ARCH_MAGIC_WINCE
;
2810 case bfd_arch_sparc
:
2811 *magicp
= SPARCMAGIC
;
2813 /* Just overwrite the usual value if we're doing Lynx. */
2814 *magicp
= LYNXCOFFMAGIC
;
2820 case bfd_arch_rs6000
:
2822 case bfd_arch_powerpc
:
2824 BFD_ASSERT (bfd_get_flavour (abfd
) == bfd_target_xcoff_flavour
);
2825 *magicp
= bfd_xcoff_magic_number (abfd
);
2830 case bfd_arch_mcore
:
2831 * magicp
= MCOREMAGIC
;
2835 default: /* Unknown architecture. */
2836 /* Fall through to "return FALSE" below, to avoid
2837 "statement never reached" errors on the one below. */
2845 coff_set_arch_mach (bfd
* abfd
,
2846 enum bfd_architecture arch
,
2847 unsigned long machine
)
2850 unsigned short dummy2
;
2852 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
2855 if (arch
!= bfd_arch_unknown
2856 && ! coff_set_flags (abfd
, &dummy1
, &dummy2
))
2857 return FALSE
; /* We can't represent this type. */
2859 return TRUE
; /* We're easy... */
2862 #ifdef COFF_IMAGE_WITH_PE
2864 /* This is used to sort sections by VMA, as required by PE image
2868 sort_by_secaddr (const void * arg1
, const void * arg2
)
2870 const asection
*a
= *(const asection
**) arg1
;
2871 const asection
*b
= *(const asection
**) arg2
;
2873 if (a
->vma
< b
->vma
)
2875 else if (a
->vma
> b
->vma
)
2881 #endif /* COFF_IMAGE_WITH_PE */
2883 /* Calculate the file position for each section. */
2885 #define ALIGN_SECTIONS_IN_FILE
2886 #if defined(TIC80COFF) || defined(TICOFF)
2887 #undef ALIGN_SECTIONS_IN_FILE
2891 coff_compute_section_file_positions (bfd
* abfd
)
2894 file_ptr sofar
= bfd_coff_filhsz (abfd
);
2895 bfd_boolean align_adjust
;
2896 unsigned int target_index
;
2897 #ifdef ALIGN_SECTIONS_IN_FILE
2898 asection
*previous
= NULL
;
2902 #ifdef COFF_IMAGE_WITH_PE
2905 if (coff_data (abfd
)->link_info
2906 || (pe_data (abfd
) && pe_data (abfd
)->pe_opthdr
.FileAlignment
))
2908 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
2910 /* If no file alignment has been set, default to one.
2911 This repairs 'ld -r' for arm-wince-pe target. */
2915 /* PR 17512: file: 0ac816d3. */
2918 bfd_set_error (bfd_error_file_too_big
);
2920 /* xgettext:c-format */
2921 (_("%pB: page size is too large (0x%x)"), abfd
, page_size
);
2926 page_size
= PE_DEF_FILE_ALIGNMENT
;
2928 #ifdef COFF_PAGE_SIZE
2929 int page_size
= COFF_PAGE_SIZE
;
2934 /* On XCOFF, if we have symbols, set up the .debug section. */
2935 if (bfd_get_symcount (abfd
) > 0)
2938 bfd_size_type i
, symcount
;
2942 symcount
= bfd_get_symcount (abfd
);
2943 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
2945 coff_symbol_type
*cf
;
2947 cf
= coff_symbol_from (*symp
);
2949 && cf
->native
!= NULL
2950 && cf
->native
->is_sym
2951 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
2955 len
= strlen (bfd_asymbol_name (*symp
));
2956 if (len
> SYMNMLEN
|| bfd_coff_force_symnames_in_strings (abfd
))
2957 sz
+= len
+ 1 + bfd_coff_debug_string_prefix_length (abfd
);
2964 dsec
= bfd_make_section_old_way (abfd
, DOT_DEBUG
);
2968 dsec
->flags
|= SEC_HAS_CONTENTS
;
2973 if (bfd_get_start_address (abfd
))
2974 /* A start address may have been added to the original file. In this
2975 case it will need an optional header to record it. */
2976 abfd
->flags
|= EXEC_P
;
2978 if (abfd
->flags
& EXEC_P
)
2979 sofar
+= bfd_coff_aoutsz (abfd
);
2981 else if (xcoff_data (abfd
)->full_aouthdr
)
2982 sofar
+= bfd_coff_aoutsz (abfd
);
2984 sofar
+= SMALL_AOUTSZ
;
2987 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2990 /* XCOFF handles overflows in the reloc and line number count fields
2991 by allocating a new section header to hold the correct counts. */
2992 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2993 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
2994 sofar
+= bfd_coff_scnhsz (abfd
);
2997 #ifdef COFF_IMAGE_WITH_PE
2999 /* PE requires the sections to be in memory order when listed in
3000 the section headers. It also does not like empty loadable
3001 sections. The sections apparently do not have to be in the
3002 right order in the image file itself, but we do need to get the
3003 target_index values right. */
3006 asection
**section_list
;
3010 #ifdef COFF_PAGE_SIZE
3011 /* Clear D_PAGED if section alignment is smaller than
3013 if (pe_data (abfd
)->pe_opthdr
.SectionAlignment
< COFF_PAGE_SIZE
)
3014 abfd
->flags
&= ~D_PAGED
;
3018 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3021 /* We allocate an extra cell to simplify the final loop. */
3022 amt
= sizeof (struct asection
*) * (count
+ 1);
3023 section_list
= (asection
**) bfd_malloc (amt
);
3024 if (section_list
== NULL
)
3028 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3030 section_list
[i
] = current
;
3033 section_list
[i
] = NULL
;
3035 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
3037 /* Rethread the linked list into sorted order; at the same time,
3038 assign target_index values. */
3040 abfd
->sections
= NULL
;
3041 abfd
->section_last
= NULL
;
3042 for (i
= 0; i
< count
; i
++)
3044 current
= section_list
[i
];
3045 bfd_section_list_append (abfd
, current
);
3047 /* Later, if the section has zero size, we'll be throwing it
3048 away, so we don't want to number it now. Note that having
3049 a zero size and having real contents are different
3050 concepts: .bss has no contents, but (usually) non-zero
3052 if (current
->size
== 0)
3054 /* Discard. However, it still might have (valid) symbols
3055 in it, so arbitrarily set it to section 1 (indexing is
3056 1-based here; usually .text). __end__ and other
3057 contents of .endsection really have this happen.
3058 FIXME: This seems somewhat dubious. */
3059 current
->target_index
= 1;
3062 current
->target_index
= target_index
++;
3065 free (section_list
);
3067 #else /* ! COFF_IMAGE_WITH_PE */
3069 /* Set the target_index field. */
3071 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3072 current
->target_index
= target_index
++;
3074 #endif /* ! COFF_IMAGE_WITH_PE */
3076 if (target_index
>= bfd_coff_max_nscns (abfd
))
3078 bfd_set_error (bfd_error_file_too_big
);
3080 /* xgettext:c-format */
3081 (_("%pB: too many sections (%d)"), abfd
, target_index
);
3085 align_adjust
= FALSE
;
3086 for (current
= abfd
->sections
;
3088 current
= current
->next
)
3090 #ifdef COFF_IMAGE_WITH_PE
3091 /* With PE we have to pad each section to be a multiple of its
3092 page size too, and remember both sizes. */
3093 if (coff_section_data (abfd
, current
) == NULL
)
3095 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
3097 current
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
3098 if (current
->used_by_bfd
== NULL
)
3101 if (pei_section_data (abfd
, current
) == NULL
)
3103 bfd_size_type amt
= sizeof (struct pei_section_tdata
);
3105 coff_section_data (abfd
, current
)->tdata
= bfd_zalloc (abfd
, amt
);
3106 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
3109 if (pei_section_data (abfd
, current
)->virt_size
== 0)
3110 pei_section_data (abfd
, current
)->virt_size
= current
->size
;
3113 /* Only deal with sections which have contents. */
3114 if (!(current
->flags
& SEC_HAS_CONTENTS
))
3117 current
->rawsize
= current
->size
;
3119 #ifdef COFF_IMAGE_WITH_PE
3120 /* Make sure we skip empty sections in a PE image. */
3121 if (current
->size
== 0)
3125 /* Align the sections in the file to the same boundary on
3126 which they are aligned in virtual memory. */
3127 #ifdef ALIGN_SECTIONS_IN_FILE
3128 if ((abfd
->flags
& EXEC_P
) != 0)
3130 /* Make sure this section is aligned on the right boundary - by
3131 padding the previous section up if necessary. */
3134 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3137 /* Make sure the file offset and the vma of .text/.data are at the
3138 same page offset, so that the file can be mmap'ed without being
3139 relocated. Failing that, AIX is able to load and execute the
3140 program, but it will be silently relocated (possible as
3141 executables are PIE). But the relocation is slightly costly and
3142 complexify the use of addr2line or gdb. So better to avoid it,
3143 like does the native linker. Usually gnu ld makes sure that
3144 the vma of .text is the file offset so this issue shouldn't
3145 appear unless you are stripping such an executable.
3147 AIX loader checks the text section alignment of (vma - filepos),
3148 and the native linker doesn't try to align the text sections.
3151 0 .text 000054cc 10000128 10000128 00000128 2**5
3152 CONTENTS, ALLOC, LOAD, CODE
3155 if (!strcmp (current
->name
, _TEXT
)
3156 || !strcmp (current
->name
, _DATA
))
3158 bfd_vma align
= 4096;
3159 bfd_vma sofar_off
= sofar
% align
;
3160 bfd_vma vma_off
= current
->vma
% align
;
3162 if (vma_off
> sofar_off
)
3163 sofar
+= vma_off
- sofar_off
;
3164 else if (vma_off
< sofar_off
)
3165 sofar
+= align
+ vma_off
- sofar_off
;
3168 if (previous
!= NULL
)
3169 previous
->size
+= sofar
- old_sofar
;
3174 /* In demand paged files the low order bits of the file offset
3175 must match the low order bits of the virtual address. */
3176 #ifdef COFF_PAGE_SIZE
3177 if ((abfd
->flags
& D_PAGED
) != 0
3178 && (current
->flags
& SEC_ALLOC
) != 0)
3179 sofar
+= (current
->vma
- (bfd_vma
) sofar
) % page_size
;
3181 current
->filepos
= sofar
;
3183 #ifdef COFF_IMAGE_WITH_PE
3184 /* Set the padded size. */
3185 current
->size
= (current
->size
+ page_size
- 1) & -page_size
;
3188 sofar
+= current
->size
;
3190 #ifdef ALIGN_SECTIONS_IN_FILE
3191 /* Make sure that this section is of the right size too. */
3192 if ((abfd
->flags
& EXEC_P
) == 0)
3194 bfd_size_type old_size
;
3196 old_size
= current
->size
;
3197 current
->size
= BFD_ALIGN (current
->size
,
3198 1 << current
->alignment_power
);
3199 align_adjust
= current
->size
!= old_size
;
3200 sofar
+= current
->size
- old_size
;
3205 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3206 align_adjust
= sofar
!= old_sofar
;
3207 current
->size
+= sofar
- old_sofar
;
3211 #ifdef COFF_IMAGE_WITH_PE
3212 /* For PE we need to make sure we pad out to the aligned
3213 size, in case the caller only writes out data to the
3215 if (pei_section_data (abfd
, current
)->virt_size
< current
->size
)
3216 align_adjust
= TRUE
;
3220 /* Force .lib sections to start at zero. The vma is then
3221 incremented in coff_set_section_contents. This is right for
3223 if (strcmp (current
->name
, _LIB
) == 0)
3224 bfd_set_section_vma (current
, 0);
3227 #ifdef ALIGN_SECTIONS_IN_FILE
3232 /* It is now safe to write to the output file. If we needed an
3233 alignment adjustment for the last section, then make sure that
3234 there is a byte at offset sofar. If there are no symbols and no
3235 relocs, then nothing follows the last section. If we don't force
3236 the last byte out, then the file may appear to be truncated. */
3242 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
3243 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3247 /* Make sure the relocations are aligned. We don't need to make
3248 sure that this byte exists, because it will only matter if there
3249 really are relocs. */
3250 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
3252 obj_relocbase (abfd
) = sofar
;
3253 abfd
->output_has_begun
= TRUE
;
3258 #ifdef COFF_IMAGE_WITH_PE
3260 static unsigned int pelength
;
3261 static unsigned int peheader
;
3264 coff_read_word (bfd
*abfd
, unsigned int *value
)
3269 status
= bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3277 *value
= (unsigned int) b
[0];
3279 *value
= (unsigned int) (b
[0] + (b
[1] << 8));
3281 pelength
+= (unsigned int) status
;
3287 coff_compute_checksum (bfd
*abfd
)
3289 bfd_boolean more_data
;
3296 filepos
= (file_ptr
) 0;
3300 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
3303 more_data
= coff_read_word (abfd
, &value
);
3305 total
= 0xffff & (total
+ (total
>> 0x10));
3310 return (0xffff & (total
+ (total
>> 0x10)));
3314 coff_apply_checksum (bfd
*abfd
)
3316 unsigned int computed
;
3317 unsigned int checksum
= 0;
3319 if (bfd_seek (abfd
, 0x3c, SEEK_SET
) != 0)
3322 if (!coff_read_word (abfd
, &peheader
))
3325 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3329 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3331 if (bfd_seek (abfd
, peheader
, SEEK_SET
) != 0)
3334 computed
= coff_compute_checksum (abfd
);
3336 checksum
= computed
+ pelength
;
3338 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3341 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3346 #endif /* COFF_IMAGE_WITH_PE */
3349 coff_write_object_contents (bfd
* abfd
)
3352 bfd_boolean hasrelocs
= FALSE
;
3353 bfd_boolean haslinno
= FALSE
;
3354 #ifdef COFF_IMAGE_WITH_PE
3355 bfd_boolean hasdebug
= FALSE
;
3358 file_ptr reloc_base
;
3359 file_ptr lineno_base
;
3361 unsigned long reloc_size
= 0, reloc_count
= 0;
3362 unsigned long lnno_size
= 0;
3363 bfd_boolean long_section_names
;
3364 asection
*text_sec
= NULL
;
3365 asection
*data_sec
= NULL
;
3366 asection
*bss_sec
= NULL
;
3367 struct internal_filehdr internal_f
;
3368 struct internal_aouthdr internal_a
;
3369 #ifdef COFF_LONG_SECTION_NAMES
3370 size_t string_size
= STRING_SIZE_SIZE
;
3373 bfd_set_error (bfd_error_system_call
);
3375 /* Make a pass through the symbol table to count line number entries and
3376 put them into the correct asections. */
3377 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3379 if (! abfd
->output_has_begun
)
3381 if (! coff_compute_section_file_positions (abfd
))
3385 reloc_base
= obj_relocbase (abfd
);
3387 /* Work out the size of the reloc and linno areas. */
3389 for (current
= abfd
->sections
; current
!= NULL
; current
=
3393 /* We store the actual reloc count in the first reloc's addr. */
3394 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3397 reloc_count
+= current
->reloc_count
;
3400 reloc_size
= reloc_count
* bfd_coff_relsz (abfd
);
3402 lineno_base
= reloc_base
+ reloc_size
;
3403 sym_base
= lineno_base
+ lnno_size
;
3405 /* Indicate in each section->line_filepos its actual file address. */
3406 for (current
= abfd
->sections
; current
!= NULL
; current
=
3409 if (current
->lineno_count
)
3411 current
->line_filepos
= lineno_base
;
3412 current
->moving_line_filepos
= lineno_base
;
3413 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3416 current
->line_filepos
= 0;
3418 if (current
->reloc_count
)
3420 current
->rel_filepos
= reloc_base
;
3421 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3423 /* Extra reloc to hold real count. */
3424 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3425 reloc_base
+= bfd_coff_relsz (abfd
);
3429 current
->rel_filepos
= 0;
3432 /* Write section headers to the file. */
3433 internal_f
.f_nscns
= 0;
3435 if ((abfd
->flags
& EXEC_P
) != 0)
3436 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3439 scn_base
= bfd_coff_filhsz (abfd
);
3442 if (xcoff_data (abfd
)->full_aouthdr
)
3443 scn_base
+= bfd_coff_aoutsz (abfd
);
3445 scn_base
+= SMALL_AOUTSZ
;
3450 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3453 long_section_names
= FALSE
;
3454 for (current
= abfd
->sections
;
3456 current
= current
->next
)
3458 struct internal_scnhdr section
;
3459 #ifdef COFF_IMAGE_WITH_PE
3460 bfd_boolean is_reloc_section
= FALSE
;
3462 if (strcmp (current
->name
, DOT_RELOC
) == 0)
3464 is_reloc_section
= TRUE
;
3466 pe_data (abfd
)->has_reloc_section
= 1;
3470 internal_f
.f_nscns
++;
3472 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3474 #ifdef COFF_LONG_SECTION_NAMES
3475 /* Handle long section names as in PE. This must be compatible
3476 with the code in coff_write_symbols and _bfd_coff_final_link. */
3477 if (bfd_coff_long_section_names (abfd
))
3481 len
= strlen (current
->name
);
3484 /* The s_name field is defined to be NUL-padded but need not be
3485 NUL-terminated. We use a temporary buffer so that we can still
3486 sprintf all eight chars without splatting a terminating NUL
3487 over the first byte of the following member (s_paddr). */
3488 /* PR 21096: The +20 is to stop a bogus warning from gcc7 about
3489 a possible buffer overflow. */
3490 char s_name_buf
[SCNNMLEN
+ 1 + 20];
3492 /* An inherent limitation of the /nnnnnnn notation used to indicate
3493 the offset of the long name in the string table is that we
3494 cannot address entries beyone the ten million byte boundary. */
3495 if (string_size
>= 10000000)
3497 bfd_set_error (bfd_error_file_too_big
);
3499 /* xgettext:c-format */
3500 (_("%pB: section %pA: string table overflow at offset %ld"),
3501 abfd
, current
, (unsigned long) string_size
);
3505 /* We do not need to use snprintf here as we have already verfied
3506 that string_size is not too big, plus we have an overlarge
3507 buffer, just in case. */
3508 sprintf (s_name_buf
, "/%lu", (unsigned long) string_size
);
3509 /* Then strncpy takes care of any padding for us. */
3510 strncpy (section
.s_name
, s_name_buf
, SCNNMLEN
);
3511 string_size
+= len
+ 1;
3512 long_section_names
= TRUE
;
3518 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3519 Ian Taylor <ian@cygnus.com>. */
3520 if (strcmp (current
->name
, _LIB
) == 0)
3521 section
.s_vaddr
= 0;
3524 section
.s_vaddr
= current
->vma
;
3525 section
.s_paddr
= current
->lma
;
3526 section
.s_size
= current
->size
;
3527 #ifdef coff_get_section_load_page
3528 section
.s_page
= coff_get_section_load_page (current
);
3534 section
.s_paddr
= 0;
3536 #ifdef COFF_IMAGE_WITH_PE
3537 /* Reminder: s_paddr holds the virtual size of the section. */
3538 if (coff_section_data (abfd
, current
) != NULL
3539 && pei_section_data (abfd
, current
) != NULL
)
3540 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3542 section
.s_paddr
= 0;
3545 /* If this section has no size or is unloadable then the scnptr
3547 if (current
->size
== 0
3548 || (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3549 section
.s_scnptr
= 0;
3551 section
.s_scnptr
= current
->filepos
;
3553 section
.s_relptr
= current
->rel_filepos
;
3554 section
.s_lnnoptr
= current
->line_filepos
;
3555 section
.s_nreloc
= current
->reloc_count
;
3556 section
.s_nlnno
= current
->lineno_count
;
3557 #ifndef COFF_IMAGE_WITH_PE
3558 /* In PEI, relocs come in the .reloc section. */
3559 if (current
->reloc_count
!= 0)
3562 if (current
->lineno_count
!= 0)
3564 #ifdef COFF_IMAGE_WITH_PE
3565 if ((current
->flags
& SEC_DEBUGGING
) != 0
3566 && ! is_reloc_section
)
3572 /* Indicate the use of an XCOFF overflow section header. */
3573 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3575 section
.s_nreloc
= 0xffff;
3576 section
.s_nlnno
= 0xffff;
3581 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3583 if (!strcmp (current
->name
, _TEXT
))
3585 else if (!strcmp (current
->name
, _DATA
))
3587 else if (!strcmp (current
->name
, _BSS
))
3590 #ifdef COFF_ENCODE_ALIGNMENT
3591 COFF_ENCODE_ALIGNMENT(section
, current
->alignment_power
);
3592 if ((unsigned int)COFF_DECODE_ALIGNMENT(section
.s_flags
)
3593 != current
->alignment_power
)
3595 bfd_boolean warn
= coff_data (abfd
)->link_info
3596 && !bfd_link_relocatable (coff_data (abfd
)->link_info
);
3599 /* xgettext:c-format */
3600 (_("%pB:%s section %s: alignment 2**%u not representable"),
3601 abfd
, warn
? " warning:" : "", current
->name
,
3602 current
->alignment_power
);
3605 bfd_set_error (bfd_error_nonrepresentable_section
);
3611 #ifdef COFF_IMAGE_WITH_PE
3612 /* Suppress output of the sections if they are null. ld
3613 includes the bss and data sections even if there is no size
3614 assigned to them. NT loader doesn't like it if these section
3615 headers are included if the sections themselves are not
3616 needed. See also coff_compute_section_file_positions. */
3617 if (section
.s_size
== 0)
3618 internal_f
.f_nscns
--;
3623 bfd_size_type amt
= bfd_coff_scnhsz (abfd
);
3625 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3626 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3631 /* PE stores COMDAT section information in the symbol table. If
3632 this section is supposed to have some COMDAT info, track down
3633 the symbol in the symbol table and modify it. */
3634 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3636 unsigned int i
, count
;
3638 coff_symbol_type
*csym
= NULL
;
3642 count
= bfd_get_symcount (abfd
);
3643 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3645 if ((*psym
)->section
!= current
)
3648 /* Remember the location of the first symbol in this
3650 if (psymsec
== NULL
)
3653 /* See if this is the section symbol. */
3654 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3656 csym
= coff_symbol_from (*psym
);
3658 || csym
->native
== NULL
3659 || ! csym
->native
->is_sym
3660 || csym
->native
->u
.syment
.n_numaux
< 1
3661 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3662 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3665 /* Here *PSYM is the section symbol for CURRENT. */
3672 Note that we might not if we're converting the file from
3673 some other object file format. */
3676 combined_entry_type
*aux
;
3678 /* We don't touch the x_checksum field. The
3679 x_associated field is not currently supported. */
3681 aux
= csym
->native
+ 1;
3682 BFD_ASSERT (! aux
->is_sym
);
3683 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3685 case SEC_LINK_DUPLICATES_DISCARD
:
3686 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3689 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3690 aux
->u
.auxent
.x_scn
.x_comdat
=
3691 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3694 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3695 aux
->u
.auxent
.x_scn
.x_comdat
=
3696 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3699 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3700 aux
->u
.auxent
.x_scn
.x_comdat
=
3701 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3705 /* The COMDAT symbol must be the first symbol from this
3706 section in the symbol table. In order to make this
3707 work, we move the COMDAT symbol before the first
3708 symbol we found in the search above. It's OK to
3709 rearrange the symbol table at this point, because
3710 coff_renumber_symbols is going to rearrange it
3711 further and fix up all the aux entries. */
3712 if (psym
!= psymsec
)
3718 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3719 pcopy
[0] = pcopy
[-1];
3724 #endif /* COFF_WITH_PE */
3729 /* XCOFF handles overflows in the reloc and line number count fields
3730 by creating a new section header to hold the correct values. */
3731 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3733 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3735 struct internal_scnhdr scnhdr
;
3739 internal_f
.f_nscns
++;
3740 memcpy (scnhdr
.s_name
, ".ovrflo", 8);
3741 scnhdr
.s_paddr
= current
->reloc_count
;
3742 scnhdr
.s_vaddr
= current
->lineno_count
;
3744 scnhdr
.s_scnptr
= 0;
3745 scnhdr
.s_relptr
= current
->rel_filepos
;
3746 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3747 scnhdr
.s_nreloc
= current
->target_index
;
3748 scnhdr
.s_nlnno
= current
->target_index
;
3749 scnhdr
.s_flags
= STYP_OVRFLO
;
3750 amt
= bfd_coff_scnhsz (abfd
);
3751 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3752 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3759 /* OK, now set up the filehdr... */
3761 /* Don't include the internal abs section in the section count */
3763 /* We will NOT put a fucking timestamp in the header here. Every time you
3764 put it back, I will come in and take it out again. I'm sorry. This
3765 field does not belong here. We fill it with a 0 so it compares the
3766 same but is not a reasonable time. -- gnu@cygnus.com */
3767 internal_f
.f_timdat
= 0;
3768 internal_f
.f_flags
= 0;
3770 if (abfd
->flags
& EXEC_P
)
3771 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3774 internal_f
.f_opthdr
= 0;
3777 if (xcoff_data (abfd
)->full_aouthdr
)
3778 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3780 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
3786 internal_f
.f_flags
|= F_RELFLG
;
3788 internal_f
.f_flags
|= F_LNNO
;
3789 if (abfd
->flags
& EXEC_P
)
3790 internal_f
.f_flags
|= F_EXEC
;
3791 #ifdef COFF_IMAGE_WITH_PE
3793 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
3794 if (pe_data (abfd
)->real_flags
& IMAGE_FILE_LARGE_ADDRESS_AWARE
)
3795 internal_f
.f_flags
|= IMAGE_FILE_LARGE_ADDRESS_AWARE
;
3798 #ifndef COFF_WITH_pex64
3800 internal_f
.f_flags
|= IMAGE_FILE_32BIT_MACHINE
;
3802 if (bfd_little_endian (abfd
))
3803 internal_f
.f_flags
|= F_AR32WR
;
3805 internal_f
.f_flags
|= F_AR32W
;
3810 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
3811 but it doesn't hurt to set it internally. */
3812 internal_f
.f_target_id
= TI_TARGET_ID
;
3814 #ifdef TIC80_TARGET_ID
3815 internal_f
.f_target_id
= TIC80_TARGET_ID
;
3818 /* FIXME, should do something about the other byte orders and
3822 if ((abfd
->flags
& DYNAMIC
) != 0)
3823 internal_f
.f_flags
|= F_SHROBJ
;
3824 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
3825 internal_f
.f_flags
|= F_DYNLOAD
;
3828 memset (&internal_a
, 0, sizeof internal_a
);
3830 /* Set up architecture-dependent stuff. */
3832 unsigned int magic
= 0;
3833 unsigned short flags
= 0;
3835 coff_set_flags (abfd
, &magic
, &flags
);
3836 internal_f
.f_magic
= magic
;
3837 internal_f
.f_flags
|= flags
;
3838 /* ...and the "opt"hdr... */
3840 #ifdef TICOFF_AOUT_MAGIC
3841 internal_a
.magic
= TICOFF_AOUT_MAGIC
;
3842 #define __A_MAGIC_SET__
3845 internal_a
.magic
= TIC80_ARCH_MAGIC
;
3846 #define __A_MAGIC_SET__
3850 #define __A_MAGIC_SET__
3851 internal_a
.magic
= ZMAGIC
;
3855 #define __A_MAGIC_SET__
3856 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3859 #if defined MCORE_PE
3860 #define __A_MAGIC_SET__
3861 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3865 #define __A_MAGIC_SET__
3867 internal_a
.magic
= LYNXCOFFMAGIC
;
3869 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR64_MAGIC
;
3871 internal_a
.magic
= ZMAGIC
;
3876 #define __A_MAGIC_SET__
3877 internal_a
.magic
= PE32PMAGIC
;
3881 #define __A_MAGIC_SET__
3883 internal_a
.magic
= LYNXCOFFMAGIC
;
3888 #define __A_MAGIC_SET__
3889 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
3890 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
3891 RS6K_AOUTHDR_OMAGIC
;
3894 #if defined(SH) && defined(COFF_WITH_PE)
3895 #define __A_MAGIC_SET__
3896 internal_a
.magic
= SH_PE_MAGIC
;
3899 #if defined(MIPS) && defined(COFF_WITH_PE)
3900 #define __A_MAGIC_SET__
3901 internal_a
.magic
= MIPS_PE_MAGIC
;
3904 #ifndef __A_MAGIC_SET__
3905 #include "Your aouthdr magic number is not being set!"
3907 #undef __A_MAGIC_SET__
3911 /* FIXME: Does anybody ever set this to another value? */
3912 internal_a
.vstamp
= 0;
3914 /* Now should write relocs, strings, syms. */
3915 obj_sym_filepos (abfd
) = sym_base
;
3917 if (bfd_get_symcount (abfd
) != 0)
3921 if (!coff_renumber_symbols (abfd
, &firstundef
))
3923 coff_mangle_symbols (abfd
);
3924 if (! coff_write_symbols (abfd
))
3926 if (! coff_write_linenumbers (abfd
))
3928 if (! coff_write_relocs (abfd
, firstundef
))
3931 #ifdef COFF_LONG_SECTION_NAMES
3932 else if (long_section_names
&& ! obj_coff_strings_written (abfd
))
3934 /* If we have long section names we have to write out the string
3935 table even if there are no symbols. */
3936 if (! coff_write_symbols (abfd
))
3940 #ifdef COFF_IMAGE_WITH_PE
3942 else if ((abfd
->flags
& EXEC_P
) != 0)
3946 /* PowerPC PE appears to require that all executable files be
3947 rounded up to the page size. */
3950 (file_ptr
) BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
3952 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3958 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3959 backend linker, and obj_raw_syment_count is not valid until after
3960 coff_write_symbols is called. */
3961 if (obj_raw_syment_count (abfd
) != 0)
3963 internal_f
.f_symptr
= sym_base
;
3965 /* AIX appears to require that F_RELFLG not be set if there are
3966 local symbols but no relocations. */
3967 internal_f
.f_flags
&=~ F_RELFLG
;
3972 if (long_section_names
)
3973 internal_f
.f_symptr
= sym_base
;
3975 internal_f
.f_symptr
= 0;
3976 internal_f
.f_flags
|= F_LSYMS
;
3981 internal_a
.tsize
= text_sec
->size
;
3982 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
3986 internal_a
.dsize
= data_sec
->size
;
3987 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
3991 internal_a
.bsize
= bss_sec
->size
;
3992 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
3993 internal_a
.data_start
= bss_sec
->vma
;
3996 internal_a
.entry
= bfd_get_start_address (abfd
);
3997 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
4000 if (xcoff_data (abfd
)->full_aouthdr
)
4003 asection
*loader_sec
;
4005 internal_a
.vstamp
= 1;
4007 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
4008 if (internal_a
.o_snentry
== 0)
4009 internal_a
.entry
= (bfd_vma
) -1;
4011 if (text_sec
!= NULL
)
4013 internal_a
.o_sntext
= text_sec
->target_index
;
4014 internal_a
.o_algntext
= bfd_section_alignment (text_sec
);
4018 internal_a
.o_sntext
= 0;
4019 internal_a
.o_algntext
= 0;
4021 if (data_sec
!= NULL
)
4023 internal_a
.o_sndata
= data_sec
->target_index
;
4024 internal_a
.o_algndata
= bfd_section_alignment (data_sec
);
4028 internal_a
.o_sndata
= 0;
4029 internal_a
.o_algndata
= 0;
4031 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
4032 if (loader_sec
!= NULL
)
4033 internal_a
.o_snloader
= loader_sec
->target_index
;
4035 internal_a
.o_snloader
= 0;
4036 if (bss_sec
!= NULL
)
4037 internal_a
.o_snbss
= bss_sec
->target_index
;
4039 internal_a
.o_snbss
= 0;
4041 toc
= xcoff_data (abfd
)->toc
;
4042 internal_a
.o_toc
= toc
;
4043 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
4045 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
4046 if (xcoff_data (abfd
)->cputype
!= -1)
4047 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
4050 switch (bfd_get_arch (abfd
))
4052 case bfd_arch_rs6000
:
4053 internal_a
.o_cputype
= 4;
4055 case bfd_arch_powerpc
:
4056 if (bfd_get_mach (abfd
) == bfd_mach_ppc
)
4057 internal_a
.o_cputype
= 3;
4059 internal_a
.o_cputype
= 1;
4065 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
4066 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
4072 /* After object contents are finalized so we can compute a reasonable hash,
4073 but before header is written so we can update it to point to debug directory. */
4074 struct pe_tdata
*pe
= pe_data (abfd
);
4076 if (pe
->build_id
.after_write_object_contents
!= NULL
)
4077 (*pe
->build_id
.after_write_object_contents
) (abfd
);
4081 /* Now write header. */
4082 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
4087 bfd_size_type amount
= bfd_coff_filhsz (abfd
);
4089 buff
= (char *) bfd_malloc (amount
);
4093 bfd_coff_swap_filehdr_out (abfd
, & internal_f
, buff
);
4094 amount
= bfd_bwrite (buff
, amount
, abfd
);
4098 if (amount
!= bfd_coff_filhsz (abfd
))
4102 if (abfd
->flags
& EXEC_P
)
4104 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4105 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4107 bfd_size_type amount
= bfd_coff_aoutsz (abfd
);
4109 buff
= (char *) bfd_malloc (amount
);
4113 coff_swap_aouthdr_out (abfd
, & internal_a
, buff
);
4114 amount
= bfd_bwrite (buff
, amount
, abfd
);
4118 if (amount
!= bfd_coff_aoutsz (abfd
))
4121 #ifdef COFF_IMAGE_WITH_PE
4122 if (! coff_apply_checksum (abfd
))
4132 /* XCOFF seems to always write at least a small a.out header. */
4133 coff_swap_aouthdr_out (abfd
, & internal_a
, & buff
);
4134 if (xcoff_data (abfd
)->full_aouthdr
)
4135 size
= bfd_coff_aoutsz (abfd
);
4137 size
= SMALL_AOUTSZ
;
4138 if (bfd_bwrite (& buff
, (bfd_size_type
) size
, abfd
) != size
)
4147 coff_set_section_contents (bfd
* abfd
,
4149 const void * location
,
4151 bfd_size_type count
)
4153 if (! abfd
->output_has_begun
) /* Set by bfd.c handler. */
4155 if (! coff_compute_section_file_positions (abfd
))
4159 #if defined(_LIB) && !defined(TARG_AUX)
4160 /* The physical address field of a .lib section is used to hold the
4161 number of shared libraries in the section. This code counts the
4162 number of sections being written, and increments the lma field
4165 I have found no documentation on the contents of this section.
4166 Experimentation indicates that the section contains zero or more
4167 records, each of which has the following structure:
4169 - a (four byte) word holding the length of this record, in words,
4170 - a word that always seems to be set to "2",
4171 - the path to a shared library, null-terminated and then padded
4172 to a whole word boundary.
4174 bfd_assert calls have been added to alert if an attempt is made
4175 to write a section which doesn't follow these assumptions. The
4176 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4177 <robertl@arnet.com> (Thanks!).
4179 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4180 if (strcmp (section
->name
, _LIB
) == 0)
4182 bfd_byte
*rec
, *recend
;
4184 rec
= (bfd_byte
*) location
;
4185 recend
= rec
+ count
;
4186 while (rec
< recend
)
4189 rec
+= bfd_get_32 (abfd
, rec
) * 4;
4192 BFD_ASSERT (rec
== recend
);
4196 /* Don't write out bss sections - one way to do this is to
4197 see if the filepos has not been set. */
4198 if (section
->filepos
== 0)
4201 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0)
4207 return bfd_bwrite (location
, count
, abfd
) == count
;
4211 buy_and_read (bfd
*abfd
, file_ptr where
,
4212 bfd_size_type nmemb
, bfd_size_type size
)
4214 void *area
= bfd_alloc2 (abfd
, nmemb
, size
);
4219 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0
4220 || bfd_bread (area
, size
, abfd
) != size
)
4229 Creating the linenumber table is done by reading in the entire
4230 coff linenumber table, and creating another table for internal use.
4232 A coff linenumber table is structured so that each function
4233 is marked as having a line number of 0. Each line within the
4234 function is an offset from the first line in the function. The
4235 base of the line number information for the table is stored in
4236 the symbol associated with the function.
4238 Note: The PE format uses line number 0 for a flag indicating a
4241 The information is copied from the external to the internal
4242 table, and each symbol which marks a function is marked by
4245 How does this work ?
4249 coff_sort_func_alent (const void * arg1
, const void * arg2
)
4251 const alent
*al1
= *(const alent
**) arg1
;
4252 const alent
*al2
= *(const alent
**) arg2
;
4253 const coff_symbol_type
*s1
= (const coff_symbol_type
*) (al1
->u
.sym
);
4254 const coff_symbol_type
*s2
= (const coff_symbol_type
*) (al2
->u
.sym
);
4256 if (s1
== NULL
|| s2
== NULL
)
4258 if (s1
->symbol
.value
< s2
->symbol
.value
)
4260 else if (s1
->symbol
.value
> s2
->symbol
.value
)
4267 coff_slurp_line_table (bfd
*abfd
, asection
*asect
)
4269 LINENO
*native_lineno
;
4270 alent
*lineno_cache
;
4271 unsigned int counter
;
4273 bfd_vma prev_offset
= 0;
4274 bfd_boolean ordered
= TRUE
;
4275 unsigned int nbr_func
;
4277 bfd_boolean have_func
;
4278 bfd_boolean ret
= TRUE
;
4280 if (asect
->lineno_count
== 0)
4283 BFD_ASSERT (asect
->lineno
== NULL
);
4285 if (asect
->lineno_count
> asect
->size
)
4288 (_("%pB: warning: line number count (%#lx) exceeds section size (%#lx)"),
4289 abfd
, (unsigned long) asect
->lineno_count
, (unsigned long) asect
->size
);
4293 lineno_cache
= (alent
*) bfd_alloc2 (abfd
,
4294 (bfd_size_type
) asect
->lineno_count
+ 1,
4296 if (lineno_cache
== NULL
)
4299 native_lineno
= (LINENO
*) buy_and_read (abfd
, asect
->line_filepos
,
4300 asect
->lineno_count
,
4301 bfd_coff_linesz (abfd
));
4302 if (native_lineno
== NULL
)
4305 (_("%pB: warning: line number table read failed"), abfd
);
4306 bfd_release (abfd
, lineno_cache
);
4310 cache_ptr
= lineno_cache
;
4311 asect
->lineno
= lineno_cache
;
4312 src
= native_lineno
;
4316 for (counter
= 0; counter
< asect
->lineno_count
; counter
++, src
++)
4318 struct internal_lineno dst
;
4320 bfd_coff_swap_lineno_in (abfd
, src
, &dst
);
4321 cache_ptr
->line_number
= dst
.l_lnno
;
4322 /* Appease memory checkers that get all excited about
4323 uninitialised memory when copying alents if u.offset is
4324 larger than u.sym. (64-bit BFD on 32-bit host.) */
4325 memset (&cache_ptr
->u
, 0, sizeof (cache_ptr
->u
));
4327 if (cache_ptr
->line_number
== 0)
4329 combined_entry_type
* ent
;
4330 unsigned long symndx
;
4331 coff_symbol_type
*sym
;
4334 symndx
= dst
.l_addr
.l_symndx
;
4335 if (symndx
>= obj_raw_syment_count (abfd
))
4338 /* xgettext:c-format */
4339 (_("%pB: warning: illegal symbol index 0x%lx in line number entry %d"),
4340 abfd
, symndx
, counter
);
4341 cache_ptr
->line_number
= -1;
4346 ent
= obj_raw_syments (abfd
) + symndx
;
4347 /* FIXME: We should not be casting between ints and
4348 pointers like this. */
4352 /* xgettext:c-format */
4353 (_("%pB: warning: illegal symbol index 0x%lx in line number entry %d"),
4354 abfd
, symndx
, counter
);
4355 cache_ptr
->line_number
= -1;
4359 sym
= (coff_symbol_type
*) (ent
->u
.syment
._n
._n_n
._n_zeroes
);
4361 /* PR 17512 file: 078-10659-0.004 */
4362 if (sym
< obj_symbols (abfd
)
4363 || sym
>= obj_symbols (abfd
) + bfd_get_symcount (abfd
))
4366 /* xgettext:c-format */
4367 (_("%pB: warning: illegal symbol in line number entry %d"),
4369 cache_ptr
->line_number
= -1;
4376 cache_ptr
->u
.sym
= (asymbol
*) sym
;
4377 if (sym
->lineno
!= NULL
)
4379 /* xgettext:c-format */
4380 (_("%pB: warning: duplicate line number information for `%s'"),
4381 abfd
, bfd_asymbol_name (&sym
->symbol
));
4383 sym
->lineno
= cache_ptr
;
4384 if (sym
->symbol
.value
< prev_offset
)
4386 prev_offset
= sym
->symbol
.value
;
4388 else if (!have_func
)
4389 /* Drop line information that has no associated function.
4390 PR 17521: file: 078-10659-0.004. */
4393 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
- bfd_section_vma (asect
);
4397 asect
->lineno_count
= cache_ptr
- lineno_cache
;
4398 memset (cache_ptr
, 0, sizeof (*cache_ptr
));
4399 bfd_release (abfd
, native_lineno
);
4401 /* On some systems (eg AIX5.3) the lineno table may not be sorted. */
4404 /* Sort the table. */
4406 alent
*n_lineno_cache
;
4408 /* Create a table of functions. */
4409 func_table
= (alent
**) bfd_alloc2 (abfd
, nbr_func
, sizeof (alent
*));
4410 if (func_table
!= NULL
)
4412 alent
**p
= func_table
;
4415 for (i
= 0; i
< asect
->lineno_count
; i
++)
4416 if (lineno_cache
[i
].line_number
== 0)
4417 *p
++ = &lineno_cache
[i
];
4419 BFD_ASSERT ((unsigned int) (p
- func_table
) == nbr_func
);
4421 /* Sort by functions. */
4422 qsort (func_table
, nbr_func
, sizeof (alent
*), coff_sort_func_alent
);
4424 /* Create the new sorted table. */
4425 n_lineno_cache
= (alent
*) bfd_alloc2 (abfd
, asect
->lineno_count
,
4427 if (n_lineno_cache
!= NULL
)
4429 alent
*n_cache_ptr
= n_lineno_cache
;
4431 for (i
= 0; i
< nbr_func
; i
++)
4433 coff_symbol_type
*sym
;
4434 alent
*old_ptr
= func_table
[i
];
4436 /* Update the function entry. */
4437 sym
= (coff_symbol_type
*) old_ptr
->u
.sym
;
4438 /* PR binutils/17512: Point the lineno to where
4439 this entry will be after the memcpy below. */
4440 sym
->lineno
= lineno_cache
+ (n_cache_ptr
- n_lineno_cache
);
4441 /* Copy the function and line number entries. */
4443 *n_cache_ptr
++ = *old_ptr
++;
4444 while (old_ptr
->line_number
!= 0);
4447 memcpy (lineno_cache
, n_lineno_cache
,
4448 asect
->lineno_count
* sizeof (alent
));
4452 bfd_release (abfd
, func_table
);
4461 /* Slurp in the symbol table, converting it to generic form. Note
4462 that if coff_relocate_section is defined, the linker will read
4463 symbols via coff_link_add_symbols, rather than via this routine. */
4466 coff_slurp_symbol_table (bfd
* abfd
)
4468 combined_entry_type
*native_symbols
;
4469 coff_symbol_type
*cached_area
;
4470 unsigned int *table_ptr
;
4471 unsigned int number_of_symbols
= 0;
4472 bfd_boolean ret
= TRUE
;
4474 if (obj_symbols (abfd
))
4477 /* Read in the symbol table. */
4478 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4481 /* Allocate enough room for all the symbols in cached form. */
4482 cached_area
= (coff_symbol_type
*) bfd_alloc2 (abfd
,
4483 obj_raw_syment_count (abfd
),
4484 sizeof (coff_symbol_type
));
4485 if (cached_area
== NULL
)
4488 table_ptr
= (unsigned int *) bfd_zalloc2 (abfd
, obj_raw_syment_count (abfd
),
4489 sizeof (unsigned int));
4491 if (table_ptr
== NULL
)
4495 coff_symbol_type
*dst
= cached_area
;
4496 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4497 unsigned int this_index
= 0;
4499 while (this_index
< last_native_index
)
4501 combined_entry_type
*src
= native_symbols
+ this_index
;
4502 table_ptr
[this_index
] = number_of_symbols
;
4504 dst
->symbol
.the_bfd
= abfd
;
4505 BFD_ASSERT (src
->is_sym
);
4506 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4507 /* We use the native name field to point to the cached field. */
4508 src
->u
.syment
._n
._n_n
._n_zeroes
= (bfd_hostptr_t
) dst
;
4509 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4510 src
->u
.syment
.n_scnum
);
4511 dst
->symbol
.flags
= 0;
4512 /* PR 17512: file: 079-7098-0.001:0.1. */
4513 dst
->symbol
.value
= 0;
4514 dst
->done_lineno
= FALSE
;
4516 switch (src
->u
.syment
.n_sclass
)
4522 case C_THUMBEXTFUNC
:
4526 #if ! defined _AIX52 && ! defined AIX_WEAK_SUPPORT
4531 case C_SYSTEM
: /* System Wide variable. */
4534 /* In PE, 0x68 (104) denotes a section symbol. */
4536 /* In PE, 0x69 (105) denotes a weak external symbol. */
4539 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4541 case COFF_SYMBOL_GLOBAL
:
4542 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4543 #if defined COFF_WITH_PE
4544 /* PE sets the symbol to a value relative to the
4545 start of the section. */
4546 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4548 dst
->symbol
.value
= (src
->u
.syment
.n_value
4549 - dst
->symbol
.section
->vma
);
4551 if (ISFCN ((src
->u
.syment
.n_type
)))
4552 /* A function ext does not go at the end of a
4554 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4557 case COFF_SYMBOL_COMMON
:
4558 dst
->symbol
.section
= bfd_com_section_ptr
;
4559 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4562 case COFF_SYMBOL_UNDEFINED
:
4563 dst
->symbol
.section
= bfd_und_section_ptr
;
4564 dst
->symbol
.value
= 0;
4567 case COFF_SYMBOL_PE_SECTION
:
4568 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4569 dst
->symbol
.value
= 0;
4572 case COFF_SYMBOL_LOCAL
:
4573 dst
->symbol
.flags
= BSF_LOCAL
;
4574 #if defined COFF_WITH_PE
4575 /* PE sets the symbol to a value relative to the
4576 start of the section. */
4577 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4579 dst
->symbol
.value
= (src
->u
.syment
.n_value
4580 - dst
->symbol
.section
->vma
);
4582 if (ISFCN ((src
->u
.syment
.n_type
)))
4583 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4588 /* A symbol with a csect entry should not go at the end. */
4589 if (src
->u
.syment
.n_numaux
> 0)
4590 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4594 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4595 dst
->symbol
.flags
|= BSF_WEAK
;
4597 if (src
->u
.syment
.n_sclass
== C_SECTION
4598 && src
->u
.syment
.n_scnum
> 0)
4599 dst
->symbol
.flags
= BSF_LOCAL
;
4601 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
4603 || src
->u
.syment
.n_sclass
== C_AIX_WEAKEXT
4606 dst
->symbol
.flags
|= BSF_WEAK
;
4610 case C_STAT
: /* Static. */
4612 case C_THUMBSTAT
: /* Thumb static. */
4613 case C_THUMBLABEL
: /* Thumb label. */
4614 case C_THUMBSTATFUNC
:/* Thumb static function. */
4617 case C_DWARF
: /* A label in a dwarf section. */
4618 case C_INFO
: /* A label in a comment section. */
4620 case C_LABEL
: /* Label. */
4621 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4622 dst
->symbol
.flags
= BSF_DEBUGGING
;
4624 dst
->symbol
.flags
= BSF_LOCAL
;
4626 /* Base the value as an index from the base of the
4627 section, if there is one. */
4628 if (dst
->symbol
.section
)
4630 #if defined COFF_WITH_PE
4631 /* PE sets the symbol to a value relative to the
4632 start of the section. */
4633 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4635 dst
->symbol
.value
= (src
->u
.syment
.n_value
4636 - dst
->symbol
.section
->vma
);
4640 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4643 case C_MOS
: /* Member of structure. */
4644 case C_EOS
: /* End of structure. */
4645 case C_REGPARM
: /* Register parameter. */
4646 case C_REG
: /* register variable. */
4647 /* C_AUTOARG conflicts with TI COFF C_UEXT. */
4648 case C_TPDEF
: /* Type definition. */
4650 case C_AUTO
: /* Automatic variable. */
4651 case C_FIELD
: /* Bit field. */
4652 case C_ENTAG
: /* Enumeration tag. */
4653 case C_MOE
: /* Member of enumeration. */
4654 case C_MOU
: /* Member of union. */
4655 case C_UNTAG
: /* Union tag. */
4656 dst
->symbol
.flags
= BSF_DEBUGGING
;
4657 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4660 case C_FILE
: /* File name. */
4661 case C_STRTAG
: /* Structure tag. */
4678 dst
->symbol
.flags
= BSF_DEBUGGING
;
4679 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4683 case C_BINCL
: /* Beginning of include file. */
4684 case C_EINCL
: /* Ending of include file. */
4685 /* The value is actually a pointer into the line numbers
4686 of the file. We locate the line number entry, and
4687 set the section to the section which contains it, and
4688 the value to the index in that section. */
4692 dst
->symbol
.flags
= BSF_DEBUGGING
;
4693 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4694 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4695 && ((file_ptr
) (sec
->line_filepos
4696 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4697 > (file_ptr
) src
->u
.syment
.n_value
))
4700 dst
->symbol
.value
= 0;
4703 dst
->symbol
.section
= sec
;
4704 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4705 - sec
->line_filepos
)
4706 / bfd_coff_linesz (abfd
));
4713 dst
->symbol
.flags
= BSF_DEBUGGING
;
4715 /* The value is actually a symbol index. Save a pointer
4716 to the symbol instead of the index. FIXME: This
4717 should use a union. */
4718 src
->u
.syment
.n_value
=
4719 (long) (intptr_t) (native_symbols
+ src
->u
.syment
.n_value
);
4720 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4725 case C_BLOCK
: /* ".bb" or ".eb". */
4726 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf"). */
4727 case C_EFCN
: /* Physical end of function. */
4728 #if defined COFF_WITH_PE
4729 /* PE sets the symbol to a value relative to the start
4731 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4732 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4734 /* PE uses funny values for .ef and .lf; don't
4736 dst
->symbol
.flags
= BSF_DEBUGGING
;
4739 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4741 /* Base the value as an index from the base of the
4743 dst
->symbol
.flags
= BSF_LOCAL
;
4744 dst
->symbol
.value
= (src
->u
.syment
.n_value
4745 - dst
->symbol
.section
->vma
);
4749 case C_STATLAB
: /* Static load time label. */
4750 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4751 dst
->symbol
.flags
= BSF_GLOBAL
;
4755 /* PE DLLs sometimes have zeroed out symbols for some
4756 reason. Just ignore them without a warning. */
4757 if (src
->u
.syment
.n_type
== 0
4758 && src
->u
.syment
.n_value
== 0
4759 && src
->u
.syment
.n_scnum
== 0)
4762 /* XCOFF specific: deleted entry. */
4763 if (src
->u
.syment
.n_value
== C_NULL_VALUE
)
4767 case C_EXTDEF
: /* External definition. */
4768 case C_ULABEL
: /* Undefined label. */
4769 case C_USTATIC
: /* Undefined static. */
4770 #ifndef COFF_WITH_PE
4771 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4772 class to represent a section symbol. */
4773 case C_LINE
: /* line # reformatted as symbol table entry. */
4774 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4775 case C_ALIAS
: /* Duplicate tag. */
4777 /* New storage classes for TI COFF. */
4778 #if defined(TIC80COFF) || defined(TICOFF)
4779 case C_UEXT
: /* Tentative external definition. */
4781 case C_EXTLAB
: /* External load time label. */
4784 /* xgettext:c-format */
4785 (_("%pB: unrecognized storage class %d for %s symbol `%s'"),
4786 abfd
, src
->u
.syment
.n_sclass
,
4787 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4790 case C_HIDDEN
: /* Ext symbol in dmert public lib. */
4791 /* PR 20722: These symbols can also be generated by
4792 building DLLs with --gc-sections enabled. */
4793 dst
->symbol
.flags
= BSF_DEBUGGING
;
4794 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4799 dst
->symbol
.udata
.i
= 0;
4802 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
4804 number_of_symbols
++;
4808 obj_symbols (abfd
) = cached_area
;
4809 obj_raw_syments (abfd
) = native_symbols
;
4811 abfd
->symcount
= number_of_symbols
;
4812 obj_convert (abfd
) = table_ptr
;
4813 /* Slurp the line tables for each section too. */
4820 if (! coff_slurp_line_table (abfd
, p
))
4829 /* Classify a COFF symbol. A couple of targets have globally visible
4830 symbols which are not class C_EXT, and this handles those. It also
4831 recognizes some special PE cases. */
4833 static enum coff_symbol_classification
4834 coff_classify_symbol (bfd
*abfd
,
4835 struct internal_syment
*syment
)
4837 /* FIXME: This partially duplicates the switch in
4838 coff_slurp_symbol_table. */
4839 switch (syment
->n_sclass
)
4845 case C_THUMBEXTFUNC
:
4853 if (syment
->n_scnum
== 0)
4855 if (syment
->n_value
== 0)
4856 return COFF_SYMBOL_UNDEFINED
;
4858 return COFF_SYMBOL_COMMON
;
4860 return COFF_SYMBOL_GLOBAL
;
4867 if (syment
->n_sclass
== C_STAT
)
4869 if (syment
->n_scnum
== 0)
4870 /* The Microsoft compiler sometimes generates these if a
4871 small static function is inlined every time it is used.
4872 The function is discarded, but the symbol table entry
4874 return COFF_SYMBOL_LOCAL
;
4876 #ifdef STRICT_PE_FORMAT
4877 /* This is correct for Microsoft generated objects, but it
4878 breaks gas generated objects. */
4879 if (syment
->n_value
== 0)
4883 char buf
[SYMNMLEN
+ 1];
4885 name
= _bfd_coff_internal_syment_name (abfd
, syment
, buf
)
4886 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
4887 if (sec
!= NULL
&& name
!= NULL
4888 && (strcmp (bfd_section_name (sec
), name
) == 0))
4889 return COFF_SYMBOL_PE_SECTION
;
4893 return COFF_SYMBOL_LOCAL
;
4896 if (syment
->n_sclass
== C_SECTION
)
4898 /* In some cases in a DLL generated by the Microsoft linker, the
4899 n_value field will contain garbage. FIXME: This should
4900 probably be handled by the swapping function instead. */
4901 syment
->n_value
= 0;
4902 if (syment
->n_scnum
== 0)
4903 return COFF_SYMBOL_UNDEFINED
;
4904 return COFF_SYMBOL_PE_SECTION
;
4906 #endif /* COFF_WITH_PE */
4908 /* If it is not a global symbol, we presume it is a local symbol. */
4909 if (syment
->n_scnum
== 0)
4911 char buf
[SYMNMLEN
+ 1];
4914 /* xgettext:c-format */
4915 (_("warning: %pB: local symbol `%s' has no section"),
4916 abfd
, _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
4919 return COFF_SYMBOL_LOCAL
;
4926 Coff relocations are easily transformed into the internal BFD form
4929 Reading a coff relocation table is done in the following stages:
4931 o Read the entire coff relocation table into memory.
4933 o Process each relocation in turn; first swap it from the
4934 external to the internal form.
4936 o Turn the symbol referenced in the relocation's symbol index
4937 into a pointer into the canonical symbol table.
4938 This table is the same as the one returned by a call to
4939 @code{bfd_canonicalize_symtab}. The back end will call that
4940 routine and save the result if a canonicalization hasn't been done.
4942 o The reloc index is turned into a pointer to a howto
4943 structure, in a back end specific way. For instance, the 386
4944 uses the @code{r_type} to directly produce an index
4945 into a howto table vector.
4949 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
4951 coff_symbol_type *coffsym = NULL; \
4953 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
4954 coffsym = (obj_symbols (abfd) \
4955 + (cache_ptr->sym_ptr_ptr - symbols)); \
4957 coffsym = coff_symbol_from (ptr); \
4958 if (coffsym != NULL \
4959 && coffsym->native->is_sym \
4960 && coffsym->native->u.syment.n_scnum == 0) \
4961 cache_ptr->addend = 0; \
4962 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
4963 && ptr->section != NULL) \
4964 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
4966 cache_ptr->addend = 0; \
4971 coff_slurp_reloc_table (bfd
* abfd
, sec_ptr asect
, asymbol
** symbols
)
4973 RELOC
*native_relocs
;
4974 arelent
*reloc_cache
;
4978 if (asect
->relocation
)
4980 if (asect
->reloc_count
== 0)
4982 if (asect
->flags
& SEC_CONSTRUCTOR
)
4984 if (!coff_slurp_symbol_table (abfd
))
4987 native_relocs
= (RELOC
*) buy_and_read (abfd
, asect
->rel_filepos
,
4989 bfd_coff_relsz (abfd
));
4990 reloc_cache
= (arelent
*) bfd_alloc2 (abfd
, asect
->reloc_count
,
4993 if (reloc_cache
== NULL
|| native_relocs
== NULL
)
4996 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
4998 struct internal_reloc dst
;
4999 struct external_reloc
*src
;
5000 #ifndef RELOC_PROCESSING
5004 cache_ptr
= reloc_cache
+ idx
;
5005 src
= native_relocs
+ idx
;
5008 coff_swap_reloc_in (abfd
, src
, &dst
);
5010 #ifdef RELOC_PROCESSING
5011 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
5013 cache_ptr
->address
= dst
.r_vaddr
;
5015 if (dst
.r_symndx
!= -1 && symbols
!= NULL
)
5017 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
5020 /* xgettext:c-format */
5021 (_("%pB: warning: illegal symbol index %ld in relocs"),
5022 abfd
, dst
.r_symndx
);
5023 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5028 cache_ptr
->sym_ptr_ptr
= (symbols
5029 + obj_convert (abfd
)[dst
.r_symndx
]);
5030 ptr
= *(cache_ptr
->sym_ptr_ptr
);
5035 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5039 /* The symbols definitions that we have read in have been
5040 relocated as if their sections started at 0. But the offsets
5041 refering to the symbols in the raw data have not been
5042 modified, so we have to have a negative addend to compensate.
5044 Note that symbols which used to be common must be left alone. */
5046 /* Calculate any reloc addend by looking at the symbol. */
5047 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
5050 cache_ptr
->address
-= asect
->vma
;
5051 /* !! cache_ptr->section = NULL;*/
5053 /* Fill in the cache_ptr->howto field from dst.r_type. */
5054 RTYPE2HOWTO (cache_ptr
, &dst
);
5055 #endif /* RELOC_PROCESSING */
5057 if (cache_ptr
->howto
== NULL
)
5060 /* xgettext:c-format */
5061 (_("%pB: illegal relocation type %d at address %#" PRIx64
),
5062 abfd
, dst
.r_type
, (uint64_t) dst
.r_vaddr
);
5063 bfd_set_error (bfd_error_bad_value
);
5068 asect
->relocation
= reloc_cache
;
5072 #ifndef coff_rtype_to_howto
5075 /* Get the howto structure for a reloc. This is only used if the file
5076 including this one defines coff_relocate_section to be
5077 _bfd_coff_generic_relocate_section, so it is OK if it does not
5078 always work. It is the responsibility of the including file to
5079 make sure it is reasonable if it is needed. */
5081 static reloc_howto_type
*
5082 coff_rtype_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
5083 asection
*sec ATTRIBUTE_UNUSED
,
5084 struct internal_reloc
*rel ATTRIBUTE_UNUSED
,
5085 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
,
5086 struct internal_syment
*sym ATTRIBUTE_UNUSED
,
5087 bfd_vma
*addendp ATTRIBUTE_UNUSED
)
5091 genrel
.howto
= NULL
;
5092 RTYPE2HOWTO (&genrel
, rel
);
5093 return genrel
.howto
;
5096 #else /* ! defined (RTYPE2HOWTO) */
5098 #define coff_rtype_to_howto NULL
5100 #endif /* ! defined (RTYPE2HOWTO) */
5101 #endif /* ! defined (coff_rtype_to_howto) */
5103 /* This is stupid. This function should be a boolean predicate. */
5106 coff_canonicalize_reloc (bfd
* abfd
,
5111 arelent
*tblptr
= section
->relocation
;
5112 unsigned int count
= 0;
5114 if (section
->flags
& SEC_CONSTRUCTOR
)
5116 /* This section has relocs made up by us, they are not in the
5117 file, so take them out of their chain and place them into
5118 the data area provided. */
5119 arelent_chain
*chain
= section
->constructor_chain
;
5121 for (count
= 0; count
< section
->reloc_count
; count
++)
5123 *relptr
++ = &chain
->relent
;
5124 chain
= chain
->next
;
5129 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
5132 tblptr
= section
->relocation
;
5134 for (; count
++ < section
->reloc_count
;)
5135 *relptr
++ = tblptr
++;
5138 return section
->reloc_count
;
5141 #ifndef coff_set_reloc
5142 #define coff_set_reloc _bfd_generic_set_reloc
5145 #ifndef coff_reloc16_estimate
5146 #define coff_reloc16_estimate dummy_reloc16_estimate
5149 dummy_reloc16_estimate (bfd
*abfd ATTRIBUTE_UNUSED
,
5150 asection
*input_section ATTRIBUTE_UNUSED
,
5151 arelent
*reloc ATTRIBUTE_UNUSED
,
5152 unsigned int shrink ATTRIBUTE_UNUSED
,
5153 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
)
5161 #ifndef coff_reloc16_extra_cases
5163 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5165 /* This works even if abort is not declared in any header file. */
5168 dummy_reloc16_extra_cases (bfd
*abfd ATTRIBUTE_UNUSED
,
5169 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
5170 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
,
5171 arelent
*reloc ATTRIBUTE_UNUSED
,
5172 bfd_byte
*data ATTRIBUTE_UNUSED
,
5173 unsigned int *src_ptr ATTRIBUTE_UNUSED
,
5174 unsigned int *dst_ptr ATTRIBUTE_UNUSED
)
5180 /* If coff_relocate_section is defined, we can use the optimized COFF
5181 backend linker. Otherwise we must continue to use the old linker. */
5183 #ifdef coff_relocate_section
5185 #ifndef coff_bfd_link_hash_table_create
5186 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5188 #ifndef coff_bfd_link_add_symbols
5189 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5191 #ifndef coff_bfd_final_link
5192 #define coff_bfd_final_link _bfd_coff_final_link
5195 #else /* ! defined (coff_relocate_section) */
5197 #define coff_relocate_section NULL
5198 #ifndef coff_bfd_link_hash_table_create
5199 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5201 #ifndef coff_bfd_link_add_symbols
5202 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5204 #define coff_bfd_final_link _bfd_generic_final_link
5206 #endif /* ! defined (coff_relocate_section) */
5208 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5209 #define coff_bfd_copy_link_hash_symbol_type \
5210 _bfd_generic_copy_link_hash_symbol_type
5211 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5213 #define coff_bfd_link_check_relocs _bfd_generic_link_check_relocs
5215 #ifndef coff_start_final_link
5216 #define coff_start_final_link NULL
5219 #ifndef coff_adjust_symndx
5220 #define coff_adjust_symndx NULL
5223 #ifndef coff_link_add_one_symbol
5224 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5227 #ifndef coff_link_output_has_begun
5230 coff_link_output_has_begun (bfd
* abfd
,
5231 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
)
5233 return abfd
->output_has_begun
;
5237 #ifndef coff_final_link_postscript
5240 coff_final_link_postscript (bfd
* abfd ATTRIBUTE_UNUSED
,
5241 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
)
5247 #ifndef coff_SWAP_aux_in
5248 #define coff_SWAP_aux_in coff_swap_aux_in
5250 #ifndef coff_SWAP_sym_in
5251 #define coff_SWAP_sym_in coff_swap_sym_in
5253 #ifndef coff_SWAP_lineno_in
5254 #define coff_SWAP_lineno_in coff_swap_lineno_in
5256 #ifndef coff_SWAP_aux_out
5257 #define coff_SWAP_aux_out coff_swap_aux_out
5259 #ifndef coff_SWAP_sym_out
5260 #define coff_SWAP_sym_out coff_swap_sym_out
5262 #ifndef coff_SWAP_lineno_out
5263 #define coff_SWAP_lineno_out coff_swap_lineno_out
5265 #ifndef coff_SWAP_reloc_out
5266 #define coff_SWAP_reloc_out coff_swap_reloc_out
5268 #ifndef coff_SWAP_filehdr_out
5269 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5271 #ifndef coff_SWAP_aouthdr_out
5272 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5274 #ifndef coff_SWAP_scnhdr_out
5275 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5277 #ifndef coff_SWAP_reloc_in
5278 #define coff_SWAP_reloc_in coff_swap_reloc_in
5280 #ifndef coff_SWAP_filehdr_in
5281 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5283 #ifndef coff_SWAP_aouthdr_in
5284 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5286 #ifndef coff_SWAP_scnhdr_in
5287 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5290 static bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED
=
5292 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5293 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5294 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5295 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5296 coff_SWAP_scnhdr_out
,
5297 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5298 #ifdef COFF_LONG_FILENAMES
5303 COFF_DEFAULT_LONG_SECTION_NAMES
,
5304 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5305 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5310 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5316 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5317 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5318 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5319 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5320 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5321 coff_classify_symbol
, coff_compute_section_file_positions
,
5322 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5323 coff_adjust_symndx
, coff_link_add_one_symbol
,
5324 coff_link_output_has_begun
, coff_final_link_postscript
,
5329 /* COFF0 differs in file/section header size and relocation entry size. */
5331 static bfd_coff_backend_data ticoff0_swap_table
=
5333 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5334 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5335 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5336 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5337 coff_SWAP_scnhdr_out
,
5338 FILHSZ_V0
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ_V0
, LINESZ
, FILNMLEN
,
5339 #ifdef COFF_LONG_FILENAMES
5344 COFF_DEFAULT_LONG_SECTION_NAMES
,
5345 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5346 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5351 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5357 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5358 coff_SWAP_reloc_in
, ticoff0_bad_format_hook
, coff_set_arch_mach_hook
,
5359 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5360 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5361 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5362 coff_classify_symbol
, coff_compute_section_file_positions
,
5363 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5364 coff_adjust_symndx
, coff_link_add_one_symbol
,
5365 coff_link_output_has_begun
, coff_final_link_postscript
,
5371 /* COFF1 differs in section header size. */
5373 static bfd_coff_backend_data ticoff1_swap_table
=
5375 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5376 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5377 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5378 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5379 coff_SWAP_scnhdr_out
,
5380 FILHSZ
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5381 #ifdef COFF_LONG_FILENAMES
5386 COFF_DEFAULT_LONG_SECTION_NAMES
,
5387 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5388 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5393 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5399 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5400 coff_SWAP_reloc_in
, ticoff1_bad_format_hook
, coff_set_arch_mach_hook
,
5401 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5402 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5403 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5404 coff_classify_symbol
, coff_compute_section_file_positions
,
5405 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5406 coff_adjust_symndx
, coff_link_add_one_symbol
,
5407 coff_link_output_has_begun
, coff_final_link_postscript
,
5408 bfd_pe_print_pdata
/* huh */
5412 #ifdef COFF_WITH_PE_BIGOBJ
5413 /* The UID for bigobj files. */
5415 static const char header_bigobj_classid
[16] =
5417 0xC7, 0xA1, 0xBA, 0xD1,
5421 0xFA, 0xF6, 0x6A, 0xA4, 0xDC, 0xB8
5424 /* Swap routines. */
5427 coff_bigobj_swap_filehdr_in (bfd
* abfd
, void * src
, void * dst
)
5429 struct external_ANON_OBJECT_HEADER_BIGOBJ
*filehdr_src
=
5430 (struct external_ANON_OBJECT_HEADER_BIGOBJ
*) src
;
5431 struct internal_filehdr
*filehdr_dst
= (struct internal_filehdr
*) dst
;
5433 filehdr_dst
->f_magic
= H_GET_16 (abfd
, filehdr_src
->Machine
);
5434 filehdr_dst
->f_nscns
= H_GET_32 (abfd
, filehdr_src
->NumberOfSections
);
5435 filehdr_dst
->f_timdat
= H_GET_32 (abfd
, filehdr_src
->TimeDateStamp
);
5436 filehdr_dst
->f_symptr
=
5437 GET_FILEHDR_SYMPTR (abfd
, filehdr_src
->PointerToSymbolTable
);
5438 filehdr_dst
->f_nsyms
= H_GET_32 (abfd
, filehdr_src
->NumberOfSymbols
);
5439 filehdr_dst
->f_opthdr
= 0;
5440 filehdr_dst
->f_flags
= 0;
5442 /* Check other magic numbers. */
5443 if (H_GET_16 (abfd
, filehdr_src
->Sig1
) != IMAGE_FILE_MACHINE_UNKNOWN
5444 || H_GET_16 (abfd
, filehdr_src
->Sig2
) != 0xffff
5445 || H_GET_16 (abfd
, filehdr_src
->Version
) != 2
5446 || memcmp (filehdr_src
->ClassID
, header_bigobj_classid
, 16) != 0)
5447 filehdr_dst
->f_opthdr
= 0xffff;
5449 /* Note that CLR metadata are ignored. */
5453 coff_bigobj_swap_filehdr_out (bfd
*abfd
, void * in
, void * out
)
5455 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
5456 struct external_ANON_OBJECT_HEADER_BIGOBJ
*filehdr_out
=
5457 (struct external_ANON_OBJECT_HEADER_BIGOBJ
*) out
;
5459 memset (filehdr_out
, 0, sizeof (*filehdr_out
));
5461 H_PUT_16 (abfd
, IMAGE_FILE_MACHINE_UNKNOWN
, filehdr_out
->Sig1
);
5462 H_PUT_16 (abfd
, 0xffff, filehdr_out
->Sig2
);
5463 H_PUT_16 (abfd
, 2, filehdr_out
->Version
);
5464 memcpy (filehdr_out
->ClassID
, header_bigobj_classid
, 16);
5465 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->Machine
);
5466 H_PUT_32 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->NumberOfSections
);
5467 H_PUT_32 (abfd
, filehdr_in
->f_timdat
, filehdr_out
->TimeDateStamp
);
5468 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
,
5469 filehdr_out
->PointerToSymbolTable
);
5470 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->NumberOfSymbols
);
5472 return bfd_coff_filhsz (abfd
);
5476 coff_bigobj_swap_sym_in (bfd
* abfd
, void * ext1
, void * in1
)
5478 SYMENT_BIGOBJ
*ext
= (SYMENT_BIGOBJ
*) ext1
;
5479 struct internal_syment
*in
= (struct internal_syment
*) in1
;
5481 if (ext
->e
.e_name
[0] == 0)
5483 in
->_n
._n_n
._n_zeroes
= 0;
5484 in
->_n
._n_n
._n_offset
= H_GET_32 (abfd
, ext
->e
.e
.e_offset
);
5488 #if SYMNMLEN != E_SYMNMLEN
5489 #error we need to cope with truncating or extending SYMNMLEN
5491 memcpy (in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
5495 in
->n_value
= H_GET_32 (abfd
, ext
->e_value
);
5496 BFD_ASSERT (sizeof (in
->n_scnum
) >= 4);
5497 in
->n_scnum
= H_GET_32 (abfd
, ext
->e_scnum
);
5498 in
->n_type
= H_GET_16 (abfd
, ext
->e_type
);
5499 in
->n_sclass
= H_GET_8 (abfd
, ext
->e_sclass
);
5500 in
->n_numaux
= H_GET_8 (abfd
, ext
->e_numaux
);
5504 coff_bigobj_swap_sym_out (bfd
* abfd
, void * inp
, void * extp
)
5506 struct internal_syment
*in
= (struct internal_syment
*) inp
;
5507 SYMENT_BIGOBJ
*ext
= (SYMENT_BIGOBJ
*) extp
;
5509 if (in
->_n
._n_name
[0] == 0)
5511 H_PUT_32 (abfd
, 0, ext
->e
.e
.e_zeroes
);
5512 H_PUT_32 (abfd
, in
->_n
._n_n
._n_offset
, ext
->e
.e
.e_offset
);
5516 #if SYMNMLEN != E_SYMNMLEN
5517 #error we need to cope with truncating or extending SYMNMLEN
5519 memcpy (ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
5523 H_PUT_32 (abfd
, in
->n_value
, ext
->e_value
);
5524 H_PUT_32 (abfd
, in
->n_scnum
, ext
->e_scnum
);
5526 H_PUT_16 (abfd
, in
->n_type
, ext
->e_type
);
5527 H_PUT_8 (abfd
, in
->n_sclass
, ext
->e_sclass
);
5528 H_PUT_8 (abfd
, in
->n_numaux
, ext
->e_numaux
);
5530 return SYMESZ_BIGOBJ
;
5534 coff_bigobj_swap_aux_in (bfd
*abfd
,
5542 AUXENT_BIGOBJ
*ext
= (AUXENT_BIGOBJ
*) ext1
;
5543 union internal_auxent
*in
= (union internal_auxent
*) in1
;
5545 /* Make sure that all fields in the aux structure are
5547 memset (in
, 0, sizeof * in
);
5554 memcpy (in
->x_file
.x_fname
, ext
->File
.Name
,
5555 numaux
* sizeof (AUXENT_BIGOBJ
));
5558 memcpy (in
->x_file
.x_fname
, ext
->File
.Name
, sizeof (ext
->File
.Name
));
5566 in
->x_scn
.x_scnlen
= H_GET_32 (abfd
, ext
->Section
.Length
);
5567 in
->x_scn
.x_nreloc
=
5568 H_GET_16 (abfd
, ext
->Section
.NumberOfRelocations
);
5569 in
->x_scn
.x_nlinno
=
5570 H_GET_16 (abfd
, ext
->Section
.NumberOfLinenumbers
);
5571 in
->x_scn
.x_checksum
= H_GET_32 (abfd
, ext
->Section
.Checksum
);
5572 in
->x_scn
.x_associated
= H_GET_16 (abfd
, ext
->Section
.Number
)
5573 | (H_GET_16 (abfd
, ext
->Section
.HighNumber
) << 16);
5574 in
->x_scn
.x_comdat
= H_GET_8 (abfd
, ext
->Section
.Selection
);
5580 in
->x_sym
.x_tagndx
.l
= H_GET_32 (abfd
, ext
->Sym
.WeakDefaultSymIndex
);
5581 /* Characteristics is ignored. */
5587 coff_bigobj_swap_aux_out (bfd
* abfd
,
5591 int indx ATTRIBUTE_UNUSED
,
5592 int numaux ATTRIBUTE_UNUSED
,
5595 union internal_auxent
* in
= (union internal_auxent
*) inp
;
5596 AUXENT_BIGOBJ
*ext
= (AUXENT_BIGOBJ
*) extp
;
5598 memset (ext
, 0, AUXESZ
);
5603 memcpy (ext
->File
.Name
, in
->x_file
.x_fname
, sizeof (ext
->File
.Name
));
5612 H_PUT_32 (abfd
, in
->x_scn
.x_scnlen
, ext
->Section
.Length
);
5613 H_PUT_16 (abfd
, in
->x_scn
.x_nreloc
,
5614 ext
->Section
.NumberOfRelocations
);
5615 H_PUT_16 (abfd
, in
->x_scn
.x_nlinno
,
5616 ext
->Section
.NumberOfLinenumbers
);
5617 H_PUT_32 (abfd
, in
->x_scn
.x_checksum
, ext
->Section
.Checksum
);
5618 H_PUT_16 (abfd
, in
->x_scn
.x_associated
& 0xffff,
5619 ext
->Section
.Number
);
5620 H_PUT_16 (abfd
, (in
->x_scn
.x_associated
>> 16),
5621 ext
->Section
.HighNumber
);
5622 H_PUT_8 (abfd
, in
->x_scn
.x_comdat
, ext
->Section
.Selection
);
5628 H_PUT_32 (abfd
, in
->x_sym
.x_tagndx
.l
, ext
->Sym
.WeakDefaultSymIndex
);
5629 H_PUT_32 (abfd
, 1, ext
->Sym
.WeakSearchType
);
5634 static bfd_coff_backend_data bigobj_swap_table
=
5636 coff_bigobj_swap_aux_in
, coff_bigobj_swap_sym_in
, coff_SWAP_lineno_in
,
5637 coff_bigobj_swap_aux_out
, coff_bigobj_swap_sym_out
,
5638 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5639 coff_bigobj_swap_filehdr_out
, coff_SWAP_aouthdr_out
,
5640 coff_SWAP_scnhdr_out
,
5641 FILHSZ_BIGOBJ
, AOUTSZ
, SCNHSZ
, SYMESZ_BIGOBJ
, AUXESZ_BIGOBJ
,
5642 RELSZ
, LINESZ
, FILNMLEN_BIGOBJ
,
5644 COFF_DEFAULT_LONG_SECTION_NAMES
,
5645 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5649 coff_bigobj_swap_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5650 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5651 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5652 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5653 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5654 coff_classify_symbol
, coff_compute_section_file_positions
,
5655 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5656 coff_adjust_symndx
, coff_link_add_one_symbol
,
5657 coff_link_output_has_begun
, coff_final_link_postscript
,
5658 bfd_pe_print_pdata
/* huh */
5661 #endif /* COFF_WITH_PE_BIGOBJ */
5663 #ifndef coff_close_and_cleanup
5664 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5667 #ifndef coff_bfd_free_cached_info
5668 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5671 #ifndef coff_get_section_contents
5672 #define coff_get_section_contents _bfd_generic_get_section_contents
5675 #ifndef coff_bfd_copy_private_symbol_data
5676 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5679 #ifndef coff_bfd_copy_private_header_data
5680 #define coff_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
5683 #ifndef coff_bfd_copy_private_section_data
5684 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5687 #ifndef coff_bfd_copy_private_bfd_data
5688 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5691 #ifndef coff_bfd_merge_private_bfd_data
5692 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5695 #ifndef coff_bfd_set_private_flags
5696 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5699 #ifndef coff_bfd_print_private_bfd_data
5700 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5703 #ifndef coff_bfd_is_local_label_name
5704 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5707 #ifndef coff_bfd_is_target_special_symbol
5708 #define coff_bfd_is_target_special_symbol _bfd_bool_bfd_asymbol_false
5711 #ifndef coff_read_minisymbols
5712 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5715 #ifndef coff_minisymbol_to_symbol
5716 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5719 /* The reloc lookup routine must be supplied by each individual COFF
5721 #ifndef coff_bfd_reloc_type_lookup
5722 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5724 #ifndef coff_bfd_reloc_name_lookup
5725 #define coff_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5728 #ifndef coff_bfd_get_relocated_section_contents
5729 #define coff_bfd_get_relocated_section_contents \
5730 bfd_generic_get_relocated_section_contents
5733 #ifndef coff_bfd_relax_section
5734 #define coff_bfd_relax_section bfd_generic_relax_section
5737 #ifndef coff_bfd_gc_sections
5738 #define coff_bfd_gc_sections bfd_coff_gc_sections
5741 #ifndef coff_bfd_lookup_section_flags
5742 #define coff_bfd_lookup_section_flags bfd_generic_lookup_section_flags
5745 #ifndef coff_bfd_merge_sections
5746 #define coff_bfd_merge_sections bfd_generic_merge_sections
5749 #ifndef coff_bfd_is_group_section
5750 #define coff_bfd_is_group_section bfd_generic_is_group_section
5753 #ifndef coff_bfd_group_name
5754 #define coff_bfd_group_name bfd_coff_group_name
5757 #ifndef coff_bfd_discard_group
5758 #define coff_bfd_discard_group bfd_generic_discard_group
5761 #ifndef coff_section_already_linked
5762 #define coff_section_already_linked \
5763 _bfd_coff_section_already_linked
5766 #ifndef coff_bfd_define_common_symbol
5767 #define coff_bfd_define_common_symbol bfd_generic_define_common_symbol
5770 #ifndef coff_bfd_link_hide_symbol
5771 #define coff_bfd_link_hide_symbol _bfd_generic_link_hide_symbol
5774 #ifndef coff_bfd_define_start_stop
5775 #define coff_bfd_define_start_stop bfd_generic_define_start_stop
5778 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5779 const bfd_target VAR = \
5782 bfd_target_coff_flavour, \
5783 BFD_ENDIAN_BIG, /* Data byte order is big. */ \
5784 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5785 /* object flags */ \
5786 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5787 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5788 /* section flags */ \
5789 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5790 UNDER, /* Leading symbol underscore. */ \
5791 '/', /* AR_pad_char. */ \
5792 15, /* AR_max_namelen. */ \
5793 0, /* match priority. */ \
5795 /* Data conversion functions. */ \
5796 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5797 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5798 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5800 /* Header conversion functions. */ \
5801 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5802 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5803 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5805 { /* bfd_check_format. */ \
5806 _bfd_dummy_target, \
5808 bfd_generic_archive_p, \
5811 { /* bfd_set_format. */ \
5812 _bfd_bool_bfd_false_error, \
5814 _bfd_generic_mkarchive, \
5815 _bfd_bool_bfd_false_error \
5817 { /* bfd_write_contents. */ \
5818 _bfd_bool_bfd_false_error, \
5819 coff_write_object_contents, \
5820 _bfd_write_archive_contents, \
5821 _bfd_bool_bfd_false_error \
5824 BFD_JUMP_TABLE_GENERIC (coff), \
5825 BFD_JUMP_TABLE_COPY (coff), \
5826 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5827 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5828 BFD_JUMP_TABLE_SYMBOLS (coff), \
5829 BFD_JUMP_TABLE_RELOCS (coff), \
5830 BFD_JUMP_TABLE_WRITE (coff), \
5831 BFD_JUMP_TABLE_LINK (coff), \
5832 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5839 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5840 const bfd_target VAR = \
5843 bfd_target_coff_flavour, \
5844 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5845 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5846 /* object flags */ \
5847 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5848 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5849 /* section flags */ \
5850 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5851 UNDER, /* Leading symbol underscore. */ \
5852 '/', /* AR_pad_char. */ \
5853 15, /* AR_max_namelen. */ \
5854 0, /* match priority. */ \
5856 /* Data conversion functions. */ \
5857 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5858 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5859 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5861 /* Header conversion functions. */ \
5862 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5863 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5864 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5866 { /* bfd_check_format. */ \
5867 _bfd_dummy_target, \
5869 bfd_generic_archive_p, \
5872 { /* bfd_set_format. */ \
5873 _bfd_bool_bfd_false_error, \
5875 _bfd_generic_mkarchive, \
5876 _bfd_bool_bfd_false_error \
5878 { /* bfd_write_contents. */ \
5879 _bfd_bool_bfd_false_error, \
5880 coff_write_object_contents, \
5881 _bfd_write_archive_contents, \
5882 _bfd_bool_bfd_false_error \
5885 BFD_JUMP_TABLE_GENERIC (coff), \
5886 BFD_JUMP_TABLE_COPY (coff), \
5887 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5888 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5889 BFD_JUMP_TABLE_SYMBOLS (coff), \
5890 BFD_JUMP_TABLE_RELOCS (coff), \
5891 BFD_JUMP_TABLE_WRITE (coff), \
5892 BFD_JUMP_TABLE_LINK (coff), \
5893 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5900 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5901 const bfd_target VAR = \
5904 bfd_target_coff_flavour, \
5905 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5906 BFD_ENDIAN_LITTLE, /* Header byte order is little. */ \
5907 /* object flags */ \
5908 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5909 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5910 /* section flags */ \
5911 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5912 UNDER, /* Leading symbol underscore. */ \
5913 '/', /* AR_pad_char. */ \
5914 15, /* AR_max_namelen. */ \
5915 0, /* match priority. */ \
5917 /* Data conversion functions. */ \
5918 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5919 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5920 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5921 /* Header conversion functions. */ \
5922 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5923 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5924 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5926 { /* bfd_check_format. */ \
5927 _bfd_dummy_target, \
5929 bfd_generic_archive_p, \
5932 { /* bfd_set_format. */ \
5933 _bfd_bool_bfd_false_error, \
5935 _bfd_generic_mkarchive, \
5936 _bfd_bool_bfd_false_error \
5938 { /* bfd_write_contents. */ \
5939 _bfd_bool_bfd_false_error, \
5940 coff_write_object_contents, \
5941 _bfd_write_archive_contents, \
5942 _bfd_bool_bfd_false_error \
5945 BFD_JUMP_TABLE_GENERIC (coff), \
5946 BFD_JUMP_TABLE_COPY (coff), \
5947 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5948 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5949 BFD_JUMP_TABLE_SYMBOLS (coff), \
5950 BFD_JUMP_TABLE_RELOCS (coff), \
5951 BFD_JUMP_TABLE_WRITE (coff), \
5952 BFD_JUMP_TABLE_LINK (coff), \
5953 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \