1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright (C) 1990-2018 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 void * buy_and_read
427 (bfd
*, file_ptr
, bfd_size_type
);
428 static bfd_boolean coff_slurp_line_table
430 static bfd_boolean coff_slurp_symbol_table
432 static enum coff_symbol_classification coff_classify_symbol
433 (bfd
*, struct internal_syment
*);
434 static bfd_boolean coff_slurp_reloc_table
435 (bfd
*, asection
*, asymbol
**);
436 static long coff_canonicalize_reloc
437 (bfd
*, asection
*, arelent
**, asymbol
**);
438 #ifndef coff_mkobject_hook
439 static void * coff_mkobject_hook
440 (bfd
*, void *, void *);
443 static flagword handle_COMDAT
444 (bfd
*, flagword
, void *, const char *, asection
*);
446 #ifdef COFF_IMAGE_WITH_PE
447 static bfd_boolean coff_read_word
448 (bfd
*, unsigned int *);
449 static unsigned int coff_compute_checksum
451 static bfd_boolean coff_apply_checksum
455 static bfd_boolean ticoff0_bad_format_hook
457 static bfd_boolean ticoff1_bad_format_hook
461 /* void warning(); */
463 #if defined (COFF_LONG_SECTION_NAMES)
465 bfd_coff_set_long_section_names_allowed (bfd
*abfd
, int enable
)
467 coff_backend_info (abfd
)->_bfd_coff_long_section_names
= enable
;
470 #else /* !defined (COFF_LONG_SECTION_NAMES) */
472 bfd_coff_set_long_section_names_disallowed (bfd
*abfd
, int enable
)
478 #endif /* defined (COFF_LONG_SECTION_NAMES) */
480 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
481 the incoming SEC_* flags. The inverse of this function is
482 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
483 should probably mirror the changes in styp_to_sec_flags(). */
487 /* Macros for setting debugging flags. */
490 #define STYP_XCOFF_DEBUG STYP_DEBUG
492 #define STYP_XCOFF_DEBUG STYP_INFO
495 #ifdef COFF_ALIGN_IN_S_FLAGS
496 #define STYP_DEBUG_INFO STYP_DSECT
498 #define STYP_DEBUG_INFO STYP_INFO
502 sec_to_styp_flags (const char *sec_name
, flagword sec_flags
)
506 if (!strcmp (sec_name
, _TEXT
))
508 styp_flags
= STYP_TEXT
;
510 else if (!strcmp (sec_name
, _DATA
))
512 styp_flags
= STYP_DATA
;
514 else if (!strcmp (sec_name
, _BSS
))
516 styp_flags
= STYP_BSS
;
519 else if (!strcmp (sec_name
, _COMMENT
))
521 styp_flags
= STYP_INFO
;
522 #endif /* _COMMENT */
525 else if (!strcmp (sec_name
, _LIB
))
527 styp_flags
= STYP_LIB
;
531 else if (!strcmp (sec_name
, _LIT
))
533 styp_flags
= STYP_LIT
;
536 else if (CONST_STRNEQ (sec_name
, DOT_DEBUG
)
537 || CONST_STRNEQ (sec_name
, DOT_ZDEBUG
))
539 /* Handle the XCOFF debug section and DWARF2 debug sections. */
541 styp_flags
= STYP_XCOFF_DEBUG
;
543 styp_flags
= STYP_DEBUG_INFO
;
545 else if (CONST_STRNEQ (sec_name
, ".stab"))
547 styp_flags
= STYP_DEBUG_INFO
;
549 #ifdef COFF_LONG_SECTION_NAMES
550 else if (CONST_STRNEQ (sec_name
, GNU_LINKONCE_WI
)
551 || CONST_STRNEQ (sec_name
, GNU_LINKONCE_WT
))
553 styp_flags
= STYP_DEBUG_INFO
;
557 else if (!strcmp (sec_name
, _PAD
))
559 styp_flags
= STYP_PAD
;
561 else if (!strcmp (sec_name
, _LOADER
))
563 styp_flags
= STYP_LOADER
;
565 else if (!strcmp (sec_name
, _EXCEPT
))
567 styp_flags
= STYP_EXCEPT
;
569 else if (!strcmp (sec_name
, _TYPCHK
))
571 styp_flags
= STYP_TYPCHK
;
573 else if (sec_flags
& SEC_DEBUGGING
)
577 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
578 if (!strcmp (sec_name
, xcoff_dwsect_names
[i
].name
))
580 styp_flags
= STYP_DWARF
| xcoff_dwsect_names
[i
].flag
;
585 /* Try and figure out what it should be */
586 else if (sec_flags
& SEC_CODE
)
588 styp_flags
= STYP_TEXT
;
590 else if (sec_flags
& SEC_DATA
)
592 styp_flags
= STYP_DATA
;
594 else if (sec_flags
& SEC_READONLY
)
596 #ifdef STYP_LIT /* 29k readonly text/data section */
597 styp_flags
= STYP_LIT
;
599 styp_flags
= STYP_TEXT
;
600 #endif /* STYP_LIT */
602 else if (sec_flags
& SEC_LOAD
)
604 styp_flags
= STYP_TEXT
;
606 else if (sec_flags
& SEC_ALLOC
)
608 styp_flags
= STYP_BSS
;
612 if (sec_flags
& SEC_TIC54X_CLINK
)
613 styp_flags
|= STYP_CLINK
;
617 if (sec_flags
& SEC_TIC54X_BLOCK
)
618 styp_flags
|= STYP_BLOCK
;
622 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
623 styp_flags
|= STYP_NOLOAD
;
629 #else /* COFF_WITH_PE */
631 /* The PE version; see above for the general comments. The non-PE
632 case seems to be more guessing, and breaks PE format; specifically,
633 .rdata is readonly, but it sure ain't text. Really, all this
634 should be set up properly in gas (or whatever assembler is in use),
635 and honor whatever objcopy/strip, etc. sent us as input. */
638 sec_to_styp_flags (const char *sec_name
, flagword sec_flags
)
641 bfd_boolean is_dbg
= FALSE
;
643 if (CONST_STRNEQ (sec_name
, DOT_DEBUG
)
644 || CONST_STRNEQ (sec_name
, DOT_ZDEBUG
)
645 #ifdef COFF_LONG_SECTION_NAMES
646 || CONST_STRNEQ (sec_name
, GNU_LINKONCE_WI
)
647 || CONST_STRNEQ (sec_name
, GNU_LINKONCE_WT
)
649 || CONST_STRNEQ (sec_name
, ".stab"))
652 /* caution: there are at least three groups of symbols that have
653 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
654 SEC_* are the BFD internal flags, used for generic BFD
655 information. STYP_* are the COFF section flags which appear in
656 COFF files. IMAGE_SCN_* are the PE section flags which appear in
657 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
658 but there are more IMAGE_SCN_* flags. */
660 /* FIXME: There is no gas syntax to specify the debug section flag. */
663 sec_flags
&= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
664 | SEC_LINK_DUPLICATES_SAME_CONTENTS
665 | SEC_LINK_DUPLICATES_SAME_SIZE
);
666 sec_flags
|= SEC_DEBUGGING
| SEC_READONLY
;
672 if ((sec_flags
& SEC_CODE
) != 0)
673 styp_flags
|= IMAGE_SCN_CNT_CODE
;
674 if ((sec_flags
& (SEC_DATA
| SEC_DEBUGGING
)) != 0)
675 styp_flags
|= IMAGE_SCN_CNT_INITIALIZED_DATA
;
676 if ((sec_flags
& SEC_ALLOC
) != 0 && (sec_flags
& SEC_LOAD
) == 0)
677 styp_flags
|= IMAGE_SCN_CNT_UNINITIALIZED_DATA
; /* ==STYP_BSS */
679 /* skip constRUCTOR */
681 if ((sec_flags
& SEC_IS_COMMON
) != 0)
682 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
683 if ((sec_flags
& SEC_DEBUGGING
) != 0)
684 styp_flags
|= IMAGE_SCN_MEM_DISCARDABLE
;
685 if ((sec_flags
& SEC_EXCLUDE
) != 0 && !is_dbg
)
686 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
687 if ((sec_flags
& SEC_NEVER_LOAD
) != 0 && !is_dbg
)
688 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
691 if (sec_flags
& SEC_LINK_ONCE
)
692 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
694 & (SEC_LINK_DUPLICATES_DISCARD
| SEC_LINK_DUPLICATES_SAME_CONTENTS
695 | SEC_LINK_DUPLICATES_SAME_SIZE
)) != 0)
696 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
698 /* skip LINKER_CREATED */
700 if ((sec_flags
& SEC_COFF_NOREAD
) == 0)
701 styp_flags
|= IMAGE_SCN_MEM_READ
; /* Invert NOREAD for read. */
702 if ((sec_flags
& SEC_READONLY
) == 0)
703 styp_flags
|= IMAGE_SCN_MEM_WRITE
; /* Invert READONLY for write. */
704 if (sec_flags
& SEC_CODE
)
705 styp_flags
|= IMAGE_SCN_MEM_EXECUTE
; /* CODE->EXECUTE. */
706 if (sec_flags
& SEC_COFF_SHARED
)
707 styp_flags
|= IMAGE_SCN_MEM_SHARED
; /* Shared remains meaningful. */
712 #endif /* COFF_WITH_PE */
714 /* Return a word with SEC_* flags set to represent the incoming STYP_*
715 flags (from scnhdr.s_flags). The inverse of this function is
716 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
717 should probably mirror the changes in sec_to_styp_flags(). */
722 styp_to_sec_flags (bfd
*abfd ATTRIBUTE_UNUSED
,
725 asection
*section ATTRIBUTE_UNUSED
,
728 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
729 long styp_flags
= internal_s
->s_flags
;
730 flagword sec_flags
= 0;
733 if (styp_flags
& STYP_BLOCK
)
734 sec_flags
|= SEC_TIC54X_BLOCK
;
738 if (styp_flags
& STYP_CLINK
)
739 sec_flags
|= SEC_TIC54X_CLINK
;
743 if (styp_flags
& STYP_NOLOAD
)
744 sec_flags
|= SEC_NEVER_LOAD
;
745 #endif /* STYP_NOLOAD */
747 /* For 386 COFF, at least, an unloadable text or data section is
748 actually a shared library section. */
749 if (styp_flags
& STYP_TEXT
)
751 if (sec_flags
& SEC_NEVER_LOAD
)
752 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
754 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
756 else if (styp_flags
& STYP_DATA
)
758 if (sec_flags
& SEC_NEVER_LOAD
)
759 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
761 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
763 else if (styp_flags
& STYP_BSS
)
765 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
766 if (sec_flags
& SEC_NEVER_LOAD
)
767 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
770 sec_flags
|= SEC_ALLOC
;
772 else if (styp_flags
& STYP_INFO
)
774 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
775 defined. coff_compute_section_file_positions uses
776 COFF_PAGE_SIZE to ensure that the low order bits of the
777 section VMA and the file offset match. If we don't know
778 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
779 and demand page loading of the file will fail. */
780 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
781 sec_flags
|= SEC_DEBUGGING
;
784 else if (styp_flags
& STYP_PAD
)
787 else if (styp_flags
& STYP_EXCEPT
)
788 sec_flags
|= SEC_LOAD
;
789 else if (styp_flags
& STYP_LOADER
)
790 sec_flags
|= SEC_LOAD
;
791 else if (styp_flags
& STYP_TYPCHK
)
792 sec_flags
|= SEC_LOAD
;
793 else if (styp_flags
& STYP_DWARF
)
794 sec_flags
|= SEC_DEBUGGING
;
796 else if (strcmp (name
, _TEXT
) == 0)
798 if (sec_flags
& SEC_NEVER_LOAD
)
799 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
801 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
803 else if (strcmp (name
, _DATA
) == 0)
805 if (sec_flags
& SEC_NEVER_LOAD
)
806 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
808 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
810 else if (strcmp (name
, _BSS
) == 0)
812 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
813 if (sec_flags
& SEC_NEVER_LOAD
)
814 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
817 sec_flags
|= SEC_ALLOC
;
819 else if (CONST_STRNEQ (name
, DOT_DEBUG
)
820 || CONST_STRNEQ (name
, DOT_ZDEBUG
)
822 || strcmp (name
, _COMMENT
) == 0
824 #ifdef COFF_LONG_SECTION_NAMES
825 || CONST_STRNEQ (name
, GNU_LINKONCE_WI
)
826 || CONST_STRNEQ (name
, GNU_LINKONCE_WT
)
828 || CONST_STRNEQ (name
, ".stab"))
830 #ifdef COFF_PAGE_SIZE
831 sec_flags
|= SEC_DEBUGGING
;
835 else if (strcmp (name
, _LIB
) == 0)
839 else if (strcmp (name
, _LIT
) == 0)
840 sec_flags
= SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
843 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
845 #ifdef STYP_LIT /* A29k readonly text/data section type. */
846 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
847 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
848 #endif /* STYP_LIT */
850 #ifdef STYP_OTHER_LOAD /* Other loaded sections. */
851 if (styp_flags
& STYP_OTHER_LOAD
)
852 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
853 #endif /* STYP_SDATA */
855 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
856 /* As a GNU extension, if the name begins with .gnu.linkonce, we
857 only link a single copy of the section. This is used to support
858 g++. g++ will emit each template expansion in its own section.
859 The symbols will be defined as weak, so that multiple definitions
860 are permitted. The GNU linker extension is to actually discard
861 all but one of the sections. */
862 if (CONST_STRNEQ (name
, ".gnu.linkonce"))
863 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
866 if (flags_ptr
== NULL
)
869 * flags_ptr
= sec_flags
;
873 #else /* COFF_WITH_PE */
876 handle_COMDAT (bfd
* abfd
,
882 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
883 bfd_byte
*esymstart
, *esym
, *esymend
;
885 char *target_name
= NULL
;
887 sec_flags
|= SEC_LINK_ONCE
;
889 /* Unfortunately, the PE format stores essential information in
890 the symbol table, of all places. We need to extract that
891 information now, so that objdump and the linker will know how
892 to handle the section without worrying about the symbols. We
893 can't call slurp_symtab, because the linker doesn't want the
896 /* COMDAT sections are special. The first symbol is the section
897 symbol, which tells what kind of COMDAT section it is. The
898 second symbol is the "comdat symbol" - the one with the
899 unique name. GNU uses the section symbol for the unique
900 name; MS uses ".text" for every comdat section. Sigh. - DJ */
902 /* This is not mirrored in sec_to_styp_flags(), but there
903 doesn't seem to be a need to, either, and it would at best be
906 if (! _bfd_coff_get_external_symbols (abfd
))
909 esymstart
= esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
910 esymend
= esym
+ obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
912 while (esym
< esymend
)
914 struct internal_syment isym
;
915 char buf
[SYMNMLEN
+ 1];
918 bfd_coff_swap_sym_in (abfd
, esym
, & isym
);
920 BFD_ASSERT (sizeof (internal_s
->s_name
) <= SYMNMLEN
);
922 if (isym
.n_scnum
== section
->target_index
)
924 /* According to the MSVC documentation, the first
925 TWO entries with the section # are both of
926 interest to us. The first one is the "section
927 symbol" (section name). The second is the comdat
928 symbol name. Here, we've found the first
929 qualifying entry; we distinguish it from the
930 second with a state flag.
932 In the case of gas-generated (at least until that
933 is fixed) .o files, it isn't necessarily the
934 second one. It may be some other later symbol.
936 Since gas also doesn't follow MS conventions and
937 emits the section similar to .text$<name>, where
938 <something> is the name we're looking for, we
939 distinguish the two as follows:
941 If the section name is simply a section name (no
942 $) we presume it's MS-generated, and look at
943 precisely the second symbol for the comdat name.
944 If the section name has a $, we assume it's
945 gas-generated, and look for <something> (whatever
946 follows the $) as the comdat symbol. */
948 /* All 3 branches use this. */
949 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
, buf
);
951 /* PR 17512 file: 078-11867-0.004 */
954 _bfd_error_handler (_("%pB: unable to load COMDAT section name"),
963 /* The first time we've seen the symbol. */
964 union internal_auxent aux
;
966 /* If it isn't the stuff we're expecting, die;
967 The MS documentation is vague, but it
968 appears that the second entry serves BOTH
969 as the comdat symbol and the defining
970 symbol record (either C_STAT or C_EXT,
971 possibly with an aux entry with debug
972 information if it's a function.) It
973 appears the only way to find the second one
974 is to count. (On Intel, they appear to be
975 adjacent, but on Alpha, they have been
978 Here, we think we've found the first one,
979 but there's some checking we can do to be
982 if (! ((isym
.n_sclass
== C_STAT
983 || isym
.n_sclass
== C_EXT
)
984 && BTYPE (isym
.n_type
) == T_NULL
985 && isym
.n_value
== 0))
987 /* Malformed input files can trigger this test.
989 _bfd_error_handler (_("%pB: error: unexpected symbol '%s' in COMDAT section"),
994 /* FIXME LATER: MSVC generates section names
995 like .text for comdats. Gas generates
996 names like .text$foo__Fv (in the case of a
997 function). See comment above for more. */
999 if (isym
.n_sclass
== C_STAT
&& strcmp (name
, symname
) != 0)
1000 /* xgettext:c-format */
1001 _bfd_error_handler (_("%pB: warning: COMDAT symbol '%s'"
1002 " does not match section name '%s'"),
1003 abfd
, symname
, name
);
1007 /* PR 17512: file: e2cfe54f. */
1008 if (esym
+ bfd_coff_symesz (abfd
) >= esymend
)
1010 /* xgettext:c-format */
1011 _bfd_error_handler (_("%pB: warning: no symbol for"
1012 " section '%s' found"),
1016 /* This is the section symbol. */
1017 bfd_coff_swap_aux_in (abfd
, (esym
+ bfd_coff_symesz (abfd
)),
1018 isym
.n_type
, isym
.n_sclass
,
1019 0, isym
.n_numaux
, & aux
);
1021 target_name
= strchr (name
, '$');
1022 if (target_name
!= NULL
)
1030 /* FIXME: Microsoft uses NODUPLICATES and
1031 ASSOCIATIVE, but gnu uses ANY and
1032 SAME_SIZE. Unfortunately, gnu doesn't do
1033 the comdat symbols right. So, until we can
1034 fix it to do the right thing, we are
1035 temporarily disabling comdats for the MS
1036 types (they're used in DLLs and C++, but we
1037 don't support *their* C++ libraries anyway
1040 /* Cygwin does not follow the MS style, and
1041 uses ANY and SAME_SIZE where NODUPLICATES
1042 and ASSOCIATIVE should be used. For
1043 Interix, we just do the right thing up
1046 switch (aux
.x_scn
.x_comdat
)
1048 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
1049 #ifdef STRICT_PE_FORMAT
1050 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
1052 sec_flags
&= ~SEC_LINK_ONCE
;
1056 case IMAGE_COMDAT_SELECT_ANY
:
1057 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1060 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
1061 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
1064 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
1065 /* Not yet fully implemented ??? */
1066 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
1069 /* debug$S gets this case; other
1072 /* There may be no symbol... we'll search
1073 the whole table... Is this the right
1074 place to play this game? Or should we do
1075 it when reading it in. */
1076 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
1077 #ifdef STRICT_PE_FORMAT
1078 /* FIXME: This is not currently implemented. */
1079 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1081 sec_flags
&= ~SEC_LINK_ONCE
;
1085 default: /* 0 means "no symbol" */
1086 /* debug$F gets this case; other
1088 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1095 /* Gas mode: the first matching on partial name. */
1097 #ifndef TARGET_UNDERSCORE
1098 #define TARGET_UNDERSCORE 0
1100 /* Is this the name we're looking for ? */
1101 if (strcmp (target_name
,
1102 symname
+ (TARGET_UNDERSCORE
? 1 : 0)) != 0)
1104 /* Not the name we're looking for */
1105 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1110 /* MSVC mode: the lexically second symbol (or
1111 drop through from the above). */
1116 /* This must the second symbol with the
1117 section #. It is the actual symbol name.
1118 Intel puts the two adjacent, but Alpha (at
1119 least) spreads them out. */
1121 amt
= sizeof (struct coff_comdat_info
);
1122 coff_section_data (abfd
, section
)->comdat
1123 = (struct coff_comdat_info
*) bfd_alloc (abfd
, amt
);
1124 if (coff_section_data (abfd
, section
)->comdat
== NULL
)
1127 coff_section_data (abfd
, section
)->comdat
->symbol
=
1128 (esym
- esymstart
) / bfd_coff_symesz (abfd
);
1130 amt
= strlen (symname
) + 1;
1131 newname
= (char *) bfd_alloc (abfd
, amt
);
1132 if (newname
== NULL
)
1135 strcpy (newname
, symname
);
1136 coff_section_data (abfd
, section
)->comdat
->name
1144 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1152 /* The PE version; see above for the general comments.
1154 Since to set the SEC_LINK_ONCE and associated flags, we have to
1155 look at the symbol table anyway, we return the symbol table index
1156 of the symbol being used as the COMDAT symbol. This is admittedly
1157 ugly, but there's really nowhere else that we have access to the
1158 required information. FIXME: Is the COMDAT symbol index used for
1159 any purpose other than objdump? */
1162 styp_to_sec_flags (bfd
*abfd
,
1166 flagword
*flags_ptr
)
1168 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
1169 unsigned long styp_flags
= internal_s
->s_flags
;
1171 bfd_boolean result
= TRUE
;
1172 bfd_boolean is_dbg
= FALSE
;
1174 if (CONST_STRNEQ (name
, DOT_DEBUG
)
1175 || CONST_STRNEQ (name
, DOT_ZDEBUG
)
1176 #ifdef COFF_LONG_SECTION_NAMES
1177 || CONST_STRNEQ (name
, GNU_LINKONCE_WI
)
1178 || CONST_STRNEQ (name
, GNU_LINKONCE_WT
)
1180 || CONST_STRNEQ (name
, ".stab"))
1182 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
1183 sec_flags
= SEC_READONLY
;
1185 /* If section disallows read, then set the NOREAD flag. */
1186 if ((styp_flags
& IMAGE_SCN_MEM_READ
) == 0)
1187 sec_flags
|= SEC_COFF_NOREAD
;
1189 /* Process each flag bit in styp_flags in turn. */
1192 unsigned long flag
= styp_flags
& - styp_flags
;
1193 char * unhandled
= NULL
;
1195 styp_flags
&= ~ flag
;
1197 /* We infer from the distinct read/write/execute bits the settings
1198 of some of the bfd flags; the actual values, should we need them,
1199 are also in pei_section_data (abfd, section)->pe_flags. */
1204 unhandled
= "STYP_DSECT";
1207 unhandled
= "STYP_GROUP";
1210 unhandled
= "STYP_COPY";
1213 unhandled
= "STYP_OVER";
1215 #ifdef SEC_NEVER_LOAD
1217 sec_flags
|= SEC_NEVER_LOAD
;
1220 case IMAGE_SCN_MEM_READ
:
1221 sec_flags
&= ~SEC_COFF_NOREAD
;
1223 case IMAGE_SCN_TYPE_NO_PAD
:
1226 case IMAGE_SCN_LNK_OTHER
:
1227 unhandled
= "IMAGE_SCN_LNK_OTHER";
1229 case IMAGE_SCN_MEM_NOT_CACHED
:
1230 unhandled
= "IMAGE_SCN_MEM_NOT_CACHED";
1232 case IMAGE_SCN_MEM_NOT_PAGED
:
1233 /* Generate a warning message rather using the 'unhandled'
1234 variable as this will allow some .sys files generate by
1235 other toolchains to be processed. See bugzilla issue 196. */
1236 /* xgettext:c-format */
1237 _bfd_error_handler (_("%pB: warning: ignoring section flag"
1238 " %s in section %s"),
1239 abfd
, "IMAGE_SCN_MEM_NOT_PAGED", name
);
1241 case IMAGE_SCN_MEM_EXECUTE
:
1242 sec_flags
|= SEC_CODE
;
1244 case IMAGE_SCN_MEM_WRITE
:
1245 sec_flags
&= ~ SEC_READONLY
;
1247 case IMAGE_SCN_MEM_DISCARDABLE
:
1248 /* The MS PE spec says that debug sections are DISCARDABLE,
1249 but the presence of a DISCARDABLE flag does not necessarily
1250 mean that a given section contains debug information. Thus
1251 we only set the SEC_DEBUGGING flag on sections that we
1252 recognise as containing debug information. */
1255 || strcmp (name
, _COMMENT
) == 0
1259 sec_flags
|= SEC_DEBUGGING
| SEC_READONLY
;
1262 case IMAGE_SCN_MEM_SHARED
:
1263 sec_flags
|= SEC_COFF_SHARED
;
1265 case IMAGE_SCN_LNK_REMOVE
:
1267 sec_flags
|= SEC_EXCLUDE
;
1269 case IMAGE_SCN_CNT_CODE
:
1270 sec_flags
|= SEC_CODE
| SEC_ALLOC
| SEC_LOAD
;
1272 case IMAGE_SCN_CNT_INITIALIZED_DATA
:
1274 sec_flags
|= SEC_DEBUGGING
;
1276 sec_flags
|= SEC_DATA
| SEC_ALLOC
| SEC_LOAD
;
1278 case IMAGE_SCN_CNT_UNINITIALIZED_DATA
:
1279 sec_flags
|= SEC_ALLOC
;
1281 case IMAGE_SCN_LNK_INFO
:
1282 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1283 defined. coff_compute_section_file_positions uses
1284 COFF_PAGE_SIZE to ensure that the low order bits of the
1285 section VMA and the file offset match. If we don't know
1286 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1287 and demand page loading of the file will fail. */
1288 #ifdef COFF_PAGE_SIZE
1289 sec_flags
|= SEC_DEBUGGING
;
1292 case IMAGE_SCN_LNK_COMDAT
:
1293 /* COMDAT gets very special treatment. */
1294 sec_flags
= handle_COMDAT (abfd
, sec_flags
, hdr
, name
, section
);
1297 /* Silently ignore for now. */
1301 /* If the section flag was not handled, report it here. */
1302 if (unhandled
!= NULL
)
1305 /* xgettext:c-format */
1306 (_("%pB (%s): section flag %s (%#lx) ignored"),
1307 abfd
, name
, unhandled
, flag
);
1312 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1313 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1314 only link a single copy of the section. This is used to support
1315 g++. g++ will emit each template expansion in its own section.
1316 The symbols will be defined as weak, so that multiple definitions
1317 are permitted. The GNU linker extension is to actually discard
1318 all but one of the sections. */
1319 if (CONST_STRNEQ (name
, ".gnu.linkonce"))
1320 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1324 * flags_ptr
= sec_flags
;
1329 #endif /* COFF_WITH_PE */
1331 #define get_index(symbol) ((symbol)->udata.i)
1335 bfd_coff_backend_data
1339 .{* COFF symbol classifications. *}
1341 .enum coff_symbol_classification
1343 . {* Global symbol. *}
1344 . COFF_SYMBOL_GLOBAL,
1345 . {* Common symbol. *}
1346 . COFF_SYMBOL_COMMON,
1347 . {* Undefined symbol. *}
1348 . COFF_SYMBOL_UNDEFINED,
1349 . {* Local symbol. *}
1350 . COFF_SYMBOL_LOCAL,
1351 . {* PE section symbol. *}
1352 . COFF_SYMBOL_PE_SECTION
1355 .typedef asection * (*coff_gc_mark_hook_fn)
1356 . (asection *, struct bfd_link_info *, struct internal_reloc *,
1357 . struct coff_link_hash_entry *, struct internal_syment *);
1359 Special entry points for gdb to swap in coff symbol table parts:
1362 . void (*_bfd_coff_swap_aux_in)
1363 . (bfd *, void *, int, int, int, int, void *);
1365 . void (*_bfd_coff_swap_sym_in)
1366 . (bfd *, void *, void *);
1368 . void (*_bfd_coff_swap_lineno_in)
1369 . (bfd *, void *, void *);
1371 . unsigned int (*_bfd_coff_swap_aux_out)
1372 . (bfd *, void *, int, int, int, int, void *);
1374 . unsigned int (*_bfd_coff_swap_sym_out)
1375 . (bfd *, void *, void *);
1377 . unsigned int (*_bfd_coff_swap_lineno_out)
1378 . (bfd *, void *, void *);
1380 . unsigned int (*_bfd_coff_swap_reloc_out)
1381 . (bfd *, void *, void *);
1383 . unsigned int (*_bfd_coff_swap_filehdr_out)
1384 . (bfd *, void *, void *);
1386 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1387 . (bfd *, void *, void *);
1389 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1390 . (bfd *, void *, void *);
1392 . unsigned int _bfd_filhsz;
1393 . unsigned int _bfd_aoutsz;
1394 . unsigned int _bfd_scnhsz;
1395 . unsigned int _bfd_symesz;
1396 . unsigned int _bfd_auxesz;
1397 . unsigned int _bfd_relsz;
1398 . unsigned int _bfd_linesz;
1399 . unsigned int _bfd_filnmlen;
1400 . bfd_boolean _bfd_coff_long_filenames;
1402 . bfd_boolean _bfd_coff_long_section_names;
1403 . bfd_boolean (*_bfd_coff_set_long_section_names)
1406 . unsigned int _bfd_coff_default_section_alignment_power;
1407 . bfd_boolean _bfd_coff_force_symnames_in_strings;
1408 . unsigned int _bfd_coff_debug_string_prefix_length;
1409 . unsigned int _bfd_coff_max_nscns;
1411 . void (*_bfd_coff_swap_filehdr_in)
1412 . (bfd *, void *, void *);
1414 . void (*_bfd_coff_swap_aouthdr_in)
1415 . (bfd *, void *, void *);
1417 . void (*_bfd_coff_swap_scnhdr_in)
1418 . (bfd *, void *, void *);
1420 . void (*_bfd_coff_swap_reloc_in)
1421 . (bfd *abfd, void *, void *);
1423 . bfd_boolean (*_bfd_coff_bad_format_hook)
1426 . bfd_boolean (*_bfd_coff_set_arch_mach_hook)
1429 . void * (*_bfd_coff_mkobject_hook)
1430 . (bfd *, void *, void *);
1432 . bfd_boolean (*_bfd_styp_to_sec_flags_hook)
1433 . (bfd *, void *, const char *, asection *, flagword *);
1435 . void (*_bfd_set_alignment_hook)
1436 . (bfd *, asection *, void *);
1438 . bfd_boolean (*_bfd_coff_slurp_symbol_table)
1441 . bfd_boolean (*_bfd_coff_symname_in_debug)
1442 . (bfd *, struct internal_syment *);
1444 . bfd_boolean (*_bfd_coff_pointerize_aux_hook)
1445 . (bfd *, combined_entry_type *, combined_entry_type *,
1446 . unsigned int, combined_entry_type *);
1448 . bfd_boolean (*_bfd_coff_print_aux)
1449 . (bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1450 . combined_entry_type *, unsigned int);
1452 . void (*_bfd_coff_reloc16_extra_cases)
1453 . (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1454 . bfd_byte *, unsigned int *, unsigned int *);
1456 . int (*_bfd_coff_reloc16_estimate)
1457 . (bfd *, asection *, arelent *, unsigned int,
1458 . struct bfd_link_info *);
1460 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1461 . (bfd *, struct internal_syment *);
1463 . bfd_boolean (*_bfd_coff_compute_section_file_positions)
1466 . bfd_boolean (*_bfd_coff_start_final_link)
1467 . (bfd *, struct bfd_link_info *);
1469 . bfd_boolean (*_bfd_coff_relocate_section)
1470 . (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1471 . struct internal_reloc *, struct internal_syment *, asection **);
1473 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1474 . (bfd *, asection *, struct internal_reloc *,
1475 . struct coff_link_hash_entry *, struct internal_syment *, bfd_vma *);
1477 . bfd_boolean (*_bfd_coff_adjust_symndx)
1478 . (bfd *, struct bfd_link_info *, bfd *, asection *,
1479 . struct internal_reloc *, bfd_boolean *);
1481 . bfd_boolean (*_bfd_coff_link_add_one_symbol)
1482 . (struct bfd_link_info *, bfd *, const char *, flagword,
1483 . asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
1484 . struct bfd_link_hash_entry **);
1486 . bfd_boolean (*_bfd_coff_link_output_has_begun)
1487 . (bfd *, struct coff_final_link_info *);
1489 . bfd_boolean (*_bfd_coff_final_link_postscript)
1490 . (bfd *, struct coff_final_link_info *);
1492 . bfd_boolean (*_bfd_coff_print_pdata)
1495 .} bfd_coff_backend_data;
1497 .#define coff_backend_info(abfd) \
1498 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1500 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1501 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1503 .#define bfd_coff_swap_sym_in(a,e,i) \
1504 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1506 .#define bfd_coff_swap_lineno_in(a,e,i) \
1507 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1509 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1510 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1512 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1513 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1515 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1516 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1518 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1519 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1521 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1522 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1524 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1525 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1527 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1528 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1530 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1531 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1532 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1533 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1534 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1535 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1536 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1537 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1538 .#define bfd_coff_long_filenames(abfd) \
1539 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1540 .#define bfd_coff_long_section_names(abfd) \
1541 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1542 .#define bfd_coff_set_long_section_names(abfd, enable) \
1543 . ((coff_backend_info (abfd)->_bfd_coff_set_long_section_names) (abfd, enable))
1544 .#define bfd_coff_default_section_alignment_power(abfd) \
1545 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1546 .#define bfd_coff_max_nscns(abfd) \
1547 . (coff_backend_info (abfd)->_bfd_coff_max_nscns)
1549 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1550 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1552 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1553 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1555 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1556 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1558 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1559 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1561 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1562 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1564 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1565 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1566 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1567 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1568 . (abfd, filehdr, aouthdr))
1570 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1571 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1572 . (abfd, scnhdr, name, section, flags_ptr))
1574 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1575 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1577 .#define bfd_coff_slurp_symbol_table(abfd)\
1578 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1580 .#define bfd_coff_symname_in_debug(abfd, sym)\
1581 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1583 .#define bfd_coff_force_symnames_in_strings(abfd)\
1584 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1586 .#define bfd_coff_debug_string_prefix_length(abfd)\
1587 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1589 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1590 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1591 . (abfd, file, base, symbol, aux, indaux))
1593 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1594 . reloc, data, src_ptr, dst_ptr)\
1595 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1596 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1598 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1599 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1600 . (abfd, section, reloc, shrink, link_info))
1602 .#define bfd_coff_classify_symbol(abfd, sym)\
1603 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1606 .#define bfd_coff_compute_section_file_positions(abfd)\
1607 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1610 .#define bfd_coff_start_final_link(obfd, info)\
1611 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1613 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1614 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1615 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1616 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1617 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1618 . (abfd, sec, rel, h, sym, addendp))
1619 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1620 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1621 . (obfd, info, ibfd, sec, rel, adjustedp))
1622 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1623 . value, string, cp, coll, hashp)\
1624 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1625 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1627 .#define bfd_coff_link_output_has_begun(a,p) \
1628 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p))
1629 .#define bfd_coff_final_link_postscript(a,p) \
1630 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p))
1632 .#define bfd_coff_have_print_pdata(a) \
1633 . (coff_backend_info (a)->_bfd_coff_print_pdata)
1634 .#define bfd_coff_print_pdata(a,p) \
1635 . ((coff_backend_info (a)->_bfd_coff_print_pdata) (a, p))
1637 .{* Macro: Returns true if the bfd is a PE executable as opposed to a
1638 . PE object file. *}
1639 .#define bfd_pei_p(abfd) \
1640 . (CONST_STRNEQ ((abfd)->xvec->name, "pei-"))
1643 /* See whether the magic number matches. */
1646 coff_bad_format_hook (bfd
* abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1648 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1650 if (BADMAG (*internal_f
))
1658 ticoff0_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1660 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1662 if (COFF0_BADMAG (*internal_f
))
1671 ticoff1_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1673 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1675 if (COFF1_BADMAG (*internal_f
))
1682 /* Check whether this section uses an alignment other than the
1686 coff_set_custom_section_alignment (bfd
*abfd ATTRIBUTE_UNUSED
,
1688 const struct coff_section_alignment_entry
*alignment_table
,
1689 const unsigned int table_size
)
1691 const unsigned int default_alignment
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1694 for (i
= 0; i
< table_size
; ++i
)
1696 const char *secname
= bfd_get_section_name (abfd
, section
);
1698 if (alignment_table
[i
].comparison_length
== (unsigned int) -1
1699 ? strcmp (alignment_table
[i
].name
, secname
) == 0
1700 : strncmp (alignment_table
[i
].name
, secname
,
1701 alignment_table
[i
].comparison_length
) == 0)
1704 if (i
>= table_size
)
1707 if (alignment_table
[i
].default_alignment_min
!= COFF_ALIGNMENT_FIELD_EMPTY
1708 && default_alignment
< alignment_table
[i
].default_alignment_min
)
1711 if (alignment_table
[i
].default_alignment_max
!= COFF_ALIGNMENT_FIELD_EMPTY
1712 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1713 && default_alignment
> alignment_table
[i
].default_alignment_max
1718 section
->alignment_power
= alignment_table
[i
].alignment_power
;
1721 /* Custom section alignment records. */
1723 static const struct coff_section_alignment_entry
1724 coff_section_alignment_table
[] =
1726 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1727 COFF_SECTION_ALIGNMENT_ENTRIES
,
1729 /* There must not be any gaps between .stabstr sections. */
1730 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1731 1, COFF_ALIGNMENT_FIELD_EMPTY
, 0 },
1732 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1733 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1734 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1735 /* Similarly for the .ctors and .dtors sections. */
1736 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1737 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1738 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1739 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 }
1742 static const unsigned int coff_section_alignment_table_size
=
1743 sizeof coff_section_alignment_table
/ sizeof coff_section_alignment_table
[0];
1745 /* Initialize a section structure with information peculiar to this
1746 particular implementation of COFF. */
1749 coff_new_section_hook (bfd
* abfd
, asection
* section
)
1751 combined_entry_type
*native
;
1753 unsigned char sclass
= C_STAT
;
1755 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1758 if (bfd_xcoff_text_align_power (abfd
) != 0
1759 && strcmp (bfd_get_section_name (abfd
, section
), ".text") == 0)
1760 section
->alignment_power
= bfd_xcoff_text_align_power (abfd
);
1761 else if (bfd_xcoff_data_align_power (abfd
) != 0
1762 && strcmp (bfd_get_section_name (abfd
, section
), ".data") == 0)
1763 section
->alignment_power
= bfd_xcoff_data_align_power (abfd
);
1768 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
1769 if (strcmp (bfd_get_section_name (abfd
, section
),
1770 xcoff_dwsect_names
[i
].name
) == 0)
1772 section
->alignment_power
= 0;
1779 /* Set up the section symbol. */
1780 if (!_bfd_generic_new_section_hook (abfd
, section
))
1783 /* Allocate aux records for section symbols, to store size and
1786 @@ The 10 is a guess at a plausible maximum number of aux entries
1787 (but shouldn't be a constant). */
1788 amt
= sizeof (combined_entry_type
) * 10;
1789 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
1793 /* We don't need to set up n_name, n_value, or n_scnum in the native
1794 symbol information, since they'll be overridden by the BFD symbol
1795 anyhow. However, we do need to set the type and storage class,
1796 in case this symbol winds up getting written out. The value 0
1797 for n_numaux is already correct. */
1799 native
->is_sym
= TRUE
;
1800 native
->u
.syment
.n_type
= T_NULL
;
1801 native
->u
.syment
.n_sclass
= sclass
;
1803 coffsymbol (section
->symbol
)->native
= native
;
1805 coff_set_custom_section_alignment (abfd
, section
,
1806 coff_section_alignment_table
,
1807 coff_section_alignment_table_size
);
1812 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1814 /* Set the alignment of a BFD section. */
1817 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1821 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1824 #ifdef COFF_DECODE_ALIGNMENT
1825 i
= COFF_DECODE_ALIGNMENT(hdr
->s_flags
);
1827 section
->alignment_power
= i
;
1829 #ifdef coff_set_section_load_page
1830 coff_set_section_load_page (section
, hdr
->s_page
);
1834 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1838 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1842 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1844 unsigned int alignment_power_const
1845 = hdr
->s_flags
& IMAGE_SCN_ALIGN_POWER_BIT_MASK
;
1847 switch (alignment_power_const
)
1849 case IMAGE_SCN_ALIGN_8192BYTES
:
1850 case IMAGE_SCN_ALIGN_4096BYTES
:
1851 case IMAGE_SCN_ALIGN_2048BYTES
:
1852 case IMAGE_SCN_ALIGN_1024BYTES
:
1853 case IMAGE_SCN_ALIGN_512BYTES
:
1854 case IMAGE_SCN_ALIGN_256BYTES
:
1855 case IMAGE_SCN_ALIGN_128BYTES
:
1856 case IMAGE_SCN_ALIGN_64BYTES
:
1857 case IMAGE_SCN_ALIGN_32BYTES
:
1858 case IMAGE_SCN_ALIGN_16BYTES
:
1859 case IMAGE_SCN_ALIGN_8BYTES
:
1860 case IMAGE_SCN_ALIGN_4BYTES
:
1861 case IMAGE_SCN_ALIGN_2BYTES
:
1862 case IMAGE_SCN_ALIGN_1BYTES
:
1863 section
->alignment_power
1864 = IMAGE_SCN_ALIGN_POWER_NUM (alignment_power_const
);
1870 /* In a PE image file, the s_paddr field holds the virtual size of a
1871 section, while the s_size field holds the raw size. We also keep
1872 the original section flag value, since not every bit can be
1873 mapped onto a generic BFD section bit. */
1874 if (coff_section_data (abfd
, section
) == NULL
)
1876 amt
= sizeof (struct coff_section_tdata
);
1877 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
1878 if (section
->used_by_bfd
== NULL
)
1879 /* FIXME: Return error. */
1883 if (pei_section_data (abfd
, section
) == NULL
)
1885 amt
= sizeof (struct pei_section_tdata
);
1886 coff_section_data (abfd
, section
)->tdata
= bfd_zalloc (abfd
, amt
);
1887 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1888 /* FIXME: Return error. */
1891 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1892 pei_section_data (abfd
, section
)->pe_flags
= hdr
->s_flags
;
1894 section
->lma
= hdr
->s_vaddr
;
1896 /* Check for extended relocs. */
1897 if (hdr
->s_flags
& IMAGE_SCN_LNK_NRELOC_OVFL
)
1899 struct external_reloc dst
;
1900 struct internal_reloc n
;
1901 file_ptr oldpos
= bfd_tell (abfd
);
1902 bfd_size_type relsz
= bfd_coff_relsz (abfd
);
1904 if (bfd_seek (abfd
, (file_ptr
) hdr
->s_relptr
, 0) != 0)
1906 if (bfd_bread (& dst
, relsz
, abfd
) != relsz
)
1909 coff_swap_reloc_in (abfd
, &dst
, &n
);
1910 if (bfd_seek (abfd
, oldpos
, 0) != 0)
1912 section
->reloc_count
= hdr
->s_nreloc
= n
.r_vaddr
- 1;
1913 section
->rel_filepos
+= relsz
;
1915 else if (hdr
->s_nreloc
== 0xffff)
1917 (_("%pB: warning: claims to have 0xffff relocs, without overflow"),
1921 #undef ELIFALIGN_SET
1923 #else /* ! COFF_WITH_PE */
1926 /* We grossly abuse this function to handle XCOFF overflow headers.
1927 When we see one, we correct the reloc and line number counts in the
1928 real header, and remove the section we just created. */
1931 coff_set_alignment_hook (bfd
*abfd
, asection
*section
, void * scnhdr
)
1933 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1936 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1939 real_sec
= coff_section_from_bfd_index (abfd
, (int) hdr
->s_nreloc
);
1940 if (real_sec
== NULL
)
1943 real_sec
->reloc_count
= hdr
->s_paddr
;
1944 real_sec
->lineno_count
= hdr
->s_vaddr
;
1946 if (!bfd_section_removed_from_list (abfd
, section
))
1948 bfd_section_list_remove (abfd
, section
);
1949 --abfd
->section_count
;
1953 #else /* ! RS6000COFF_C */
1956 coff_set_alignment_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
1957 asection
*section ATTRIBUTE_UNUSED
,
1958 void *scnhdr ATTRIBUTE_UNUSED
)
1962 #endif /* ! RS6000COFF_C */
1963 #endif /* ! COFF_WITH_PE */
1964 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1966 #ifndef coff_mkobject
1969 coff_mkobject (bfd
* abfd
)
1971 coff_data_type
*coff
;
1972 bfd_size_type amt
= sizeof (coff_data_type
);
1974 abfd
->tdata
.coff_obj_data
= bfd_zalloc (abfd
, amt
);
1975 if (abfd
->tdata
.coff_obj_data
== NULL
)
1977 coff
= coff_data (abfd
);
1978 coff
->symbols
= NULL
;
1979 coff
->conversion_table
= NULL
;
1980 coff
->raw_syments
= NULL
;
1981 coff
->relocbase
= 0;
1982 coff
->local_toc_sym_map
= 0;
1984 /* make_abs_section(abfd);*/
1990 /* Create the COFF backend specific information. */
1992 #ifndef coff_mkobject_hook
1994 coff_mkobject_hook (bfd
* abfd
,
1996 void * aouthdr ATTRIBUTE_UNUSED
)
1998 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1999 coff_data_type
*coff
;
2001 if (! coff_mkobject (abfd
))
2004 coff
= coff_data (abfd
);
2006 coff
->sym_filepos
= internal_f
->f_symptr
;
2008 /* These members communicate important constants about the symbol
2009 table to GDB's symbol-reading code. These `constants'
2010 unfortunately vary among coff implementations... */
2011 coff
->local_n_btmask
= N_BTMASK
;
2012 coff
->local_n_btshft
= N_BTSHFT
;
2013 coff
->local_n_tmask
= N_TMASK
;
2014 coff
->local_n_tshift
= N_TSHIFT
;
2015 coff
->local_symesz
= bfd_coff_symesz (abfd
);
2016 coff
->local_auxesz
= bfd_coff_auxesz (abfd
);
2017 coff
->local_linesz
= bfd_coff_linesz (abfd
);
2019 coff
->timestamp
= internal_f
->f_timdat
;
2021 obj_raw_syment_count (abfd
) =
2022 obj_conv_table_size (abfd
) =
2023 internal_f
->f_nsyms
;
2026 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
2027 abfd
->flags
|= DYNAMIC
;
2028 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= bfd_coff_aoutsz (abfd
))
2030 struct internal_aouthdr
*internal_a
=
2031 (struct internal_aouthdr
*) aouthdr
;
2032 struct xcoff_tdata
*xcoff
;
2034 xcoff
= xcoff_data (abfd
);
2035 # ifdef U803XTOCMAGIC
2036 xcoff
->xcoff64
= internal_f
->f_magic
== U803XTOCMAGIC
;
2040 xcoff
->full_aouthdr
= TRUE
;
2041 xcoff
->toc
= internal_a
->o_toc
;
2042 xcoff
->sntoc
= internal_a
->o_sntoc
;
2043 xcoff
->snentry
= internal_a
->o_snentry
;
2044 bfd_xcoff_text_align_power (abfd
) = internal_a
->o_algntext
;
2045 bfd_xcoff_data_align_power (abfd
) = internal_a
->o_algndata
;
2046 xcoff
->modtype
= internal_a
->o_modtype
;
2047 xcoff
->cputype
= internal_a
->o_cputype
;
2048 xcoff
->maxdata
= internal_a
->o_maxdata
;
2049 xcoff
->maxstack
= internal_a
->o_maxstack
;
2054 /* Set the flags field from the COFF header read in. */
2055 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
2060 /* FIXME: I'm not sure this is ever executed, since peicode.h
2061 defines coff_mkobject_hook. */
2062 if ((internal_f
->f_flags
& IMAGE_FILE_DEBUG_STRIPPED
) == 0)
2063 abfd
->flags
|= HAS_DEBUG
;
2066 if ((internal_f
->f_flags
& F_GO32STUB
) != 0)
2068 coff
->go32stub
= (char *) bfd_alloc (abfd
, (bfd_size_type
) GO32_STUBSIZE
);
2069 if (coff
->go32stub
== NULL
)
2072 if (coff
->go32stub
!= NULL
)
2073 memcpy (coff
->go32stub
, internal_f
->go32stub
, GO32_STUBSIZE
);
2079 /* Determine the machine architecture and type. FIXME: This is target
2080 dependent because the magic numbers are defined in the target
2081 dependent header files. But there is no particular need for this.
2082 If the magic numbers were moved to a separate file, this function
2083 would be target independent and would also be much more successful
2084 at linking together COFF files for different architectures. */
2087 coff_set_arch_mach_hook (bfd
*abfd
, void * filehdr
)
2089 unsigned long machine
;
2090 enum bfd_architecture arch
;
2091 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
2093 /* Zero selects the default machine for an arch. */
2095 switch (internal_f
->f_magic
)
2099 arch
= bfd_arch_powerpc
;
2105 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler. */
2106 case LYNXCOFFMAGIC
: /* Shadows the m68k Lynx number below, sigh. */
2107 arch
= bfd_arch_i386
;
2112 arch
= bfd_arch_i386
;
2113 machine
= bfd_mach_x86_64
;
2118 arch
= bfd_arch_ia64
;
2125 arch
= bfd_arch_arm
;
2126 machine
= bfd_arm_get_mach_from_notes (abfd
, ARM_NOTE_SECTION
);
2127 if (machine
== bfd_mach_arm_unknown
)
2129 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
2131 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
2132 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
2133 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
2135 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
2136 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
2137 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
2138 /* The COFF header does not have enough bits available
2139 to cover all the different ARM architectures. So
2140 we interpret F_ARM_5, the highest flag value to mean
2141 "the highest ARM architecture known to BFD" which is
2142 currently the XScale. */
2143 case F_ARM_5
: machine
= bfd_mach_arm_XScale
; break;
2151 #ifdef MC68KBCSMAGIC
2154 #ifdef APOLLOM68KMAGIC
2155 case APOLLOM68KMAGIC
:
2157 #ifdef LYNXCOFFMAGIC
2160 arch
= bfd_arch_m68k
;
2161 machine
= bfd_mach_m68020
;
2166 arch
= bfd_arch_z80
;
2167 switch (internal_f
->f_flags
& F_MACHMASK
)
2170 case bfd_mach_z80strict
<< 12:
2171 case bfd_mach_z80
<< 12:
2172 case bfd_mach_z80full
<< 12:
2173 case bfd_mach_r800
<< 12:
2174 machine
= ((unsigned)internal_f
->f_flags
& F_MACHMASK
) >> 12;
2183 arch
= bfd_arch_z8k
;
2184 switch (internal_f
->f_flags
& F_MACHMASK
)
2187 machine
= bfd_mach_z8001
;
2190 machine
= bfd_mach_z8002
;
2210 if (xcoff_data (abfd
)->cputype
!= -1)
2211 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
2214 /* We did not get a value from the a.out header. If the
2215 file has not been stripped, we may be able to get the
2216 architecture information from the first symbol, if it
2217 is a .file symbol. */
2218 if (obj_raw_syment_count (abfd
) == 0)
2223 struct internal_syment sym
;
2224 bfd_size_type amt
= bfd_coff_symesz (abfd
);
2226 buf
= bfd_malloc (amt
);
2229 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
2230 || bfd_bread (buf
, amt
, abfd
) != amt
)
2235 bfd_coff_swap_sym_in (abfd
, buf
, & sym
);
2236 if (sym
.n_sclass
== C_FILE
)
2237 cputype
= sym
.n_type
& 0xff;
2244 /* FIXME: We don't handle all cases here. */
2249 arch
= bfd_xcoff_architecture (abfd
);
2250 machine
= bfd_xcoff_machine (abfd
);
2254 arch
= bfd_arch_powerpc
;
2255 machine
= bfd_mach_ppc_601
;
2257 case 2: /* 64 bit PowerPC */
2258 arch
= bfd_arch_powerpc
;
2259 machine
= bfd_mach_ppc_620
;
2262 arch
= bfd_arch_powerpc
;
2263 machine
= bfd_mach_ppc
;
2266 arch
= bfd_arch_rs6000
;
2267 machine
= bfd_mach_rs6k
;
2276 arch
= bfd_arch_we32k
;
2280 #ifdef SH_ARCH_MAGIC_BIG
2281 case SH_ARCH_MAGIC_BIG
:
2282 case SH_ARCH_MAGIC_LITTLE
:
2284 case SH_ARCH_MAGIC_WINCE
:
2290 #ifdef MIPS_ARCH_MAGIC_WINCE
2291 case MIPS_ARCH_MAGIC_WINCE
:
2292 arch
= bfd_arch_mips
;
2298 #ifdef LYNXCOFFMAGIC
2301 arch
= bfd_arch_sparc
;
2307 arch
= bfd_arch_tic30
;
2312 #ifdef TICOFF_TARGET_ARCH
2313 /* This TI COFF section should be used by all new TI COFF v0 targets. */
2315 arch
= TICOFF_TARGET_ARCH
;
2316 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2322 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */
2323 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */
2326 switch (internal_f
->f_target_id
)
2330 arch
= TICOFF_TARGET_ARCH
;
2331 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2335 arch
= bfd_arch_obscure
;
2337 (_("unrecognized TI COFF target id '0x%x'"),
2338 internal_f
->f_target_id
);
2344 #ifdef TIC80_ARCH_MAGIC
2345 case TIC80_ARCH_MAGIC
:
2346 arch
= bfd_arch_tic80
;
2352 arch
= bfd_arch_mcore
;
2358 arch
= bfd_arch_w65
;
2362 default: /* Unreadable input file type. */
2363 arch
= bfd_arch_obscure
;
2367 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2372 symname_in_debug_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2373 struct internal_syment
*sym ATTRIBUTE_UNUSED
)
2375 #ifdef SYMNAME_IN_DEBUG
2376 return SYMNAME_IN_DEBUG (sym
) != 0;
2385 #define FORCE_SYMNAMES_IN_STRINGS
2388 /* Handle the csect auxent of a C_EXT, C_AIX_WEAKEXT or C_HIDEXT symbol. */
2391 coff_pointerize_aux_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2392 combined_entry_type
*table_base
,
2393 combined_entry_type
*symbol
,
2394 unsigned int indaux
,
2395 combined_entry_type
*aux
)
2397 BFD_ASSERT (symbol
->is_sym
);
2398 int n_sclass
= symbol
->u
.syment
.n_sclass
;
2400 if (CSECT_SYM_P (n_sclass
)
2401 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2403 BFD_ASSERT (! aux
->is_sym
);
2404 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2406 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2407 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2408 aux
->fix_scnlen
= 1;
2411 /* Return TRUE to indicate that the caller should not do any
2412 further work on this auxent. */
2416 /* Return FALSE to indicate that this auxent should be handled by
2422 #define coff_pointerize_aux_hook 0
2423 #endif /* ! RS6000COFF_C */
2425 /* Print an aux entry. This returns TRUE if it has printed it. */
2428 coff_print_aux (bfd
*abfd ATTRIBUTE_UNUSED
,
2429 FILE *file ATTRIBUTE_UNUSED
,
2430 combined_entry_type
*table_base ATTRIBUTE_UNUSED
,
2431 combined_entry_type
*symbol ATTRIBUTE_UNUSED
,
2432 combined_entry_type
*aux ATTRIBUTE_UNUSED
,
2433 unsigned int indaux ATTRIBUTE_UNUSED
)
2435 BFD_ASSERT (symbol
->is_sym
);
2436 BFD_ASSERT (! aux
->is_sym
);
2438 if (CSECT_SYM_P (symbol
->u
.syment
.n_sclass
)
2439 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2441 /* This is a csect entry. */
2442 fprintf (file
, "AUX ");
2443 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2445 BFD_ASSERT (! aux
->fix_scnlen
);
2446 fprintf (file
, "val %5" BFD_VMA_FMT
"d",
2447 aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2451 fprintf (file
, "indx ");
2452 if (! aux
->fix_scnlen
)
2453 fprintf (file
, "%4" BFD_VMA_FMT
"d",
2454 aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2456 fprintf (file
, "%4ld",
2457 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2460 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2461 aux
->u
.auxent
.x_csect
.x_parmhash
,
2462 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2463 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2464 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2465 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2466 aux
->u
.auxent
.x_csect
.x_stab
,
2467 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2472 /* Return FALSE to indicate that no special action was taken. */
2480 To write relocations, the back end steps though the
2481 canonical relocation table and create an
2482 @code{internal_reloc}. The symbol index to use is removed from
2483 the @code{offset} field in the symbol table supplied. The
2484 address comes directly from the sum of the section base
2485 address and the relocation offset; the type is dug directly
2486 from the howto field. Then the @code{internal_reloc} is
2487 swapped into the shape of an @code{external_reloc} and written
2495 /* AUX's ld wants relocations to be sorted. */
2497 compare_arelent_ptr (const void * x
, const void * y
)
2499 const arelent
**a
= (const arelent
**) x
;
2500 const arelent
**b
= (const arelent
**) y
;
2501 bfd_size_type aadr
= (*a
)->address
;
2502 bfd_size_type badr
= (*b
)->address
;
2504 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2507 #endif /* TARG_AUX */
2510 coff_write_relocs (bfd
* abfd
, int first_undef
)
2514 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2517 struct external_reloc dst
;
2524 /* Sort relocations before we write them out. */
2527 amt
= s
->reloc_count
;
2528 amt
*= sizeof (arelent
*);
2529 p
= bfd_malloc (amt
);
2532 if (s
->reloc_count
> 0)
2537 memcpy (p
, s
->orelocation
, (size_t) amt
);
2538 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2543 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2547 if (obj_pe (abfd
) && s
->reloc_count
>= 0xffff)
2549 /* Encode real count here as first reloc. */
2550 struct internal_reloc n
;
2552 memset (& n
, 0, sizeof (n
));
2553 /* Add one to count *this* reloc (grr). */
2554 n
.r_vaddr
= s
->reloc_count
+ 1;
2555 coff_swap_reloc_out (abfd
, &n
, &dst
);
2556 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2557 abfd
) != bfd_coff_relsz (abfd
))
2562 for (i
= 0; i
< s
->reloc_count
; i
++)
2564 struct internal_reloc n
;
2567 memset (& n
, 0, sizeof (n
));
2569 /* Now we've renumbered the symbols we know where the
2570 undefined symbols live in the table. Check the reloc
2571 entries for symbols who's output bfd isn't the right one.
2572 This is because the symbol was undefined (which means
2573 that all the pointers are never made to point to the same
2574 place). This is a bad thing,'cause the symbols attached
2575 to the output bfd are indexed, so that the relocation
2576 entries know which symbol index they point to. So we
2577 have to look up the output symbol here. */
2579 if (q
->sym_ptr_ptr
[0] != NULL
&& q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2582 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2583 asymbol
**outsyms
= abfd
->outsymbols
;
2585 for (j
= first_undef
; outsyms
[j
]; j
++)
2587 const char *intable
= outsyms
[j
]->name
;
2589 if (strcmp (intable
, sname
) == 0)
2591 /* Got a hit, so repoint the reloc. */
2592 q
->sym_ptr_ptr
= outsyms
+ j
;
2598 n
.r_vaddr
= q
->address
+ s
->vma
;
2601 /* The 29k const/consth reloc pair is a real kludge. The consth
2602 part doesn't have a symbol; it has an offset. So rebuilt
2604 if (q
->howto
->type
== R_IHCONST
)
2605 n
.r_symndx
= q
->addend
;
2608 if (q
->sym_ptr_ptr
&& q
->sym_ptr_ptr
[0] != NULL
)
2610 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2611 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
, s
))
2613 if ((*q
->sym_ptr_ptr
)->section
== bfd_abs_section_ptr
2614 && ((*q
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) != 0)
2616 /* This is a relocation relative to the absolute symbol. */
2620 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2621 /* Check to see if the symbol reloc points to a symbol
2622 we don't have in our symbol table. */
2623 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2625 bfd_set_error (bfd_error_bad_value
);
2626 /* xgettext:c-format */
2627 _bfd_error_handler (_("%pB: reloc against a non-existent"
2628 " symbol index: %ld"),
2635 #ifdef SWAP_OUT_RELOC_OFFSET
2636 n
.r_offset
= q
->addend
;
2640 /* Work out reloc type from what is required. */
2641 SELECT_RELOC (n
, q
->howto
);
2643 n
.r_type
= q
->howto
->type
;
2645 coff_swap_reloc_out (abfd
, &n
, &dst
);
2647 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2648 abfd
) != bfd_coff_relsz (abfd
))
2661 /* Set flags and magic number of a coff file from architecture and machine
2662 type. Result is TRUE if we can represent the arch&type, FALSE if not. */
2665 coff_set_flags (bfd
* abfd
,
2666 unsigned int *magicp ATTRIBUTE_UNUSED
,
2667 unsigned short *flagsp ATTRIBUTE_UNUSED
)
2669 switch (bfd_get_arch (abfd
))
2674 switch (bfd_get_mach (abfd
))
2677 case bfd_mach_z80strict
:
2679 case bfd_mach_z80full
:
2681 *flagsp
= bfd_get_mach (abfd
) << 12;
2693 switch (bfd_get_mach (abfd
))
2695 case bfd_mach_z8001
: *flagsp
= F_Z8001
; break;
2696 case bfd_mach_z8002
: *flagsp
= F_Z8002
; break;
2697 default: return FALSE
;
2703 case bfd_arch_tic30
:
2704 *magicp
= TIC30MAGIC
;
2708 #ifdef TICOFF_DEFAULT_MAGIC
2709 case TICOFF_TARGET_ARCH
:
2710 /* If there's no indication of which version we want, use the default. */
2712 *magicp
= TICOFF_DEFAULT_MAGIC
;
2715 /* We may want to output in a different COFF version. */
2716 switch (abfd
->xvec
->name
[4])
2719 *magicp
= TICOFF0MAGIC
;
2722 *magicp
= TICOFF1MAGIC
;
2725 *magicp
= TICOFF2MAGIC
;
2731 TICOFF_TARGET_MACHINE_SET (flagsp
, bfd_get_mach (abfd
));
2735 #ifdef TIC80_ARCH_MAGIC
2736 case bfd_arch_tic80
:
2737 *magicp
= TIC80_ARCH_MAGIC
;
2744 * magicp
= ARMPEMAGIC
;
2746 * magicp
= ARMMAGIC
;
2749 if (APCS_SET (abfd
))
2751 if (APCS_26_FLAG (abfd
))
2752 * flagsp
|= F_APCS26
;
2754 if (APCS_FLOAT_FLAG (abfd
))
2755 * flagsp
|= F_APCS_FLOAT
;
2757 if (PIC_FLAG (abfd
))
2760 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2761 * flagsp
|= F_INTERWORK
;
2762 switch (bfd_get_mach (abfd
))
2764 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2765 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2766 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2767 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2768 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2769 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2770 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2771 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2772 See also the comment in coff_set_arch_mach_hook(). */
2773 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break;
2774 case bfd_mach_arm_5TE
: * flagsp
|= F_ARM_5
; break;
2775 case bfd_mach_arm_XScale
: * flagsp
|= F_ARM_5
; break;
2781 case bfd_arch_powerpc
:
2786 #if defined(I386MAGIC) || defined(AMD64MAGIC)
2788 #if defined(I386MAGIC)
2789 *magicp
= I386MAGIC
;
2792 /* Just overwrite the usual value if we're doing Lynx. */
2793 *magicp
= LYNXCOFFMAGIC
;
2795 #if defined AMD64MAGIC
2796 *magicp
= AMD64MAGIC
;
2803 *magicp
= IA64MAGIC
;
2809 #ifdef APOLLOM68KMAGIC
2810 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
2812 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2813 #ifdef NAMES_HAVE_UNDERSCORE
2814 *magicp
= MC68KBCSMAGIC
;
2816 *magicp
= MC68MAGIC
;
2820 /* Just overwrite the usual value if we're doing Lynx. */
2821 *magicp
= LYNXCOFFMAGIC
;
2826 #ifdef SH_ARCH_MAGIC_BIG
2828 #ifdef COFF_IMAGE_WITH_PE
2829 *magicp
= SH_ARCH_MAGIC_WINCE
;
2831 if (bfd_big_endian (abfd
))
2832 *magicp
= SH_ARCH_MAGIC_BIG
;
2834 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2839 #ifdef MIPS_ARCH_MAGIC_WINCE
2841 *magicp
= MIPS_ARCH_MAGIC_WINCE
;
2846 case bfd_arch_sparc
:
2847 *magicp
= SPARCMAGIC
;
2849 /* Just overwrite the usual value if we're doing Lynx. */
2850 *magicp
= LYNXCOFFMAGIC
;
2856 case bfd_arch_we32k
:
2857 *magicp
= WE32KMAGIC
;
2862 case bfd_arch_rs6000
:
2864 case bfd_arch_powerpc
:
2866 BFD_ASSERT (bfd_get_flavour (abfd
) == bfd_target_xcoff_flavour
);
2867 *magicp
= bfd_xcoff_magic_number (abfd
);
2872 case bfd_arch_mcore
:
2873 * magicp
= MCOREMAGIC
;
2883 default: /* Unknown architecture. */
2884 /* Fall through to "return FALSE" below, to avoid
2885 "statement never reached" errors on the one below. */
2893 coff_set_arch_mach (bfd
* abfd
,
2894 enum bfd_architecture arch
,
2895 unsigned long machine
)
2898 unsigned short dummy2
;
2900 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
2903 if (arch
!= bfd_arch_unknown
2904 && ! coff_set_flags (abfd
, &dummy1
, &dummy2
))
2905 return FALSE
; /* We can't represent this type. */
2907 return TRUE
; /* We're easy... */
2910 #ifdef COFF_IMAGE_WITH_PE
2912 /* This is used to sort sections by VMA, as required by PE image
2916 sort_by_secaddr (const void * arg1
, const void * arg2
)
2918 const asection
*a
= *(const asection
**) arg1
;
2919 const asection
*b
= *(const asection
**) arg2
;
2921 if (a
->vma
< b
->vma
)
2923 else if (a
->vma
> b
->vma
)
2929 #endif /* COFF_IMAGE_WITH_PE */
2931 /* Calculate the file position for each section. */
2933 #define ALIGN_SECTIONS_IN_FILE
2934 #if defined(TIC80COFF) || defined(TICOFF)
2935 #undef ALIGN_SECTIONS_IN_FILE
2939 coff_compute_section_file_positions (bfd
* abfd
)
2942 file_ptr sofar
= bfd_coff_filhsz (abfd
);
2943 bfd_boolean align_adjust
;
2944 unsigned int target_index
;
2945 #ifdef ALIGN_SECTIONS_IN_FILE
2946 asection
*previous
= NULL
;
2950 #ifdef COFF_IMAGE_WITH_PE
2953 if (coff_data (abfd
)->link_info
2954 || (pe_data (abfd
) && pe_data (abfd
)->pe_opthdr
.FileAlignment
))
2956 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
2958 /* If no file alignment has been set, default to one.
2959 This repairs 'ld -r' for arm-wince-pe target. */
2963 /* PR 17512: file: 0ac816d3. */
2966 bfd_set_error (bfd_error_file_too_big
);
2968 /* xgettext:c-format */
2969 (_("%pB: page size is too large (0x%x)"), abfd
, page_size
);
2974 page_size
= PE_DEF_FILE_ALIGNMENT
;
2976 #ifdef COFF_PAGE_SIZE
2977 int page_size
= COFF_PAGE_SIZE
;
2982 /* On XCOFF, if we have symbols, set up the .debug section. */
2983 if (bfd_get_symcount (abfd
) > 0)
2986 bfd_size_type i
, symcount
;
2990 symcount
= bfd_get_symcount (abfd
);
2991 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
2993 coff_symbol_type
*cf
;
2995 cf
= coff_symbol_from (*symp
);
2997 && cf
->native
!= NULL
2998 && cf
->native
->is_sym
2999 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
3003 len
= strlen (bfd_asymbol_name (*symp
));
3004 if (len
> SYMNMLEN
|| bfd_coff_force_symnames_in_strings (abfd
))
3005 sz
+= len
+ 1 + bfd_coff_debug_string_prefix_length (abfd
);
3012 dsec
= bfd_make_section_old_way (abfd
, DOT_DEBUG
);
3016 dsec
->flags
|= SEC_HAS_CONTENTS
;
3021 if (bfd_get_start_address (abfd
))
3022 /* A start address may have been added to the original file. In this
3023 case it will need an optional header to record it. */
3024 abfd
->flags
|= EXEC_P
;
3026 if (abfd
->flags
& EXEC_P
)
3027 sofar
+= bfd_coff_aoutsz (abfd
);
3029 else if (xcoff_data (abfd
)->full_aouthdr
)
3030 sofar
+= bfd_coff_aoutsz (abfd
);
3032 sofar
+= SMALL_AOUTSZ
;
3035 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
3038 /* XCOFF handles overflows in the reloc and line number count fields
3039 by allocating a new section header to hold the correct counts. */
3040 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3041 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3042 sofar
+= bfd_coff_scnhsz (abfd
);
3045 #ifdef COFF_IMAGE_WITH_PE
3047 /* PE requires the sections to be in memory order when listed in
3048 the section headers. It also does not like empty loadable
3049 sections. The sections apparently do not have to be in the
3050 right order in the image file itself, but we do need to get the
3051 target_index values right. */
3054 asection
**section_list
;
3058 #ifdef COFF_PAGE_SIZE
3059 /* Clear D_PAGED if section alignment is smaller than
3061 if (pe_data (abfd
)->pe_opthdr
.SectionAlignment
< COFF_PAGE_SIZE
)
3062 abfd
->flags
&= ~D_PAGED
;
3066 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3069 /* We allocate an extra cell to simplify the final loop. */
3070 amt
= sizeof (struct asection
*) * (count
+ 1);
3071 section_list
= (asection
**) bfd_malloc (amt
);
3072 if (section_list
== NULL
)
3076 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3078 section_list
[i
] = current
;
3081 section_list
[i
] = NULL
;
3083 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
3085 /* Rethread the linked list into sorted order; at the same time,
3086 assign target_index values. */
3088 abfd
->sections
= NULL
;
3089 abfd
->section_last
= NULL
;
3090 for (i
= 0; i
< count
; i
++)
3092 current
= section_list
[i
];
3093 bfd_section_list_append (abfd
, current
);
3095 /* Later, if the section has zero size, we'll be throwing it
3096 away, so we don't want to number it now. Note that having
3097 a zero size and having real contents are different
3098 concepts: .bss has no contents, but (usually) non-zero
3100 if (current
->size
== 0)
3102 /* Discard. However, it still might have (valid) symbols
3103 in it, so arbitrarily set it to section 1 (indexing is
3104 1-based here; usually .text). __end__ and other
3105 contents of .endsection really have this happen.
3106 FIXME: This seems somewhat dubious. */
3107 current
->target_index
= 1;
3110 current
->target_index
= target_index
++;
3113 free (section_list
);
3115 #else /* ! COFF_IMAGE_WITH_PE */
3117 /* Set the target_index field. */
3119 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3120 current
->target_index
= target_index
++;
3122 #endif /* ! COFF_IMAGE_WITH_PE */
3124 if (target_index
>= bfd_coff_max_nscns (abfd
))
3126 bfd_set_error (bfd_error_file_too_big
);
3128 /* xgettext:c-format */
3129 (_("%pB: too many sections (%d)"), abfd
, target_index
);
3133 align_adjust
= FALSE
;
3134 for (current
= abfd
->sections
;
3136 current
= current
->next
)
3138 #ifdef COFF_IMAGE_WITH_PE
3139 /* With PE we have to pad each section to be a multiple of its
3140 page size too, and remember both sizes. */
3141 if (coff_section_data (abfd
, current
) == NULL
)
3143 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
3145 current
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
3146 if (current
->used_by_bfd
== NULL
)
3149 if (pei_section_data (abfd
, current
) == NULL
)
3151 bfd_size_type amt
= sizeof (struct pei_section_tdata
);
3153 coff_section_data (abfd
, current
)->tdata
= bfd_zalloc (abfd
, amt
);
3154 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
3157 if (pei_section_data (abfd
, current
)->virt_size
== 0)
3158 pei_section_data (abfd
, current
)->virt_size
= current
->size
;
3161 /* Only deal with sections which have contents. */
3162 if (!(current
->flags
& SEC_HAS_CONTENTS
))
3165 current
->rawsize
= current
->size
;
3167 #ifdef COFF_IMAGE_WITH_PE
3168 /* Make sure we skip empty sections in a PE image. */
3169 if (current
->size
== 0)
3173 /* Align the sections in the file to the same boundary on
3174 which they are aligned in virtual memory. */
3175 #ifdef ALIGN_SECTIONS_IN_FILE
3176 if ((abfd
->flags
& EXEC_P
) != 0)
3178 /* Make sure this section is aligned on the right boundary - by
3179 padding the previous section up if necessary. */
3182 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3185 /* Make sure the file offset and the vma of .text/.data are at the
3186 same page offset, so that the file can be mmap'ed without being
3187 relocated. Failing that, AIX is able to load and execute the
3188 program, but it will be silently relocated (possible as
3189 executables are PIE). But the relocation is slightly costly and
3190 complexify the use of addr2line or gdb. So better to avoid it,
3191 like does the native linker. Usually gnu ld makes sure that
3192 the vma of .text is the file offset so this issue shouldn't
3193 appear unless you are stripping such an executable.
3195 AIX loader checks the text section alignment of (vma - filepos),
3196 and the native linker doesn't try to align the text sections.
3199 0 .text 000054cc 10000128 10000128 00000128 2**5
3200 CONTENTS, ALLOC, LOAD, CODE
3203 if (!strcmp (current
->name
, _TEXT
)
3204 || !strcmp (current
->name
, _DATA
))
3206 bfd_vma align
= 4096;
3207 bfd_vma sofar_off
= sofar
% align
;
3208 bfd_vma vma_off
= current
->vma
% align
;
3210 if (vma_off
> sofar_off
)
3211 sofar
+= vma_off
- sofar_off
;
3212 else if (vma_off
< sofar_off
)
3213 sofar
+= align
+ vma_off
- sofar_off
;
3216 if (previous
!= NULL
)
3217 previous
->size
+= sofar
- old_sofar
;
3222 /* In demand paged files the low order bits of the file offset
3223 must match the low order bits of the virtual address. */
3224 #ifdef COFF_PAGE_SIZE
3225 if ((abfd
->flags
& D_PAGED
) != 0
3226 && (current
->flags
& SEC_ALLOC
) != 0)
3227 sofar
+= (current
->vma
- (bfd_vma
) sofar
) % page_size
;
3229 current
->filepos
= sofar
;
3231 #ifdef COFF_IMAGE_WITH_PE
3232 /* Set the padded size. */
3233 current
->size
= (current
->size
+ page_size
- 1) & -page_size
;
3236 sofar
+= current
->size
;
3238 #ifdef ALIGN_SECTIONS_IN_FILE
3239 /* Make sure that this section is of the right size too. */
3240 if ((abfd
->flags
& EXEC_P
) == 0)
3242 bfd_size_type old_size
;
3244 old_size
= current
->size
;
3245 current
->size
= BFD_ALIGN (current
->size
,
3246 1 << current
->alignment_power
);
3247 align_adjust
= current
->size
!= old_size
;
3248 sofar
+= current
->size
- old_size
;
3253 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3254 align_adjust
= sofar
!= old_sofar
;
3255 current
->size
+= sofar
- old_sofar
;
3259 #ifdef COFF_IMAGE_WITH_PE
3260 /* For PE we need to make sure we pad out to the aligned
3261 size, in case the caller only writes out data to the
3263 if (pei_section_data (abfd
, current
)->virt_size
< current
->size
)
3264 align_adjust
= TRUE
;
3268 /* Force .lib sections to start at zero. The vma is then
3269 incremented in coff_set_section_contents. This is right for
3271 if (strcmp (current
->name
, _LIB
) == 0)
3272 (void) bfd_set_section_vma (abfd
, current
, 0);
3275 #ifdef ALIGN_SECTIONS_IN_FILE
3280 /* It is now safe to write to the output file. If we needed an
3281 alignment adjustment for the last section, then make sure that
3282 there is a byte at offset sofar. If there are no symbols and no
3283 relocs, then nothing follows the last section. If we don't force
3284 the last byte out, then the file may appear to be truncated. */
3290 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
3291 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3295 /* Make sure the relocations are aligned. We don't need to make
3296 sure that this byte exists, because it will only matter if there
3297 really are relocs. */
3298 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
3300 obj_relocbase (abfd
) = sofar
;
3301 abfd
->output_has_begun
= TRUE
;
3306 #ifdef COFF_IMAGE_WITH_PE
3308 static unsigned int pelength
;
3309 static unsigned int peheader
;
3312 coff_read_word (bfd
*abfd
, unsigned int *value
)
3317 status
= bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3325 *value
= (unsigned int) b
[0];
3327 *value
= (unsigned int) (b
[0] + (b
[1] << 8));
3329 pelength
+= (unsigned int) status
;
3335 coff_compute_checksum (bfd
*abfd
)
3337 bfd_boolean more_data
;
3344 filepos
= (file_ptr
) 0;
3348 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
3351 more_data
= coff_read_word (abfd
, &value
);
3353 total
= 0xffff & (total
+ (total
>> 0x10));
3358 return (0xffff & (total
+ (total
>> 0x10)));
3362 coff_apply_checksum (bfd
*abfd
)
3364 unsigned int computed
;
3365 unsigned int checksum
= 0;
3367 if (bfd_seek (abfd
, 0x3c, SEEK_SET
) != 0)
3370 if (!coff_read_word (abfd
, &peheader
))
3373 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3377 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3379 if (bfd_seek (abfd
, peheader
, SEEK_SET
) != 0)
3382 computed
= coff_compute_checksum (abfd
);
3384 checksum
= computed
+ pelength
;
3386 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3389 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3394 #endif /* COFF_IMAGE_WITH_PE */
3397 coff_write_object_contents (bfd
* abfd
)
3400 bfd_boolean hasrelocs
= FALSE
;
3401 bfd_boolean haslinno
= FALSE
;
3402 #ifdef COFF_IMAGE_WITH_PE
3403 bfd_boolean hasdebug
= FALSE
;
3406 file_ptr reloc_base
;
3407 file_ptr lineno_base
;
3409 unsigned long reloc_size
= 0, reloc_count
= 0;
3410 unsigned long lnno_size
= 0;
3411 bfd_boolean long_section_names
;
3412 asection
*text_sec
= NULL
;
3413 asection
*data_sec
= NULL
;
3414 asection
*bss_sec
= NULL
;
3415 struct internal_filehdr internal_f
;
3416 struct internal_aouthdr internal_a
;
3417 #ifdef COFF_LONG_SECTION_NAMES
3418 size_t string_size
= STRING_SIZE_SIZE
;
3421 bfd_set_error (bfd_error_system_call
);
3423 /* Make a pass through the symbol table to count line number entries and
3424 put them into the correct asections. */
3425 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3427 if (! abfd
->output_has_begun
)
3429 if (! coff_compute_section_file_positions (abfd
))
3433 reloc_base
= obj_relocbase (abfd
);
3435 /* Work out the size of the reloc and linno areas. */
3437 for (current
= abfd
->sections
; current
!= NULL
; current
=
3441 /* We store the actual reloc count in the first reloc's addr. */
3442 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3445 reloc_count
+= current
->reloc_count
;
3448 reloc_size
= reloc_count
* bfd_coff_relsz (abfd
);
3450 lineno_base
= reloc_base
+ reloc_size
;
3451 sym_base
= lineno_base
+ lnno_size
;
3453 /* Indicate in each section->line_filepos its actual file address. */
3454 for (current
= abfd
->sections
; current
!= NULL
; current
=
3457 if (current
->lineno_count
)
3459 current
->line_filepos
= lineno_base
;
3460 current
->moving_line_filepos
= lineno_base
;
3461 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3464 current
->line_filepos
= 0;
3466 if (current
->reloc_count
)
3468 current
->rel_filepos
= reloc_base
;
3469 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3471 /* Extra reloc to hold real count. */
3472 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3473 reloc_base
+= bfd_coff_relsz (abfd
);
3477 current
->rel_filepos
= 0;
3480 /* Write section headers to the file. */
3481 internal_f
.f_nscns
= 0;
3483 if ((abfd
->flags
& EXEC_P
) != 0)
3484 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3487 scn_base
= bfd_coff_filhsz (abfd
);
3490 if (xcoff_data (abfd
)->full_aouthdr
)
3491 scn_base
+= bfd_coff_aoutsz (abfd
);
3493 scn_base
+= SMALL_AOUTSZ
;
3498 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3501 long_section_names
= FALSE
;
3502 for (current
= abfd
->sections
;
3504 current
= current
->next
)
3506 struct internal_scnhdr section
;
3507 #ifdef COFF_IMAGE_WITH_PE
3508 bfd_boolean is_reloc_section
= FALSE
;
3510 if (strcmp (current
->name
, DOT_RELOC
) == 0)
3512 is_reloc_section
= TRUE
;
3514 pe_data (abfd
)->has_reloc_section
= 1;
3518 internal_f
.f_nscns
++;
3520 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3522 #ifdef COFF_LONG_SECTION_NAMES
3523 /* Handle long section names as in PE. This must be compatible
3524 with the code in coff_write_symbols and _bfd_coff_final_link. */
3525 if (bfd_coff_long_section_names (abfd
))
3529 len
= strlen (current
->name
);
3532 /* The s_name field is defined to be NUL-padded but need not be
3533 NUL-terminated. We use a temporary buffer so that we can still
3534 sprintf all eight chars without splatting a terminating NUL
3535 over the first byte of the following member (s_paddr). */
3536 /* PR 21096: The +20 is to stop a bogus warning from gcc7 about
3537 a possible buffer overflow. */
3538 char s_name_buf
[SCNNMLEN
+ 1 + 20];
3540 /* An inherent limitation of the /nnnnnnn notation used to indicate
3541 the offset of the long name in the string table is that we
3542 cannot address entries beyone the ten million byte boundary. */
3543 if (string_size
>= 10000000)
3545 bfd_set_error (bfd_error_file_too_big
);
3547 /* xgettext:c-format */
3548 (_("%pB: section %pA: string table overflow at offset %ld"),
3549 abfd
, current
, (unsigned long) string_size
);
3553 /* We do not need to use snprintf here as we have already verfied
3554 that string_size is not too big, plus we have an overlarge
3555 buffer, just in case. */
3556 sprintf (s_name_buf
, "/%lu", (unsigned long) string_size
);
3557 /* Then strncpy takes care of any padding for us. */
3558 strncpy (section
.s_name
, s_name_buf
, SCNNMLEN
);
3559 string_size
+= len
+ 1;
3560 long_section_names
= TRUE
;
3566 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3567 Ian Taylor <ian@cygnus.com>. */
3568 if (strcmp (current
->name
, _LIB
) == 0)
3569 section
.s_vaddr
= 0;
3572 section
.s_vaddr
= current
->vma
;
3573 section
.s_paddr
= current
->lma
;
3574 section
.s_size
= current
->size
;
3575 #ifdef coff_get_section_load_page
3576 section
.s_page
= coff_get_section_load_page (current
);
3582 section
.s_paddr
= 0;
3584 #ifdef COFF_IMAGE_WITH_PE
3585 /* Reminder: s_paddr holds the virtual size of the section. */
3586 if (coff_section_data (abfd
, current
) != NULL
3587 && pei_section_data (abfd
, current
) != NULL
)
3588 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3590 section
.s_paddr
= 0;
3593 /* If this section has no size or is unloadable then the scnptr
3595 if (current
->size
== 0
3596 || (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3597 section
.s_scnptr
= 0;
3599 section
.s_scnptr
= current
->filepos
;
3601 section
.s_relptr
= current
->rel_filepos
;
3602 section
.s_lnnoptr
= current
->line_filepos
;
3603 section
.s_nreloc
= current
->reloc_count
;
3604 section
.s_nlnno
= current
->lineno_count
;
3605 #ifndef COFF_IMAGE_WITH_PE
3606 /* In PEI, relocs come in the .reloc section. */
3607 if (current
->reloc_count
!= 0)
3610 if (current
->lineno_count
!= 0)
3612 #ifdef COFF_IMAGE_WITH_PE
3613 if ((current
->flags
& SEC_DEBUGGING
) != 0
3614 && ! is_reloc_section
)
3620 /* Indicate the use of an XCOFF overflow section header. */
3621 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3623 section
.s_nreloc
= 0xffff;
3624 section
.s_nlnno
= 0xffff;
3629 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3631 if (!strcmp (current
->name
, _TEXT
))
3633 else if (!strcmp (current
->name
, _DATA
))
3635 else if (!strcmp (current
->name
, _BSS
))
3638 #ifdef COFF_ENCODE_ALIGNMENT
3639 COFF_ENCODE_ALIGNMENT(section
, current
->alignment_power
);
3640 if ((unsigned int)COFF_DECODE_ALIGNMENT(section
.s_flags
)
3641 != current
->alignment_power
)
3643 bfd_boolean warn
= coff_data (abfd
)->link_info
3644 && !bfd_link_relocatable (coff_data (abfd
)->link_info
);
3647 /* xgettext:c-format */
3648 (_("%pB:%s section %s: alignment 2**%u not representable"),
3649 abfd
, warn
? " warning:" : "", current
->name
,
3650 current
->alignment_power
);
3653 bfd_set_error (bfd_error_nonrepresentable_section
);
3659 #ifdef COFF_IMAGE_WITH_PE
3660 /* Suppress output of the sections if they are null. ld
3661 includes the bss and data sections even if there is no size
3662 assigned to them. NT loader doesn't like it if these section
3663 headers are included if the sections themselves are not
3664 needed. See also coff_compute_section_file_positions. */
3665 if (section
.s_size
== 0)
3666 internal_f
.f_nscns
--;
3671 bfd_size_type amt
= bfd_coff_scnhsz (abfd
);
3673 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3674 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3679 /* PE stores COMDAT section information in the symbol table. If
3680 this section is supposed to have some COMDAT info, track down
3681 the symbol in the symbol table and modify it. */
3682 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3684 unsigned int i
, count
;
3686 coff_symbol_type
*csym
= NULL
;
3690 count
= bfd_get_symcount (abfd
);
3691 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3693 if ((*psym
)->section
!= current
)
3696 /* Remember the location of the first symbol in this
3698 if (psymsec
== NULL
)
3701 /* See if this is the section symbol. */
3702 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3704 csym
= coff_symbol_from (*psym
);
3706 || csym
->native
== NULL
3707 || ! csym
->native
->is_sym
3708 || csym
->native
->u
.syment
.n_numaux
< 1
3709 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3710 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3713 /* Here *PSYM is the section symbol for CURRENT. */
3720 Note that we might not if we're converting the file from
3721 some other object file format. */
3724 combined_entry_type
*aux
;
3726 /* We don't touch the x_checksum field. The
3727 x_associated field is not currently supported. */
3729 aux
= csym
->native
+ 1;
3730 BFD_ASSERT (! aux
->is_sym
);
3731 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3733 case SEC_LINK_DUPLICATES_DISCARD
:
3734 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3737 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3738 aux
->u
.auxent
.x_scn
.x_comdat
=
3739 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3742 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3743 aux
->u
.auxent
.x_scn
.x_comdat
=
3744 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3747 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3748 aux
->u
.auxent
.x_scn
.x_comdat
=
3749 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3753 /* The COMDAT symbol must be the first symbol from this
3754 section in the symbol table. In order to make this
3755 work, we move the COMDAT symbol before the first
3756 symbol we found in the search above. It's OK to
3757 rearrange the symbol table at this point, because
3758 coff_renumber_symbols is going to rearrange it
3759 further and fix up all the aux entries. */
3760 if (psym
!= psymsec
)
3766 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3767 pcopy
[0] = pcopy
[-1];
3772 #endif /* COFF_WITH_PE */
3777 /* XCOFF handles overflows in the reloc and line number count fields
3778 by creating a new section header to hold the correct values. */
3779 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3781 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3783 struct internal_scnhdr scnhdr
;
3787 internal_f
.f_nscns
++;
3788 memcpy (scnhdr
.s_name
, ".ovrflo", 8);
3789 scnhdr
.s_paddr
= current
->reloc_count
;
3790 scnhdr
.s_vaddr
= current
->lineno_count
;
3792 scnhdr
.s_scnptr
= 0;
3793 scnhdr
.s_relptr
= current
->rel_filepos
;
3794 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3795 scnhdr
.s_nreloc
= current
->target_index
;
3796 scnhdr
.s_nlnno
= current
->target_index
;
3797 scnhdr
.s_flags
= STYP_OVRFLO
;
3798 amt
= bfd_coff_scnhsz (abfd
);
3799 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3800 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3807 /* OK, now set up the filehdr... */
3809 /* Don't include the internal abs section in the section count */
3811 /* We will NOT put a fucking timestamp in the header here. Every time you
3812 put it back, I will come in and take it out again. I'm sorry. This
3813 field does not belong here. We fill it with a 0 so it compares the
3814 same but is not a reasonable time. -- gnu@cygnus.com */
3815 internal_f
.f_timdat
= 0;
3816 internal_f
.f_flags
= 0;
3818 if (abfd
->flags
& EXEC_P
)
3819 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3822 internal_f
.f_opthdr
= 0;
3825 if (xcoff_data (abfd
)->full_aouthdr
)
3826 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3828 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
3834 internal_f
.f_flags
|= F_RELFLG
;
3836 internal_f
.f_flags
|= F_LNNO
;
3837 if (abfd
->flags
& EXEC_P
)
3838 internal_f
.f_flags
|= F_EXEC
;
3839 #ifdef COFF_IMAGE_WITH_PE
3841 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
3842 if (pe_data (abfd
)->real_flags
& IMAGE_FILE_LARGE_ADDRESS_AWARE
)
3843 internal_f
.f_flags
|= IMAGE_FILE_LARGE_ADDRESS_AWARE
;
3846 #ifndef COFF_WITH_pex64
3848 internal_f
.f_flags
|= IMAGE_FILE_32BIT_MACHINE
;
3850 if (bfd_little_endian (abfd
))
3851 internal_f
.f_flags
|= F_AR32WR
;
3853 internal_f
.f_flags
|= F_AR32W
;
3858 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
3859 but it doesn't hurt to set it internally. */
3860 internal_f
.f_target_id
= TI_TARGET_ID
;
3862 #ifdef TIC80_TARGET_ID
3863 internal_f
.f_target_id
= TIC80_TARGET_ID
;
3866 /* FIXME, should do something about the other byte orders and
3870 if ((abfd
->flags
& DYNAMIC
) != 0)
3871 internal_f
.f_flags
|= F_SHROBJ
;
3872 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
3873 internal_f
.f_flags
|= F_DYNLOAD
;
3876 memset (&internal_a
, 0, sizeof internal_a
);
3878 /* Set up architecture-dependent stuff. */
3880 unsigned int magic
= 0;
3881 unsigned short flags
= 0;
3883 coff_set_flags (abfd
, &magic
, &flags
);
3884 internal_f
.f_magic
= magic
;
3885 internal_f
.f_flags
|= flags
;
3886 /* ...and the "opt"hdr... */
3888 #ifdef TICOFF_AOUT_MAGIC
3889 internal_a
.magic
= TICOFF_AOUT_MAGIC
;
3890 #define __A_MAGIC_SET__
3893 internal_a
.magic
= TIC80_ARCH_MAGIC
;
3894 #define __A_MAGIC_SET__
3898 #define __A_MAGIC_SET__
3899 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
3902 #if defined(M68) || defined(WE32K) || defined(M68K)
3903 #define __A_MAGIC_SET__
3905 internal_a
.magic
= LYNXCOFFMAGIC
;
3907 #if defined(TARG_AUX)
3908 internal_a
.magic
= (abfd
->flags
& D_PAGED
? PAGEMAGICPEXECPAGED
:
3909 abfd
->flags
& WP_TEXT
? PAGEMAGICPEXECSWAPPED
:
3910 PAGEMAGICEXECSWAPPED
);
3912 #if defined (PAGEMAGICPEXECPAGED)
3913 internal_a
.magic
= PAGEMAGICPEXECPAGED
;
3915 #endif /* TARG_AUX */
3917 #endif /* M68 || WE32K || M68K */
3920 #define __A_MAGIC_SET__
3921 internal_a
.magic
= ZMAGIC
;
3925 #define __A_MAGIC_SET__
3926 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3929 #if defined MCORE_PE
3930 #define __A_MAGIC_SET__
3931 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3935 #define __A_MAGIC_SET__
3937 internal_a
.magic
= LYNXCOFFMAGIC
;
3939 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR64_MAGIC
;
3941 internal_a
.magic
= ZMAGIC
;
3946 #define __A_MAGIC_SET__
3947 internal_a
.magic
= PE32PMAGIC
;
3951 #define __A_MAGIC_SET__
3953 internal_a
.magic
= LYNXCOFFMAGIC
;
3958 #define __A_MAGIC_SET__
3959 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
3960 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
3961 RS6K_AOUTHDR_OMAGIC
;
3964 #if defined(SH) && defined(COFF_WITH_PE)
3965 #define __A_MAGIC_SET__
3966 internal_a
.magic
= SH_PE_MAGIC
;
3969 #if defined(MIPS) && defined(COFF_WITH_PE)
3970 #define __A_MAGIC_SET__
3971 internal_a
.magic
= MIPS_PE_MAGIC
;
3974 #ifndef __A_MAGIC_SET__
3975 #include "Your aouthdr magic number is not being set!"
3977 #undef __A_MAGIC_SET__
3981 /* FIXME: Does anybody ever set this to another value? */
3982 internal_a
.vstamp
= 0;
3984 /* Now should write relocs, strings, syms. */
3985 obj_sym_filepos (abfd
) = sym_base
;
3987 if (bfd_get_symcount (abfd
) != 0)
3991 if (!coff_renumber_symbols (abfd
, &firstundef
))
3993 coff_mangle_symbols (abfd
);
3994 if (! coff_write_symbols (abfd
))
3996 if (! coff_write_linenumbers (abfd
))
3998 if (! coff_write_relocs (abfd
, firstundef
))
4001 #ifdef COFF_LONG_SECTION_NAMES
4002 else if (long_section_names
&& ! obj_coff_strings_written (abfd
))
4004 /* If we have long section names we have to write out the string
4005 table even if there are no symbols. */
4006 if (! coff_write_symbols (abfd
))
4010 #ifdef COFF_IMAGE_WITH_PE
4012 else if ((abfd
->flags
& EXEC_P
) != 0)
4016 /* PowerPC PE appears to require that all executable files be
4017 rounded up to the page size. */
4020 (file_ptr
) BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
4022 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
4028 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
4029 backend linker, and obj_raw_syment_count is not valid until after
4030 coff_write_symbols is called. */
4031 if (obj_raw_syment_count (abfd
) != 0)
4033 internal_f
.f_symptr
= sym_base
;
4035 /* AIX appears to require that F_RELFLG not be set if there are
4036 local symbols but no relocations. */
4037 internal_f
.f_flags
&=~ F_RELFLG
;
4042 if (long_section_names
)
4043 internal_f
.f_symptr
= sym_base
;
4045 internal_f
.f_symptr
= 0;
4046 internal_f
.f_flags
|= F_LSYMS
;
4051 internal_a
.tsize
= text_sec
->size
;
4052 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
4056 internal_a
.dsize
= data_sec
->size
;
4057 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
4061 internal_a
.bsize
= bss_sec
->size
;
4062 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
4063 internal_a
.data_start
= bss_sec
->vma
;
4066 internal_a
.entry
= bfd_get_start_address (abfd
);
4067 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
4070 if (xcoff_data (abfd
)->full_aouthdr
)
4073 asection
*loader_sec
;
4075 internal_a
.vstamp
= 1;
4077 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
4078 if (internal_a
.o_snentry
== 0)
4079 internal_a
.entry
= (bfd_vma
) -1;
4081 if (text_sec
!= NULL
)
4083 internal_a
.o_sntext
= text_sec
->target_index
;
4084 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
4088 internal_a
.o_sntext
= 0;
4089 internal_a
.o_algntext
= 0;
4091 if (data_sec
!= NULL
)
4093 internal_a
.o_sndata
= data_sec
->target_index
;
4094 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
4098 internal_a
.o_sndata
= 0;
4099 internal_a
.o_algndata
= 0;
4101 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
4102 if (loader_sec
!= NULL
)
4103 internal_a
.o_snloader
= loader_sec
->target_index
;
4105 internal_a
.o_snloader
= 0;
4106 if (bss_sec
!= NULL
)
4107 internal_a
.o_snbss
= bss_sec
->target_index
;
4109 internal_a
.o_snbss
= 0;
4111 toc
= xcoff_data (abfd
)->toc
;
4112 internal_a
.o_toc
= toc
;
4113 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
4115 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
4116 if (xcoff_data (abfd
)->cputype
!= -1)
4117 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
4120 switch (bfd_get_arch (abfd
))
4122 case bfd_arch_rs6000
:
4123 internal_a
.o_cputype
= 4;
4125 case bfd_arch_powerpc
:
4126 if (bfd_get_mach (abfd
) == bfd_mach_ppc
)
4127 internal_a
.o_cputype
= 3;
4129 internal_a
.o_cputype
= 1;
4135 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
4136 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
4142 /* After object contents are finalized so we can compute a reasonable hash,
4143 but before header is written so we can update it to point to debug directory. */
4144 struct pe_tdata
*pe
= pe_data (abfd
);
4146 if (pe
->build_id
.after_write_object_contents
!= NULL
)
4147 (*pe
->build_id
.after_write_object_contents
) (abfd
);
4151 /* Now write header. */
4152 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
4157 bfd_size_type amount
= bfd_coff_filhsz (abfd
);
4159 buff
= (char *) bfd_malloc (amount
);
4163 bfd_coff_swap_filehdr_out (abfd
, & internal_f
, buff
);
4164 amount
= bfd_bwrite (buff
, amount
, abfd
);
4168 if (amount
!= bfd_coff_filhsz (abfd
))
4172 if (abfd
->flags
& EXEC_P
)
4174 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4175 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4177 bfd_size_type amount
= bfd_coff_aoutsz (abfd
);
4179 buff
= (char *) bfd_malloc (amount
);
4183 coff_swap_aouthdr_out (abfd
, & internal_a
, buff
);
4184 amount
= bfd_bwrite (buff
, amount
, abfd
);
4188 if (amount
!= bfd_coff_aoutsz (abfd
))
4191 #ifdef COFF_IMAGE_WITH_PE
4192 if (! coff_apply_checksum (abfd
))
4202 /* XCOFF seems to always write at least a small a.out header. */
4203 coff_swap_aouthdr_out (abfd
, & internal_a
, & buff
);
4204 if (xcoff_data (abfd
)->full_aouthdr
)
4205 size
= bfd_coff_aoutsz (abfd
);
4207 size
= SMALL_AOUTSZ
;
4208 if (bfd_bwrite (& buff
, (bfd_size_type
) size
, abfd
) != size
)
4217 coff_set_section_contents (bfd
* abfd
,
4219 const void * location
,
4221 bfd_size_type count
)
4223 if (! abfd
->output_has_begun
) /* Set by bfd.c handler. */
4225 if (! coff_compute_section_file_positions (abfd
))
4229 #if defined(_LIB) && !defined(TARG_AUX)
4230 /* The physical address field of a .lib section is used to hold the
4231 number of shared libraries in the section. This code counts the
4232 number of sections being written, and increments the lma field
4235 I have found no documentation on the contents of this section.
4236 Experimentation indicates that the section contains zero or more
4237 records, each of which has the following structure:
4239 - a (four byte) word holding the length of this record, in words,
4240 - a word that always seems to be set to "2",
4241 - the path to a shared library, null-terminated and then padded
4242 to a whole word boundary.
4244 bfd_assert calls have been added to alert if an attempt is made
4245 to write a section which doesn't follow these assumptions. The
4246 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4247 <robertl@arnet.com> (Thanks!).
4249 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4250 if (strcmp (section
->name
, _LIB
) == 0)
4252 bfd_byte
*rec
, *recend
;
4254 rec
= (bfd_byte
*) location
;
4255 recend
= rec
+ count
;
4256 while (rec
< recend
)
4259 rec
+= bfd_get_32 (abfd
, rec
) * 4;
4262 BFD_ASSERT (rec
== recend
);
4266 /* Don't write out bss sections - one way to do this is to
4267 see if the filepos has not been set. */
4268 if (section
->filepos
== 0)
4271 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0)
4277 return bfd_bwrite (location
, count
, abfd
) == count
;
4281 buy_and_read (bfd
*abfd
, file_ptr where
, bfd_size_type size
)
4283 void * area
= bfd_alloc (abfd
, size
);
4287 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0
4288 || bfd_bread (area
, size
, abfd
) != size
)
4297 Creating the linenumber table is done by reading in the entire
4298 coff linenumber table, and creating another table for internal use.
4300 A coff linenumber table is structured so that each function
4301 is marked as having a line number of 0. Each line within the
4302 function is an offset from the first line in the function. The
4303 base of the line number information for the table is stored in
4304 the symbol associated with the function.
4306 Note: The PE format uses line number 0 for a flag indicating a
4309 The information is copied from the external to the internal
4310 table, and each symbol which marks a function is marked by
4313 How does this work ?
4317 coff_sort_func_alent (const void * arg1
, const void * arg2
)
4319 const alent
*al1
= *(const alent
**) arg1
;
4320 const alent
*al2
= *(const alent
**) arg2
;
4321 const coff_symbol_type
*s1
= (const coff_symbol_type
*) (al1
->u
.sym
);
4322 const coff_symbol_type
*s2
= (const coff_symbol_type
*) (al2
->u
.sym
);
4324 if (s1
== NULL
|| s2
== NULL
)
4326 if (s1
->symbol
.value
< s2
->symbol
.value
)
4328 else if (s1
->symbol
.value
> s2
->symbol
.value
)
4335 coff_slurp_line_table (bfd
*abfd
, asection
*asect
)
4337 LINENO
*native_lineno
;
4338 alent
*lineno_cache
;
4340 unsigned int counter
;
4342 bfd_vma prev_offset
= 0;
4343 bfd_boolean ordered
= TRUE
;
4344 unsigned int nbr_func
;
4346 bfd_boolean have_func
;
4347 bfd_boolean ret
= TRUE
;
4349 BFD_ASSERT (asect
->lineno
== NULL
);
4351 if (asect
->lineno_count
> asect
->size
)
4354 (_("%pB: warning: line number count (%#lx) exceeds section size (%#lx)"),
4355 abfd
, (unsigned long) asect
->lineno_count
, (unsigned long) asect
->size
);
4359 amt
= ((bfd_size_type
) asect
->lineno_count
+ 1) * sizeof (alent
);
4360 lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
);
4361 if (lineno_cache
== NULL
)
4364 amt
= (bfd_size_type
) bfd_coff_linesz (abfd
) * asect
->lineno_count
;
4365 native_lineno
= (LINENO
*) buy_and_read (abfd
, asect
->line_filepos
, amt
);
4366 if (native_lineno
== NULL
)
4369 (_("%pB: warning: line number table read failed"), abfd
);
4370 bfd_release (abfd
, lineno_cache
);
4374 cache_ptr
= lineno_cache
;
4375 asect
->lineno
= lineno_cache
;
4376 src
= native_lineno
;
4380 for (counter
= 0; counter
< asect
->lineno_count
; counter
++, src
++)
4382 struct internal_lineno dst
;
4384 bfd_coff_swap_lineno_in (abfd
, src
, &dst
);
4385 cache_ptr
->line_number
= dst
.l_lnno
;
4386 /* Appease memory checkers that get all excited about
4387 uninitialised memory when copying alents if u.offset is
4388 larger than u.sym. (64-bit BFD on 32-bit host.) */
4389 memset (&cache_ptr
->u
, 0, sizeof (cache_ptr
->u
));
4391 if (cache_ptr
->line_number
== 0)
4393 combined_entry_type
* ent
;
4394 unsigned long symndx
;
4395 coff_symbol_type
*sym
;
4398 symndx
= dst
.l_addr
.l_symndx
;
4399 if (symndx
>= obj_raw_syment_count (abfd
))
4402 /* xgettext:c-format */
4403 (_("%pB: warning: illegal symbol index 0x%lx in line number entry %d"),
4404 abfd
, symndx
, counter
);
4405 cache_ptr
->line_number
= -1;
4410 ent
= obj_raw_syments (abfd
) + symndx
;
4411 /* FIXME: We should not be casting between ints and
4412 pointers like this. */
4416 /* xgettext:c-format */
4417 (_("%pB: warning: illegal symbol index 0x%lx in line number entry %d"),
4418 abfd
, symndx
, counter
);
4419 cache_ptr
->line_number
= -1;
4423 sym
= (coff_symbol_type
*) (ent
->u
.syment
._n
._n_n
._n_zeroes
);
4425 /* PR 17512 file: 078-10659-0.004 */
4426 if (sym
< obj_symbols (abfd
)
4427 || sym
>= obj_symbols (abfd
) + bfd_get_symcount (abfd
))
4430 /* xgettext:c-format */
4431 (_("%pB: warning: illegal symbol in line number entry %d"),
4433 cache_ptr
->line_number
= -1;
4440 cache_ptr
->u
.sym
= (asymbol
*) sym
;
4441 if (sym
->lineno
!= NULL
)
4443 /* xgettext:c-format */
4444 (_("%pB: warning: duplicate line number information for `%s'"),
4445 abfd
, bfd_asymbol_name (&sym
->symbol
));
4447 sym
->lineno
= cache_ptr
;
4448 if (sym
->symbol
.value
< prev_offset
)
4450 prev_offset
= sym
->symbol
.value
;
4452 else if (!have_func
)
4453 /* Drop line information that has no associated function.
4454 PR 17521: file: 078-10659-0.004. */
4457 cache_ptr
->u
.offset
= (dst
.l_addr
.l_paddr
4458 - bfd_section_vma (abfd
, asect
));
4462 asect
->lineno_count
= cache_ptr
- lineno_cache
;
4463 memset (cache_ptr
, 0, sizeof (*cache_ptr
));
4464 bfd_release (abfd
, native_lineno
);
4466 /* On some systems (eg AIX5.3) the lineno table may not be sorted. */
4469 /* Sort the table. */
4471 alent
*n_lineno_cache
;
4473 /* Create a table of functions. */
4474 func_table
= (alent
**) bfd_alloc (abfd
, nbr_func
* sizeof (alent
*));
4475 if (func_table
!= NULL
)
4477 alent
**p
= func_table
;
4480 for (i
= 0; i
< asect
->lineno_count
; i
++)
4481 if (lineno_cache
[i
].line_number
== 0)
4482 *p
++ = &lineno_cache
[i
];
4484 BFD_ASSERT ((unsigned int) (p
- func_table
) == nbr_func
);
4486 /* Sort by functions. */
4487 qsort (func_table
, nbr_func
, sizeof (alent
*), coff_sort_func_alent
);
4489 /* Create the new sorted table. */
4490 amt
= (bfd_size_type
) asect
->lineno_count
* sizeof (alent
);
4491 n_lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
);
4492 if (n_lineno_cache
!= NULL
)
4494 alent
*n_cache_ptr
= n_lineno_cache
;
4496 for (i
= 0; i
< nbr_func
; i
++)
4498 coff_symbol_type
*sym
;
4499 alent
*old_ptr
= func_table
[i
];
4501 /* Update the function entry. */
4502 sym
= (coff_symbol_type
*) old_ptr
->u
.sym
;
4503 /* PR binutils/17512: Point the lineno to where
4504 this entry will be after the memcpy below. */
4505 sym
->lineno
= lineno_cache
+ (n_cache_ptr
- n_lineno_cache
);
4506 /* Copy the function and line number entries. */
4508 *n_cache_ptr
++ = *old_ptr
++;
4509 while (old_ptr
->line_number
!= 0);
4511 BFD_ASSERT ((bfd_size_type
) (n_cache_ptr
- n_lineno_cache
) == (amt
/ sizeof (alent
)));
4513 memcpy (lineno_cache
, n_lineno_cache
, amt
);
4517 bfd_release (abfd
, func_table
);
4526 /* Slurp in the symbol table, converting it to generic form. Note
4527 that if coff_relocate_section is defined, the linker will read
4528 symbols via coff_link_add_symbols, rather than via this routine. */
4531 coff_slurp_symbol_table (bfd
* abfd
)
4533 combined_entry_type
*native_symbols
;
4534 coff_symbol_type
*cached_area
;
4535 unsigned int *table_ptr
;
4537 unsigned int number_of_symbols
= 0;
4538 bfd_boolean ret
= TRUE
;
4540 if (obj_symbols (abfd
))
4543 /* Read in the symbol table. */
4544 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4547 /* Allocate enough room for all the symbols in cached form. */
4548 amt
= obj_raw_syment_count (abfd
);
4549 amt
*= sizeof (coff_symbol_type
);
4550 cached_area
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
4551 if (cached_area
== NULL
)
4554 amt
= obj_raw_syment_count (abfd
);
4555 amt
*= sizeof (unsigned int);
4556 table_ptr
= (unsigned int *) bfd_zalloc (abfd
, amt
);
4558 if (table_ptr
== NULL
)
4562 coff_symbol_type
*dst
= cached_area
;
4563 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4564 unsigned int this_index
= 0;
4566 while (this_index
< last_native_index
)
4568 combined_entry_type
*src
= native_symbols
+ this_index
;
4569 table_ptr
[this_index
] = number_of_symbols
;
4571 dst
->symbol
.the_bfd
= abfd
;
4572 BFD_ASSERT (src
->is_sym
);
4573 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4574 /* We use the native name field to point to the cached field. */
4575 src
->u
.syment
._n
._n_n
._n_zeroes
= (bfd_hostptr_t
) dst
;
4576 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4577 src
->u
.syment
.n_scnum
);
4578 dst
->symbol
.flags
= 0;
4579 /* PR 17512: file: 079-7098-0.001:0.1. */
4580 dst
->symbol
.value
= 0;
4581 dst
->done_lineno
= FALSE
;
4583 switch (src
->u
.syment
.n_sclass
)
4589 case C_THUMBEXTFUNC
:
4593 #if ! defined _AIX52 && ! defined AIX_WEAK_SUPPORT
4598 case C_SYSTEM
: /* System Wide variable. */
4601 /* In PE, 0x68 (104) denotes a section symbol. */
4603 /* In PE, 0x69 (105) denotes a weak external symbol. */
4606 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4608 case COFF_SYMBOL_GLOBAL
:
4609 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4610 #if defined COFF_WITH_PE
4611 /* PE sets the symbol to a value relative to the
4612 start of the section. */
4613 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4615 dst
->symbol
.value
= (src
->u
.syment
.n_value
4616 - dst
->symbol
.section
->vma
);
4618 if (ISFCN ((src
->u
.syment
.n_type
)))
4619 /* A function ext does not go at the end of a
4621 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4624 case COFF_SYMBOL_COMMON
:
4625 dst
->symbol
.section
= bfd_com_section_ptr
;
4626 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4629 case COFF_SYMBOL_UNDEFINED
:
4630 dst
->symbol
.section
= bfd_und_section_ptr
;
4631 dst
->symbol
.value
= 0;
4634 case COFF_SYMBOL_PE_SECTION
:
4635 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4636 dst
->symbol
.value
= 0;
4639 case COFF_SYMBOL_LOCAL
:
4640 dst
->symbol
.flags
= BSF_LOCAL
;
4641 #if defined COFF_WITH_PE
4642 /* PE sets the symbol to a value relative to the
4643 start of the section. */
4644 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4646 dst
->symbol
.value
= (src
->u
.syment
.n_value
4647 - dst
->symbol
.section
->vma
);
4649 if (ISFCN ((src
->u
.syment
.n_type
)))
4650 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4655 /* A symbol with a csect entry should not go at the end. */
4656 if (src
->u
.syment
.n_numaux
> 0)
4657 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4661 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4662 dst
->symbol
.flags
|= BSF_WEAK
;
4664 if (src
->u
.syment
.n_sclass
== C_SECTION
4665 && src
->u
.syment
.n_scnum
> 0)
4666 dst
->symbol
.flags
= BSF_LOCAL
;
4668 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
4670 || src
->u
.syment
.n_sclass
== C_AIX_WEAKEXT
4673 dst
->symbol
.flags
|= BSF_WEAK
;
4677 case C_STAT
: /* Static. */
4679 case C_THUMBSTAT
: /* Thumb static. */
4680 case C_THUMBLABEL
: /* Thumb label. */
4681 case C_THUMBSTATFUNC
:/* Thumb static function. */
4684 case C_DWARF
: /* A label in a dwarf section. */
4685 case C_INFO
: /* A label in a comment section. */
4687 case C_LABEL
: /* Label. */
4688 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4689 dst
->symbol
.flags
= BSF_DEBUGGING
;
4691 dst
->symbol
.flags
= BSF_LOCAL
;
4693 /* Base the value as an index from the base of the
4694 section, if there is one. */
4695 if (dst
->symbol
.section
)
4697 #if defined COFF_WITH_PE
4698 /* PE sets the symbol to a value relative to the
4699 start of the section. */
4700 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4702 dst
->symbol
.value
= (src
->u
.syment
.n_value
4703 - dst
->symbol
.section
->vma
);
4707 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4710 case C_MOS
: /* Member of structure. */
4711 case C_EOS
: /* End of structure. */
4712 case C_REGPARM
: /* Register parameter. */
4713 case C_REG
: /* register variable. */
4714 /* C_AUTOARG conflicts with TI COFF C_UEXT. */
4715 case C_TPDEF
: /* Type definition. */
4717 case C_AUTO
: /* Automatic variable. */
4718 case C_FIELD
: /* Bit field. */
4719 case C_ENTAG
: /* Enumeration tag. */
4720 case C_MOE
: /* Member of enumeration. */
4721 case C_MOU
: /* Member of union. */
4722 case C_UNTAG
: /* Union tag. */
4723 dst
->symbol
.flags
= BSF_DEBUGGING
;
4724 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4727 case C_FILE
: /* File name. */
4728 case C_STRTAG
: /* Structure tag. */
4745 dst
->symbol
.flags
= BSF_DEBUGGING
;
4746 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4750 case C_BINCL
: /* Beginning of include file. */
4751 case C_EINCL
: /* Ending of include file. */
4752 /* The value is actually a pointer into the line numbers
4753 of the file. We locate the line number entry, and
4754 set the section to the section which contains it, and
4755 the value to the index in that section. */
4759 dst
->symbol
.flags
= BSF_DEBUGGING
;
4760 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4761 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4762 && ((file_ptr
) (sec
->line_filepos
4763 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4764 > (file_ptr
) src
->u
.syment
.n_value
))
4767 dst
->symbol
.value
= 0;
4770 dst
->symbol
.section
= sec
;
4771 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4772 - sec
->line_filepos
)
4773 / bfd_coff_linesz (abfd
));
4780 dst
->symbol
.flags
= BSF_DEBUGGING
;
4782 /* The value is actually a symbol index. Save a pointer
4783 to the symbol instead of the index. FIXME: This
4784 should use a union. */
4785 src
->u
.syment
.n_value
=
4786 (long) (intptr_t) (native_symbols
+ src
->u
.syment
.n_value
);
4787 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4792 case C_BLOCK
: /* ".bb" or ".eb". */
4793 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf"). */
4794 case C_EFCN
: /* Physical end of function. */
4795 #if defined COFF_WITH_PE
4796 /* PE sets the symbol to a value relative to the start
4798 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4799 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4801 /* PE uses funny values for .ef and .lf; don't
4803 dst
->symbol
.flags
= BSF_DEBUGGING
;
4806 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4808 /* Base the value as an index from the base of the
4810 dst
->symbol
.flags
= BSF_LOCAL
;
4811 dst
->symbol
.value
= (src
->u
.syment
.n_value
4812 - dst
->symbol
.section
->vma
);
4816 case C_STATLAB
: /* Static load time label. */
4817 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4818 dst
->symbol
.flags
= BSF_GLOBAL
;
4822 /* PE DLLs sometimes have zeroed out symbols for some
4823 reason. Just ignore them without a warning. */
4824 if (src
->u
.syment
.n_type
== 0
4825 && src
->u
.syment
.n_value
== 0
4826 && src
->u
.syment
.n_scnum
== 0)
4829 /* XCOFF specific: deleted entry. */
4830 if (src
->u
.syment
.n_value
== C_NULL_VALUE
)
4834 case C_EXTDEF
: /* External definition. */
4835 case C_ULABEL
: /* Undefined label. */
4836 case C_USTATIC
: /* Undefined static. */
4837 #ifndef COFF_WITH_PE
4838 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4839 class to represent a section symbol. */
4840 case C_LINE
: /* line # reformatted as symbol table entry. */
4841 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4842 case C_ALIAS
: /* Duplicate tag. */
4844 /* New storage classes for TI COFF. */
4845 #if defined(TIC80COFF) || defined(TICOFF)
4846 case C_UEXT
: /* Tentative external definition. */
4848 case C_EXTLAB
: /* External load time label. */
4851 /* xgettext:c-format */
4852 (_("%pB: unrecognized storage class %d for %s symbol `%s'"),
4853 abfd
, src
->u
.syment
.n_sclass
,
4854 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4857 case C_HIDDEN
: /* Ext symbol in dmert public lib. */
4858 /* PR 20722: These symbols can also be generated by
4859 building DLLs with --gc-sections enabled. */
4860 dst
->symbol
.flags
= BSF_DEBUGGING
;
4861 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4866 dst
->symbol
.udata
.i
= 0;
4869 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
4871 number_of_symbols
++;
4875 obj_symbols (abfd
) = cached_area
;
4876 obj_raw_syments (abfd
) = native_symbols
;
4878 bfd_get_symcount (abfd
) = number_of_symbols
;
4879 obj_convert (abfd
) = table_ptr
;
4880 /* Slurp the line tables for each section too. */
4887 if (! coff_slurp_line_table (abfd
, p
))
4896 /* Classify a COFF symbol. A couple of targets have globally visible
4897 symbols which are not class C_EXT, and this handles those. It also
4898 recognizes some special PE cases. */
4900 static enum coff_symbol_classification
4901 coff_classify_symbol (bfd
*abfd
,
4902 struct internal_syment
*syment
)
4904 /* FIXME: This partially duplicates the switch in
4905 coff_slurp_symbol_table. */
4906 switch (syment
->n_sclass
)
4912 case C_THUMBEXTFUNC
:
4920 if (syment
->n_scnum
== 0)
4922 if (syment
->n_value
== 0)
4923 return COFF_SYMBOL_UNDEFINED
;
4925 return COFF_SYMBOL_COMMON
;
4927 return COFF_SYMBOL_GLOBAL
;
4934 if (syment
->n_sclass
== C_STAT
)
4936 if (syment
->n_scnum
== 0)
4937 /* The Microsoft compiler sometimes generates these if a
4938 small static function is inlined every time it is used.
4939 The function is discarded, but the symbol table entry
4941 return COFF_SYMBOL_LOCAL
;
4943 #ifdef STRICT_PE_FORMAT
4944 /* This is correct for Microsoft generated objects, but it
4945 breaks gas generated objects. */
4946 if (syment
->n_value
== 0)
4950 char buf
[SYMNMLEN
+ 1];
4952 name
= _bfd_coff_internal_syment_name (abfd
, syment
, buf
)
4953 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
4954 if (sec
!= NULL
&& name
!= NULL
4955 && (strcmp (bfd_get_section_name (abfd
, sec
), name
) == 0))
4956 return COFF_SYMBOL_PE_SECTION
;
4960 return COFF_SYMBOL_LOCAL
;
4963 if (syment
->n_sclass
== C_SECTION
)
4965 /* In some cases in a DLL generated by the Microsoft linker, the
4966 n_value field will contain garbage. FIXME: This should
4967 probably be handled by the swapping function instead. */
4968 syment
->n_value
= 0;
4969 if (syment
->n_scnum
== 0)
4970 return COFF_SYMBOL_UNDEFINED
;
4971 return COFF_SYMBOL_PE_SECTION
;
4973 #endif /* COFF_WITH_PE */
4975 /* If it is not a global symbol, we presume it is a local symbol. */
4976 if (syment
->n_scnum
== 0)
4978 char buf
[SYMNMLEN
+ 1];
4981 /* xgettext:c-format */
4982 (_("warning: %pB: local symbol `%s' has no section"),
4983 abfd
, _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
4986 return COFF_SYMBOL_LOCAL
;
4993 Coff relocations are easily transformed into the internal BFD form
4996 Reading a coff relocation table is done in the following stages:
4998 o Read the entire coff relocation table into memory.
5000 o Process each relocation in turn; first swap it from the
5001 external to the internal form.
5003 o Turn the symbol referenced in the relocation's symbol index
5004 into a pointer into the canonical symbol table.
5005 This table is the same as the one returned by a call to
5006 @code{bfd_canonicalize_symtab}. The back end will call that
5007 routine and save the result if a canonicalization hasn't been done.
5009 o The reloc index is turned into a pointer to a howto
5010 structure, in a back end specific way. For instance, the 386
5011 uses the @code{r_type} to directly produce an index
5012 into a howto table vector.
5016 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
5018 coff_symbol_type *coffsym = NULL; \
5020 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
5021 coffsym = (obj_symbols (abfd) \
5022 + (cache_ptr->sym_ptr_ptr - symbols)); \
5024 coffsym = coff_symbol_from (ptr); \
5025 if (coffsym != NULL \
5026 && coffsym->native->is_sym \
5027 && coffsym->native->u.syment.n_scnum == 0) \
5028 cache_ptr->addend = 0; \
5029 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
5030 && ptr->section != NULL) \
5031 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
5033 cache_ptr->addend = 0; \
5038 coff_slurp_reloc_table (bfd
* abfd
, sec_ptr asect
, asymbol
** symbols
)
5040 RELOC
*native_relocs
;
5041 arelent
*reloc_cache
;
5046 if (asect
->relocation
)
5048 if (asect
->reloc_count
== 0)
5050 if (asect
->flags
& SEC_CONSTRUCTOR
)
5052 if (!coff_slurp_symbol_table (abfd
))
5055 amt
= (bfd_size_type
) bfd_coff_relsz (abfd
) * asect
->reloc_count
;
5056 native_relocs
= (RELOC
*) buy_and_read (abfd
, asect
->rel_filepos
, amt
);
5057 amt
= (bfd_size_type
) asect
->reloc_count
* sizeof (arelent
);
5058 reloc_cache
= (arelent
*) bfd_alloc (abfd
, amt
);
5060 if (reloc_cache
== NULL
|| native_relocs
== NULL
)
5063 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
5065 struct internal_reloc dst
;
5066 struct external_reloc
*src
;
5067 #ifndef RELOC_PROCESSING
5071 cache_ptr
= reloc_cache
+ idx
;
5072 src
= native_relocs
+ idx
;
5075 coff_swap_reloc_in (abfd
, src
, &dst
);
5077 #ifdef RELOC_PROCESSING
5078 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
5080 cache_ptr
->address
= dst
.r_vaddr
;
5082 if (dst
.r_symndx
!= -1 && symbols
!= NULL
)
5084 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
5087 /* xgettext:c-format */
5088 (_("%pB: warning: illegal symbol index %ld in relocs"),
5089 abfd
, dst
.r_symndx
);
5090 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5095 cache_ptr
->sym_ptr_ptr
= (symbols
5096 + obj_convert (abfd
)[dst
.r_symndx
]);
5097 ptr
= *(cache_ptr
->sym_ptr_ptr
);
5102 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5106 /* The symbols definitions that we have read in have been
5107 relocated as if their sections started at 0. But the offsets
5108 refering to the symbols in the raw data have not been
5109 modified, so we have to have a negative addend to compensate.
5111 Note that symbols which used to be common must be left alone. */
5113 /* Calculate any reloc addend by looking at the symbol. */
5114 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
5117 cache_ptr
->address
-= asect
->vma
;
5118 /* !! cache_ptr->section = NULL;*/
5120 /* Fill in the cache_ptr->howto field from dst.r_type. */
5121 RTYPE2HOWTO (cache_ptr
, &dst
);
5122 #endif /* RELOC_PROCESSING */
5124 if (cache_ptr
->howto
== NULL
)
5127 /* xgettext:c-format */
5128 (_("%pB: illegal relocation type %d at address %#" PRIx64
),
5129 abfd
, dst
.r_type
, (uint64_t) dst
.r_vaddr
);
5130 bfd_set_error (bfd_error_bad_value
);
5135 asect
->relocation
= reloc_cache
;
5139 #ifndef coff_rtype_to_howto
5142 /* Get the howto structure for a reloc. This is only used if the file
5143 including this one defines coff_relocate_section to be
5144 _bfd_coff_generic_relocate_section, so it is OK if it does not
5145 always work. It is the responsibility of the including file to
5146 make sure it is reasonable if it is needed. */
5148 static reloc_howto_type
*
5149 coff_rtype_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
5150 asection
*sec ATTRIBUTE_UNUSED
,
5151 struct internal_reloc
*rel ATTRIBUTE_UNUSED
,
5152 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
,
5153 struct internal_syment
*sym ATTRIBUTE_UNUSED
,
5154 bfd_vma
*addendp ATTRIBUTE_UNUSED
)
5158 genrel
.howto
= NULL
;
5159 RTYPE2HOWTO (&genrel
, rel
);
5160 return genrel
.howto
;
5163 #else /* ! defined (RTYPE2HOWTO) */
5165 #define coff_rtype_to_howto NULL
5167 #endif /* ! defined (RTYPE2HOWTO) */
5168 #endif /* ! defined (coff_rtype_to_howto) */
5170 /* This is stupid. This function should be a boolean predicate. */
5173 coff_canonicalize_reloc (bfd
* abfd
,
5178 arelent
*tblptr
= section
->relocation
;
5179 unsigned int count
= 0;
5181 if (section
->flags
& SEC_CONSTRUCTOR
)
5183 /* This section has relocs made up by us, they are not in the
5184 file, so take them out of their chain and place them into
5185 the data area provided. */
5186 arelent_chain
*chain
= section
->constructor_chain
;
5188 for (count
= 0; count
< section
->reloc_count
; count
++)
5190 *relptr
++ = &chain
->relent
;
5191 chain
= chain
->next
;
5196 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
5199 tblptr
= section
->relocation
;
5201 for (; count
++ < section
->reloc_count
;)
5202 *relptr
++ = tblptr
++;
5205 return section
->reloc_count
;
5208 #ifndef coff_set_reloc
5209 #define coff_set_reloc _bfd_generic_set_reloc
5212 #ifndef coff_reloc16_estimate
5213 #define coff_reloc16_estimate dummy_reloc16_estimate
5216 dummy_reloc16_estimate (bfd
*abfd ATTRIBUTE_UNUSED
,
5217 asection
*input_section ATTRIBUTE_UNUSED
,
5218 arelent
*reloc ATTRIBUTE_UNUSED
,
5219 unsigned int shrink ATTRIBUTE_UNUSED
,
5220 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
)
5228 #ifndef coff_reloc16_extra_cases
5230 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5232 /* This works even if abort is not declared in any header file. */
5235 dummy_reloc16_extra_cases (bfd
*abfd ATTRIBUTE_UNUSED
,
5236 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
5237 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
,
5238 arelent
*reloc ATTRIBUTE_UNUSED
,
5239 bfd_byte
*data ATTRIBUTE_UNUSED
,
5240 unsigned int *src_ptr ATTRIBUTE_UNUSED
,
5241 unsigned int *dst_ptr ATTRIBUTE_UNUSED
)
5247 /* If coff_relocate_section is defined, we can use the optimized COFF
5248 backend linker. Otherwise we must continue to use the old linker. */
5250 #ifdef coff_relocate_section
5252 #ifndef coff_bfd_link_hash_table_create
5253 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5255 #ifndef coff_bfd_link_add_symbols
5256 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5258 #ifndef coff_bfd_final_link
5259 #define coff_bfd_final_link _bfd_coff_final_link
5262 #else /* ! defined (coff_relocate_section) */
5264 #define coff_relocate_section NULL
5265 #ifndef coff_bfd_link_hash_table_create
5266 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5268 #ifndef coff_bfd_link_add_symbols
5269 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5271 #define coff_bfd_final_link _bfd_generic_final_link
5273 #endif /* ! defined (coff_relocate_section) */
5275 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5276 #define coff_bfd_copy_link_hash_symbol_type \
5277 _bfd_generic_copy_link_hash_symbol_type
5278 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5280 #define coff_bfd_link_check_relocs _bfd_generic_link_check_relocs
5282 #ifndef coff_start_final_link
5283 #define coff_start_final_link NULL
5286 #ifndef coff_adjust_symndx
5287 #define coff_adjust_symndx NULL
5290 #ifndef coff_link_add_one_symbol
5291 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5294 #ifndef coff_link_output_has_begun
5297 coff_link_output_has_begun (bfd
* abfd
,
5298 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
)
5300 return abfd
->output_has_begun
;
5304 #ifndef coff_final_link_postscript
5307 coff_final_link_postscript (bfd
* abfd ATTRIBUTE_UNUSED
,
5308 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
)
5314 #ifndef coff_SWAP_aux_in
5315 #define coff_SWAP_aux_in coff_swap_aux_in
5317 #ifndef coff_SWAP_sym_in
5318 #define coff_SWAP_sym_in coff_swap_sym_in
5320 #ifndef coff_SWAP_lineno_in
5321 #define coff_SWAP_lineno_in coff_swap_lineno_in
5323 #ifndef coff_SWAP_aux_out
5324 #define coff_SWAP_aux_out coff_swap_aux_out
5326 #ifndef coff_SWAP_sym_out
5327 #define coff_SWAP_sym_out coff_swap_sym_out
5329 #ifndef coff_SWAP_lineno_out
5330 #define coff_SWAP_lineno_out coff_swap_lineno_out
5332 #ifndef coff_SWAP_reloc_out
5333 #define coff_SWAP_reloc_out coff_swap_reloc_out
5335 #ifndef coff_SWAP_filehdr_out
5336 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5338 #ifndef coff_SWAP_aouthdr_out
5339 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5341 #ifndef coff_SWAP_scnhdr_out
5342 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5344 #ifndef coff_SWAP_reloc_in
5345 #define coff_SWAP_reloc_in coff_swap_reloc_in
5347 #ifndef coff_SWAP_filehdr_in
5348 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5350 #ifndef coff_SWAP_aouthdr_in
5351 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5353 #ifndef coff_SWAP_scnhdr_in
5354 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5357 static bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED
=
5359 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5360 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5361 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5362 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5363 coff_SWAP_scnhdr_out
,
5364 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5365 #ifdef COFF_LONG_FILENAMES
5370 COFF_DEFAULT_LONG_SECTION_NAMES
,
5371 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5372 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5377 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5383 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5384 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5385 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5386 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5387 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5388 coff_classify_symbol
, coff_compute_section_file_positions
,
5389 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5390 coff_adjust_symndx
, coff_link_add_one_symbol
,
5391 coff_link_output_has_begun
, coff_final_link_postscript
,
5396 /* COFF0 differs in file/section header size and relocation entry size. */
5398 static bfd_coff_backend_data ticoff0_swap_table
=
5400 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5401 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5402 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5403 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5404 coff_SWAP_scnhdr_out
,
5405 FILHSZ_V0
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ_V0
, LINESZ
, FILNMLEN
,
5406 #ifdef COFF_LONG_FILENAMES
5411 COFF_DEFAULT_LONG_SECTION_NAMES
,
5412 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5413 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5418 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5424 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5425 coff_SWAP_reloc_in
, ticoff0_bad_format_hook
, coff_set_arch_mach_hook
,
5426 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5427 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5428 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5429 coff_classify_symbol
, coff_compute_section_file_positions
,
5430 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5431 coff_adjust_symndx
, coff_link_add_one_symbol
,
5432 coff_link_output_has_begun
, coff_final_link_postscript
,
5438 /* COFF1 differs in section header size. */
5440 static bfd_coff_backend_data ticoff1_swap_table
=
5442 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5443 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5444 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5445 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5446 coff_SWAP_scnhdr_out
,
5447 FILHSZ
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5448 #ifdef COFF_LONG_FILENAMES
5453 COFF_DEFAULT_LONG_SECTION_NAMES
,
5454 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5455 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5460 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5466 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5467 coff_SWAP_reloc_in
, ticoff1_bad_format_hook
, coff_set_arch_mach_hook
,
5468 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5469 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5470 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5471 coff_classify_symbol
, coff_compute_section_file_positions
,
5472 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5473 coff_adjust_symndx
, coff_link_add_one_symbol
,
5474 coff_link_output_has_begun
, coff_final_link_postscript
,
5475 bfd_pe_print_pdata
/* huh */
5479 #ifdef COFF_WITH_PE_BIGOBJ
5480 /* The UID for bigobj files. */
5482 static const char header_bigobj_classid
[16] =
5484 0xC7, 0xA1, 0xBA, 0xD1,
5488 0xFA, 0xF6, 0x6A, 0xA4, 0xDC, 0xB8
5491 /* Swap routines. */
5494 coff_bigobj_swap_filehdr_in (bfd
* abfd
, void * src
, void * dst
)
5496 struct external_ANON_OBJECT_HEADER_BIGOBJ
*filehdr_src
=
5497 (struct external_ANON_OBJECT_HEADER_BIGOBJ
*) src
;
5498 struct internal_filehdr
*filehdr_dst
= (struct internal_filehdr
*) dst
;
5500 filehdr_dst
->f_magic
= H_GET_16 (abfd
, filehdr_src
->Machine
);
5501 filehdr_dst
->f_nscns
= H_GET_32 (abfd
, filehdr_src
->NumberOfSections
);
5502 filehdr_dst
->f_timdat
= H_GET_32 (abfd
, filehdr_src
->TimeDateStamp
);
5503 filehdr_dst
->f_symptr
=
5504 GET_FILEHDR_SYMPTR (abfd
, filehdr_src
->PointerToSymbolTable
);
5505 filehdr_dst
->f_nsyms
= H_GET_32 (abfd
, filehdr_src
->NumberOfSymbols
);
5506 filehdr_dst
->f_opthdr
= 0;
5507 filehdr_dst
->f_flags
= 0;
5509 /* Check other magic numbers. */
5510 if (H_GET_16 (abfd
, filehdr_src
->Sig1
) != IMAGE_FILE_MACHINE_UNKNOWN
5511 || H_GET_16 (abfd
, filehdr_src
->Sig2
) != 0xffff
5512 || H_GET_16 (abfd
, filehdr_src
->Version
) != 2
5513 || memcmp (filehdr_src
->ClassID
, header_bigobj_classid
, 16) != 0)
5514 filehdr_dst
->f_opthdr
= 0xffff;
5516 /* Note that CLR metadata are ignored. */
5520 coff_bigobj_swap_filehdr_out (bfd
*abfd
, void * in
, void * out
)
5522 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
5523 struct external_ANON_OBJECT_HEADER_BIGOBJ
*filehdr_out
=
5524 (struct external_ANON_OBJECT_HEADER_BIGOBJ
*) out
;
5526 memset (filehdr_out
, 0, sizeof (*filehdr_out
));
5528 H_PUT_16 (abfd
, IMAGE_FILE_MACHINE_UNKNOWN
, filehdr_out
->Sig1
);
5529 H_PUT_16 (abfd
, 0xffff, filehdr_out
->Sig2
);
5530 H_PUT_16 (abfd
, 2, filehdr_out
->Version
);
5531 memcpy (filehdr_out
->ClassID
, header_bigobj_classid
, 16);
5532 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->Machine
);
5533 H_PUT_32 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->NumberOfSections
);
5534 H_PUT_32 (abfd
, filehdr_in
->f_timdat
, filehdr_out
->TimeDateStamp
);
5535 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
,
5536 filehdr_out
->PointerToSymbolTable
);
5537 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->NumberOfSymbols
);
5539 return bfd_coff_filhsz (abfd
);
5543 coff_bigobj_swap_sym_in (bfd
* abfd
, void * ext1
, void * in1
)
5545 SYMENT_BIGOBJ
*ext
= (SYMENT_BIGOBJ
*) ext1
;
5546 struct internal_syment
*in
= (struct internal_syment
*) in1
;
5548 if (ext
->e
.e_name
[0] == 0)
5550 in
->_n
._n_n
._n_zeroes
= 0;
5551 in
->_n
._n_n
._n_offset
= H_GET_32 (abfd
, ext
->e
.e
.e_offset
);
5555 #if SYMNMLEN != E_SYMNMLEN
5556 #error we need to cope with truncating or extending SYMNMLEN
5558 memcpy (in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
5562 in
->n_value
= H_GET_32 (abfd
, ext
->e_value
);
5563 BFD_ASSERT (sizeof (in
->n_scnum
) >= 4);
5564 in
->n_scnum
= H_GET_32 (abfd
, ext
->e_scnum
);
5565 in
->n_type
= H_GET_16 (abfd
, ext
->e_type
);
5566 in
->n_sclass
= H_GET_8 (abfd
, ext
->e_sclass
);
5567 in
->n_numaux
= H_GET_8 (abfd
, ext
->e_numaux
);
5571 coff_bigobj_swap_sym_out (bfd
* abfd
, void * inp
, void * extp
)
5573 struct internal_syment
*in
= (struct internal_syment
*) inp
;
5574 SYMENT_BIGOBJ
*ext
= (SYMENT_BIGOBJ
*) extp
;
5576 if (in
->_n
._n_name
[0] == 0)
5578 H_PUT_32 (abfd
, 0, ext
->e
.e
.e_zeroes
);
5579 H_PUT_32 (abfd
, in
->_n
._n_n
._n_offset
, ext
->e
.e
.e_offset
);
5583 #if SYMNMLEN != E_SYMNMLEN
5584 #error we need to cope with truncating or extending SYMNMLEN
5586 memcpy (ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
5590 H_PUT_32 (abfd
, in
->n_value
, ext
->e_value
);
5591 H_PUT_32 (abfd
, in
->n_scnum
, ext
->e_scnum
);
5593 H_PUT_16 (abfd
, in
->n_type
, ext
->e_type
);
5594 H_PUT_8 (abfd
, in
->n_sclass
, ext
->e_sclass
);
5595 H_PUT_8 (abfd
, in
->n_numaux
, ext
->e_numaux
);
5597 return SYMESZ_BIGOBJ
;
5601 coff_bigobj_swap_aux_in (bfd
*abfd
,
5609 AUXENT_BIGOBJ
*ext
= (AUXENT_BIGOBJ
*) ext1
;
5610 union internal_auxent
*in
= (union internal_auxent
*) in1
;
5618 memcpy (in
->x_file
.x_fname
, ext
->File
.Name
,
5619 numaux
* sizeof (AUXENT_BIGOBJ
));
5622 memcpy (in
->x_file
.x_fname
, ext
->File
.Name
, sizeof (ext
->File
.Name
));
5630 in
->x_scn
.x_scnlen
= H_GET_32 (abfd
, ext
->Section
.Length
);
5631 in
->x_scn
.x_nreloc
=
5632 H_GET_16 (abfd
, ext
->Section
.NumberOfRelocations
);
5633 in
->x_scn
.x_nlinno
=
5634 H_GET_16 (abfd
, ext
->Section
.NumberOfLinenumbers
);
5635 in
->x_scn
.x_checksum
= H_GET_32 (abfd
, ext
->Section
.Checksum
);
5636 in
->x_scn
.x_associated
= H_GET_16 (abfd
, ext
->Section
.Number
)
5637 | (H_GET_16 (abfd
, ext
->Section
.HighNumber
) << 16);
5638 in
->x_scn
.x_comdat
= H_GET_8 (abfd
, ext
->Section
.Selection
);
5644 in
->x_sym
.x_tagndx
.l
= H_GET_32 (abfd
, ext
->Sym
.WeakDefaultSymIndex
);
5645 /* Characteristics is ignored. */
5651 coff_bigobj_swap_aux_out (bfd
* abfd
,
5655 int indx ATTRIBUTE_UNUSED
,
5656 int numaux ATTRIBUTE_UNUSED
,
5659 union internal_auxent
* in
= (union internal_auxent
*) inp
;
5660 AUXENT_BIGOBJ
*ext
= (AUXENT_BIGOBJ
*) extp
;
5662 memset (ext
, 0, AUXESZ
);
5667 memcpy (ext
->File
.Name
, in
->x_file
.x_fname
, sizeof (ext
->File
.Name
));
5676 H_PUT_32 (abfd
, in
->x_scn
.x_scnlen
, ext
->Section
.Length
);
5677 H_PUT_16 (abfd
, in
->x_scn
.x_nreloc
,
5678 ext
->Section
.NumberOfRelocations
);
5679 H_PUT_16 (abfd
, in
->x_scn
.x_nlinno
,
5680 ext
->Section
.NumberOfLinenumbers
);
5681 H_PUT_32 (abfd
, in
->x_scn
.x_checksum
, ext
->Section
.Checksum
);
5682 H_PUT_16 (abfd
, in
->x_scn
.x_associated
& 0xffff,
5683 ext
->Section
.Number
);
5684 H_PUT_16 (abfd
, (in
->x_scn
.x_associated
>> 16),
5685 ext
->Section
.HighNumber
);
5686 H_PUT_8 (abfd
, in
->x_scn
.x_comdat
, ext
->Section
.Selection
);
5692 H_PUT_32 (abfd
, in
->x_sym
.x_tagndx
.l
, ext
->Sym
.WeakDefaultSymIndex
);
5693 H_PUT_32 (abfd
, 1, ext
->Sym
.WeakSearchType
);
5698 static bfd_coff_backend_data bigobj_swap_table
=
5700 coff_bigobj_swap_aux_in
, coff_bigobj_swap_sym_in
, coff_SWAP_lineno_in
,
5701 coff_bigobj_swap_aux_out
, coff_bigobj_swap_sym_out
,
5702 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5703 coff_bigobj_swap_filehdr_out
, coff_SWAP_aouthdr_out
,
5704 coff_SWAP_scnhdr_out
,
5705 FILHSZ_BIGOBJ
, AOUTSZ
, SCNHSZ
, SYMESZ_BIGOBJ
, AUXESZ_BIGOBJ
,
5706 RELSZ
, LINESZ
, FILNMLEN_BIGOBJ
,
5708 COFF_DEFAULT_LONG_SECTION_NAMES
,
5709 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5713 coff_bigobj_swap_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5714 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5715 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5716 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5717 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5718 coff_classify_symbol
, coff_compute_section_file_positions
,
5719 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5720 coff_adjust_symndx
, coff_link_add_one_symbol
,
5721 coff_link_output_has_begun
, coff_final_link_postscript
,
5722 bfd_pe_print_pdata
/* huh */
5725 #endif /* COFF_WITH_PE_BIGOBJ */
5727 #ifndef coff_close_and_cleanup
5728 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5731 #ifndef coff_bfd_free_cached_info
5732 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5735 #ifndef coff_get_section_contents
5736 #define coff_get_section_contents _bfd_generic_get_section_contents
5739 #ifndef coff_bfd_copy_private_symbol_data
5740 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5743 #ifndef coff_bfd_copy_private_header_data
5744 #define coff_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
5747 #ifndef coff_bfd_copy_private_section_data
5748 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5751 #ifndef coff_bfd_copy_private_bfd_data
5752 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5755 #ifndef coff_bfd_merge_private_bfd_data
5756 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5759 #ifndef coff_bfd_set_private_flags
5760 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5763 #ifndef coff_bfd_print_private_bfd_data
5764 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5767 #ifndef coff_bfd_is_local_label_name
5768 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5771 #ifndef coff_bfd_is_target_special_symbol
5772 #define coff_bfd_is_target_special_symbol _bfd_bool_bfd_asymbol_false
5775 #ifndef coff_read_minisymbols
5776 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5779 #ifndef coff_minisymbol_to_symbol
5780 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5783 /* The reloc lookup routine must be supplied by each individual COFF
5785 #ifndef coff_bfd_reloc_type_lookup
5786 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5788 #ifndef coff_bfd_reloc_name_lookup
5789 #define coff_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5792 #ifndef coff_bfd_get_relocated_section_contents
5793 #define coff_bfd_get_relocated_section_contents \
5794 bfd_generic_get_relocated_section_contents
5797 #ifndef coff_bfd_relax_section
5798 #define coff_bfd_relax_section bfd_generic_relax_section
5801 #ifndef coff_bfd_gc_sections
5802 #define coff_bfd_gc_sections bfd_coff_gc_sections
5805 #ifndef coff_bfd_lookup_section_flags
5806 #define coff_bfd_lookup_section_flags bfd_generic_lookup_section_flags
5809 #ifndef coff_bfd_merge_sections
5810 #define coff_bfd_merge_sections bfd_generic_merge_sections
5813 #ifndef coff_bfd_is_group_section
5814 #define coff_bfd_is_group_section bfd_generic_is_group_section
5817 #ifndef coff_bfd_discard_group
5818 #define coff_bfd_discard_group bfd_generic_discard_group
5821 #ifndef coff_section_already_linked
5822 #define coff_section_already_linked \
5823 _bfd_coff_section_already_linked
5826 #ifndef coff_bfd_define_common_symbol
5827 #define coff_bfd_define_common_symbol bfd_generic_define_common_symbol
5830 #ifndef coff_bfd_define_start_stop
5831 #define coff_bfd_define_start_stop bfd_generic_define_start_stop
5834 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5835 const bfd_target VAR = \
5838 bfd_target_coff_flavour, \
5839 BFD_ENDIAN_BIG, /* Data byte order is big. */ \
5840 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5841 /* object flags */ \
5842 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5843 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5844 /* section flags */ \
5845 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5846 UNDER, /* Leading symbol underscore. */ \
5847 '/', /* AR_pad_char. */ \
5848 15, /* AR_max_namelen. */ \
5849 0, /* match priority. */ \
5851 /* Data conversion functions. */ \
5852 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5853 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5854 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5856 /* Header conversion functions. */ \
5857 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5858 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5859 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5861 { /* bfd_check_format. */ \
5862 _bfd_dummy_target, \
5864 bfd_generic_archive_p, \
5867 { /* bfd_set_format. */ \
5868 _bfd_bool_bfd_false_error, \
5870 _bfd_generic_mkarchive, \
5871 _bfd_bool_bfd_false_error \
5873 { /* bfd_write_contents. */ \
5874 _bfd_bool_bfd_false_error, \
5875 coff_write_object_contents, \
5876 _bfd_write_archive_contents, \
5877 _bfd_bool_bfd_false_error \
5880 BFD_JUMP_TABLE_GENERIC (coff), \
5881 BFD_JUMP_TABLE_COPY (coff), \
5882 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5883 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5884 BFD_JUMP_TABLE_SYMBOLS (coff), \
5885 BFD_JUMP_TABLE_RELOCS (coff), \
5886 BFD_JUMP_TABLE_WRITE (coff), \
5887 BFD_JUMP_TABLE_LINK (coff), \
5888 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5895 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5896 const bfd_target VAR = \
5899 bfd_target_coff_flavour, \
5900 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5901 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5902 /* object flags */ \
5903 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5904 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5905 /* section flags */ \
5906 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5907 UNDER, /* Leading symbol underscore. */ \
5908 '/', /* AR_pad_char. */ \
5909 15, /* AR_max_namelen. */ \
5910 0, /* match priority. */ \
5912 /* Data conversion functions. */ \
5913 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5914 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5915 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5917 /* Header conversion functions. */ \
5918 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5919 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5920 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5922 { /* bfd_check_format. */ \
5923 _bfd_dummy_target, \
5925 bfd_generic_archive_p, \
5928 { /* bfd_set_format. */ \
5929 _bfd_bool_bfd_false_error, \
5931 _bfd_generic_mkarchive, \
5932 _bfd_bool_bfd_false_error \
5934 { /* bfd_write_contents. */ \
5935 _bfd_bool_bfd_false_error, \
5936 coff_write_object_contents, \
5937 _bfd_write_archive_contents, \
5938 _bfd_bool_bfd_false_error \
5941 BFD_JUMP_TABLE_GENERIC (coff), \
5942 BFD_JUMP_TABLE_COPY (coff), \
5943 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5944 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5945 BFD_JUMP_TABLE_SYMBOLS (coff), \
5946 BFD_JUMP_TABLE_RELOCS (coff), \
5947 BFD_JUMP_TABLE_WRITE (coff), \
5948 BFD_JUMP_TABLE_LINK (coff), \
5949 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5956 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5957 const bfd_target VAR = \
5960 bfd_target_coff_flavour, \
5961 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5962 BFD_ENDIAN_LITTLE, /* Header byte order is little. */ \
5963 /* object flags */ \
5964 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5965 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5966 /* section flags */ \
5967 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5968 UNDER, /* Leading symbol underscore. */ \
5969 '/', /* AR_pad_char. */ \
5970 15, /* AR_max_namelen. */ \
5971 0, /* match priority. */ \
5973 /* Data conversion functions. */ \
5974 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5975 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5976 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5977 /* Header conversion functions. */ \
5978 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5979 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5980 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5982 { /* bfd_check_format. */ \
5983 _bfd_dummy_target, \
5985 bfd_generic_archive_p, \
5988 { /* bfd_set_format. */ \
5989 _bfd_bool_bfd_false_error, \
5991 _bfd_generic_mkarchive, \
5992 _bfd_bool_bfd_false_error \
5994 { /* bfd_write_contents. */ \
5995 _bfd_bool_bfd_false_error, \
5996 coff_write_object_contents, \
5997 _bfd_write_archive_contents, \
5998 _bfd_bool_bfd_false_error \
6001 BFD_JUMP_TABLE_GENERIC (coff), \
6002 BFD_JUMP_TABLE_COPY (coff), \
6003 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
6004 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
6005 BFD_JUMP_TABLE_SYMBOLS (coff), \
6006 BFD_JUMP_TABLE_RELOCS (coff), \
6007 BFD_JUMP_TABLE_WRITE (coff), \
6008 BFD_JUMP_TABLE_LINK (coff), \
6009 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \