1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright (C) 1990-2020 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
,
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 ((bfd_applicable_section_flags (abfd
) & SEC_SMALL_DATA
) != 0
854 && (CONST_STRNEQ (name
, ".sbss")
855 || CONST_STRNEQ (name
, ".sdata")))
856 sec_flags
|= SEC_SMALL_DATA
;
858 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
859 /* As a GNU extension, if the name begins with .gnu.linkonce, we
860 only link a single copy of the section. This is used to support
861 g++. g++ will emit each template expansion in its own section.
862 The symbols will be defined as weak, so that multiple definitions
863 are permitted. The GNU linker extension is to actually discard
864 all but one of the sections. */
865 if (CONST_STRNEQ (name
, ".gnu.linkonce"))
866 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
869 if (flags_ptr
== NULL
)
872 * flags_ptr
= sec_flags
;
876 #else /* COFF_WITH_PE */
879 handle_COMDAT (bfd
* abfd
,
885 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
886 bfd_byte
*esymstart
, *esym
, *esymend
;
888 char *target_name
= NULL
;
890 sec_flags
|= SEC_LINK_ONCE
;
892 /* Unfortunately, the PE format stores essential information in
893 the symbol table, of all places. We need to extract that
894 information now, so that objdump and the linker will know how
895 to handle the section without worrying about the symbols. We
896 can't call slurp_symtab, because the linker doesn't want the
899 /* COMDAT sections are special. The first symbol is the section
900 symbol, which tells what kind of COMDAT section it is. The
901 second symbol is the "comdat symbol" - the one with the
902 unique name. GNU uses the section symbol for the unique
903 name; MS uses ".text" for every comdat section. Sigh. - DJ */
905 /* This is not mirrored in sec_to_styp_flags(), but there
906 doesn't seem to be a need to, either, and it would at best be
909 if (! _bfd_coff_get_external_symbols (abfd
))
912 esymstart
= esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
913 esymend
= esym
+ obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
915 while (esym
< esymend
)
917 struct internal_syment isym
;
918 char buf
[SYMNMLEN
+ 1];
921 bfd_coff_swap_sym_in (abfd
, esym
, & isym
);
923 BFD_ASSERT (sizeof (internal_s
->s_name
) <= SYMNMLEN
);
925 if (isym
.n_scnum
== section
->target_index
)
927 /* According to the MSVC documentation, the first
928 TWO entries with the section # are both of
929 interest to us. The first one is the "section
930 symbol" (section name). The second is the comdat
931 symbol name. Here, we've found the first
932 qualifying entry; we distinguish it from the
933 second with a state flag.
935 In the case of gas-generated (at least until that
936 is fixed) .o files, it isn't necessarily the
937 second one. It may be some other later symbol.
939 Since gas also doesn't follow MS conventions and
940 emits the section similar to .text$<name>, where
941 <something> is the name we're looking for, we
942 distinguish the two as follows:
944 If the section name is simply a section name (no
945 $) we presume it's MS-generated, and look at
946 precisely the second symbol for the comdat name.
947 If the section name has a $, we assume it's
948 gas-generated, and look for <something> (whatever
949 follows the $) as the comdat symbol. */
951 /* All 3 branches use this. */
952 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
, buf
);
954 /* PR 17512 file: 078-11867-0.004 */
957 _bfd_error_handler (_("%pB: unable to load COMDAT section name"),
966 /* The first time we've seen the symbol. */
967 union internal_auxent aux
;
969 /* If it isn't the stuff we're expecting, die;
970 The MS documentation is vague, but it
971 appears that the second entry serves BOTH
972 as the comdat symbol and the defining
973 symbol record (either C_STAT or C_EXT,
974 possibly with an aux entry with debug
975 information if it's a function.) It
976 appears the only way to find the second one
977 is to count. (On Intel, they appear to be
978 adjacent, but on Alpha, they have been
981 Here, we think we've found the first one,
982 but there's some checking we can do to be
985 if (! ((isym
.n_sclass
== C_STAT
986 || isym
.n_sclass
== C_EXT
)
987 && BTYPE (isym
.n_type
) == T_NULL
988 && isym
.n_value
== 0))
990 /* Malformed input files can trigger this test.
992 _bfd_error_handler (_("%pB: error: unexpected symbol '%s' in COMDAT section"),
997 /* FIXME LATER: MSVC generates section names
998 like .text for comdats. Gas generates
999 names like .text$foo__Fv (in the case of a
1000 function). See comment above for more. */
1002 if (isym
.n_sclass
== C_STAT
&& strcmp (name
, symname
) != 0)
1003 /* xgettext:c-format */
1004 _bfd_error_handler (_("%pB: warning: COMDAT symbol '%s'"
1005 " does not match section name '%s'"),
1006 abfd
, symname
, name
);
1010 /* PR 17512: file: e2cfe54f. */
1011 if (esym
+ bfd_coff_symesz (abfd
) >= esymend
)
1013 /* xgettext:c-format */
1014 _bfd_error_handler (_("%pB: warning: no symbol for"
1015 " section '%s' found"),
1019 /* This is the section symbol. */
1020 bfd_coff_swap_aux_in (abfd
, (esym
+ bfd_coff_symesz (abfd
)),
1021 isym
.n_type
, isym
.n_sclass
,
1022 0, isym
.n_numaux
, & aux
);
1024 target_name
= strchr (name
, '$');
1025 if (target_name
!= NULL
)
1033 /* FIXME: Microsoft uses NODUPLICATES and
1034 ASSOCIATIVE, but gnu uses ANY and
1035 SAME_SIZE. Unfortunately, gnu doesn't do
1036 the comdat symbols right. So, until we can
1037 fix it to do the right thing, we are
1038 temporarily disabling comdats for the MS
1039 types (they're used in DLLs and C++, but we
1040 don't support *their* C++ libraries anyway
1043 /* Cygwin does not follow the MS style, and
1044 uses ANY and SAME_SIZE where NODUPLICATES
1045 and ASSOCIATIVE should be used. For
1046 Interix, we just do the right thing up
1049 switch (aux
.x_scn
.x_comdat
)
1051 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
1052 #ifdef STRICT_PE_FORMAT
1053 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
1055 sec_flags
&= ~SEC_LINK_ONCE
;
1059 case IMAGE_COMDAT_SELECT_ANY
:
1060 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1063 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
1064 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
1067 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
1068 /* Not yet fully implemented ??? */
1069 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
1072 /* debug$S gets this case; other
1075 /* There may be no symbol... we'll search
1076 the whole table... Is this the right
1077 place to play this game? Or should we do
1078 it when reading it in. */
1079 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
1080 #ifdef STRICT_PE_FORMAT
1081 /* FIXME: This is not currently implemented. */
1082 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1084 sec_flags
&= ~SEC_LINK_ONCE
;
1088 default: /* 0 means "no symbol" */
1089 /* debug$F gets this case; other
1091 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1098 /* Gas mode: the first matching on partial name. */
1100 #ifndef TARGET_UNDERSCORE
1101 #define TARGET_UNDERSCORE 0
1103 /* Is this the name we're looking for ? */
1104 if (strcmp (target_name
,
1105 symname
+ (TARGET_UNDERSCORE
? 1 : 0)) != 0)
1107 /* Not the name we're looking for */
1108 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1113 /* MSVC mode: the lexically second symbol (or
1114 drop through from the above). */
1119 /* This must the second symbol with the
1120 section #. It is the actual symbol name.
1121 Intel puts the two adjacent, but Alpha (at
1122 least) spreads them out. */
1124 amt
= sizeof (struct coff_comdat_info
);
1125 coff_section_data (abfd
, section
)->comdat
1126 = (struct coff_comdat_info
*) bfd_alloc (abfd
, amt
);
1127 if (coff_section_data (abfd
, section
)->comdat
== NULL
)
1130 coff_section_data (abfd
, section
)->comdat
->symbol
=
1131 (esym
- esymstart
) / bfd_coff_symesz (abfd
);
1133 amt
= strlen (symname
) + 1;
1134 newname
= (char *) bfd_alloc (abfd
, amt
);
1135 if (newname
== NULL
)
1138 strcpy (newname
, symname
);
1139 coff_section_data (abfd
, section
)->comdat
->name
1147 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1155 /* The PE version; see above for the general comments.
1157 Since to set the SEC_LINK_ONCE and associated flags, we have to
1158 look at the symbol table anyway, we return the symbol table index
1159 of the symbol being used as the COMDAT symbol. This is admittedly
1160 ugly, but there's really nowhere else that we have access to the
1161 required information. FIXME: Is the COMDAT symbol index used for
1162 any purpose other than objdump? */
1165 styp_to_sec_flags (bfd
*abfd
,
1169 flagword
*flags_ptr
)
1171 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
1172 unsigned long styp_flags
= internal_s
->s_flags
;
1174 bfd_boolean result
= TRUE
;
1175 bfd_boolean is_dbg
= FALSE
;
1177 if (CONST_STRNEQ (name
, DOT_DEBUG
)
1178 || CONST_STRNEQ (name
, DOT_ZDEBUG
)
1179 #ifdef COFF_LONG_SECTION_NAMES
1180 || CONST_STRNEQ (name
, GNU_LINKONCE_WI
)
1181 || CONST_STRNEQ (name
, GNU_LINKONCE_WT
)
1182 /* FIXME: These definitions ought to be in a header file. */
1183 #define GNU_DEBUGLINK ".gnu_debuglink"
1184 #define GNU_DEBUGALTLINK ".gnu_debugaltlink"
1185 || CONST_STRNEQ (name
, GNU_DEBUGLINK
)
1186 || CONST_STRNEQ (name
, GNU_DEBUGALTLINK
)
1188 || CONST_STRNEQ (name
, ".stab"))
1190 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
1191 sec_flags
= SEC_READONLY
;
1193 /* If section disallows read, then set the NOREAD flag. */
1194 if ((styp_flags
& IMAGE_SCN_MEM_READ
) == 0)
1195 sec_flags
|= SEC_COFF_NOREAD
;
1197 /* Process each flag bit in styp_flags in turn. */
1200 unsigned long flag
= styp_flags
& - styp_flags
;
1201 char * unhandled
= NULL
;
1203 styp_flags
&= ~ flag
;
1205 /* We infer from the distinct read/write/execute bits the settings
1206 of some of the bfd flags; the actual values, should we need them,
1207 are also in pei_section_data (abfd, section)->pe_flags. */
1212 unhandled
= "STYP_DSECT";
1215 unhandled
= "STYP_GROUP";
1218 unhandled
= "STYP_COPY";
1221 unhandled
= "STYP_OVER";
1223 #ifdef SEC_NEVER_LOAD
1225 sec_flags
|= SEC_NEVER_LOAD
;
1228 case IMAGE_SCN_MEM_READ
:
1229 sec_flags
&= ~SEC_COFF_NOREAD
;
1231 case IMAGE_SCN_TYPE_NO_PAD
:
1234 case IMAGE_SCN_LNK_OTHER
:
1235 unhandled
= "IMAGE_SCN_LNK_OTHER";
1237 case IMAGE_SCN_MEM_NOT_CACHED
:
1238 unhandled
= "IMAGE_SCN_MEM_NOT_CACHED";
1240 case IMAGE_SCN_MEM_NOT_PAGED
:
1241 /* Generate a warning message rather using the 'unhandled'
1242 variable as this will allow some .sys files generate by
1243 other toolchains to be processed. See bugzilla issue 196. */
1244 /* xgettext:c-format */
1245 _bfd_error_handler (_("%pB: warning: ignoring section flag"
1246 " %s in section %s"),
1247 abfd
, "IMAGE_SCN_MEM_NOT_PAGED", name
);
1249 case IMAGE_SCN_MEM_EXECUTE
:
1250 sec_flags
|= SEC_CODE
;
1252 case IMAGE_SCN_MEM_WRITE
:
1253 sec_flags
&= ~ SEC_READONLY
;
1255 case IMAGE_SCN_MEM_DISCARDABLE
:
1256 /* The MS PE spec says that debug sections are DISCARDABLE,
1257 but the presence of a DISCARDABLE flag does not necessarily
1258 mean that a given section contains debug information. Thus
1259 we only set the SEC_DEBUGGING flag on sections that we
1260 recognise as containing debug information. */
1263 || strcmp (name
, _COMMENT
) == 0
1267 sec_flags
|= SEC_DEBUGGING
| SEC_READONLY
;
1270 case IMAGE_SCN_MEM_SHARED
:
1271 sec_flags
|= SEC_COFF_SHARED
;
1273 case IMAGE_SCN_LNK_REMOVE
:
1275 sec_flags
|= SEC_EXCLUDE
;
1277 case IMAGE_SCN_CNT_CODE
:
1278 sec_flags
|= SEC_CODE
| SEC_ALLOC
| SEC_LOAD
;
1280 case IMAGE_SCN_CNT_INITIALIZED_DATA
:
1282 sec_flags
|= SEC_DEBUGGING
;
1284 sec_flags
|= SEC_DATA
| SEC_ALLOC
| SEC_LOAD
;
1286 case IMAGE_SCN_CNT_UNINITIALIZED_DATA
:
1287 sec_flags
|= SEC_ALLOC
;
1289 case IMAGE_SCN_LNK_INFO
:
1290 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1291 defined. coff_compute_section_file_positions uses
1292 COFF_PAGE_SIZE to ensure that the low order bits of the
1293 section VMA and the file offset match. If we don't know
1294 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1295 and demand page loading of the file will fail. */
1296 #ifdef COFF_PAGE_SIZE
1297 sec_flags
|= SEC_DEBUGGING
;
1300 case IMAGE_SCN_LNK_COMDAT
:
1301 /* COMDAT gets very special treatment. */
1302 sec_flags
= handle_COMDAT (abfd
, sec_flags
, hdr
, name
, section
);
1305 /* Silently ignore for now. */
1309 /* If the section flag was not handled, report it here. */
1310 if (unhandled
!= NULL
)
1313 /* xgettext:c-format */
1314 (_("%pB (%s): section flag %s (%#lx) ignored"),
1315 abfd
, name
, unhandled
, flag
);
1320 if ((bfd_applicable_section_flags (abfd
) & SEC_SMALL_DATA
) != 0
1321 && (CONST_STRNEQ (name
, ".sbss")
1322 || CONST_STRNEQ (name
, ".sdata")))
1323 sec_flags
|= SEC_SMALL_DATA
;
1325 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1326 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1327 only link a single copy of the section. This is used to support
1328 g++. g++ will emit each template expansion in its own section.
1329 The symbols will be defined as weak, so that multiple definitions
1330 are permitted. The GNU linker extension is to actually discard
1331 all but one of the sections. */
1332 if (CONST_STRNEQ (name
, ".gnu.linkonce"))
1333 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1337 * flags_ptr
= sec_flags
;
1342 #endif /* COFF_WITH_PE */
1344 #define get_index(symbol) ((symbol)->udata.i)
1348 bfd_coff_backend_data
1352 .{* COFF symbol classifications. *}
1354 .enum coff_symbol_classification
1356 . {* Global symbol. *}
1357 . COFF_SYMBOL_GLOBAL,
1358 . {* Common symbol. *}
1359 . COFF_SYMBOL_COMMON,
1360 . {* Undefined symbol. *}
1361 . COFF_SYMBOL_UNDEFINED,
1362 . {* Local symbol. *}
1363 . COFF_SYMBOL_LOCAL,
1364 . {* PE section symbol. *}
1365 . COFF_SYMBOL_PE_SECTION
1368 .typedef asection * (*coff_gc_mark_hook_fn)
1369 . (asection *, struct bfd_link_info *, struct internal_reloc *,
1370 . struct coff_link_hash_entry *, struct internal_syment *);
1372 Special entry points for gdb to swap in coff symbol table parts:
1375 . void (*_bfd_coff_swap_aux_in)
1376 . (bfd *, void *, int, int, int, int, void *);
1378 . void (*_bfd_coff_swap_sym_in)
1379 . (bfd *, void *, void *);
1381 . void (*_bfd_coff_swap_lineno_in)
1382 . (bfd *, void *, void *);
1384 . unsigned int (*_bfd_coff_swap_aux_out)
1385 . (bfd *, void *, int, int, int, int, void *);
1387 . unsigned int (*_bfd_coff_swap_sym_out)
1388 . (bfd *, void *, void *);
1390 . unsigned int (*_bfd_coff_swap_lineno_out)
1391 . (bfd *, void *, void *);
1393 . unsigned int (*_bfd_coff_swap_reloc_out)
1394 . (bfd *, void *, void *);
1396 . unsigned int (*_bfd_coff_swap_filehdr_out)
1397 . (bfd *, void *, void *);
1399 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1400 . (bfd *, void *, void *);
1402 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1403 . (bfd *, void *, void *);
1405 . unsigned int _bfd_filhsz;
1406 . unsigned int _bfd_aoutsz;
1407 . unsigned int _bfd_scnhsz;
1408 . unsigned int _bfd_symesz;
1409 . unsigned int _bfd_auxesz;
1410 . unsigned int _bfd_relsz;
1411 . unsigned int _bfd_linesz;
1412 . unsigned int _bfd_filnmlen;
1413 . bfd_boolean _bfd_coff_long_filenames;
1415 . bfd_boolean _bfd_coff_long_section_names;
1416 . bfd_boolean (*_bfd_coff_set_long_section_names)
1419 . unsigned int _bfd_coff_default_section_alignment_power;
1420 . bfd_boolean _bfd_coff_force_symnames_in_strings;
1421 . unsigned int _bfd_coff_debug_string_prefix_length;
1422 . unsigned int _bfd_coff_max_nscns;
1424 . void (*_bfd_coff_swap_filehdr_in)
1425 . (bfd *, void *, void *);
1427 . void (*_bfd_coff_swap_aouthdr_in)
1428 . (bfd *, void *, void *);
1430 . void (*_bfd_coff_swap_scnhdr_in)
1431 . (bfd *, void *, void *);
1433 . void (*_bfd_coff_swap_reloc_in)
1434 . (bfd *abfd, void *, void *);
1436 . bfd_boolean (*_bfd_coff_bad_format_hook)
1439 . bfd_boolean (*_bfd_coff_set_arch_mach_hook)
1442 . void * (*_bfd_coff_mkobject_hook)
1443 . (bfd *, void *, void *);
1445 . bfd_boolean (*_bfd_styp_to_sec_flags_hook)
1446 . (bfd *, void *, const char *, asection *, flagword *);
1448 . void (*_bfd_set_alignment_hook)
1449 . (bfd *, asection *, void *);
1451 . bfd_boolean (*_bfd_coff_slurp_symbol_table)
1454 . bfd_boolean (*_bfd_coff_symname_in_debug)
1455 . (bfd *, struct internal_syment *);
1457 . bfd_boolean (*_bfd_coff_pointerize_aux_hook)
1458 . (bfd *, combined_entry_type *, combined_entry_type *,
1459 . unsigned int, combined_entry_type *);
1461 . bfd_boolean (*_bfd_coff_print_aux)
1462 . (bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1463 . combined_entry_type *, unsigned int);
1465 . void (*_bfd_coff_reloc16_extra_cases)
1466 . (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1467 . bfd_byte *, unsigned int *, unsigned int *);
1469 . int (*_bfd_coff_reloc16_estimate)
1470 . (bfd *, asection *, arelent *, unsigned int,
1471 . struct bfd_link_info *);
1473 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1474 . (bfd *, struct internal_syment *);
1476 . bfd_boolean (*_bfd_coff_compute_section_file_positions)
1479 . bfd_boolean (*_bfd_coff_start_final_link)
1480 . (bfd *, struct bfd_link_info *);
1482 . bfd_boolean (*_bfd_coff_relocate_section)
1483 . (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1484 . struct internal_reloc *, struct internal_syment *, asection **);
1486 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1487 . (bfd *, asection *, struct internal_reloc *,
1488 . struct coff_link_hash_entry *, struct internal_syment *, bfd_vma *);
1490 . bfd_boolean (*_bfd_coff_adjust_symndx)
1491 . (bfd *, struct bfd_link_info *, bfd *, asection *,
1492 . struct internal_reloc *, bfd_boolean *);
1494 . bfd_boolean (*_bfd_coff_link_add_one_symbol)
1495 . (struct bfd_link_info *, bfd *, const char *, flagword,
1496 . asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
1497 . struct bfd_link_hash_entry **);
1499 . bfd_boolean (*_bfd_coff_link_output_has_begun)
1500 . (bfd *, struct coff_final_link_info *);
1502 . bfd_boolean (*_bfd_coff_final_link_postscript)
1503 . (bfd *, struct coff_final_link_info *);
1505 . bfd_boolean (*_bfd_coff_print_pdata)
1508 .} bfd_coff_backend_data;
1510 .#define coff_backend_info(abfd) \
1511 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1513 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1514 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1516 .#define bfd_coff_swap_sym_in(a,e,i) \
1517 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1519 .#define bfd_coff_swap_lineno_in(a,e,i) \
1520 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1522 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1523 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1525 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1526 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1528 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1529 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1531 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1532 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1534 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1535 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1537 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1538 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1540 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1541 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1543 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1544 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1545 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1546 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1547 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1548 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1549 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1550 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1551 .#define bfd_coff_long_filenames(abfd) \
1552 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1553 .#define bfd_coff_long_section_names(abfd) \
1554 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1555 .#define bfd_coff_set_long_section_names(abfd, enable) \
1556 . ((coff_backend_info (abfd)->_bfd_coff_set_long_section_names) (abfd, enable))
1557 .#define bfd_coff_default_section_alignment_power(abfd) \
1558 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1559 .#define bfd_coff_max_nscns(abfd) \
1560 . (coff_backend_info (abfd)->_bfd_coff_max_nscns)
1562 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1563 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1565 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1566 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1568 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1569 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1571 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1572 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1574 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1575 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1577 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1578 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1579 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1580 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1581 . (abfd, filehdr, aouthdr))
1583 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1584 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1585 . (abfd, scnhdr, name, section, flags_ptr))
1587 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1588 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1590 .#define bfd_coff_slurp_symbol_table(abfd)\
1591 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1593 .#define bfd_coff_symname_in_debug(abfd, sym)\
1594 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1596 .#define bfd_coff_force_symnames_in_strings(abfd)\
1597 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1599 .#define bfd_coff_debug_string_prefix_length(abfd)\
1600 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1602 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1603 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1604 . (abfd, file, base, symbol, aux, indaux))
1606 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1607 . reloc, data, src_ptr, dst_ptr)\
1608 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1609 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1611 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1612 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1613 . (abfd, section, reloc, shrink, link_info))
1615 .#define bfd_coff_classify_symbol(abfd, sym)\
1616 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1619 .#define bfd_coff_compute_section_file_positions(abfd)\
1620 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1623 .#define bfd_coff_start_final_link(obfd, info)\
1624 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1626 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1627 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1628 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1629 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1630 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1631 . (abfd, sec, rel, h, sym, addendp))
1632 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1633 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1634 . (obfd, info, ibfd, sec, rel, adjustedp))
1635 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1636 . value, string, cp, coll, hashp)\
1637 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1638 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1640 .#define bfd_coff_link_output_has_begun(a,p) \
1641 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p))
1642 .#define bfd_coff_final_link_postscript(a,p) \
1643 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p))
1645 .#define bfd_coff_have_print_pdata(a) \
1646 . (coff_backend_info (a)->_bfd_coff_print_pdata)
1647 .#define bfd_coff_print_pdata(a,p) \
1648 . ((coff_backend_info (a)->_bfd_coff_print_pdata) (a, p))
1650 .{* Macro: Returns true if the bfd is a PE executable as opposed to a
1651 . PE object file. *}
1652 .#define bfd_pei_p(abfd) \
1653 . (CONST_STRNEQ ((abfd)->xvec->name, "pei-"))
1656 /* See whether the magic number matches. */
1659 coff_bad_format_hook (bfd
* abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1661 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1663 if (BADMAG (*internal_f
))
1671 ticoff0_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1673 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1675 if (COFF0_BADMAG (*internal_f
))
1684 ticoff1_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1686 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1688 if (COFF1_BADMAG (*internal_f
))
1695 /* Check whether this section uses an alignment other than the
1699 coff_set_custom_section_alignment (bfd
*abfd ATTRIBUTE_UNUSED
,
1701 const struct coff_section_alignment_entry
*alignment_table
,
1702 const unsigned int table_size
)
1704 const unsigned int default_alignment
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1707 for (i
= 0; i
< table_size
; ++i
)
1709 const char *secname
= bfd_section_name (section
);
1711 if (alignment_table
[i
].comparison_length
== (unsigned int) -1
1712 ? strcmp (alignment_table
[i
].name
, secname
) == 0
1713 : strncmp (alignment_table
[i
].name
, secname
,
1714 alignment_table
[i
].comparison_length
) == 0)
1717 if (i
>= table_size
)
1720 if (alignment_table
[i
].default_alignment_min
!= COFF_ALIGNMENT_FIELD_EMPTY
1721 && default_alignment
< alignment_table
[i
].default_alignment_min
)
1724 if (alignment_table
[i
].default_alignment_max
!= COFF_ALIGNMENT_FIELD_EMPTY
1725 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1726 && default_alignment
> alignment_table
[i
].default_alignment_max
1731 section
->alignment_power
= alignment_table
[i
].alignment_power
;
1734 /* Custom section alignment records. */
1736 static const struct coff_section_alignment_entry
1737 coff_section_alignment_table
[] =
1739 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1740 COFF_SECTION_ALIGNMENT_ENTRIES
,
1742 /* There must not be any gaps between .stabstr sections. */
1743 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1744 1, COFF_ALIGNMENT_FIELD_EMPTY
, 0 },
1745 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1746 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1747 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1748 /* Similarly for the .ctors and .dtors sections. */
1749 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1750 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1751 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1752 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 }
1755 static const unsigned int coff_section_alignment_table_size
=
1756 sizeof coff_section_alignment_table
/ sizeof coff_section_alignment_table
[0];
1758 /* Initialize a section structure with information peculiar to this
1759 particular implementation of COFF. */
1762 coff_new_section_hook (bfd
* abfd
, asection
* section
)
1764 combined_entry_type
*native
;
1766 unsigned char sclass
= C_STAT
;
1768 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1771 if (bfd_xcoff_text_align_power (abfd
) != 0
1772 && strcmp (bfd_section_name (section
), ".text") == 0)
1773 section
->alignment_power
= bfd_xcoff_text_align_power (abfd
);
1774 else if (bfd_xcoff_data_align_power (abfd
) != 0
1775 && strcmp (bfd_section_name (section
), ".data") == 0)
1776 section
->alignment_power
= bfd_xcoff_data_align_power (abfd
);
1781 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
1782 if (strcmp (bfd_section_name (section
),
1783 xcoff_dwsect_names
[i
].name
) == 0)
1785 section
->alignment_power
= 0;
1792 /* Set up the section symbol. */
1793 if (!_bfd_generic_new_section_hook (abfd
, section
))
1796 /* Allocate aux records for section symbols, to store size and
1799 @@ The 10 is a guess at a plausible maximum number of aux entries
1800 (but shouldn't be a constant). */
1801 amt
= sizeof (combined_entry_type
) * 10;
1802 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
1806 /* We don't need to set up n_name, n_value, or n_scnum in the native
1807 symbol information, since they'll be overridden by the BFD symbol
1808 anyhow. However, we do need to set the type and storage class,
1809 in case this symbol winds up getting written out. The value 0
1810 for n_numaux is already correct. */
1812 native
->is_sym
= TRUE
;
1813 native
->u
.syment
.n_type
= T_NULL
;
1814 native
->u
.syment
.n_sclass
= sclass
;
1816 coffsymbol (section
->symbol
)->native
= native
;
1818 coff_set_custom_section_alignment (abfd
, section
,
1819 coff_section_alignment_table
,
1820 coff_section_alignment_table_size
);
1825 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1827 /* Set the alignment of a BFD section. */
1830 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1834 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1837 #ifdef COFF_DECODE_ALIGNMENT
1838 i
= COFF_DECODE_ALIGNMENT(hdr
->s_flags
);
1840 section
->alignment_power
= i
;
1842 #ifdef coff_set_section_load_page
1843 coff_set_section_load_page (section
, hdr
->s_page
);
1847 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1851 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1855 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1857 unsigned int alignment_power_const
1858 = hdr
->s_flags
& IMAGE_SCN_ALIGN_POWER_BIT_MASK
;
1860 switch (alignment_power_const
)
1862 case IMAGE_SCN_ALIGN_8192BYTES
:
1863 case IMAGE_SCN_ALIGN_4096BYTES
:
1864 case IMAGE_SCN_ALIGN_2048BYTES
:
1865 case IMAGE_SCN_ALIGN_1024BYTES
:
1866 case IMAGE_SCN_ALIGN_512BYTES
:
1867 case IMAGE_SCN_ALIGN_256BYTES
:
1868 case IMAGE_SCN_ALIGN_128BYTES
:
1869 case IMAGE_SCN_ALIGN_64BYTES
:
1870 case IMAGE_SCN_ALIGN_32BYTES
:
1871 case IMAGE_SCN_ALIGN_16BYTES
:
1872 case IMAGE_SCN_ALIGN_8BYTES
:
1873 case IMAGE_SCN_ALIGN_4BYTES
:
1874 case IMAGE_SCN_ALIGN_2BYTES
:
1875 case IMAGE_SCN_ALIGN_1BYTES
:
1876 section
->alignment_power
1877 = IMAGE_SCN_ALIGN_POWER_NUM (alignment_power_const
);
1883 /* In a PE image file, the s_paddr field holds the virtual size of a
1884 section, while the s_size field holds the raw size. We also keep
1885 the original section flag value, since not every bit can be
1886 mapped onto a generic BFD section bit. */
1887 if (coff_section_data (abfd
, section
) == NULL
)
1889 amt
= sizeof (struct coff_section_tdata
);
1890 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
1891 if (section
->used_by_bfd
== NULL
)
1892 /* FIXME: Return error. */
1896 if (pei_section_data (abfd
, section
) == NULL
)
1898 amt
= sizeof (struct pei_section_tdata
);
1899 coff_section_data (abfd
, section
)->tdata
= bfd_zalloc (abfd
, amt
);
1900 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1901 /* FIXME: Return error. */
1904 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1905 pei_section_data (abfd
, section
)->pe_flags
= hdr
->s_flags
;
1907 section
->lma
= hdr
->s_vaddr
;
1909 /* Check for extended relocs. */
1910 if (hdr
->s_flags
& IMAGE_SCN_LNK_NRELOC_OVFL
)
1912 struct external_reloc dst
;
1913 struct internal_reloc n
;
1914 file_ptr oldpos
= bfd_tell (abfd
);
1915 bfd_size_type relsz
= bfd_coff_relsz (abfd
);
1917 if (bfd_seek (abfd
, (file_ptr
) hdr
->s_relptr
, 0) != 0)
1919 if (bfd_bread (& dst
, relsz
, abfd
) != relsz
)
1922 coff_swap_reloc_in (abfd
, &dst
, &n
);
1923 if (bfd_seek (abfd
, oldpos
, 0) != 0)
1925 section
->reloc_count
= hdr
->s_nreloc
= n
.r_vaddr
- 1;
1926 section
->rel_filepos
+= relsz
;
1928 else if (hdr
->s_nreloc
== 0xffff)
1930 (_("%pB: warning: claims to have 0xffff relocs, without overflow"),
1934 #undef ELIFALIGN_SET
1936 #else /* ! COFF_WITH_PE */
1939 /* We grossly abuse this function to handle XCOFF overflow headers.
1940 When we see one, we correct the reloc and line number counts in the
1941 real header, and remove the section we just created. */
1944 coff_set_alignment_hook (bfd
*abfd
, asection
*section
, void * scnhdr
)
1946 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1949 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1952 real_sec
= coff_section_from_bfd_index (abfd
, (int) hdr
->s_nreloc
);
1953 if (real_sec
== NULL
)
1956 real_sec
->reloc_count
= hdr
->s_paddr
;
1957 real_sec
->lineno_count
= hdr
->s_vaddr
;
1959 if (!bfd_section_removed_from_list (abfd
, section
))
1961 bfd_section_list_remove (abfd
, section
);
1962 --abfd
->section_count
;
1966 #else /* ! RS6000COFF_C */
1969 coff_set_alignment_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
1970 asection
*section ATTRIBUTE_UNUSED
,
1971 void *scnhdr ATTRIBUTE_UNUSED
)
1975 #endif /* ! RS6000COFF_C */
1976 #endif /* ! COFF_WITH_PE */
1977 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1979 #ifndef coff_mkobject
1982 coff_mkobject (bfd
* abfd
)
1984 coff_data_type
*coff
;
1985 size_t amt
= sizeof (coff_data_type
);
1987 abfd
->tdata
.coff_obj_data
= bfd_zalloc (abfd
, amt
);
1988 if (abfd
->tdata
.coff_obj_data
== NULL
)
1990 coff
= coff_data (abfd
);
1991 coff
->symbols
= NULL
;
1992 coff
->conversion_table
= NULL
;
1993 coff
->raw_syments
= NULL
;
1994 coff
->relocbase
= 0;
1995 coff
->local_toc_sym_map
= 0;
1997 /* make_abs_section(abfd);*/
2003 /* Create the COFF backend specific information. */
2005 #ifndef coff_mkobject_hook
2007 coff_mkobject_hook (bfd
* abfd
,
2009 void * aouthdr ATTRIBUTE_UNUSED
)
2011 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
2012 coff_data_type
*coff
;
2014 if (! coff_mkobject (abfd
))
2017 coff
= coff_data (abfd
);
2019 coff
->sym_filepos
= internal_f
->f_symptr
;
2021 /* These members communicate important constants about the symbol
2022 table to GDB's symbol-reading code. These `constants'
2023 unfortunately vary among coff implementations... */
2024 coff
->local_n_btmask
= N_BTMASK
;
2025 coff
->local_n_btshft
= N_BTSHFT
;
2026 coff
->local_n_tmask
= N_TMASK
;
2027 coff
->local_n_tshift
= N_TSHIFT
;
2028 coff
->local_symesz
= bfd_coff_symesz (abfd
);
2029 coff
->local_auxesz
= bfd_coff_auxesz (abfd
);
2030 coff
->local_linesz
= bfd_coff_linesz (abfd
);
2032 coff
->timestamp
= internal_f
->f_timdat
;
2034 obj_raw_syment_count (abfd
) =
2035 obj_conv_table_size (abfd
) =
2036 internal_f
->f_nsyms
;
2039 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
2040 abfd
->flags
|= DYNAMIC
;
2041 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= bfd_coff_aoutsz (abfd
))
2043 struct internal_aouthdr
*internal_a
=
2044 (struct internal_aouthdr
*) aouthdr
;
2045 struct xcoff_tdata
*xcoff
;
2047 xcoff
= xcoff_data (abfd
);
2048 # ifdef U803XTOCMAGIC
2049 xcoff
->xcoff64
= internal_f
->f_magic
== U803XTOCMAGIC
;
2053 xcoff
->full_aouthdr
= TRUE
;
2054 xcoff
->toc
= internal_a
->o_toc
;
2055 xcoff
->sntoc
= internal_a
->o_sntoc
;
2056 xcoff
->snentry
= internal_a
->o_snentry
;
2057 bfd_xcoff_text_align_power (abfd
) = internal_a
->o_algntext
;
2058 bfd_xcoff_data_align_power (abfd
) = internal_a
->o_algndata
;
2059 xcoff
->modtype
= internal_a
->o_modtype
;
2060 xcoff
->cputype
= internal_a
->o_cputype
;
2061 xcoff
->maxdata
= internal_a
->o_maxdata
;
2062 xcoff
->maxstack
= internal_a
->o_maxstack
;
2067 /* Set the flags field from the COFF header read in. */
2068 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
2073 /* FIXME: I'm not sure this is ever executed, since peicode.h
2074 defines coff_mkobject_hook. */
2075 if ((internal_f
->f_flags
& IMAGE_FILE_DEBUG_STRIPPED
) == 0)
2076 abfd
->flags
|= HAS_DEBUG
;
2079 if ((internal_f
->f_flags
& F_GO32STUB
) != 0)
2081 coff
->go32stub
= (char *) bfd_alloc (abfd
, (bfd_size_type
) GO32_STUBSIZE
);
2082 if (coff
->go32stub
== NULL
)
2085 if (coff
->go32stub
!= NULL
)
2086 memcpy (coff
->go32stub
, internal_f
->go32stub
, GO32_STUBSIZE
);
2092 /* Determine the machine architecture and type. FIXME: This is target
2093 dependent because the magic numbers are defined in the target
2094 dependent header files. But there is no particular need for this.
2095 If the magic numbers were moved to a separate file, this function
2096 would be target independent and would also be much more successful
2097 at linking together COFF files for different architectures. */
2100 coff_set_arch_mach_hook (bfd
*abfd
, void * filehdr
)
2102 unsigned long machine
;
2103 enum bfd_architecture arch
;
2104 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
2106 /* Zero selects the default machine for an arch. */
2108 switch (internal_f
->f_magic
)
2112 arch
= bfd_arch_powerpc
;
2118 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler. */
2120 case I386_APPLE_MAGIC
:
2121 case I386_FREEBSD_MAGIC
:
2122 case I386_LINUX_MAGIC
:
2123 case I386_NETBSD_MAGIC
:
2124 arch
= bfd_arch_i386
;
2129 case AMD64_APPLE_MAGIC
:
2130 case AMD64_FREEBSD_MAGIC
:
2131 case AMD64_LINUX_MAGIC
:
2132 case AMD64_NETBSD_MAGIC
:
2133 arch
= bfd_arch_i386
;
2134 machine
= bfd_mach_x86_64
;
2139 arch
= bfd_arch_ia64
;
2146 arch
= bfd_arch_arm
;
2147 machine
= bfd_arm_get_mach_from_notes (abfd
, ARM_NOTE_SECTION
);
2148 if (machine
== bfd_mach_arm_unknown
)
2150 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
2152 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
2153 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
2154 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
2156 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
2157 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
2158 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
2159 /* The COFF header does not have enough bits available
2160 to cover all the different ARM architectures. So
2161 we interpret F_ARM_5, the highest flag value to mean
2162 "the highest ARM architecture known to BFD" which is
2163 currently the XScale. */
2164 case F_ARM_5
: machine
= bfd_mach_arm_XScale
; break;
2171 arch
= bfd_arch_z80
;
2172 switch (internal_f
->f_flags
& F_MACHMASK
)
2174 case bfd_mach_z80strict
<< 12:
2175 case bfd_mach_z80
<< 12:
2176 case bfd_mach_z80n
<< 12:
2177 case bfd_mach_z80full
<< 12:
2178 case bfd_mach_r800
<< 12:
2179 case bfd_mach_gbz80
<< 12:
2180 case bfd_mach_z180
<< 12:
2181 case bfd_mach_ez80_z80
<< 12:
2182 case bfd_mach_ez80_adl
<< 12:
2183 machine
= ((unsigned)internal_f
->f_flags
& F_MACHMASK
) >> 12;
2192 arch
= bfd_arch_z8k
;
2193 switch (internal_f
->f_flags
& F_MACHMASK
)
2196 machine
= bfd_mach_z8001
;
2199 machine
= bfd_mach_z8002
;
2219 if (xcoff_data (abfd
)->cputype
!= -1)
2220 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
2223 /* We did not get a value from the a.out header. If the
2224 file has not been stripped, we may be able to get the
2225 architecture information from the first symbol, if it
2226 is a .file symbol. */
2227 if (obj_raw_syment_count (abfd
) == 0)
2232 struct internal_syment sym
;
2233 bfd_size_type amt
= bfd_coff_symesz (abfd
);
2235 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
2237 buf
= _bfd_malloc_and_read (abfd
, amt
, amt
);
2240 bfd_coff_swap_sym_in (abfd
, buf
, & sym
);
2241 if (sym
.n_sclass
== C_FILE
)
2242 cputype
= sym
.n_type
& 0xff;
2249 /* FIXME: We don't handle all cases here. */
2254 arch
= bfd_xcoff_architecture (abfd
);
2255 machine
= bfd_xcoff_machine (abfd
);
2259 arch
= bfd_arch_powerpc
;
2260 machine
= bfd_mach_ppc_601
;
2262 case 2: /* 64 bit PowerPC */
2263 arch
= bfd_arch_powerpc
;
2264 machine
= bfd_mach_ppc_620
;
2267 arch
= bfd_arch_powerpc
;
2268 machine
= bfd_mach_ppc
;
2271 arch
= bfd_arch_rs6000
;
2272 machine
= bfd_mach_rs6k
;
2279 #ifdef SH_ARCH_MAGIC_BIG
2280 case SH_ARCH_MAGIC_BIG
:
2281 case SH_ARCH_MAGIC_LITTLE
:
2283 case SH_ARCH_MAGIC_WINCE
:
2289 #ifdef MIPS_ARCH_MAGIC_WINCE
2290 case MIPS_ARCH_MAGIC_WINCE
:
2291 arch
= bfd_arch_mips
;
2297 #ifdef LYNXCOFFMAGIC
2300 arch
= bfd_arch_sparc
;
2306 arch
= bfd_arch_tic30
;
2311 #ifdef TICOFF_TARGET_ARCH
2312 /* This TI COFF section should be used by all new TI COFF v0 targets. */
2314 arch
= TICOFF_TARGET_ARCH
;
2315 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2321 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */
2322 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */
2325 switch (internal_f
->f_target_id
)
2329 arch
= TICOFF_TARGET_ARCH
;
2330 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2334 arch
= bfd_arch_obscure
;
2336 (_("unrecognized TI COFF target id '0x%x'"),
2337 internal_f
->f_target_id
);
2345 arch
= bfd_arch_mcore
;
2349 default: /* Unreadable input file type. */
2350 arch
= bfd_arch_obscure
;
2354 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2359 symname_in_debug_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2360 struct internal_syment
*sym ATTRIBUTE_UNUSED
)
2362 #ifdef SYMNAME_IN_DEBUG
2363 return SYMNAME_IN_DEBUG (sym
) != 0;
2372 #define FORCE_SYMNAMES_IN_STRINGS
2375 /* Handle the csect auxent of a C_EXT, C_AIX_WEAKEXT or C_HIDEXT symbol. */
2378 coff_pointerize_aux_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2379 combined_entry_type
*table_base
,
2380 combined_entry_type
*symbol
,
2381 unsigned int indaux
,
2382 combined_entry_type
*aux
)
2384 BFD_ASSERT (symbol
->is_sym
);
2385 int n_sclass
= symbol
->u
.syment
.n_sclass
;
2387 if (CSECT_SYM_P (n_sclass
)
2388 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2390 BFD_ASSERT (! aux
->is_sym
);
2391 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2393 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2394 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2395 aux
->fix_scnlen
= 1;
2398 /* Return TRUE to indicate that the caller should not do any
2399 further work on this auxent. */
2403 /* Return FALSE to indicate that this auxent should be handled by
2409 #define coff_pointerize_aux_hook 0
2410 #endif /* ! RS6000COFF_C */
2412 /* Print an aux entry. This returns TRUE if it has printed it. */
2415 coff_print_aux (bfd
*abfd ATTRIBUTE_UNUSED
,
2416 FILE *file ATTRIBUTE_UNUSED
,
2417 combined_entry_type
*table_base ATTRIBUTE_UNUSED
,
2418 combined_entry_type
*symbol ATTRIBUTE_UNUSED
,
2419 combined_entry_type
*aux ATTRIBUTE_UNUSED
,
2420 unsigned int indaux ATTRIBUTE_UNUSED
)
2422 BFD_ASSERT (symbol
->is_sym
);
2423 BFD_ASSERT (! aux
->is_sym
);
2425 if (CSECT_SYM_P (symbol
->u
.syment
.n_sclass
)
2426 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2428 /* This is a csect entry. */
2429 fprintf (file
, "AUX ");
2430 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2432 BFD_ASSERT (! aux
->fix_scnlen
);
2433 fprintf (file
, "val %5" BFD_VMA_FMT
"d",
2434 aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2438 fprintf (file
, "indx ");
2439 if (! aux
->fix_scnlen
)
2440 fprintf (file
, "%4" BFD_VMA_FMT
"d",
2441 aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2443 fprintf (file
, "%4ld",
2444 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2447 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2448 aux
->u
.auxent
.x_csect
.x_parmhash
,
2449 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2450 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2451 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2452 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2453 aux
->u
.auxent
.x_csect
.x_stab
,
2454 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2459 /* Return FALSE to indicate that no special action was taken. */
2467 To write relocations, the back end steps though the
2468 canonical relocation table and create an
2469 @code{internal_reloc}. The symbol index to use is removed from
2470 the @code{offset} field in the symbol table supplied. The
2471 address comes directly from the sum of the section base
2472 address and the relocation offset; the type is dug directly
2473 from the howto field. Then the @code{internal_reloc} is
2474 swapped into the shape of an @code{external_reloc} and written
2482 /* AUX's ld wants relocations to be sorted. */
2484 compare_arelent_ptr (const void * x
, const void * y
)
2486 const arelent
**a
= (const arelent
**) x
;
2487 const arelent
**b
= (const arelent
**) y
;
2488 bfd_size_type aadr
= (*a
)->address
;
2489 bfd_size_type badr
= (*b
)->address
;
2491 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2494 #endif /* TARG_AUX */
2497 coff_write_relocs (bfd
* abfd
, int first_undef
)
2501 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2504 struct external_reloc dst
;
2511 /* Sort relocations before we write them out. */
2514 amt
= s
->reloc_count
;
2515 amt
*= sizeof (arelent
*);
2516 p
= bfd_malloc (amt
);
2519 if (s
->reloc_count
> 0)
2524 memcpy (p
, s
->orelocation
, (size_t) amt
);
2525 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2530 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2534 if (obj_pe (abfd
) && s
->reloc_count
>= 0xffff)
2536 /* Encode real count here as first reloc. */
2537 struct internal_reloc n
;
2539 memset (& n
, 0, sizeof (n
));
2540 /* Add one to count *this* reloc (grr). */
2541 n
.r_vaddr
= s
->reloc_count
+ 1;
2542 coff_swap_reloc_out (abfd
, &n
, &dst
);
2543 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2544 abfd
) != bfd_coff_relsz (abfd
))
2549 for (i
= 0; i
< s
->reloc_count
; i
++)
2551 struct internal_reloc n
;
2554 memset (& n
, 0, sizeof (n
));
2556 /* Now we've renumbered the symbols we know where the
2557 undefined symbols live in the table. Check the reloc
2558 entries for symbols who's output bfd isn't the right one.
2559 This is because the symbol was undefined (which means
2560 that all the pointers are never made to point to the same
2561 place). This is a bad thing,'cause the symbols attached
2562 to the output bfd are indexed, so that the relocation
2563 entries know which symbol index they point to. So we
2564 have to look up the output symbol here. */
2566 if (q
->sym_ptr_ptr
[0] != NULL
&& q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2569 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2570 asymbol
**outsyms
= abfd
->outsymbols
;
2572 for (j
= first_undef
; outsyms
[j
]; j
++)
2574 const char *intable
= outsyms
[j
]->name
;
2576 if (strcmp (intable
, sname
) == 0)
2578 /* Got a hit, so repoint the reloc. */
2579 q
->sym_ptr_ptr
= outsyms
+ j
;
2585 n
.r_vaddr
= q
->address
+ s
->vma
;
2588 /* The 29k const/consth reloc pair is a real kludge. The consth
2589 part doesn't have a symbol; it has an offset. So rebuilt
2591 if (q
->howto
->type
== R_IHCONST
)
2592 n
.r_symndx
= q
->addend
;
2595 if (q
->sym_ptr_ptr
&& q
->sym_ptr_ptr
[0] != NULL
)
2597 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2598 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
, s
))
2600 if ((*q
->sym_ptr_ptr
)->section
== bfd_abs_section_ptr
2601 && ((*q
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) != 0)
2603 /* This is a relocation relative to the absolute symbol. */
2607 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2608 /* Check to see if the symbol reloc points to a symbol
2609 we don't have in our symbol table. */
2610 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2612 bfd_set_error (bfd_error_bad_value
);
2613 /* xgettext:c-format */
2614 _bfd_error_handler (_("%pB: reloc against a non-existent"
2615 " symbol index: %ld"),
2622 #ifdef SWAP_OUT_RELOC_OFFSET
2623 n
.r_offset
= q
->addend
;
2627 /* Work out reloc type from what is required. */
2628 SELECT_RELOC (n
, q
->howto
);
2630 n
.r_type
= q
->howto
->type
;
2632 coff_swap_reloc_out (abfd
, &n
, &dst
);
2634 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2635 abfd
) != bfd_coff_relsz (abfd
))
2648 /* Set flags and magic number of a coff file from architecture and machine
2649 type. Result is TRUE if we can represent the arch&type, FALSE if not. */
2652 coff_set_flags (bfd
* abfd
,
2653 unsigned int *magicp ATTRIBUTE_UNUSED
,
2654 unsigned short *flagsp ATTRIBUTE_UNUSED
)
2656 switch (bfd_get_arch (abfd
))
2661 switch (bfd_get_mach (abfd
))
2663 case bfd_mach_z80strict
:
2666 case bfd_mach_z80full
:
2668 case bfd_mach_gbz80
:
2670 case bfd_mach_ez80_z80
:
2671 case bfd_mach_ez80_adl
:
2672 *flagsp
= bfd_get_mach (abfd
) << 12;
2684 switch (bfd_get_mach (abfd
))
2686 case bfd_mach_z8001
: *flagsp
= F_Z8001
; break;
2687 case bfd_mach_z8002
: *flagsp
= F_Z8002
; break;
2688 default: return FALSE
;
2694 case bfd_arch_tic30
:
2695 *magicp
= TIC30MAGIC
;
2699 #ifdef TICOFF_DEFAULT_MAGIC
2700 case TICOFF_TARGET_ARCH
:
2701 /* If there's no indication of which version we want, use the default. */
2703 *magicp
= TICOFF_DEFAULT_MAGIC
;
2706 /* We may want to output in a different COFF version. */
2707 switch (abfd
->xvec
->name
[4])
2710 *magicp
= TICOFF0MAGIC
;
2713 *magicp
= TICOFF1MAGIC
;
2716 *magicp
= TICOFF2MAGIC
;
2722 TICOFF_TARGET_MACHINE_SET (flagsp
, bfd_get_mach (abfd
));
2729 * magicp
= ARMPEMAGIC
;
2731 * magicp
= ARMMAGIC
;
2734 if (APCS_SET (abfd
))
2736 if (APCS_26_FLAG (abfd
))
2737 * flagsp
|= F_APCS26
;
2739 if (APCS_FLOAT_FLAG (abfd
))
2740 * flagsp
|= F_APCS_FLOAT
;
2742 if (PIC_FLAG (abfd
))
2745 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2746 * flagsp
|= F_INTERWORK
;
2747 switch (bfd_get_mach (abfd
))
2749 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2750 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2751 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2752 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2753 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2754 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2755 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2756 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2757 See also the comment in coff_set_arch_mach_hook(). */
2758 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break;
2759 case bfd_mach_arm_5TE
: * flagsp
|= F_ARM_5
; break;
2760 case bfd_mach_arm_XScale
: * flagsp
|= F_ARM_5
; break;
2766 case bfd_arch_powerpc
:
2771 #if defined(I386MAGIC) || defined(AMD64MAGIC)
2773 #if defined(I386MAGIC)
2774 *magicp
= I386MAGIC
;
2777 /* Just overwrite the usual value if we're doing Lynx. */
2778 *magicp
= LYNXCOFFMAGIC
;
2780 #if defined AMD64MAGIC
2781 *magicp
= AMD64MAGIC
;
2788 *magicp
= IA64MAGIC
;
2792 #ifdef SH_ARCH_MAGIC_BIG
2794 #ifdef COFF_IMAGE_WITH_PE
2795 *magicp
= SH_ARCH_MAGIC_WINCE
;
2797 if (bfd_big_endian (abfd
))
2798 *magicp
= SH_ARCH_MAGIC_BIG
;
2800 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2805 #ifdef MIPS_ARCH_MAGIC_WINCE
2807 *magicp
= MIPS_ARCH_MAGIC_WINCE
;
2812 case bfd_arch_sparc
:
2813 *magicp
= SPARCMAGIC
;
2815 /* Just overwrite the usual value if we're doing Lynx. */
2816 *magicp
= LYNXCOFFMAGIC
;
2822 case bfd_arch_rs6000
:
2824 case bfd_arch_powerpc
:
2826 BFD_ASSERT (bfd_get_flavour (abfd
) == bfd_target_xcoff_flavour
);
2827 *magicp
= bfd_xcoff_magic_number (abfd
);
2832 case bfd_arch_mcore
:
2833 * magicp
= MCOREMAGIC
;
2837 default: /* Unknown architecture. */
2838 /* Fall through to "return FALSE" below, to avoid
2839 "statement never reached" errors on the one below. */
2847 coff_set_arch_mach (bfd
* abfd
,
2848 enum bfd_architecture arch
,
2849 unsigned long machine
)
2852 unsigned short dummy2
;
2854 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
2857 if (arch
!= bfd_arch_unknown
2858 && ! coff_set_flags (abfd
, &dummy1
, &dummy2
))
2859 return FALSE
; /* We can't represent this type. */
2861 return TRUE
; /* We're easy... */
2864 #ifdef COFF_IMAGE_WITH_PE
2866 /* This is used to sort sections by VMA, as required by PE image
2870 sort_by_secaddr (const void * arg1
, const void * arg2
)
2872 const asection
*a
= *(const asection
**) arg1
;
2873 const asection
*b
= *(const asection
**) arg2
;
2875 if (a
->vma
< b
->vma
)
2877 else if (a
->vma
> b
->vma
)
2883 #endif /* COFF_IMAGE_WITH_PE */
2885 /* Calculate the file position for each section. */
2887 #define ALIGN_SECTIONS_IN_FILE
2889 #undef ALIGN_SECTIONS_IN_FILE
2893 coff_compute_section_file_positions (bfd
* abfd
)
2896 file_ptr sofar
= bfd_coff_filhsz (abfd
);
2897 bfd_boolean align_adjust
;
2898 unsigned int target_index
;
2899 #ifdef ALIGN_SECTIONS_IN_FILE
2900 asection
*previous
= NULL
;
2904 #ifdef COFF_IMAGE_WITH_PE
2907 if (coff_data (abfd
)->link_info
2908 || (pe_data (abfd
) && pe_data (abfd
)->pe_opthdr
.FileAlignment
))
2910 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
2912 /* If no file alignment has been set, default to one.
2913 This repairs 'ld -r' for arm-wince-pe target. */
2917 /* PR 17512: file: 0ac816d3. */
2920 bfd_set_error (bfd_error_file_too_big
);
2922 /* xgettext:c-format */
2923 (_("%pB: page size is too large (0x%x)"), abfd
, page_size
);
2928 page_size
= PE_DEF_FILE_ALIGNMENT
;
2930 #ifdef COFF_PAGE_SIZE
2931 int page_size
= COFF_PAGE_SIZE
;
2936 /* On XCOFF, if we have symbols, set up the .debug section. */
2937 if (bfd_get_symcount (abfd
) > 0)
2940 bfd_size_type i
, symcount
;
2944 symcount
= bfd_get_symcount (abfd
);
2945 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
2947 coff_symbol_type
*cf
;
2949 cf
= coff_symbol_from (*symp
);
2951 && cf
->native
!= NULL
2952 && cf
->native
->is_sym
2953 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
2957 len
= strlen (bfd_asymbol_name (*symp
));
2958 if (len
> SYMNMLEN
|| bfd_coff_force_symnames_in_strings (abfd
))
2959 sz
+= len
+ 1 + bfd_coff_debug_string_prefix_length (abfd
);
2966 dsec
= bfd_make_section_old_way (abfd
, DOT_DEBUG
);
2970 dsec
->flags
|= SEC_HAS_CONTENTS
;
2975 if (bfd_get_start_address (abfd
))
2976 /* A start address may have been added to the original file. In this
2977 case it will need an optional header to record it. */
2978 abfd
->flags
|= EXEC_P
;
2980 if (abfd
->flags
& EXEC_P
)
2981 sofar
+= bfd_coff_aoutsz (abfd
);
2983 else if (xcoff_data (abfd
)->full_aouthdr
)
2984 sofar
+= bfd_coff_aoutsz (abfd
);
2986 sofar
+= SMALL_AOUTSZ
;
2989 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2992 /* XCOFF handles overflows in the reloc and line number count fields
2993 by allocating a new section header to hold the correct counts. */
2994 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2995 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
2996 sofar
+= bfd_coff_scnhsz (abfd
);
2999 #ifdef COFF_IMAGE_WITH_PE
3001 /* PE requires the sections to be in memory order when listed in
3002 the section headers. It also does not like empty loadable
3003 sections. The sections apparently do not have to be in the
3004 right order in the image file itself, but we do need to get the
3005 target_index values right. */
3008 asection
**section_list
;
3012 #ifdef COFF_PAGE_SIZE
3013 /* Clear D_PAGED if section alignment is smaller than
3015 if (pe_data (abfd
)->pe_opthdr
.SectionAlignment
< COFF_PAGE_SIZE
)
3016 abfd
->flags
&= ~D_PAGED
;
3020 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3023 /* We allocate an extra cell to simplify the final loop. */
3024 amt
= sizeof (struct asection
*) * (count
+ 1);
3025 section_list
= (asection
**) bfd_malloc (amt
);
3026 if (section_list
== NULL
)
3030 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3032 section_list
[i
] = current
;
3035 section_list
[i
] = NULL
;
3037 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
3039 /* Rethread the linked list into sorted order; at the same time,
3040 assign target_index values. */
3042 abfd
->sections
= NULL
;
3043 abfd
->section_last
= NULL
;
3044 for (i
= 0; i
< count
; i
++)
3046 current
= section_list
[i
];
3047 bfd_section_list_append (abfd
, current
);
3049 /* Later, if the section has zero size, we'll be throwing it
3050 away, so we don't want to number it now. Note that having
3051 a zero size and having real contents are different
3052 concepts: .bss has no contents, but (usually) non-zero
3054 if (current
->size
== 0)
3056 /* Discard. However, it still might have (valid) symbols
3057 in it, so arbitrarily set it to section 1 (indexing is
3058 1-based here; usually .text). __end__ and other
3059 contents of .endsection really have this happen.
3060 FIXME: This seems somewhat dubious. */
3061 current
->target_index
= 1;
3064 current
->target_index
= target_index
++;
3067 free (section_list
);
3069 #else /* ! COFF_IMAGE_WITH_PE */
3071 /* Set the target_index field. */
3073 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3074 current
->target_index
= target_index
++;
3076 #endif /* ! COFF_IMAGE_WITH_PE */
3078 if (target_index
>= bfd_coff_max_nscns (abfd
))
3080 bfd_set_error (bfd_error_file_too_big
);
3082 /* xgettext:c-format */
3083 (_("%pB: too many sections (%d)"), abfd
, target_index
);
3087 align_adjust
= FALSE
;
3088 for (current
= abfd
->sections
;
3090 current
= current
->next
)
3092 #ifdef COFF_IMAGE_WITH_PE
3093 /* With PE we have to pad each section to be a multiple of its
3094 page size too, and remember both sizes. */
3095 if (coff_section_data (abfd
, current
) == NULL
)
3097 size_t amt
= sizeof (struct coff_section_tdata
);
3099 current
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
3100 if (current
->used_by_bfd
== NULL
)
3103 if (pei_section_data (abfd
, current
) == NULL
)
3105 size_t amt
= sizeof (struct pei_section_tdata
);
3107 coff_section_data (abfd
, current
)->tdata
= bfd_zalloc (abfd
, amt
);
3108 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
3111 if (pei_section_data (abfd
, current
)->virt_size
== 0)
3112 pei_section_data (abfd
, current
)->virt_size
= current
->size
;
3115 /* Only deal with sections which have contents. */
3116 if (!(current
->flags
& SEC_HAS_CONTENTS
))
3119 current
->rawsize
= current
->size
;
3121 #ifdef COFF_IMAGE_WITH_PE
3122 /* Make sure we skip empty sections in a PE image. */
3123 if (current
->size
== 0)
3127 /* Align the sections in the file to the same boundary on
3128 which they are aligned in virtual memory. */
3129 #ifdef ALIGN_SECTIONS_IN_FILE
3130 if ((abfd
->flags
& EXEC_P
) != 0)
3132 /* Make sure this section is aligned on the right boundary - by
3133 padding the previous section up if necessary. */
3136 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3139 /* Make sure the file offset and the vma of .text/.data are at the
3140 same page offset, so that the file can be mmap'ed without being
3141 relocated. Failing that, AIX is able to load and execute the
3142 program, but it will be silently relocated (possible as
3143 executables are PIE). But the relocation is slightly costly and
3144 complexify the use of addr2line or gdb. So better to avoid it,
3145 like does the native linker. Usually gnu ld makes sure that
3146 the vma of .text is the file offset so this issue shouldn't
3147 appear unless you are stripping such an executable.
3149 AIX loader checks the text section alignment of (vma - filepos),
3150 and the native linker doesn't try to align the text sections.
3153 0 .text 000054cc 10000128 10000128 00000128 2**5
3154 CONTENTS, ALLOC, LOAD, CODE
3157 if (!strcmp (current
->name
, _TEXT
)
3158 || !strcmp (current
->name
, _DATA
))
3160 bfd_vma align
= 4096;
3161 bfd_vma sofar_off
= sofar
% align
;
3162 bfd_vma vma_off
= current
->vma
% align
;
3164 if (vma_off
> sofar_off
)
3165 sofar
+= vma_off
- sofar_off
;
3166 else if (vma_off
< sofar_off
)
3167 sofar
+= align
+ vma_off
- sofar_off
;
3170 if (previous
!= NULL
)
3171 previous
->size
+= sofar
- old_sofar
;
3176 /* In demand paged files the low order bits of the file offset
3177 must match the low order bits of the virtual address. */
3178 #ifdef COFF_PAGE_SIZE
3179 if ((abfd
->flags
& D_PAGED
) != 0
3180 && (current
->flags
& SEC_ALLOC
) != 0)
3181 sofar
+= (current
->vma
- (bfd_vma
) sofar
) % page_size
;
3183 current
->filepos
= sofar
;
3185 #ifdef COFF_IMAGE_WITH_PE
3186 /* Set the padded size. */
3187 current
->size
= (current
->size
+ page_size
- 1) & -page_size
;
3190 sofar
+= current
->size
;
3192 #ifdef ALIGN_SECTIONS_IN_FILE
3193 /* Make sure that this section is of the right size too. */
3194 if ((abfd
->flags
& EXEC_P
) == 0)
3196 bfd_size_type old_size
;
3198 old_size
= current
->size
;
3199 current
->size
= BFD_ALIGN (current
->size
,
3200 1 << current
->alignment_power
);
3201 align_adjust
= current
->size
!= old_size
;
3202 sofar
+= current
->size
- old_size
;
3207 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3208 align_adjust
= sofar
!= old_sofar
;
3209 current
->size
+= sofar
- old_sofar
;
3213 #ifdef COFF_IMAGE_WITH_PE
3214 /* For PE we need to make sure we pad out to the aligned
3215 size, in case the caller only writes out data to the
3217 if (pei_section_data (abfd
, current
)->virt_size
< current
->size
)
3218 align_adjust
= TRUE
;
3222 /* Force .lib sections to start at zero. The vma is then
3223 incremented in coff_set_section_contents. This is right for
3225 if (strcmp (current
->name
, _LIB
) == 0)
3226 bfd_set_section_vma (current
, 0);
3229 #ifdef ALIGN_SECTIONS_IN_FILE
3234 /* It is now safe to write to the output file. If we needed an
3235 alignment adjustment for the last section, then make sure that
3236 there is a byte at offset sofar. If there are no symbols and no
3237 relocs, then nothing follows the last section. If we don't force
3238 the last byte out, then the file may appear to be truncated. */
3244 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
3245 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3249 /* Make sure the relocations are aligned. We don't need to make
3250 sure that this byte exists, because it will only matter if there
3251 really are relocs. */
3252 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
3254 obj_relocbase (abfd
) = sofar
;
3255 abfd
->output_has_begun
= TRUE
;
3260 #ifdef COFF_IMAGE_WITH_PE
3262 static unsigned int pelength
;
3263 static unsigned int peheader
;
3266 coff_read_word (bfd
*abfd
, unsigned int *value
)
3271 status
= bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3279 *value
= (unsigned int) b
[0];
3281 *value
= (unsigned int) (b
[0] + (b
[1] << 8));
3283 pelength
+= (unsigned int) status
;
3289 coff_compute_checksum (bfd
*abfd
)
3291 bfd_boolean more_data
;
3298 filepos
= (file_ptr
) 0;
3302 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
3305 more_data
= coff_read_word (abfd
, &value
);
3307 total
= 0xffff & (total
+ (total
>> 0x10));
3312 return (0xffff & (total
+ (total
>> 0x10)));
3316 coff_apply_checksum (bfd
*abfd
)
3318 unsigned int computed
;
3319 unsigned int checksum
= 0;
3321 if (bfd_seek (abfd
, 0x3c, SEEK_SET
) != 0)
3324 if (!coff_read_word (abfd
, &peheader
))
3327 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3331 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3333 if (bfd_seek (abfd
, peheader
, SEEK_SET
) != 0)
3336 computed
= coff_compute_checksum (abfd
);
3338 checksum
= computed
+ pelength
;
3340 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3343 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3348 #endif /* COFF_IMAGE_WITH_PE */
3351 coff_write_object_contents (bfd
* abfd
)
3354 bfd_boolean hasrelocs
= FALSE
;
3355 bfd_boolean haslinno
= FALSE
;
3356 #ifdef COFF_IMAGE_WITH_PE
3357 bfd_boolean hasdebug
= FALSE
;
3360 file_ptr reloc_base
;
3361 file_ptr lineno_base
;
3363 unsigned long reloc_size
= 0, reloc_count
= 0;
3364 unsigned long lnno_size
= 0;
3365 bfd_boolean long_section_names
;
3366 asection
*text_sec
= NULL
;
3367 asection
*data_sec
= NULL
;
3368 asection
*bss_sec
= NULL
;
3369 struct internal_filehdr internal_f
;
3370 struct internal_aouthdr internal_a
;
3371 #ifdef COFF_LONG_SECTION_NAMES
3372 size_t string_size
= STRING_SIZE_SIZE
;
3375 bfd_set_error (bfd_error_system_call
);
3377 /* Make a pass through the symbol table to count line number entries and
3378 put them into the correct asections. */
3379 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3381 if (! abfd
->output_has_begun
)
3383 if (! coff_compute_section_file_positions (abfd
))
3387 reloc_base
= obj_relocbase (abfd
);
3389 /* Work out the size of the reloc and linno areas. */
3391 for (current
= abfd
->sections
; current
!= NULL
; current
=
3395 /* We store the actual reloc count in the first reloc's addr. */
3396 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3399 reloc_count
+= current
->reloc_count
;
3402 reloc_size
= reloc_count
* bfd_coff_relsz (abfd
);
3404 lineno_base
= reloc_base
+ reloc_size
;
3405 sym_base
= lineno_base
+ lnno_size
;
3407 /* Indicate in each section->line_filepos its actual file address. */
3408 for (current
= abfd
->sections
; current
!= NULL
; current
=
3411 if (current
->lineno_count
)
3413 current
->line_filepos
= lineno_base
;
3414 current
->moving_line_filepos
= lineno_base
;
3415 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3418 current
->line_filepos
= 0;
3420 if (current
->reloc_count
)
3422 current
->rel_filepos
= reloc_base
;
3423 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3425 /* Extra reloc to hold real count. */
3426 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3427 reloc_base
+= bfd_coff_relsz (abfd
);
3431 current
->rel_filepos
= 0;
3434 /* Write section headers to the file. */
3435 internal_f
.f_nscns
= 0;
3437 if ((abfd
->flags
& EXEC_P
) != 0)
3438 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3441 scn_base
= bfd_coff_filhsz (abfd
);
3444 if (xcoff_data (abfd
)->full_aouthdr
)
3445 scn_base
+= bfd_coff_aoutsz (abfd
);
3447 scn_base
+= SMALL_AOUTSZ
;
3452 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3455 long_section_names
= FALSE
;
3456 for (current
= abfd
->sections
;
3458 current
= current
->next
)
3460 struct internal_scnhdr section
;
3461 #ifdef COFF_IMAGE_WITH_PE
3462 bfd_boolean is_reloc_section
= FALSE
;
3464 if (strcmp (current
->name
, DOT_RELOC
) == 0)
3466 is_reloc_section
= TRUE
;
3468 pe_data (abfd
)->has_reloc_section
= 1;
3472 internal_f
.f_nscns
++;
3474 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3476 #ifdef COFF_LONG_SECTION_NAMES
3477 /* Handle long section names as in PE. This must be compatible
3478 with the code in coff_write_symbols and _bfd_coff_final_link. */
3479 if (bfd_coff_long_section_names (abfd
))
3483 len
= strlen (current
->name
);
3486 /* The s_name field is defined to be NUL-padded but need not be
3487 NUL-terminated. We use a temporary buffer so that we can still
3488 sprintf all eight chars without splatting a terminating NUL
3489 over the first byte of the following member (s_paddr). */
3490 /* PR 21096: The +20 is to stop a bogus warning from gcc7 about
3491 a possible buffer overflow. */
3492 char s_name_buf
[SCNNMLEN
+ 1 + 20];
3494 /* An inherent limitation of the /nnnnnnn notation used to indicate
3495 the offset of the long name in the string table is that we
3496 cannot address entries beyone the ten million byte boundary. */
3497 if (string_size
>= 10000000)
3499 bfd_set_error (bfd_error_file_too_big
);
3501 /* xgettext:c-format */
3502 (_("%pB: section %pA: string table overflow at offset %ld"),
3503 abfd
, current
, (unsigned long) string_size
);
3507 /* We do not need to use snprintf here as we have already verfied
3508 that string_size is not too big, plus we have an overlarge
3509 buffer, just in case. */
3510 sprintf (s_name_buf
, "/%lu", (unsigned long) string_size
);
3511 /* Then strncpy takes care of any padding for us. */
3512 strncpy (section
.s_name
, s_name_buf
, SCNNMLEN
);
3513 string_size
+= len
+ 1;
3514 long_section_names
= TRUE
;
3520 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3521 Ian Taylor <ian@cygnus.com>. */
3522 if (strcmp (current
->name
, _LIB
) == 0)
3523 section
.s_vaddr
= 0;
3526 section
.s_vaddr
= current
->vma
;
3527 section
.s_paddr
= current
->lma
;
3528 section
.s_size
= current
->size
;
3529 #ifdef coff_get_section_load_page
3530 section
.s_page
= coff_get_section_load_page (current
);
3536 section
.s_paddr
= 0;
3538 #ifdef COFF_IMAGE_WITH_PE
3539 /* Reminder: s_paddr holds the virtual size of the section. */
3540 if (coff_section_data (abfd
, current
) != NULL
3541 && pei_section_data (abfd
, current
) != NULL
)
3542 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3544 section
.s_paddr
= 0;
3547 /* If this section has no size or is unloadable then the scnptr
3549 if (current
->size
== 0
3550 || (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3551 section
.s_scnptr
= 0;
3553 section
.s_scnptr
= current
->filepos
;
3555 section
.s_relptr
= current
->rel_filepos
;
3556 section
.s_lnnoptr
= current
->line_filepos
;
3557 section
.s_nreloc
= current
->reloc_count
;
3558 section
.s_nlnno
= current
->lineno_count
;
3559 #ifndef COFF_IMAGE_WITH_PE
3560 /* In PEI, relocs come in the .reloc section. */
3561 if (current
->reloc_count
!= 0)
3564 if (current
->lineno_count
!= 0)
3566 #ifdef COFF_IMAGE_WITH_PE
3567 if ((current
->flags
& SEC_DEBUGGING
) != 0
3568 && ! is_reloc_section
)
3574 /* Indicate the use of an XCOFF overflow section header. */
3575 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3577 section
.s_nreloc
= 0xffff;
3578 section
.s_nlnno
= 0xffff;
3583 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3585 if (!strcmp (current
->name
, _TEXT
))
3587 else if (!strcmp (current
->name
, _DATA
))
3589 else if (!strcmp (current
->name
, _BSS
))
3592 #ifdef COFF_ENCODE_ALIGNMENT
3593 COFF_ENCODE_ALIGNMENT(section
, current
->alignment_power
);
3594 if ((unsigned int)COFF_DECODE_ALIGNMENT(section
.s_flags
)
3595 != current
->alignment_power
)
3597 bfd_boolean warn
= coff_data (abfd
)->link_info
3598 && !bfd_link_relocatable (coff_data (abfd
)->link_info
);
3601 /* xgettext:c-format */
3602 (_("%pB:%s section %s: alignment 2**%u not representable"),
3603 abfd
, warn
? " warning:" : "", current
->name
,
3604 current
->alignment_power
);
3607 bfd_set_error (bfd_error_nonrepresentable_section
);
3613 #ifdef COFF_IMAGE_WITH_PE
3614 /* Suppress output of the sections if they are null. ld
3615 includes the bss and data sections even if there is no size
3616 assigned to them. NT loader doesn't like it if these section
3617 headers are included if the sections themselves are not
3618 needed. See also coff_compute_section_file_positions. */
3619 if (section
.s_size
== 0)
3620 internal_f
.f_nscns
--;
3625 bfd_size_type amt
= bfd_coff_scnhsz (abfd
);
3627 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3628 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3633 /* PE stores COMDAT section information in the symbol table. If
3634 this section is supposed to have some COMDAT info, track down
3635 the symbol in the symbol table and modify it. */
3636 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3638 unsigned int i
, count
;
3640 coff_symbol_type
*csym
= NULL
;
3644 count
= bfd_get_symcount (abfd
);
3645 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3647 if ((*psym
)->section
!= current
)
3650 /* Remember the location of the first symbol in this
3652 if (psymsec
== NULL
)
3655 /* See if this is the section symbol. */
3656 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3658 csym
= coff_symbol_from (*psym
);
3660 || csym
->native
== NULL
3661 || ! csym
->native
->is_sym
3662 || csym
->native
->u
.syment
.n_numaux
< 1
3663 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3664 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3667 /* Here *PSYM is the section symbol for CURRENT. */
3674 Note that we might not if we're converting the file from
3675 some other object file format. */
3678 combined_entry_type
*aux
;
3680 /* We don't touch the x_checksum field. The
3681 x_associated field is not currently supported. */
3683 aux
= csym
->native
+ 1;
3684 BFD_ASSERT (! aux
->is_sym
);
3685 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3687 case SEC_LINK_DUPLICATES_DISCARD
:
3688 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3691 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3692 aux
->u
.auxent
.x_scn
.x_comdat
=
3693 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3696 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3697 aux
->u
.auxent
.x_scn
.x_comdat
=
3698 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3701 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3702 aux
->u
.auxent
.x_scn
.x_comdat
=
3703 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3707 /* The COMDAT symbol must be the first symbol from this
3708 section in the symbol table. In order to make this
3709 work, we move the COMDAT symbol before the first
3710 symbol we found in the search above. It's OK to
3711 rearrange the symbol table at this point, because
3712 coff_renumber_symbols is going to rearrange it
3713 further and fix up all the aux entries. */
3714 if (psym
!= psymsec
)
3720 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3721 pcopy
[0] = pcopy
[-1];
3726 #endif /* COFF_WITH_PE */
3731 /* XCOFF handles overflows in the reloc and line number count fields
3732 by creating a new section header to hold the correct values. */
3733 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3735 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3737 struct internal_scnhdr scnhdr
;
3741 internal_f
.f_nscns
++;
3742 memcpy (scnhdr
.s_name
, ".ovrflo", 8);
3743 scnhdr
.s_paddr
= current
->reloc_count
;
3744 scnhdr
.s_vaddr
= current
->lineno_count
;
3746 scnhdr
.s_scnptr
= 0;
3747 scnhdr
.s_relptr
= current
->rel_filepos
;
3748 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3749 scnhdr
.s_nreloc
= current
->target_index
;
3750 scnhdr
.s_nlnno
= current
->target_index
;
3751 scnhdr
.s_flags
= STYP_OVRFLO
;
3752 amt
= bfd_coff_scnhsz (abfd
);
3753 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3754 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3761 /* OK, now set up the filehdr... */
3763 /* Don't include the internal abs section in the section count */
3765 /* We will NOT put a fucking timestamp in the header here. Every time you
3766 put it back, I will come in and take it out again. I'm sorry. This
3767 field does not belong here. We fill it with a 0 so it compares the
3768 same but is not a reasonable time. -- gnu@cygnus.com */
3769 internal_f
.f_timdat
= 0;
3770 internal_f
.f_flags
= 0;
3772 if (abfd
->flags
& EXEC_P
)
3773 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3776 internal_f
.f_opthdr
= 0;
3779 if (xcoff_data (abfd
)->full_aouthdr
)
3780 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3782 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
3788 internal_f
.f_flags
|= F_RELFLG
;
3790 internal_f
.f_flags
|= F_LNNO
;
3791 if (abfd
->flags
& EXEC_P
)
3792 internal_f
.f_flags
|= F_EXEC
;
3793 #ifdef COFF_IMAGE_WITH_PE
3795 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
3796 if (pe_data (abfd
)->real_flags
& IMAGE_FILE_LARGE_ADDRESS_AWARE
)
3797 internal_f
.f_flags
|= IMAGE_FILE_LARGE_ADDRESS_AWARE
;
3800 #ifndef COFF_WITH_pex64
3802 internal_f
.f_flags
|= IMAGE_FILE_32BIT_MACHINE
;
3804 if (bfd_little_endian (abfd
))
3805 internal_f
.f_flags
|= F_AR32WR
;
3807 internal_f
.f_flags
|= F_AR32W
;
3812 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
3813 but it doesn't hurt to set it internally. */
3814 internal_f
.f_target_id
= TI_TARGET_ID
;
3817 /* FIXME, should do something about the other byte orders and
3821 if ((abfd
->flags
& DYNAMIC
) != 0)
3822 internal_f
.f_flags
|= F_SHROBJ
;
3823 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
3824 internal_f
.f_flags
|= F_DYNLOAD
;
3827 memset (&internal_a
, 0, sizeof internal_a
);
3829 /* Set up architecture-dependent stuff. */
3831 unsigned int magic
= 0;
3832 unsigned short flags
= 0;
3834 coff_set_flags (abfd
, &magic
, &flags
);
3835 internal_f
.f_magic
= magic
;
3836 internal_f
.f_flags
|= flags
;
3837 /* ...and the "opt"hdr... */
3839 #ifdef TICOFF_AOUT_MAGIC
3840 internal_a
.magic
= TICOFF_AOUT_MAGIC
;
3841 #define __A_MAGIC_SET__
3845 #define __A_MAGIC_SET__
3846 internal_a
.magic
= ZMAGIC
;
3850 #define __A_MAGIC_SET__
3851 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3854 #if defined MCORE_PE
3855 #define __A_MAGIC_SET__
3856 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3860 #define __A_MAGIC_SET__
3862 internal_a
.magic
= LYNXCOFFMAGIC
;
3864 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR64_MAGIC
;
3866 internal_a
.magic
= ZMAGIC
;
3871 #define __A_MAGIC_SET__
3872 internal_a
.magic
= PE32PMAGIC
;
3876 #define __A_MAGIC_SET__
3878 internal_a
.magic
= LYNXCOFFMAGIC
;
3883 #define __A_MAGIC_SET__
3884 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
3885 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
3886 RS6K_AOUTHDR_OMAGIC
;
3889 #if defined(SH) && defined(COFF_WITH_PE)
3890 #define __A_MAGIC_SET__
3891 internal_a
.magic
= SH_PE_MAGIC
;
3894 #if defined(MIPS) && defined(COFF_WITH_PE)
3895 #define __A_MAGIC_SET__
3896 internal_a
.magic
= MIPS_PE_MAGIC
;
3899 #ifndef __A_MAGIC_SET__
3900 #include "Your aouthdr magic number is not being set!"
3902 #undef __A_MAGIC_SET__
3906 /* FIXME: Does anybody ever set this to another value? */
3907 internal_a
.vstamp
= 0;
3909 /* Now should write relocs, strings, syms. */
3910 obj_sym_filepos (abfd
) = sym_base
;
3912 if (bfd_get_symcount (abfd
) != 0)
3916 if (!coff_renumber_symbols (abfd
, &firstundef
))
3918 coff_mangle_symbols (abfd
);
3919 if (! coff_write_symbols (abfd
))
3921 if (! coff_write_linenumbers (abfd
))
3923 if (! coff_write_relocs (abfd
, firstundef
))
3926 #ifdef COFF_LONG_SECTION_NAMES
3927 else if (long_section_names
&& ! obj_coff_strings_written (abfd
))
3929 /* If we have long section names we have to write out the string
3930 table even if there are no symbols. */
3931 if (! coff_write_symbols (abfd
))
3935 #ifdef COFF_IMAGE_WITH_PE
3937 else if ((abfd
->flags
& EXEC_P
) != 0)
3941 /* PowerPC PE appears to require that all executable files be
3942 rounded up to the page size. */
3945 (file_ptr
) BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
3947 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3953 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3954 backend linker, and obj_raw_syment_count is not valid until after
3955 coff_write_symbols is called. */
3956 if (obj_raw_syment_count (abfd
) != 0)
3958 internal_f
.f_symptr
= sym_base
;
3960 /* AIX appears to require that F_RELFLG not be set if there are
3961 local symbols but no relocations. */
3962 internal_f
.f_flags
&=~ F_RELFLG
;
3967 if (long_section_names
)
3968 internal_f
.f_symptr
= sym_base
;
3970 internal_f
.f_symptr
= 0;
3971 internal_f
.f_flags
|= F_LSYMS
;
3976 internal_a
.tsize
= text_sec
->size
;
3977 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
3981 internal_a
.dsize
= data_sec
->size
;
3982 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
3986 internal_a
.bsize
= bss_sec
->size
;
3987 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
3988 internal_a
.data_start
= bss_sec
->vma
;
3991 internal_a
.entry
= bfd_get_start_address (abfd
);
3992 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
3995 if (xcoff_data (abfd
)->full_aouthdr
)
3998 asection
*loader_sec
;
4000 internal_a
.vstamp
= 1;
4002 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
4003 if (internal_a
.o_snentry
== 0)
4004 internal_a
.entry
= (bfd_vma
) -1;
4006 if (text_sec
!= NULL
)
4008 internal_a
.o_sntext
= text_sec
->target_index
;
4009 internal_a
.o_algntext
= bfd_section_alignment (text_sec
);
4013 internal_a
.o_sntext
= 0;
4014 internal_a
.o_algntext
= 0;
4016 if (data_sec
!= NULL
)
4018 internal_a
.o_sndata
= data_sec
->target_index
;
4019 internal_a
.o_algndata
= bfd_section_alignment (data_sec
);
4023 internal_a
.o_sndata
= 0;
4024 internal_a
.o_algndata
= 0;
4026 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
4027 if (loader_sec
!= NULL
)
4028 internal_a
.o_snloader
= loader_sec
->target_index
;
4030 internal_a
.o_snloader
= 0;
4031 if (bss_sec
!= NULL
)
4032 internal_a
.o_snbss
= bss_sec
->target_index
;
4034 internal_a
.o_snbss
= 0;
4036 toc
= xcoff_data (abfd
)->toc
;
4037 internal_a
.o_toc
= toc
;
4038 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
4040 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
4041 if (xcoff_data (abfd
)->cputype
!= -1)
4042 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
4045 switch (bfd_get_arch (abfd
))
4047 case bfd_arch_rs6000
:
4048 internal_a
.o_cputype
= 4;
4050 case bfd_arch_powerpc
:
4051 if (bfd_get_mach (abfd
) == bfd_mach_ppc
)
4052 internal_a
.o_cputype
= 3;
4054 internal_a
.o_cputype
= 1;
4060 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
4061 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
4067 /* After object contents are finalized so we can compute a reasonable hash,
4068 but before header is written so we can update it to point to debug directory. */
4069 struct pe_tdata
*pe
= pe_data (abfd
);
4071 if (pe
->build_id
.after_write_object_contents
!= NULL
)
4072 (*pe
->build_id
.after_write_object_contents
) (abfd
);
4076 /* Now write header. */
4077 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
4082 bfd_size_type amount
= bfd_coff_filhsz (abfd
);
4084 buff
= (char *) bfd_malloc (amount
);
4088 bfd_coff_swap_filehdr_out (abfd
, & internal_f
, buff
);
4089 amount
= bfd_bwrite (buff
, amount
, abfd
);
4093 if (amount
!= bfd_coff_filhsz (abfd
))
4097 if (abfd
->flags
& EXEC_P
)
4099 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4100 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4102 bfd_size_type amount
= bfd_coff_aoutsz (abfd
);
4104 buff
= (char *) bfd_malloc (amount
);
4108 coff_swap_aouthdr_out (abfd
, & internal_a
, buff
);
4109 amount
= bfd_bwrite (buff
, amount
, abfd
);
4113 if (amount
!= bfd_coff_aoutsz (abfd
))
4116 #ifdef COFF_IMAGE_WITH_PE
4117 if (! coff_apply_checksum (abfd
))
4127 /* XCOFF seems to always write at least a small a.out header. */
4128 coff_swap_aouthdr_out (abfd
, & internal_a
, & buff
);
4129 if (xcoff_data (abfd
)->full_aouthdr
)
4130 size
= bfd_coff_aoutsz (abfd
);
4132 size
= SMALL_AOUTSZ
;
4133 if (bfd_bwrite (& buff
, (bfd_size_type
) size
, abfd
) != size
)
4142 coff_set_section_contents (bfd
* abfd
,
4144 const void * location
,
4146 bfd_size_type count
)
4148 if (! abfd
->output_has_begun
) /* Set by bfd.c handler. */
4150 if (! coff_compute_section_file_positions (abfd
))
4154 #if defined(_LIB) && !defined(TARG_AUX)
4155 /* The physical address field of a .lib section is used to hold the
4156 number of shared libraries in the section. This code counts the
4157 number of sections being written, and increments the lma field
4160 I have found no documentation on the contents of this section.
4161 Experimentation indicates that the section contains zero or more
4162 records, each of which has the following structure:
4164 - a (four byte) word holding the length of this record, in words,
4165 - a word that always seems to be set to "2",
4166 - the path to a shared library, null-terminated and then padded
4167 to a whole word boundary.
4169 bfd_assert calls have been added to alert if an attempt is made
4170 to write a section which doesn't follow these assumptions. The
4171 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4172 <robertl@arnet.com> (Thanks!).
4174 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4175 if (strcmp (section
->name
, _LIB
) == 0)
4177 bfd_byte
*rec
, *recend
;
4179 rec
= (bfd_byte
*) location
;
4180 recend
= rec
+ count
;
4181 while (rec
< recend
)
4184 rec
+= bfd_get_32 (abfd
, rec
) * 4;
4187 BFD_ASSERT (rec
== recend
);
4191 /* Don't write out bss sections - one way to do this is to
4192 see if the filepos has not been set. */
4193 if (section
->filepos
== 0)
4196 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0)
4202 return bfd_bwrite (location
, count
, abfd
) == count
;
4206 buy_and_read (bfd
*abfd
, file_ptr where
,
4207 bfd_size_type nmemb
, bfd_size_type size
)
4211 if (_bfd_mul_overflow (nmemb
, size
, &amt
))
4213 bfd_set_error (bfd_error_file_too_big
);
4216 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
4218 return _bfd_alloc_and_read (abfd
, amt
, amt
);
4225 Creating the linenumber table is done by reading in the entire
4226 coff linenumber table, and creating another table for internal use.
4228 A coff linenumber table is structured so that each function
4229 is marked as having a line number of 0. Each line within the
4230 function is an offset from the first line in the function. The
4231 base of the line number information for the table is stored in
4232 the symbol associated with the function.
4234 Note: The PE format uses line number 0 for a flag indicating a
4237 The information is copied from the external to the internal
4238 table, and each symbol which marks a function is marked by
4241 How does this work ?
4245 coff_sort_func_alent (const void * arg1
, const void * arg2
)
4247 const alent
*al1
= *(const alent
**) arg1
;
4248 const alent
*al2
= *(const alent
**) arg2
;
4249 const coff_symbol_type
*s1
= (const coff_symbol_type
*) (al1
->u
.sym
);
4250 const coff_symbol_type
*s2
= (const coff_symbol_type
*) (al2
->u
.sym
);
4252 if (s1
== NULL
|| s2
== NULL
)
4254 if (s1
->symbol
.value
< s2
->symbol
.value
)
4256 else if (s1
->symbol
.value
> s2
->symbol
.value
)
4263 coff_slurp_line_table (bfd
*abfd
, asection
*asect
)
4265 LINENO
*native_lineno
;
4266 alent
*lineno_cache
;
4267 unsigned int counter
;
4269 bfd_vma prev_offset
= 0;
4270 bfd_boolean ordered
= TRUE
;
4271 unsigned int nbr_func
;
4273 bfd_boolean have_func
;
4274 bfd_boolean ret
= TRUE
;
4277 if (asect
->lineno_count
== 0)
4280 BFD_ASSERT (asect
->lineno
== NULL
);
4282 if (asect
->lineno_count
> asect
->size
)
4285 (_("%pB: warning: line number count (%#lx) exceeds section size (%#lx)"),
4286 abfd
, (unsigned long) asect
->lineno_count
, (unsigned long) asect
->size
);
4290 if (_bfd_mul_overflow (asect
->lineno_count
+ 1, sizeof (alent
), &amt
))
4292 bfd_set_error (bfd_error_file_too_big
);
4295 lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
);
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 if (_bfd_mul_overflow (nbr_func
, sizeof (alent
*), &amt
))
4411 bfd_set_error (bfd_error_file_too_big
);
4414 else if ((func_table
= (alent
**) bfd_alloc (abfd
, amt
)) != NULL
)
4416 alent
**p
= func_table
;
4419 for (i
= 0; i
< asect
->lineno_count
; i
++)
4420 if (lineno_cache
[i
].line_number
== 0)
4421 *p
++ = &lineno_cache
[i
];
4423 BFD_ASSERT ((unsigned int) (p
- func_table
) == nbr_func
);
4425 /* Sort by functions. */
4426 qsort (func_table
, nbr_func
, sizeof (alent
*), coff_sort_func_alent
);
4428 /* Create the new sorted table. */
4429 if (_bfd_mul_overflow (asect
->lineno_count
, sizeof (alent
), &amt
))
4431 bfd_set_error (bfd_error_file_too_big
);
4434 else if ((n_lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
)) != NULL
)
4436 alent
*n_cache_ptr
= n_lineno_cache
;
4438 for (i
= 0; i
< nbr_func
; i
++)
4440 coff_symbol_type
*sym
;
4441 alent
*old_ptr
= func_table
[i
];
4443 /* Update the function entry. */
4444 sym
= (coff_symbol_type
*) old_ptr
->u
.sym
;
4445 /* PR binutils/17512: Point the lineno to where
4446 this entry will be after the memcpy below. */
4447 sym
->lineno
= lineno_cache
+ (n_cache_ptr
- n_lineno_cache
);
4448 /* Copy the function and line number entries. */
4450 *n_cache_ptr
++ = *old_ptr
++;
4451 while (old_ptr
->line_number
!= 0);
4454 memcpy (lineno_cache
, n_lineno_cache
,
4455 asect
->lineno_count
* sizeof (alent
));
4459 bfd_release (abfd
, func_table
);
4468 /* Slurp in the symbol table, converting it to generic form. Note
4469 that if coff_relocate_section is defined, the linker will read
4470 symbols via coff_link_add_symbols, rather than via this routine. */
4473 coff_slurp_symbol_table (bfd
* abfd
)
4475 combined_entry_type
*native_symbols
;
4476 coff_symbol_type
*cached_area
;
4477 unsigned int *table_ptr
;
4478 unsigned int number_of_symbols
= 0;
4479 bfd_boolean ret
= TRUE
;
4482 if (obj_symbols (abfd
))
4485 /* Read in the symbol table. */
4486 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4489 /* Allocate enough room for all the symbols in cached form. */
4490 if (_bfd_mul_overflow (obj_raw_syment_count (abfd
),
4491 sizeof (*cached_area
), &amt
))
4493 bfd_set_error (bfd_error_file_too_big
);
4496 cached_area
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
4497 if (cached_area
== NULL
)
4500 if (_bfd_mul_overflow (obj_raw_syment_count (abfd
),
4501 sizeof (*table_ptr
), &amt
))
4503 bfd_set_error (bfd_error_file_too_big
);
4506 table_ptr
= (unsigned int *) bfd_zalloc (abfd
, amt
);
4507 if (table_ptr
== NULL
)
4511 coff_symbol_type
*dst
= cached_area
;
4512 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4513 unsigned int this_index
= 0;
4515 while (this_index
< last_native_index
)
4517 combined_entry_type
*src
= native_symbols
+ this_index
;
4518 table_ptr
[this_index
] = number_of_symbols
;
4520 dst
->symbol
.the_bfd
= abfd
;
4521 BFD_ASSERT (src
->is_sym
);
4522 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4523 /* We use the native name field to point to the cached field. */
4524 src
->u
.syment
._n
._n_n
._n_zeroes
= (bfd_hostptr_t
) dst
;
4525 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4526 src
->u
.syment
.n_scnum
);
4527 dst
->symbol
.flags
= 0;
4528 /* PR 17512: file: 079-7098-0.001:0.1. */
4529 dst
->symbol
.value
= 0;
4530 dst
->done_lineno
= FALSE
;
4532 switch (src
->u
.syment
.n_sclass
)
4538 case C_THUMBEXTFUNC
:
4542 #if ! defined _AIX52 && ! defined AIX_WEAK_SUPPORT
4547 case C_SYSTEM
: /* System Wide variable. */
4550 /* In PE, 0x68 (104) denotes a section symbol. */
4552 /* In PE, 0x69 (105) denotes a weak external symbol. */
4555 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4557 case COFF_SYMBOL_GLOBAL
:
4558 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4559 #if defined COFF_WITH_PE
4560 /* PE sets the symbol to a value relative to the
4561 start of the section. */
4562 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4564 dst
->symbol
.value
= (src
->u
.syment
.n_value
4565 - dst
->symbol
.section
->vma
);
4567 if (ISFCN ((src
->u
.syment
.n_type
)))
4568 /* A function ext does not go at the end of a
4570 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4573 case COFF_SYMBOL_COMMON
:
4574 dst
->symbol
.section
= bfd_com_section_ptr
;
4575 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4578 case COFF_SYMBOL_UNDEFINED
:
4579 dst
->symbol
.section
= bfd_und_section_ptr
;
4580 dst
->symbol
.value
= 0;
4583 case COFF_SYMBOL_PE_SECTION
:
4584 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4585 dst
->symbol
.value
= 0;
4588 case COFF_SYMBOL_LOCAL
:
4589 dst
->symbol
.flags
= BSF_LOCAL
;
4590 #if defined COFF_WITH_PE
4591 /* PE sets the symbol to a value relative to the
4592 start of the section. */
4593 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4595 dst
->symbol
.value
= (src
->u
.syment
.n_value
4596 - dst
->symbol
.section
->vma
);
4598 if (ISFCN ((src
->u
.syment
.n_type
)))
4599 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4604 /* A symbol with a csect entry should not go at the end. */
4605 if (src
->u
.syment
.n_numaux
> 0)
4606 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4610 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4611 dst
->symbol
.flags
|= BSF_WEAK
;
4613 if (src
->u
.syment
.n_sclass
== C_SECTION
4614 && src
->u
.syment
.n_scnum
> 0)
4615 dst
->symbol
.flags
= BSF_LOCAL
;
4617 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
4619 || src
->u
.syment
.n_sclass
== C_AIX_WEAKEXT
4622 dst
->symbol
.flags
|= BSF_WEAK
;
4626 case C_STAT
: /* Static. */
4628 case C_THUMBSTAT
: /* Thumb static. */
4629 case C_THUMBLABEL
: /* Thumb label. */
4630 case C_THUMBSTATFUNC
:/* Thumb static function. */
4633 case C_DWARF
: /* A label in a dwarf section. */
4634 case C_INFO
: /* A label in a comment section. */
4636 case C_LABEL
: /* Label. */
4637 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4638 dst
->symbol
.flags
= BSF_DEBUGGING
;
4640 dst
->symbol
.flags
= BSF_LOCAL
;
4642 /* Base the value as an index from the base of the
4643 section, if there is one. */
4644 if (dst
->symbol
.section
)
4646 #if defined COFF_WITH_PE
4647 /* PE sets the symbol to a value relative to the
4648 start of the section. */
4649 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4651 dst
->symbol
.value
= (src
->u
.syment
.n_value
4652 - dst
->symbol
.section
->vma
);
4656 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4659 case C_MOS
: /* Member of structure. */
4660 case C_EOS
: /* End of structure. */
4661 case C_REGPARM
: /* Register parameter. */
4662 case C_REG
: /* register variable. */
4663 /* C_AUTOARG conflicts with TI COFF C_UEXT. */
4664 case C_TPDEF
: /* Type definition. */
4666 case C_AUTO
: /* Automatic variable. */
4667 case C_FIELD
: /* Bit field. */
4668 case C_ENTAG
: /* Enumeration tag. */
4669 case C_MOE
: /* Member of enumeration. */
4670 case C_MOU
: /* Member of union. */
4671 case C_UNTAG
: /* Union tag. */
4672 dst
->symbol
.flags
= BSF_DEBUGGING
;
4673 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4676 case C_FILE
: /* File name. */
4677 case C_STRTAG
: /* Structure tag. */
4694 dst
->symbol
.flags
= BSF_DEBUGGING
;
4695 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4699 case C_BINCL
: /* Beginning of include file. */
4700 case C_EINCL
: /* Ending of include file. */
4701 /* The value is actually a pointer into the line numbers
4702 of the file. We locate the line number entry, and
4703 set the section to the section which contains it, and
4704 the value to the index in that section. */
4708 dst
->symbol
.flags
= BSF_DEBUGGING
;
4709 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4710 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4711 && ((file_ptr
) (sec
->line_filepos
4712 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4713 > (file_ptr
) src
->u
.syment
.n_value
))
4716 dst
->symbol
.value
= 0;
4719 dst
->symbol
.section
= sec
;
4720 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4721 - sec
->line_filepos
)
4722 / bfd_coff_linesz (abfd
));
4729 dst
->symbol
.flags
= BSF_DEBUGGING
;
4731 /* The value is actually a symbol index. Save a pointer
4732 to the symbol instead of the index. FIXME: This
4733 should use a union. */
4734 src
->u
.syment
.n_value
=
4735 (long) (intptr_t) (native_symbols
+ src
->u
.syment
.n_value
);
4736 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4741 case C_BLOCK
: /* ".bb" or ".eb". */
4742 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf"). */
4743 case C_EFCN
: /* Physical end of function. */
4744 #if defined COFF_WITH_PE
4745 /* PE sets the symbol to a value relative to the start
4747 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4748 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4750 /* PE uses funny values for .ef and .lf; don't
4752 dst
->symbol
.flags
= BSF_DEBUGGING
;
4755 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4757 /* Base the value as an index from the base of the
4759 dst
->symbol
.flags
= BSF_LOCAL
;
4760 dst
->symbol
.value
= (src
->u
.syment
.n_value
4761 - dst
->symbol
.section
->vma
);
4765 case C_STATLAB
: /* Static load time label. */
4766 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4767 dst
->symbol
.flags
= BSF_GLOBAL
;
4771 /* PE DLLs sometimes have zeroed out symbols for some
4772 reason. Just ignore them without a warning. */
4773 if (src
->u
.syment
.n_type
== 0
4774 && src
->u
.syment
.n_value
== 0
4775 && src
->u
.syment
.n_scnum
== 0)
4778 /* XCOFF specific: deleted entry. */
4779 if (src
->u
.syment
.n_value
== C_NULL_VALUE
)
4783 case C_EXTDEF
: /* External definition. */
4784 case C_ULABEL
: /* Undefined label. */
4785 case C_USTATIC
: /* Undefined static. */
4786 #ifndef COFF_WITH_PE
4787 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4788 class to represent a section symbol. */
4789 case C_LINE
: /* line # reformatted as symbol table entry. */
4790 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4791 case C_ALIAS
: /* Duplicate tag. */
4793 /* New storage classes for TI COFF. */
4795 case C_UEXT
: /* Tentative external definition. */
4797 case C_EXTLAB
: /* External load time label. */
4800 /* xgettext:c-format */
4801 (_("%pB: unrecognized storage class %d for %s symbol `%s'"),
4802 abfd
, src
->u
.syment
.n_sclass
,
4803 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4806 case C_HIDDEN
: /* Ext symbol in dmert public lib. */
4807 /* PR 20722: These symbols can also be generated by
4808 building DLLs with --gc-sections enabled. */
4809 dst
->symbol
.flags
= BSF_DEBUGGING
;
4810 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4815 dst
->symbol
.udata
.i
= 0;
4818 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
4820 number_of_symbols
++;
4824 obj_symbols (abfd
) = cached_area
;
4825 obj_raw_syments (abfd
) = native_symbols
;
4827 abfd
->symcount
= number_of_symbols
;
4828 obj_convert (abfd
) = table_ptr
;
4829 /* Slurp the line tables for each section too. */
4836 if (! coff_slurp_line_table (abfd
, p
))
4845 /* Classify a COFF symbol. A couple of targets have globally visible
4846 symbols which are not class C_EXT, and this handles those. It also
4847 recognizes some special PE cases. */
4849 static enum coff_symbol_classification
4850 coff_classify_symbol (bfd
*abfd
,
4851 struct internal_syment
*syment
)
4853 /* FIXME: This partially duplicates the switch in
4854 coff_slurp_symbol_table. */
4855 switch (syment
->n_sclass
)
4861 case C_THUMBEXTFUNC
:
4869 if (syment
->n_scnum
== 0)
4871 if (syment
->n_value
== 0)
4872 return COFF_SYMBOL_UNDEFINED
;
4874 return COFF_SYMBOL_COMMON
;
4876 return COFF_SYMBOL_GLOBAL
;
4883 if (syment
->n_sclass
== C_STAT
)
4885 if (syment
->n_scnum
== 0)
4886 /* The Microsoft compiler sometimes generates these if a
4887 small static function is inlined every time it is used.
4888 The function is discarded, but the symbol table entry
4890 return COFF_SYMBOL_LOCAL
;
4892 #ifdef STRICT_PE_FORMAT
4893 /* This is correct for Microsoft generated objects, but it
4894 breaks gas generated objects. */
4895 if (syment
->n_value
== 0)
4899 char buf
[SYMNMLEN
+ 1];
4901 name
= _bfd_coff_internal_syment_name (abfd
, syment
, buf
)
4902 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
4903 if (sec
!= NULL
&& name
!= NULL
4904 && (strcmp (bfd_section_name (sec
), name
) == 0))
4905 return COFF_SYMBOL_PE_SECTION
;
4909 return COFF_SYMBOL_LOCAL
;
4912 if (syment
->n_sclass
== C_SECTION
)
4914 /* In some cases in a DLL generated by the Microsoft linker, the
4915 n_value field will contain garbage. FIXME: This should
4916 probably be handled by the swapping function instead. */
4917 syment
->n_value
= 0;
4918 if (syment
->n_scnum
== 0)
4919 return COFF_SYMBOL_UNDEFINED
;
4920 return COFF_SYMBOL_PE_SECTION
;
4922 #endif /* COFF_WITH_PE */
4924 /* If it is not a global symbol, we presume it is a local symbol. */
4925 if (syment
->n_scnum
== 0)
4927 char buf
[SYMNMLEN
+ 1];
4930 /* xgettext:c-format */
4931 (_("warning: %pB: local symbol `%s' has no section"),
4932 abfd
, _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
4935 return COFF_SYMBOL_LOCAL
;
4942 Coff relocations are easily transformed into the internal BFD form
4945 Reading a coff relocation table is done in the following stages:
4947 o Read the entire coff relocation table into memory.
4949 o Process each relocation in turn; first swap it from the
4950 external to the internal form.
4952 o Turn the symbol referenced in the relocation's symbol index
4953 into a pointer into the canonical symbol table.
4954 This table is the same as the one returned by a call to
4955 @code{bfd_canonicalize_symtab}. The back end will call that
4956 routine and save the result if a canonicalization hasn't been done.
4958 o The reloc index is turned into a pointer to a howto
4959 structure, in a back end specific way. For instance, the 386
4960 uses the @code{r_type} to directly produce an index
4961 into a howto table vector.
4965 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
4967 coff_symbol_type *coffsym = NULL; \
4969 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
4970 coffsym = (obj_symbols (abfd) \
4971 + (cache_ptr->sym_ptr_ptr - symbols)); \
4973 coffsym = coff_symbol_from (ptr); \
4974 if (coffsym != NULL \
4975 && coffsym->native->is_sym \
4976 && coffsym->native->u.syment.n_scnum == 0) \
4977 cache_ptr->addend = 0; \
4978 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
4979 && ptr->section != NULL) \
4980 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
4982 cache_ptr->addend = 0; \
4987 coff_slurp_reloc_table (bfd
* abfd
, sec_ptr asect
, asymbol
** symbols
)
4989 RELOC
*native_relocs
;
4990 arelent
*reloc_cache
;
4995 if (asect
->relocation
)
4997 if (asect
->reloc_count
== 0)
4999 if (asect
->flags
& SEC_CONSTRUCTOR
)
5001 if (!coff_slurp_symbol_table (abfd
))
5004 native_relocs
= (RELOC
*) buy_and_read (abfd
, asect
->rel_filepos
,
5006 bfd_coff_relsz (abfd
));
5007 if (_bfd_mul_overflow (asect
->reloc_count
, sizeof (arelent
), &amt
))
5009 bfd_set_error (bfd_error_file_too_big
);
5012 reloc_cache
= (arelent
*) bfd_alloc (abfd
, amt
);
5013 if (reloc_cache
== NULL
|| native_relocs
== NULL
)
5016 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
5018 struct internal_reloc dst
;
5019 struct external_reloc
*src
;
5020 #ifndef RELOC_PROCESSING
5024 cache_ptr
= reloc_cache
+ idx
;
5025 src
= native_relocs
+ idx
;
5028 coff_swap_reloc_in (abfd
, src
, &dst
);
5030 #ifdef RELOC_PROCESSING
5031 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
5033 cache_ptr
->address
= dst
.r_vaddr
;
5035 if (dst
.r_symndx
!= -1 && symbols
!= NULL
)
5037 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
5040 /* xgettext:c-format */
5041 (_("%pB: warning: illegal symbol index %ld in relocs"),
5042 abfd
, dst
.r_symndx
);
5043 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5048 cache_ptr
->sym_ptr_ptr
= (symbols
5049 + obj_convert (abfd
)[dst
.r_symndx
]);
5050 ptr
= *(cache_ptr
->sym_ptr_ptr
);
5055 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5059 /* The symbols definitions that we have read in have been
5060 relocated as if their sections started at 0. But the offsets
5061 refering to the symbols in the raw data have not been
5062 modified, so we have to have a negative addend to compensate.
5064 Note that symbols which used to be common must be left alone. */
5066 /* Calculate any reloc addend by looking at the symbol. */
5067 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
5070 cache_ptr
->address
-= asect
->vma
;
5071 /* !! cache_ptr->section = NULL;*/
5073 /* Fill in the cache_ptr->howto field from dst.r_type. */
5074 RTYPE2HOWTO (cache_ptr
, &dst
);
5075 #endif /* RELOC_PROCESSING */
5077 if (cache_ptr
->howto
== NULL
)
5080 /* xgettext:c-format */
5081 (_("%pB: illegal relocation type %d at address %#" PRIx64
),
5082 abfd
, dst
.r_type
, (uint64_t) dst
.r_vaddr
);
5083 bfd_set_error (bfd_error_bad_value
);
5088 asect
->relocation
= reloc_cache
;
5092 #ifndef coff_rtype_to_howto
5095 /* Get the howto structure for a reloc. This is only used if the file
5096 including this one defines coff_relocate_section to be
5097 _bfd_coff_generic_relocate_section, so it is OK if it does not
5098 always work. It is the responsibility of the including file to
5099 make sure it is reasonable if it is needed. */
5101 static reloc_howto_type
*
5102 coff_rtype_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
5103 asection
*sec ATTRIBUTE_UNUSED
,
5104 struct internal_reloc
*rel ATTRIBUTE_UNUSED
,
5105 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
,
5106 struct internal_syment
*sym ATTRIBUTE_UNUSED
,
5107 bfd_vma
*addendp ATTRIBUTE_UNUSED
)
5111 genrel
.howto
= NULL
;
5112 RTYPE2HOWTO (&genrel
, rel
);
5113 return genrel
.howto
;
5116 #else /* ! defined (RTYPE2HOWTO) */
5118 #define coff_rtype_to_howto NULL
5120 #endif /* ! defined (RTYPE2HOWTO) */
5121 #endif /* ! defined (coff_rtype_to_howto) */
5123 /* This is stupid. This function should be a boolean predicate. */
5126 coff_canonicalize_reloc (bfd
* abfd
,
5131 arelent
*tblptr
= section
->relocation
;
5132 unsigned int count
= 0;
5134 if (section
->flags
& SEC_CONSTRUCTOR
)
5136 /* This section has relocs made up by us, they are not in the
5137 file, so take them out of their chain and place them into
5138 the data area provided. */
5139 arelent_chain
*chain
= section
->constructor_chain
;
5141 for (count
= 0; count
< section
->reloc_count
; count
++)
5143 *relptr
++ = &chain
->relent
;
5144 chain
= chain
->next
;
5149 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
5152 tblptr
= section
->relocation
;
5154 for (; count
++ < section
->reloc_count
;)
5155 *relptr
++ = tblptr
++;
5158 return section
->reloc_count
;
5161 #ifndef coff_set_reloc
5162 #define coff_set_reloc _bfd_generic_set_reloc
5165 #ifndef coff_reloc16_estimate
5166 #define coff_reloc16_estimate dummy_reloc16_estimate
5169 dummy_reloc16_estimate (bfd
*abfd ATTRIBUTE_UNUSED
,
5170 asection
*input_section ATTRIBUTE_UNUSED
,
5171 arelent
*reloc ATTRIBUTE_UNUSED
,
5172 unsigned int shrink ATTRIBUTE_UNUSED
,
5173 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
)
5181 #ifndef coff_reloc16_extra_cases
5183 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5185 /* This works even if abort is not declared in any header file. */
5188 dummy_reloc16_extra_cases (bfd
*abfd ATTRIBUTE_UNUSED
,
5189 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
5190 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
,
5191 arelent
*reloc ATTRIBUTE_UNUSED
,
5192 bfd_byte
*data ATTRIBUTE_UNUSED
,
5193 unsigned int *src_ptr ATTRIBUTE_UNUSED
,
5194 unsigned int *dst_ptr ATTRIBUTE_UNUSED
)
5200 /* If coff_relocate_section is defined, we can use the optimized COFF
5201 backend linker. Otherwise we must continue to use the old linker. */
5203 #ifdef coff_relocate_section
5205 #ifndef coff_bfd_link_hash_table_create
5206 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5208 #ifndef coff_bfd_link_add_symbols
5209 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5211 #ifndef coff_bfd_final_link
5212 #define coff_bfd_final_link _bfd_coff_final_link
5215 #else /* ! defined (coff_relocate_section) */
5217 #define coff_relocate_section NULL
5218 #ifndef coff_bfd_link_hash_table_create
5219 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5221 #ifndef coff_bfd_link_add_symbols
5222 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5224 #define coff_bfd_final_link _bfd_generic_final_link
5226 #endif /* ! defined (coff_relocate_section) */
5228 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5229 #define coff_bfd_copy_link_hash_symbol_type \
5230 _bfd_generic_copy_link_hash_symbol_type
5231 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5233 #define coff_bfd_link_check_relocs _bfd_generic_link_check_relocs
5235 #ifndef coff_start_final_link
5236 #define coff_start_final_link NULL
5239 #ifndef coff_adjust_symndx
5240 #define coff_adjust_symndx NULL
5243 #ifndef coff_link_add_one_symbol
5244 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5247 #ifndef coff_link_output_has_begun
5250 coff_link_output_has_begun (bfd
* abfd
,
5251 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
)
5253 return abfd
->output_has_begun
;
5257 #ifndef coff_final_link_postscript
5260 coff_final_link_postscript (bfd
* abfd ATTRIBUTE_UNUSED
,
5261 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
)
5267 #ifndef coff_SWAP_aux_in
5268 #define coff_SWAP_aux_in coff_swap_aux_in
5270 #ifndef coff_SWAP_sym_in
5271 #define coff_SWAP_sym_in coff_swap_sym_in
5273 #ifndef coff_SWAP_lineno_in
5274 #define coff_SWAP_lineno_in coff_swap_lineno_in
5276 #ifndef coff_SWAP_aux_out
5277 #define coff_SWAP_aux_out coff_swap_aux_out
5279 #ifndef coff_SWAP_sym_out
5280 #define coff_SWAP_sym_out coff_swap_sym_out
5282 #ifndef coff_SWAP_lineno_out
5283 #define coff_SWAP_lineno_out coff_swap_lineno_out
5285 #ifndef coff_SWAP_reloc_out
5286 #define coff_SWAP_reloc_out coff_swap_reloc_out
5288 #ifndef coff_SWAP_filehdr_out
5289 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5291 #ifndef coff_SWAP_aouthdr_out
5292 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5294 #ifndef coff_SWAP_scnhdr_out
5295 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5297 #ifndef coff_SWAP_reloc_in
5298 #define coff_SWAP_reloc_in coff_swap_reloc_in
5300 #ifndef coff_SWAP_filehdr_in
5301 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5303 #ifndef coff_SWAP_aouthdr_in
5304 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5306 #ifndef coff_SWAP_scnhdr_in
5307 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5310 static bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED
=
5312 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5313 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5314 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5315 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5316 coff_SWAP_scnhdr_out
,
5317 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5318 #ifdef COFF_LONG_FILENAMES
5323 COFF_DEFAULT_LONG_SECTION_NAMES
,
5324 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5325 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5330 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5336 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5337 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5338 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5339 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5340 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5341 coff_classify_symbol
, coff_compute_section_file_positions
,
5342 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5343 coff_adjust_symndx
, coff_link_add_one_symbol
,
5344 coff_link_output_has_begun
, coff_final_link_postscript
,
5349 /* COFF0 differs in file/section header size and relocation entry size. */
5351 static bfd_coff_backend_data ticoff0_swap_table
=
5353 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5354 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5355 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5356 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5357 coff_SWAP_scnhdr_out
,
5358 FILHSZ_V0
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ_V0
, LINESZ
, FILNMLEN
,
5359 #ifdef COFF_LONG_FILENAMES
5364 COFF_DEFAULT_LONG_SECTION_NAMES
,
5365 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5366 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5371 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5377 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5378 coff_SWAP_reloc_in
, ticoff0_bad_format_hook
, coff_set_arch_mach_hook
,
5379 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5380 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5381 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5382 coff_classify_symbol
, coff_compute_section_file_positions
,
5383 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5384 coff_adjust_symndx
, coff_link_add_one_symbol
,
5385 coff_link_output_has_begun
, coff_final_link_postscript
,
5391 /* COFF1 differs in section header size. */
5393 static bfd_coff_backend_data ticoff1_swap_table
=
5395 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5396 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5397 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5398 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5399 coff_SWAP_scnhdr_out
,
5400 FILHSZ
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5401 #ifdef COFF_LONG_FILENAMES
5406 COFF_DEFAULT_LONG_SECTION_NAMES
,
5407 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5408 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5413 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5419 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5420 coff_SWAP_reloc_in
, ticoff1_bad_format_hook
, coff_set_arch_mach_hook
,
5421 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5422 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5423 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5424 coff_classify_symbol
, coff_compute_section_file_positions
,
5425 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5426 coff_adjust_symndx
, coff_link_add_one_symbol
,
5427 coff_link_output_has_begun
, coff_final_link_postscript
,
5428 bfd_pe_print_pdata
/* huh */
5432 #ifdef COFF_WITH_PE_BIGOBJ
5433 /* The UID for bigobj files. */
5435 static const char header_bigobj_classid
[16] =
5437 0xC7, 0xA1, 0xBA, 0xD1,
5441 0xFA, 0xF6, 0x6A, 0xA4, 0xDC, 0xB8
5444 /* Swap routines. */
5447 coff_bigobj_swap_filehdr_in (bfd
* abfd
, void * src
, void * dst
)
5449 struct external_ANON_OBJECT_HEADER_BIGOBJ
*filehdr_src
=
5450 (struct external_ANON_OBJECT_HEADER_BIGOBJ
*) src
;
5451 struct internal_filehdr
*filehdr_dst
= (struct internal_filehdr
*) dst
;
5453 filehdr_dst
->f_magic
= H_GET_16 (abfd
, filehdr_src
->Machine
);
5454 filehdr_dst
->f_nscns
= H_GET_32 (abfd
, filehdr_src
->NumberOfSections
);
5455 filehdr_dst
->f_timdat
= H_GET_32 (abfd
, filehdr_src
->TimeDateStamp
);
5456 filehdr_dst
->f_symptr
=
5457 GET_FILEHDR_SYMPTR (abfd
, filehdr_src
->PointerToSymbolTable
);
5458 filehdr_dst
->f_nsyms
= H_GET_32 (abfd
, filehdr_src
->NumberOfSymbols
);
5459 filehdr_dst
->f_opthdr
= 0;
5460 filehdr_dst
->f_flags
= 0;
5462 /* Check other magic numbers. */
5463 if (H_GET_16 (abfd
, filehdr_src
->Sig1
) != IMAGE_FILE_MACHINE_UNKNOWN
5464 || H_GET_16 (abfd
, filehdr_src
->Sig2
) != 0xffff
5465 || H_GET_16 (abfd
, filehdr_src
->Version
) != 2
5466 || memcmp (filehdr_src
->ClassID
, header_bigobj_classid
, 16) != 0)
5467 filehdr_dst
->f_opthdr
= 0xffff;
5469 /* Note that CLR metadata are ignored. */
5473 coff_bigobj_swap_filehdr_out (bfd
*abfd
, void * in
, void * out
)
5475 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
5476 struct external_ANON_OBJECT_HEADER_BIGOBJ
*filehdr_out
=
5477 (struct external_ANON_OBJECT_HEADER_BIGOBJ
*) out
;
5479 memset (filehdr_out
, 0, sizeof (*filehdr_out
));
5481 H_PUT_16 (abfd
, IMAGE_FILE_MACHINE_UNKNOWN
, filehdr_out
->Sig1
);
5482 H_PUT_16 (abfd
, 0xffff, filehdr_out
->Sig2
);
5483 H_PUT_16 (abfd
, 2, filehdr_out
->Version
);
5484 memcpy (filehdr_out
->ClassID
, header_bigobj_classid
, 16);
5485 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->Machine
);
5486 H_PUT_32 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->NumberOfSections
);
5487 H_PUT_32 (abfd
, filehdr_in
->f_timdat
, filehdr_out
->TimeDateStamp
);
5488 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
,
5489 filehdr_out
->PointerToSymbolTable
);
5490 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->NumberOfSymbols
);
5492 return bfd_coff_filhsz (abfd
);
5496 coff_bigobj_swap_sym_in (bfd
* abfd
, void * ext1
, void * in1
)
5498 SYMENT_BIGOBJ
*ext
= (SYMENT_BIGOBJ
*) ext1
;
5499 struct internal_syment
*in
= (struct internal_syment
*) in1
;
5501 if (ext
->e
.e_name
[0] == 0)
5503 in
->_n
._n_n
._n_zeroes
= 0;
5504 in
->_n
._n_n
._n_offset
= H_GET_32 (abfd
, ext
->e
.e
.e_offset
);
5508 #if SYMNMLEN != E_SYMNMLEN
5509 #error we need to cope with truncating or extending SYMNMLEN
5511 memcpy (in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
5515 in
->n_value
= H_GET_32 (abfd
, ext
->e_value
);
5516 BFD_ASSERT (sizeof (in
->n_scnum
) >= 4);
5517 in
->n_scnum
= H_GET_32 (abfd
, ext
->e_scnum
);
5518 in
->n_type
= H_GET_16 (abfd
, ext
->e_type
);
5519 in
->n_sclass
= H_GET_8 (abfd
, ext
->e_sclass
);
5520 in
->n_numaux
= H_GET_8 (abfd
, ext
->e_numaux
);
5524 coff_bigobj_swap_sym_out (bfd
* abfd
, void * inp
, void * extp
)
5526 struct internal_syment
*in
= (struct internal_syment
*) inp
;
5527 SYMENT_BIGOBJ
*ext
= (SYMENT_BIGOBJ
*) extp
;
5529 if (in
->_n
._n_name
[0] == 0)
5531 H_PUT_32 (abfd
, 0, ext
->e
.e
.e_zeroes
);
5532 H_PUT_32 (abfd
, in
->_n
._n_n
._n_offset
, ext
->e
.e
.e_offset
);
5536 #if SYMNMLEN != E_SYMNMLEN
5537 #error we need to cope with truncating or extending SYMNMLEN
5539 memcpy (ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
5543 H_PUT_32 (abfd
, in
->n_value
, ext
->e_value
);
5544 H_PUT_32 (abfd
, in
->n_scnum
, ext
->e_scnum
);
5546 H_PUT_16 (abfd
, in
->n_type
, ext
->e_type
);
5547 H_PUT_8 (abfd
, in
->n_sclass
, ext
->e_sclass
);
5548 H_PUT_8 (abfd
, in
->n_numaux
, ext
->e_numaux
);
5550 return SYMESZ_BIGOBJ
;
5554 coff_bigobj_swap_aux_in (bfd
*abfd
,
5562 AUXENT_BIGOBJ
*ext
= (AUXENT_BIGOBJ
*) ext1
;
5563 union internal_auxent
*in
= (union internal_auxent
*) in1
;
5565 /* Make sure that all fields in the aux structure are
5567 memset (in
, 0, sizeof * in
);
5574 memcpy (in
->x_file
.x_fname
, ext
->File
.Name
,
5575 numaux
* sizeof (AUXENT_BIGOBJ
));
5578 memcpy (in
->x_file
.x_fname
, ext
->File
.Name
, sizeof (ext
->File
.Name
));
5586 in
->x_scn
.x_scnlen
= H_GET_32 (abfd
, ext
->Section
.Length
);
5587 in
->x_scn
.x_nreloc
=
5588 H_GET_16 (abfd
, ext
->Section
.NumberOfRelocations
);
5589 in
->x_scn
.x_nlinno
=
5590 H_GET_16 (abfd
, ext
->Section
.NumberOfLinenumbers
);
5591 in
->x_scn
.x_checksum
= H_GET_32 (abfd
, ext
->Section
.Checksum
);
5592 in
->x_scn
.x_associated
= H_GET_16 (abfd
, ext
->Section
.Number
)
5593 | (H_GET_16 (abfd
, ext
->Section
.HighNumber
) << 16);
5594 in
->x_scn
.x_comdat
= H_GET_8 (abfd
, ext
->Section
.Selection
);
5600 in
->x_sym
.x_tagndx
.l
= H_GET_32 (abfd
, ext
->Sym
.WeakDefaultSymIndex
);
5601 /* Characteristics is ignored. */
5607 coff_bigobj_swap_aux_out (bfd
* abfd
,
5611 int indx ATTRIBUTE_UNUSED
,
5612 int numaux ATTRIBUTE_UNUSED
,
5615 union internal_auxent
* in
= (union internal_auxent
*) inp
;
5616 AUXENT_BIGOBJ
*ext
= (AUXENT_BIGOBJ
*) extp
;
5618 memset (ext
, 0, AUXESZ
);
5623 memcpy (ext
->File
.Name
, in
->x_file
.x_fname
, sizeof (ext
->File
.Name
));
5632 H_PUT_32 (abfd
, in
->x_scn
.x_scnlen
, ext
->Section
.Length
);
5633 H_PUT_16 (abfd
, in
->x_scn
.x_nreloc
,
5634 ext
->Section
.NumberOfRelocations
);
5635 H_PUT_16 (abfd
, in
->x_scn
.x_nlinno
,
5636 ext
->Section
.NumberOfLinenumbers
);
5637 H_PUT_32 (abfd
, in
->x_scn
.x_checksum
, ext
->Section
.Checksum
);
5638 H_PUT_16 (abfd
, in
->x_scn
.x_associated
& 0xffff,
5639 ext
->Section
.Number
);
5640 H_PUT_16 (abfd
, (in
->x_scn
.x_associated
>> 16),
5641 ext
->Section
.HighNumber
);
5642 H_PUT_8 (abfd
, in
->x_scn
.x_comdat
, ext
->Section
.Selection
);
5648 H_PUT_32 (abfd
, in
->x_sym
.x_tagndx
.l
, ext
->Sym
.WeakDefaultSymIndex
);
5649 H_PUT_32 (abfd
, 1, ext
->Sym
.WeakSearchType
);
5654 static bfd_coff_backend_data bigobj_swap_table
=
5656 coff_bigobj_swap_aux_in
, coff_bigobj_swap_sym_in
, coff_SWAP_lineno_in
,
5657 coff_bigobj_swap_aux_out
, coff_bigobj_swap_sym_out
,
5658 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5659 coff_bigobj_swap_filehdr_out
, coff_SWAP_aouthdr_out
,
5660 coff_SWAP_scnhdr_out
,
5661 FILHSZ_BIGOBJ
, AOUTSZ
, SCNHSZ
, SYMESZ_BIGOBJ
, AUXESZ_BIGOBJ
,
5662 RELSZ
, LINESZ
, FILNMLEN_BIGOBJ
,
5664 COFF_DEFAULT_LONG_SECTION_NAMES
,
5665 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5669 coff_bigobj_swap_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5670 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5671 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5672 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5673 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5674 coff_classify_symbol
, coff_compute_section_file_positions
,
5675 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5676 coff_adjust_symndx
, coff_link_add_one_symbol
,
5677 coff_link_output_has_begun
, coff_final_link_postscript
,
5678 bfd_pe_print_pdata
/* huh */
5681 #endif /* COFF_WITH_PE_BIGOBJ */
5683 #ifndef coff_close_and_cleanup
5684 #define coff_close_and_cleanup _bfd_coff_close_and_cleanup
5687 #ifndef coff_bfd_free_cached_info
5688 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5691 #ifndef coff_get_section_contents
5692 #define coff_get_section_contents _bfd_generic_get_section_contents
5695 #ifndef coff_bfd_copy_private_symbol_data
5696 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5699 #ifndef coff_bfd_copy_private_header_data
5700 #define coff_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
5703 #ifndef coff_bfd_copy_private_section_data
5704 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5707 #ifndef coff_bfd_copy_private_bfd_data
5708 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5711 #ifndef coff_bfd_merge_private_bfd_data
5712 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5715 #ifndef coff_bfd_set_private_flags
5716 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5719 #ifndef coff_bfd_print_private_bfd_data
5720 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5723 #ifndef coff_bfd_is_local_label_name
5724 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5727 #ifndef coff_bfd_is_target_special_symbol
5728 #define coff_bfd_is_target_special_symbol _bfd_bool_bfd_asymbol_false
5731 #ifndef coff_read_minisymbols
5732 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5735 #ifndef coff_minisymbol_to_symbol
5736 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5739 /* The reloc lookup routine must be supplied by each individual COFF
5741 #ifndef coff_bfd_reloc_type_lookup
5742 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5744 #ifndef coff_bfd_reloc_name_lookup
5745 #define coff_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5748 #ifndef coff_bfd_get_relocated_section_contents
5749 #define coff_bfd_get_relocated_section_contents \
5750 bfd_generic_get_relocated_section_contents
5753 #ifndef coff_bfd_relax_section
5754 #define coff_bfd_relax_section bfd_generic_relax_section
5757 #ifndef coff_bfd_gc_sections
5758 #define coff_bfd_gc_sections bfd_coff_gc_sections
5761 #ifndef coff_bfd_lookup_section_flags
5762 #define coff_bfd_lookup_section_flags bfd_generic_lookup_section_flags
5765 #ifndef coff_bfd_merge_sections
5766 #define coff_bfd_merge_sections bfd_generic_merge_sections
5769 #ifndef coff_bfd_is_group_section
5770 #define coff_bfd_is_group_section bfd_generic_is_group_section
5773 #ifndef coff_bfd_group_name
5774 #define coff_bfd_group_name bfd_coff_group_name
5777 #ifndef coff_bfd_discard_group
5778 #define coff_bfd_discard_group bfd_generic_discard_group
5781 #ifndef coff_section_already_linked
5782 #define coff_section_already_linked \
5783 _bfd_coff_section_already_linked
5786 #ifndef coff_bfd_define_common_symbol
5787 #define coff_bfd_define_common_symbol bfd_generic_define_common_symbol
5790 #ifndef coff_bfd_link_hide_symbol
5791 #define coff_bfd_link_hide_symbol _bfd_generic_link_hide_symbol
5794 #ifndef coff_bfd_define_start_stop
5795 #define coff_bfd_define_start_stop bfd_generic_define_start_stop
5798 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5799 const bfd_target VAR = \
5802 bfd_target_coff_flavour, \
5803 BFD_ENDIAN_BIG, /* Data byte order is big. */ \
5804 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5805 /* object flags */ \
5806 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5807 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5808 /* section flags */ \
5809 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5810 UNDER, /* Leading symbol underscore. */ \
5811 '/', /* AR_pad_char. */ \
5812 15, /* AR_max_namelen. */ \
5813 0, /* match priority. */ \
5815 /* Data conversion functions. */ \
5816 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5817 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5818 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5820 /* Header conversion functions. */ \
5821 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5822 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5823 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5825 { /* bfd_check_format. */ \
5826 _bfd_dummy_target, \
5828 bfd_generic_archive_p, \
5831 { /* bfd_set_format. */ \
5832 _bfd_bool_bfd_false_error, \
5834 _bfd_generic_mkarchive, \
5835 _bfd_bool_bfd_false_error \
5837 { /* bfd_write_contents. */ \
5838 _bfd_bool_bfd_false_error, \
5839 coff_write_object_contents, \
5840 _bfd_write_archive_contents, \
5841 _bfd_bool_bfd_false_error \
5844 BFD_JUMP_TABLE_GENERIC (coff), \
5845 BFD_JUMP_TABLE_COPY (coff), \
5846 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5847 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5848 BFD_JUMP_TABLE_SYMBOLS (coff), \
5849 BFD_JUMP_TABLE_RELOCS (coff), \
5850 BFD_JUMP_TABLE_WRITE (coff), \
5851 BFD_JUMP_TABLE_LINK (coff), \
5852 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5859 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5860 const bfd_target VAR = \
5863 bfd_target_coff_flavour, \
5864 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5865 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5866 /* object flags */ \
5867 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5868 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5869 /* section flags */ \
5870 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5871 UNDER, /* Leading symbol underscore. */ \
5872 '/', /* AR_pad_char. */ \
5873 15, /* AR_max_namelen. */ \
5874 0, /* match priority. */ \
5876 /* Data conversion functions. */ \
5877 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5878 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5879 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5881 /* Header conversion functions. */ \
5882 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5883 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5884 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5886 { /* bfd_check_format. */ \
5887 _bfd_dummy_target, \
5889 bfd_generic_archive_p, \
5892 { /* bfd_set_format. */ \
5893 _bfd_bool_bfd_false_error, \
5895 _bfd_generic_mkarchive, \
5896 _bfd_bool_bfd_false_error \
5898 { /* bfd_write_contents. */ \
5899 _bfd_bool_bfd_false_error, \
5900 coff_write_object_contents, \
5901 _bfd_write_archive_contents, \
5902 _bfd_bool_bfd_false_error \
5905 BFD_JUMP_TABLE_GENERIC (coff), \
5906 BFD_JUMP_TABLE_COPY (coff), \
5907 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5908 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5909 BFD_JUMP_TABLE_SYMBOLS (coff), \
5910 BFD_JUMP_TABLE_RELOCS (coff), \
5911 BFD_JUMP_TABLE_WRITE (coff), \
5912 BFD_JUMP_TABLE_LINK (coff), \
5913 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5920 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5921 const bfd_target VAR = \
5924 bfd_target_coff_flavour, \
5925 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5926 BFD_ENDIAN_LITTLE, /* Header byte order is little. */ \
5927 /* object flags */ \
5928 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5929 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5930 /* section flags */ \
5931 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5932 UNDER, /* Leading symbol underscore. */ \
5933 '/', /* AR_pad_char. */ \
5934 15, /* AR_max_namelen. */ \
5935 0, /* match priority. */ \
5937 /* Data conversion functions. */ \
5938 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5939 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5940 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5941 /* Header conversion functions. */ \
5942 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5943 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5944 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5946 { /* bfd_check_format. */ \
5947 _bfd_dummy_target, \
5949 bfd_generic_archive_p, \
5952 { /* bfd_set_format. */ \
5953 _bfd_bool_bfd_false_error, \
5955 _bfd_generic_mkarchive, \
5956 _bfd_bool_bfd_false_error \
5958 { /* bfd_write_contents. */ \
5959 _bfd_bool_bfd_false_error, \
5960 coff_write_object_contents, \
5961 _bfd_write_archive_contents, \
5962 _bfd_bool_bfd_false_error \
5965 BFD_JUMP_TABLE_GENERIC (coff), \
5966 BFD_JUMP_TABLE_COPY (coff), \
5967 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5968 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5969 BFD_JUMP_TABLE_SYMBOLS (coff), \
5970 BFD_JUMP_TABLE_RELOCS (coff), \
5971 BFD_JUMP_TABLE_WRITE (coff), \
5972 BFD_JUMP_TABLE_LINK (coff), \
5973 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \