1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright (C) 1990-2020 Free Software Foundation, Inc.
3 Written by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
22 /* Most of this hacked by Steve Chamberlain,
28 BFD supports a number of different flavours of coff format.
29 The major differences between formats are the sizes and
30 alignments of fields in structures on disk, and the occasional
33 Coff in all its varieties is implemented with a few common
34 files and a number of implementation specific files. For
35 example, the i386 coff format is implemented in the file
36 @file{coff-i386.c}. This file @code{#include}s
37 @file{coff/i386.h} which defines the external structure of the
38 coff format for the i386, and @file{coff/internal.h} which
39 defines the internal structure. @file{coff-i386.c} also
40 defines the relocations used by the i386 coff format
44 Porting to a new version of coff
46 The recommended method is to select from the existing
47 implementations the version of coff which is most like the one
48 you want to use. For example, we'll say that i386 coff is
49 the one you select, and that your coff flavour is called foo.
50 Copy @file{i386coff.c} to @file{foocoff.c}, copy
51 @file{../include/coff/i386.h} to @file{../include/coff/foo.h},
52 and add the lines to @file{targets.c} and @file{Makefile.in}
53 so that your new back end is used. Alter the shapes of the
54 structures in @file{../include/coff/foo.h} so that they match
55 what you need. You will probably also have to add
56 @code{#ifdef}s to the code in @file{coff/internal.h} and
57 @file{coffcode.h} if your version of coff is too wild.
59 You can verify that your new BFD backend works quite simply by
60 building @file{objdump} from the @file{binutils} directory,
61 and making sure that its version of what's going on and your
62 host system's idea (assuming it has the pretty standard coff
63 dump utility, usually called @code{att-dump} or just
64 @code{dump}) are the same. Then clean up your code, and send
65 what you've done to Cygnus. Then your stuff will be in the
66 next release, and you won't have to keep integrating it.
69 How the coff backend works
74 The Coff backend is split into generic routines that are
75 applicable to any Coff target and routines that are specific
76 to a particular target. The target-specific routines are
77 further split into ones which are basically the same for all
78 Coff targets except that they use the external symbol format
79 or use different values for certain constants.
81 The generic routines are in @file{coffgen.c}. These routines
82 work for any Coff target. They use some hooks into the target
83 specific code; the hooks are in a @code{bfd_coff_backend_data}
84 structure, one of which exists for each target.
86 The essentially similar target-specific routines are in
87 @file{coffcode.h}. This header file includes executable C code.
88 The various Coff targets first include the appropriate Coff
89 header file, make any special defines that are needed, and
90 then include @file{coffcode.h}.
92 Some of the Coff targets then also have additional routines in
93 the target source file itself.
96 Coff long section names
98 In the standard Coff object format, section names are limited to
99 the eight bytes available in the @code{s_name} field of the
100 @code{SCNHDR} section header structure. The format requires the
101 field to be NUL-padded, but not necessarily NUL-terminated, so
102 the longest section names permitted are a full eight characters.
104 The Microsoft PE variants of the Coff object file format add
105 an extension to support the use of long section names. This
106 extension is defined in section 4 of the Microsoft PE/COFF
107 specification (rev 8.1). If a section name is too long to fit
108 into the section header's @code{s_name} field, it is instead
109 placed into the string table, and the @code{s_name} field is
110 filled with a slash ("/") followed by the ASCII decimal
111 representation of the offset of the full name relative to the
114 Note that this implies that the extension can only be used in object
115 files, as executables do not contain a string table. The standard
116 specifies that long section names from objects emitted into executable
117 images are to be truncated.
119 However, as a GNU extension, BFD can generate executable images
120 that contain a string table and long section names. This
121 would appear to be technically valid, as the standard only says
122 that Coff debugging information is deprecated, not forbidden,
123 and in practice it works, although some tools that parse PE files
124 expecting the MS standard format may become confused; @file{PEview} is
127 The functionality is supported in BFD by code implemented under
128 the control of the macro @code{COFF_LONG_SECTION_NAMES}. If not
129 defined, the format does not support long section names in any way.
130 If defined, it is used to initialise a flag,
131 @code{_bfd_coff_long_section_names}, and a hook function pointer,
132 @code{_bfd_coff_set_long_section_names}, in the Coff backend data
133 structure. The flag controls the generation of long section names
134 in output BFDs at runtime; if it is false, as it will be by default
135 when generating an executable image, long section names are truncated;
136 if true, the long section names extension is employed. The hook
137 points to a function that allows the value of the flag to be altered
138 at runtime, on formats that support long section names at all; on
139 other formats it points to a stub that returns an error indication.
141 With input BFDs, the flag is set according to whether any long section
142 names are detected while reading the section headers. For a completely
143 new BFD, the flag is set to the default for the target format. This
144 information can be used by a client of the BFD library when deciding
145 what output format to generate, and means that a BFD that is opened
146 for read and subsequently converted to a writeable BFD and modified
147 in-place will retain whatever format it had on input.
149 If @code{COFF_LONG_SECTION_NAMES} is simply defined (blank), or is
150 defined to the value "1", then long section names are enabled by
151 default; if it is defined to the value zero, they are disabled by
152 default (but still accepted in input BFDs). The header @file{coffcode.h}
153 defines a macro, @code{COFF_DEFAULT_LONG_SECTION_NAMES}, which is
154 used in the backends to initialise the backend data structure fields
155 appropriately; see the comments for further detail.
160 Each flavour of coff supported in BFD has its own header file
161 describing the external layout of the structures. There is also
162 an internal description of the coff layout, in
163 @file{coff/internal.h}. A major function of the
164 coff backend is swapping the bytes and twiddling the bits to
165 translate the external form of the structures into the normal
166 internal form. This is all performed in the
167 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
168 elements are different sizes between different versions of
169 coff; it is the duty of the coff version specific include file
170 to override the definitions of various packing routines in
171 @file{coffcode.h}. E.g., the size of line number entry in coff is
172 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
173 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
174 correct one. No doubt, some day someone will find a version of
175 coff which has a varying field size not catered to at the
176 moment. To port BFD, that person will have to add more @code{#defines}.
177 Three of the bit twiddling routines are exported to
178 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
179 and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol
180 table on its own, but uses BFD to fix things up. More of the
181 bit twiddlers are exported for @code{gas};
182 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
183 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
184 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
185 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
186 of all the symbol table and reloc drudgery itself, thereby
187 saving the internal BFD overhead, but uses BFD to swap things
188 on the way out, making cross ports much safer. Doing so also
189 allows BFD (and thus the linker) to use the same header files
190 as @code{gas}, which makes one avenue to disaster disappear.
195 The simple canonical form for symbols used by BFD is not rich
196 enough to keep all the information available in a coff symbol
197 table. The back end gets around this problem by keeping the original
198 symbol table around, "behind the scenes".
200 When a symbol table is requested (through a call to
201 @code{bfd_canonicalize_symtab}), a request gets through to
202 @code{coff_get_normalized_symtab}. This reads the symbol table from
203 the coff file and swaps all the structures inside into the
204 internal form. It also fixes up all the pointers in the table
205 (represented in the file by offsets from the first symbol in
206 the table) into physical pointers to elements in the new
207 internal table. This involves some work since the meanings of
208 fields change depending upon context: a field that is a
209 pointer to another structure in the symbol table at one moment
210 may be the size in bytes of a structure at the next. Another
211 pass is made over the table. All symbols which mark file names
212 (<<C_FILE>> symbols) are modified so that the internal
213 string points to the value in the auxent (the real filename)
214 rather than the normal text associated with the symbol
217 At this time the symbol names are moved around. Coff stores
218 all symbols less than nine characters long physically
219 within the symbol table; longer strings are kept at the end of
220 the file in the string table. This pass moves all strings
221 into memory and replaces them with pointers to the strings.
223 The symbol table is massaged once again, this time to create
224 the canonical table used by the BFD application. Each symbol
225 is inspected in turn, and a decision made (using the
226 @code{sclass} field) about the various flags to set in the
227 @code{asymbol}. @xref{Symbols}. The generated canonical table
228 shares strings with the hidden internal symbol table.
230 Any linenumbers are read from the coff file too, and attached
231 to the symbols which own the functions the linenumbers belong to.
236 Writing a symbol to a coff file which didn't come from a coff
237 file will lose any debugging information. The @code{asymbol}
238 structure remembers the BFD from which the symbol was taken, and on
239 output the back end makes sure that the same destination target as
240 source target is present.
242 When the symbols have come from a coff file then all the
243 debugging information is preserved.
245 Symbol tables are provided for writing to the back end in a
246 vector of pointers to pointers. This allows applications like
247 the linker to accumulate and output large symbol tables
248 without having to do too much byte copying.
250 This function runs through the provided symbol table and
251 patches each symbol marked as a file place holder
252 (@code{C_FILE}) to point to the next file place holder in the
253 list. It also marks each @code{offset} field in the list with
254 the offset from the first symbol of the current symbol.
256 Another function of this procedure is to turn the canonical
257 value form of BFD into the form used by coff. Internally, BFD
258 expects symbol values to be offsets from a section base; so a
259 symbol physically at 0x120, but in a section starting at
260 0x100, would have the value 0x20. Coff expects symbols to
261 contain their final value, so symbols have their values
262 changed at this point to reflect their sum with their owning
263 section. This transformation uses the
264 <<output_section>> field of the @code{asymbol}'s
265 @code{asection} @xref{Sections}.
267 o <<coff_mangle_symbols>>
269 This routine runs though the provided symbol table and uses
270 the offsets generated by the previous pass and the pointers
271 generated when the symbol table was read in to create the
272 structured hierarchy required by coff. It changes each pointer
273 to a symbol into the index into the symbol table of the asymbol.
275 o <<coff_write_symbols>>
277 This routine runs through the symbol table and patches up the
278 symbols from their internal form into the coff way, calls the
279 bit twiddlers, and writes out the table to the file.
288 The hidden information for an <<asymbol>> is described in a
289 <<combined_entry_type>>:
293 .typedef struct coff_ptr_struct
295 . {* Remembers the offset from the first symbol in the file for
296 . this symbol. Generated by coff_renumber_symbols. *}
297 . unsigned int offset;
299 . {* Should the value of this symbol be renumbered. Used for
300 . XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
301 . unsigned int fix_value : 1;
303 . {* Should the tag field of this symbol be renumbered.
304 . Created by coff_pointerize_aux. *}
305 . unsigned int fix_tag : 1;
307 . {* Should the endidx field of this symbol be renumbered.
308 . Created by coff_pointerize_aux. *}
309 . unsigned int fix_end : 1;
311 . {* Should the x_csect.x_scnlen field be renumbered.
312 . Created by coff_pointerize_aux. *}
313 . unsigned int fix_scnlen : 1;
315 . {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
316 . index into the line number entries. Set by coff_slurp_symbol_table. *}
317 . unsigned int fix_line : 1;
319 . {* The container for the symbol structure as read and translated
323 . union internal_auxent auxent;
324 . struct internal_syment syment;
327 . {* Selector for the union above. *}
328 . bfd_boolean is_sym;
329 .} combined_entry_type;
332 .{* Each canonical asymbol really looks like this: *}
334 .typedef struct coff_symbol_struct
336 . {* The actual symbol which the rest of BFD works with *}
339 . {* A pointer to the hidden information for this symbol *}
340 . combined_entry_type *native;
342 . {* A pointer to the linenumber information for this symbol *}
343 . struct lineno_cache_entry *lineno;
345 . {* Have the line numbers been relocated yet ? *}
346 . bfd_boolean done_lineno;
351 #include "libiberty.h"
356 #include "coffswap.h"
359 #define STRING_SIZE_SIZE 4
361 #define DOT_DEBUG ".debug"
362 #define DOT_ZDEBUG ".zdebug"
363 #define GNU_LINKONCE_WI ".gnu.linkonce.wi."
364 #define GNU_LINKONCE_WT ".gnu.linkonce.wt."
365 #define DOT_RELOC ".reloc"
367 #if defined(COFF_WITH_PE) || defined(COFF_GO32_EXE) || defined(COFF_GO32)
368 # define COFF_WITH_EXTENDED_RELOC_COUNTER
371 #if defined (COFF_LONG_SECTION_NAMES)
372 /* Needed to expand the inputs to BLANKOR1TOODD. */
373 #define COFFLONGSECTIONCATHELPER(x,y) x ## y
374 /* If the input macro Y is blank or '1', return an odd number; if it is
375 '0', return an even number. Result undefined in all other cases. */
376 #define BLANKOR1TOODD(y) COFFLONGSECTIONCATHELPER(1,y)
377 /* Defined to numerical 0 or 1 according to whether generation of long
378 section names is disabled or enabled by default. */
379 #define COFF_ENABLE_LONG_SECTION_NAMES (BLANKOR1TOODD(COFF_LONG_SECTION_NAMES) & 1)
380 /* Where long section names are supported, we allow them to be enabled
381 and disabled at runtime, so select an appropriate hook function for
382 _bfd_coff_set_long_section_names. */
383 #define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_allowed
384 #else /* !defined (COFF_LONG_SECTION_NAMES) */
385 /* If long section names are not supported, this stub disallows any
386 attempt to enable them at run-time. */
387 #define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_disallowed
388 #endif /* defined (COFF_LONG_SECTION_NAMES) */
390 /* Define a macro that can be used to initialise both the fields relating
391 to long section names in the backend data struct simultaneously. */
392 #if COFF_ENABLE_LONG_SECTION_NAMES
393 #define COFF_DEFAULT_LONG_SECTION_NAMES (TRUE), COFF_LONG_SECTION_NAMES_SETTER
394 #else /* !COFF_ENABLE_LONG_SECTION_NAMES */
395 #define COFF_DEFAULT_LONG_SECTION_NAMES (FALSE), COFF_LONG_SECTION_NAMES_SETTER
396 #endif /* COFF_ENABLE_LONG_SECTION_NAMES */
398 #if defined (COFF_LONG_SECTION_NAMES)
399 static bfd_boolean bfd_coff_set_long_section_names_allowed
401 #else /* !defined (COFF_LONG_SECTION_NAMES) */
402 static bfd_boolean bfd_coff_set_long_section_names_disallowed
404 #endif /* defined (COFF_LONG_SECTION_NAMES) */
405 static long sec_to_styp_flags
406 (const char *, flagword
);
407 static bfd_boolean styp_to_sec_flags
408 (bfd
*, void *, const char *, asection
*, flagword
*);
409 static bfd_boolean coff_bad_format_hook
411 static void coff_set_custom_section_alignment
412 (bfd
*, asection
*, const struct coff_section_alignment_entry
*,
414 static bfd_boolean coff_new_section_hook
416 static bfd_boolean coff_set_arch_mach_hook
418 static bfd_boolean coff_write_relocs
420 static bfd_boolean coff_set_flags
421 (bfd
*, unsigned int *, unsigned short *);
422 static bfd_boolean coff_set_arch_mach
423 (bfd
*, enum bfd_architecture
, unsigned long) ATTRIBUTE_UNUSED
;
424 static bfd_boolean coff_compute_section_file_positions
426 static bfd_boolean coff_write_object_contents
427 (bfd
*) ATTRIBUTE_UNUSED
;
428 static bfd_boolean coff_set_section_contents
429 (bfd
*, asection
*, const void *, file_ptr
, bfd_size_type
);
430 static bfd_boolean coff_slurp_line_table
432 static bfd_boolean coff_slurp_symbol_table
434 static enum coff_symbol_classification coff_classify_symbol
435 (bfd
*, struct internal_syment
*);
436 static bfd_boolean coff_slurp_reloc_table
437 (bfd
*, asection
*, asymbol
**);
438 static long coff_canonicalize_reloc
439 (bfd
*, asection
*, arelent
**, asymbol
**);
440 #ifndef coff_mkobject_hook
441 static void * coff_mkobject_hook
442 (bfd
*, void *, void *);
445 static flagword handle_COMDAT
446 (bfd
*, flagword
, void *, const char *, asection
*);
448 #ifdef COFF_IMAGE_WITH_PE
449 static bfd_boolean coff_read_word
450 (bfd
*, unsigned int *);
451 static unsigned int coff_compute_checksum
453 static bfd_boolean coff_apply_checksum
457 static bfd_boolean ticoff0_bad_format_hook
459 static bfd_boolean ticoff1_bad_format_hook
463 /* void warning(); */
465 #if defined (COFF_LONG_SECTION_NAMES)
467 bfd_coff_set_long_section_names_allowed (bfd
*abfd
, int enable
)
469 coff_backend_info (abfd
)->_bfd_coff_long_section_names
= enable
;
472 #else /* !defined (COFF_LONG_SECTION_NAMES) */
474 bfd_coff_set_long_section_names_disallowed (bfd
*abfd
, int enable
)
480 #endif /* defined (COFF_LONG_SECTION_NAMES) */
482 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
483 the incoming SEC_* flags. The inverse of this function is
484 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
485 should probably mirror the changes in styp_to_sec_flags(). */
489 /* Macros for setting debugging flags. */
492 #define STYP_XCOFF_DEBUG STYP_DEBUG
494 #define STYP_XCOFF_DEBUG STYP_INFO
497 #ifdef COFF_ALIGN_IN_S_FLAGS
498 #define STYP_DEBUG_INFO STYP_DSECT
500 #define STYP_DEBUG_INFO STYP_INFO
504 sec_to_styp_flags (const char *sec_name
, flagword sec_flags
)
508 if (!strcmp (sec_name
, _TEXT
))
510 styp_flags
= STYP_TEXT
;
512 else if (!strcmp (sec_name
, _DATA
))
514 styp_flags
= STYP_DATA
;
516 else if (!strcmp (sec_name
, _BSS
))
518 styp_flags
= STYP_BSS
;
521 else if (!strcmp (sec_name
, _COMMENT
))
523 styp_flags
= STYP_INFO
;
524 #endif /* _COMMENT */
527 else if (!strcmp (sec_name
, _LIB
))
529 styp_flags
= STYP_LIB
;
533 else if (!strcmp (sec_name
, _LIT
))
535 styp_flags
= STYP_LIT
;
538 else if (CONST_STRNEQ (sec_name
, DOT_DEBUG
)
539 || CONST_STRNEQ (sec_name
, DOT_ZDEBUG
))
541 /* Handle the XCOFF debug section and DWARF2 debug sections. */
543 styp_flags
= STYP_XCOFF_DEBUG
;
545 styp_flags
= STYP_DEBUG_INFO
;
547 else if (CONST_STRNEQ (sec_name
, ".stab"))
549 styp_flags
= STYP_DEBUG_INFO
;
551 #ifdef COFF_LONG_SECTION_NAMES
552 else if (CONST_STRNEQ (sec_name
, GNU_LINKONCE_WI
)
553 || CONST_STRNEQ (sec_name
, GNU_LINKONCE_WT
))
555 styp_flags
= STYP_DEBUG_INFO
;
559 else if (!strcmp (sec_name
, _PAD
))
561 styp_flags
= STYP_PAD
;
563 else if (!strcmp (sec_name
, _LOADER
))
565 styp_flags
= STYP_LOADER
;
567 else if (!strcmp (sec_name
, _EXCEPT
))
569 styp_flags
= STYP_EXCEPT
;
571 else if (!strcmp (sec_name
, _TYPCHK
))
573 styp_flags
= STYP_TYPCHK
;
575 else if (sec_flags
& SEC_DEBUGGING
)
579 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
580 if (!strcmp (sec_name
, xcoff_dwsect_names
[i
].name
))
582 styp_flags
= STYP_DWARF
| xcoff_dwsect_names
[i
].flag
;
587 /* Try and figure out what it should be */
588 else if (sec_flags
& SEC_CODE
)
590 styp_flags
= STYP_TEXT
;
592 else if (sec_flags
& SEC_DATA
)
594 styp_flags
= STYP_DATA
;
596 else if (sec_flags
& SEC_READONLY
)
598 #ifdef STYP_LIT /* 29k readonly text/data section */
599 styp_flags
= STYP_LIT
;
601 styp_flags
= STYP_TEXT
;
602 #endif /* STYP_LIT */
604 else if (sec_flags
& SEC_LOAD
)
606 styp_flags
= STYP_TEXT
;
608 else if (sec_flags
& SEC_ALLOC
)
610 styp_flags
= STYP_BSS
;
614 if (sec_flags
& SEC_TIC54X_CLINK
)
615 styp_flags
|= STYP_CLINK
;
619 if (sec_flags
& SEC_TIC54X_BLOCK
)
620 styp_flags
|= STYP_BLOCK
;
624 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
625 styp_flags
|= STYP_NOLOAD
;
631 #else /* COFF_WITH_PE */
633 /* The PE version; see above for the general comments. The non-PE
634 case seems to be more guessing, and breaks PE format; specifically,
635 .rdata is readonly, but it sure ain't text. Really, all this
636 should be set up properly in gas (or whatever assembler is in use),
637 and honor whatever objcopy/strip, etc. sent us as input. */
640 sec_to_styp_flags (const char *sec_name
, flagword sec_flags
)
643 bfd_boolean is_dbg
= FALSE
;
645 if (CONST_STRNEQ (sec_name
, DOT_DEBUG
)
646 || CONST_STRNEQ (sec_name
, DOT_ZDEBUG
)
647 #ifdef COFF_LONG_SECTION_NAMES
648 || CONST_STRNEQ (sec_name
, GNU_LINKONCE_WI
)
649 || CONST_STRNEQ (sec_name
, GNU_LINKONCE_WT
)
651 || CONST_STRNEQ (sec_name
, ".stab"))
654 /* caution: there are at least three groups of symbols that have
655 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
656 SEC_* are the BFD internal flags, used for generic BFD
657 information. STYP_* are the COFF section flags which appear in
658 COFF files. IMAGE_SCN_* are the PE section flags which appear in
659 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
660 but there are more IMAGE_SCN_* flags. */
662 /* FIXME: There is no gas syntax to specify the debug section flag. */
665 sec_flags
&= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
666 | SEC_LINK_DUPLICATES_SAME_CONTENTS
667 | SEC_LINK_DUPLICATES_SAME_SIZE
);
668 sec_flags
|= SEC_DEBUGGING
| SEC_READONLY
;
674 if ((sec_flags
& SEC_CODE
) != 0)
675 styp_flags
|= IMAGE_SCN_CNT_CODE
;
676 if ((sec_flags
& (SEC_DATA
| SEC_DEBUGGING
)) != 0)
677 styp_flags
|= IMAGE_SCN_CNT_INITIALIZED_DATA
;
678 if ((sec_flags
& SEC_ALLOC
) != 0 && (sec_flags
& SEC_LOAD
) == 0)
679 styp_flags
|= IMAGE_SCN_CNT_UNINITIALIZED_DATA
; /* ==STYP_BSS */
681 /* skip constRUCTOR */
683 if ((sec_flags
& SEC_IS_COMMON
) != 0)
684 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
685 if ((sec_flags
& SEC_DEBUGGING
) != 0)
686 styp_flags
|= IMAGE_SCN_MEM_DISCARDABLE
;
687 if ((sec_flags
& SEC_EXCLUDE
) != 0 && !is_dbg
)
688 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
689 if ((sec_flags
& SEC_NEVER_LOAD
) != 0 && !is_dbg
)
690 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
693 if (sec_flags
& SEC_LINK_ONCE
)
694 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
696 & (SEC_LINK_DUPLICATES_DISCARD
| SEC_LINK_DUPLICATES_SAME_CONTENTS
697 | SEC_LINK_DUPLICATES_SAME_SIZE
)) != 0)
698 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
700 /* skip LINKER_CREATED */
702 if ((sec_flags
& SEC_COFF_NOREAD
) == 0)
703 styp_flags
|= IMAGE_SCN_MEM_READ
; /* Invert NOREAD for read. */
704 if ((sec_flags
& SEC_READONLY
) == 0)
705 styp_flags
|= IMAGE_SCN_MEM_WRITE
; /* Invert READONLY for write. */
706 if (sec_flags
& SEC_CODE
)
707 styp_flags
|= IMAGE_SCN_MEM_EXECUTE
; /* CODE->EXECUTE. */
708 if (sec_flags
& SEC_COFF_SHARED
)
709 styp_flags
|= IMAGE_SCN_MEM_SHARED
; /* Shared remains meaningful. */
714 #endif /* COFF_WITH_PE */
716 /* Return a word with SEC_* flags set to represent the incoming STYP_*
717 flags (from scnhdr.s_flags). The inverse of this function is
718 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
719 should probably mirror the changes in sec_to_styp_flags(). */
724 styp_to_sec_flags (bfd
*abfd
,
727 asection
*section ATTRIBUTE_UNUSED
,
730 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
731 long styp_flags
= internal_s
->s_flags
;
732 flagword sec_flags
= 0;
735 if (styp_flags
& STYP_BLOCK
)
736 sec_flags
|= SEC_TIC54X_BLOCK
;
740 if (styp_flags
& STYP_CLINK
)
741 sec_flags
|= SEC_TIC54X_CLINK
;
745 if (styp_flags
& STYP_NOLOAD
)
746 sec_flags
|= SEC_NEVER_LOAD
;
747 #endif /* STYP_NOLOAD */
749 /* For 386 COFF, at least, an unloadable text or data section is
750 actually a shared library section. */
751 if (styp_flags
& STYP_TEXT
)
753 if (sec_flags
& SEC_NEVER_LOAD
)
754 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
756 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
758 else if (styp_flags
& STYP_DATA
)
760 if (sec_flags
& SEC_NEVER_LOAD
)
761 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
763 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
765 else if (styp_flags
& STYP_BSS
)
767 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
768 if (sec_flags
& SEC_NEVER_LOAD
)
769 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
772 sec_flags
|= SEC_ALLOC
;
774 else if (styp_flags
& STYP_INFO
)
776 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
777 defined. coff_compute_section_file_positions uses
778 COFF_PAGE_SIZE to ensure that the low order bits of the
779 section VMA and the file offset match. If we don't know
780 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
781 and demand page loading of the file will fail. */
782 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
783 sec_flags
|= SEC_DEBUGGING
;
786 else if (styp_flags
& STYP_PAD
)
789 else if (styp_flags
& STYP_EXCEPT
)
790 sec_flags
|= SEC_LOAD
;
791 else if (styp_flags
& STYP_LOADER
)
792 sec_flags
|= SEC_LOAD
;
793 else if (styp_flags
& STYP_TYPCHK
)
794 sec_flags
|= SEC_LOAD
;
795 else if (styp_flags
& STYP_DWARF
)
796 sec_flags
|= SEC_DEBUGGING
;
798 else if (strcmp (name
, _TEXT
) == 0)
800 if (sec_flags
& SEC_NEVER_LOAD
)
801 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
803 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
805 else if (strcmp (name
, _DATA
) == 0)
807 if (sec_flags
& SEC_NEVER_LOAD
)
808 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
810 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
812 else if (strcmp (name
, _BSS
) == 0)
814 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
815 if (sec_flags
& SEC_NEVER_LOAD
)
816 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
819 sec_flags
|= SEC_ALLOC
;
821 else if (CONST_STRNEQ (name
, DOT_DEBUG
)
822 || CONST_STRNEQ (name
, DOT_ZDEBUG
)
824 || strcmp (name
, _COMMENT
) == 0
826 #ifdef COFF_LONG_SECTION_NAMES
827 || CONST_STRNEQ (name
, GNU_LINKONCE_WI
)
828 || CONST_STRNEQ (name
, GNU_LINKONCE_WT
)
830 || CONST_STRNEQ (name
, ".stab"))
832 #ifdef COFF_PAGE_SIZE
833 sec_flags
|= SEC_DEBUGGING
;
837 else if (strcmp (name
, _LIB
) == 0)
841 else if (strcmp (name
, _LIT
) == 0)
842 sec_flags
= SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
845 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
847 #ifdef STYP_LIT /* A29k readonly text/data section type. */
848 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
849 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
850 #endif /* STYP_LIT */
852 #ifdef STYP_OTHER_LOAD /* Other loaded sections. */
853 if (styp_flags
& STYP_OTHER_LOAD
)
854 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
855 #endif /* STYP_SDATA */
857 if ((bfd_applicable_section_flags (abfd
) & SEC_SMALL_DATA
) != 0
858 && (CONST_STRNEQ (name
, ".sbss")
859 || CONST_STRNEQ (name
, ".sdata")))
860 sec_flags
|= SEC_SMALL_DATA
;
862 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
863 /* As a GNU extension, if the name begins with .gnu.linkonce, we
864 only link a single copy of the section. This is used to support
865 g++. g++ will emit each template expansion in its own section.
866 The symbols will be defined as weak, so that multiple definitions
867 are permitted. The GNU linker extension is to actually discard
868 all but one of the sections. */
869 if (CONST_STRNEQ (name
, ".gnu.linkonce"))
870 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
873 if (flags_ptr
== NULL
)
876 * flags_ptr
= sec_flags
;
880 #else /* COFF_WITH_PE */
883 handle_COMDAT (bfd
* abfd
,
889 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
890 bfd_byte
*esymstart
, *esym
, *esymend
;
892 char *target_name
= NULL
;
894 sec_flags
|= SEC_LINK_ONCE
;
896 /* Unfortunately, the PE format stores essential information in
897 the symbol table, of all places. We need to extract that
898 information now, so that objdump and the linker will know how
899 to handle the section without worrying about the symbols. We
900 can't call slurp_symtab, because the linker doesn't want the
903 /* COMDAT sections are special. The first symbol is the section
904 symbol, which tells what kind of COMDAT section it is. The
905 second symbol is the "comdat symbol" - the one with the
906 unique name. GNU uses the section symbol for the unique
907 name; MS uses ".text" for every comdat section. Sigh. - DJ */
909 /* This is not mirrored in sec_to_styp_flags(), but there
910 doesn't seem to be a need to, either, and it would at best be
913 if (! _bfd_coff_get_external_symbols (abfd
))
916 esymstart
= esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
917 esymend
= esym
+ obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
919 while (esym
< esymend
)
921 struct internal_syment isym
;
922 char buf
[SYMNMLEN
+ 1];
925 bfd_coff_swap_sym_in (abfd
, esym
, & isym
);
927 BFD_ASSERT (sizeof (internal_s
->s_name
) <= SYMNMLEN
);
929 if (isym
.n_scnum
== section
->target_index
)
931 /* According to the MSVC documentation, the first
932 TWO entries with the section # are both of
933 interest to us. The first one is the "section
934 symbol" (section name). The second is the comdat
935 symbol name. Here, we've found the first
936 qualifying entry; we distinguish it from the
937 second with a state flag.
939 In the case of gas-generated (at least until that
940 is fixed) .o files, it isn't necessarily the
941 second one. It may be some other later symbol.
943 Since gas also doesn't follow MS conventions and
944 emits the section similar to .text$<name>, where
945 <something> is the name we're looking for, we
946 distinguish the two as follows:
948 If the section name is simply a section name (no
949 $) we presume it's MS-generated, and look at
950 precisely the second symbol for the comdat name.
951 If the section name has a $, we assume it's
952 gas-generated, and look for <something> (whatever
953 follows the $) as the comdat symbol. */
955 /* All 3 branches use this. */
956 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
, buf
);
958 /* PR 17512 file: 078-11867-0.004 */
961 _bfd_error_handler (_("%pB: unable to load COMDAT section name"),
970 /* The first time we've seen the symbol. */
971 union internal_auxent aux
;
973 /* If it isn't the stuff we're expecting, die;
974 The MS documentation is vague, but it
975 appears that the second entry serves BOTH
976 as the comdat symbol and the defining
977 symbol record (either C_STAT or C_EXT,
978 possibly with an aux entry with debug
979 information if it's a function.) It
980 appears the only way to find the second one
981 is to count. (On Intel, they appear to be
982 adjacent, but on Alpha, they have been
985 Here, we think we've found the first one,
986 but there's some checking we can do to be
989 if (! ((isym
.n_sclass
== C_STAT
990 || isym
.n_sclass
== C_EXT
)
991 && BTYPE (isym
.n_type
) == T_NULL
992 && isym
.n_value
== 0))
994 /* Malformed input files can trigger this test.
996 _bfd_error_handler (_("%pB: error: unexpected symbol '%s' in COMDAT section"),
1001 /* FIXME LATER: MSVC generates section names
1002 like .text for comdats. Gas generates
1003 names like .text$foo__Fv (in the case of a
1004 function). See comment above for more. */
1006 if (isym
.n_sclass
== C_STAT
&& strcmp (name
, symname
) != 0)
1007 /* xgettext:c-format */
1008 _bfd_error_handler (_("%pB: warning: COMDAT symbol '%s'"
1009 " does not match section name '%s'"),
1010 abfd
, symname
, name
);
1014 /* PR 17512: file: e2cfe54f. */
1015 if (esym
+ bfd_coff_symesz (abfd
) >= esymend
)
1017 /* xgettext:c-format */
1018 _bfd_error_handler (_("%pB: warning: no symbol for"
1019 " section '%s' found"),
1023 /* This is the section symbol. */
1024 bfd_coff_swap_aux_in (abfd
, (esym
+ bfd_coff_symesz (abfd
)),
1025 isym
.n_type
, isym
.n_sclass
,
1026 0, isym
.n_numaux
, & aux
);
1028 target_name
= strchr (name
, '$');
1029 if (target_name
!= NULL
)
1037 /* FIXME: Microsoft uses NODUPLICATES and
1038 ASSOCIATIVE, but gnu uses ANY and
1039 SAME_SIZE. Unfortunately, gnu doesn't do
1040 the comdat symbols right. So, until we can
1041 fix it to do the right thing, we are
1042 temporarily disabling comdats for the MS
1043 types (they're used in DLLs and C++, but we
1044 don't support *their* C++ libraries anyway
1047 /* Cygwin does not follow the MS style, and
1048 uses ANY and SAME_SIZE where NODUPLICATES
1049 and ASSOCIATIVE should be used. For
1050 Interix, we just do the right thing up
1053 switch (aux
.x_scn
.x_comdat
)
1055 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
1056 #ifdef STRICT_PE_FORMAT
1057 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
1059 sec_flags
&= ~SEC_LINK_ONCE
;
1063 case IMAGE_COMDAT_SELECT_ANY
:
1064 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1067 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
1068 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
1071 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
1072 /* Not yet fully implemented ??? */
1073 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
1076 /* debug$S gets this case; other
1079 /* There may be no symbol... we'll search
1080 the whole table... Is this the right
1081 place to play this game? Or should we do
1082 it when reading it in. */
1083 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
1084 #ifdef STRICT_PE_FORMAT
1085 /* FIXME: This is not currently implemented. */
1086 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1088 sec_flags
&= ~SEC_LINK_ONCE
;
1092 default: /* 0 means "no symbol" */
1093 /* debug$F gets this case; other
1095 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1102 /* Gas mode: the first matching on partial name. */
1104 #ifndef TARGET_UNDERSCORE
1105 #define TARGET_UNDERSCORE 0
1107 /* Is this the name we're looking for ? */
1108 if (strcmp (target_name
,
1109 symname
+ (TARGET_UNDERSCORE
? 1 : 0)) != 0)
1111 /* Not the name we're looking for */
1112 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1117 /* MSVC mode: the lexically second symbol (or
1118 drop through from the above). */
1123 /* This must the second symbol with the
1124 section #. It is the actual symbol name.
1125 Intel puts the two adjacent, but Alpha (at
1126 least) spreads them out. */
1128 amt
= sizeof (struct coff_comdat_info
);
1129 coff_section_data (abfd
, section
)->comdat
1130 = (struct coff_comdat_info
*) bfd_alloc (abfd
, amt
);
1131 if (coff_section_data (abfd
, section
)->comdat
== NULL
)
1134 coff_section_data (abfd
, section
)->comdat
->symbol
=
1135 (esym
- esymstart
) / bfd_coff_symesz (abfd
);
1137 amt
= strlen (symname
) + 1;
1138 newname
= (char *) bfd_alloc (abfd
, amt
);
1139 if (newname
== NULL
)
1142 strcpy (newname
, symname
);
1143 coff_section_data (abfd
, section
)->comdat
->name
1151 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1159 /* The PE version; see above for the general comments.
1161 Since to set the SEC_LINK_ONCE and associated flags, we have to
1162 look at the symbol table anyway, we return the symbol table index
1163 of the symbol being used as the COMDAT symbol. This is admittedly
1164 ugly, but there's really nowhere else that we have access to the
1165 required information. FIXME: Is the COMDAT symbol index used for
1166 any purpose other than objdump? */
1169 styp_to_sec_flags (bfd
*abfd
,
1173 flagword
*flags_ptr
)
1175 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
1176 unsigned long styp_flags
= internal_s
->s_flags
;
1178 bfd_boolean result
= TRUE
;
1179 bfd_boolean is_dbg
= FALSE
;
1181 if (CONST_STRNEQ (name
, DOT_DEBUG
)
1182 || CONST_STRNEQ (name
, DOT_ZDEBUG
)
1183 #ifdef COFF_LONG_SECTION_NAMES
1184 || CONST_STRNEQ (name
, GNU_LINKONCE_WI
)
1185 || CONST_STRNEQ (name
, GNU_LINKONCE_WT
)
1186 /* FIXME: These definitions ought to be in a header file. */
1187 #define GNU_DEBUGLINK ".gnu_debuglink"
1188 #define GNU_DEBUGALTLINK ".gnu_debugaltlink"
1189 || CONST_STRNEQ (name
, GNU_DEBUGLINK
)
1190 || CONST_STRNEQ (name
, GNU_DEBUGALTLINK
)
1192 || CONST_STRNEQ (name
, ".stab"))
1194 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
1195 sec_flags
= SEC_READONLY
;
1197 /* If section disallows read, then set the NOREAD flag. */
1198 if ((styp_flags
& IMAGE_SCN_MEM_READ
) == 0)
1199 sec_flags
|= SEC_COFF_NOREAD
;
1201 /* Process each flag bit in styp_flags in turn. */
1204 unsigned long flag
= styp_flags
& - styp_flags
;
1205 char * unhandled
= NULL
;
1207 styp_flags
&= ~ flag
;
1209 /* We infer from the distinct read/write/execute bits the settings
1210 of some of the bfd flags; the actual values, should we need them,
1211 are also in pei_section_data (abfd, section)->pe_flags. */
1216 unhandled
= "STYP_DSECT";
1219 unhandled
= "STYP_GROUP";
1222 unhandled
= "STYP_COPY";
1225 unhandled
= "STYP_OVER";
1227 #ifdef SEC_NEVER_LOAD
1229 sec_flags
|= SEC_NEVER_LOAD
;
1232 case IMAGE_SCN_MEM_READ
:
1233 sec_flags
&= ~SEC_COFF_NOREAD
;
1235 case IMAGE_SCN_TYPE_NO_PAD
:
1238 case IMAGE_SCN_LNK_OTHER
:
1239 unhandled
= "IMAGE_SCN_LNK_OTHER";
1241 case IMAGE_SCN_MEM_NOT_CACHED
:
1242 unhandled
= "IMAGE_SCN_MEM_NOT_CACHED";
1244 case IMAGE_SCN_MEM_NOT_PAGED
:
1245 /* Generate a warning message rather using the 'unhandled'
1246 variable as this will allow some .sys files generate by
1247 other toolchains to be processed. See bugzilla issue 196. */
1248 /* xgettext:c-format */
1249 _bfd_error_handler (_("%pB: warning: ignoring section flag"
1250 " %s in section %s"),
1251 abfd
, "IMAGE_SCN_MEM_NOT_PAGED", name
);
1253 case IMAGE_SCN_MEM_EXECUTE
:
1254 sec_flags
|= SEC_CODE
;
1256 case IMAGE_SCN_MEM_WRITE
:
1257 sec_flags
&= ~ SEC_READONLY
;
1259 case IMAGE_SCN_MEM_DISCARDABLE
:
1260 /* The MS PE spec says that debug sections are DISCARDABLE,
1261 but the presence of a DISCARDABLE flag does not necessarily
1262 mean that a given section contains debug information. Thus
1263 we only set the SEC_DEBUGGING flag on sections that we
1264 recognise as containing debug information. */
1267 || strcmp (name
, _COMMENT
) == 0
1271 sec_flags
|= SEC_DEBUGGING
| SEC_READONLY
;
1274 case IMAGE_SCN_MEM_SHARED
:
1275 sec_flags
|= SEC_COFF_SHARED
;
1277 case IMAGE_SCN_LNK_REMOVE
:
1279 sec_flags
|= SEC_EXCLUDE
;
1281 case IMAGE_SCN_CNT_CODE
:
1282 sec_flags
|= SEC_CODE
| SEC_ALLOC
| SEC_LOAD
;
1284 case IMAGE_SCN_CNT_INITIALIZED_DATA
:
1286 sec_flags
|= SEC_DEBUGGING
;
1288 sec_flags
|= SEC_DATA
| SEC_ALLOC
| SEC_LOAD
;
1290 case IMAGE_SCN_CNT_UNINITIALIZED_DATA
:
1291 sec_flags
|= SEC_ALLOC
;
1293 case IMAGE_SCN_LNK_INFO
:
1294 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1295 defined. coff_compute_section_file_positions uses
1296 COFF_PAGE_SIZE to ensure that the low order bits of the
1297 section VMA and the file offset match. If we don't know
1298 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1299 and demand page loading of the file will fail. */
1300 #ifdef COFF_PAGE_SIZE
1301 sec_flags
|= SEC_DEBUGGING
;
1304 case IMAGE_SCN_LNK_COMDAT
:
1305 /* COMDAT gets very special treatment. */
1306 sec_flags
= handle_COMDAT (abfd
, sec_flags
, hdr
, name
, section
);
1309 /* Silently ignore for now. */
1313 /* If the section flag was not handled, report it here. */
1314 if (unhandled
!= NULL
)
1317 /* xgettext:c-format */
1318 (_("%pB (%s): section flag %s (%#lx) ignored"),
1319 abfd
, name
, unhandled
, flag
);
1324 if ((bfd_applicable_section_flags (abfd
) & SEC_SMALL_DATA
) != 0
1325 && (CONST_STRNEQ (name
, ".sbss")
1326 || CONST_STRNEQ (name
, ".sdata")))
1327 sec_flags
|= SEC_SMALL_DATA
;
1329 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1330 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1331 only link a single copy of the section. This is used to support
1332 g++. g++ will emit each template expansion in its own section.
1333 The symbols will be defined as weak, so that multiple definitions
1334 are permitted. The GNU linker extension is to actually discard
1335 all but one of the sections. */
1336 if (CONST_STRNEQ (name
, ".gnu.linkonce"))
1337 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1341 * flags_ptr
= sec_flags
;
1346 #endif /* COFF_WITH_PE */
1348 #define get_index(symbol) ((symbol)->udata.i)
1352 bfd_coff_backend_data
1356 .{* COFF symbol classifications. *}
1358 .enum coff_symbol_classification
1360 . {* Global symbol. *}
1361 . COFF_SYMBOL_GLOBAL,
1362 . {* Common symbol. *}
1363 . COFF_SYMBOL_COMMON,
1364 . {* Undefined symbol. *}
1365 . COFF_SYMBOL_UNDEFINED,
1366 . {* Local symbol. *}
1367 . COFF_SYMBOL_LOCAL,
1368 . {* PE section symbol. *}
1369 . COFF_SYMBOL_PE_SECTION
1372 .typedef asection * (*coff_gc_mark_hook_fn)
1373 . (asection *, struct bfd_link_info *, struct internal_reloc *,
1374 . struct coff_link_hash_entry *, struct internal_syment *);
1376 Special entry points for gdb to swap in coff symbol table parts:
1379 . void (*_bfd_coff_swap_aux_in)
1380 . (bfd *, void *, int, int, int, int, void *);
1382 . void (*_bfd_coff_swap_sym_in)
1383 . (bfd *, void *, void *);
1385 . void (*_bfd_coff_swap_lineno_in)
1386 . (bfd *, void *, void *);
1388 . unsigned int (*_bfd_coff_swap_aux_out)
1389 . (bfd *, void *, int, int, int, int, void *);
1391 . unsigned int (*_bfd_coff_swap_sym_out)
1392 . (bfd *, void *, void *);
1394 . unsigned int (*_bfd_coff_swap_lineno_out)
1395 . (bfd *, void *, void *);
1397 . unsigned int (*_bfd_coff_swap_reloc_out)
1398 . (bfd *, void *, void *);
1400 . unsigned int (*_bfd_coff_swap_filehdr_out)
1401 . (bfd *, void *, void *);
1403 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1404 . (bfd *, void *, void *);
1406 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1407 . (bfd *, void *, void *);
1409 . unsigned int _bfd_filhsz;
1410 . unsigned int _bfd_aoutsz;
1411 . unsigned int _bfd_scnhsz;
1412 . unsigned int _bfd_symesz;
1413 . unsigned int _bfd_auxesz;
1414 . unsigned int _bfd_relsz;
1415 . unsigned int _bfd_linesz;
1416 . unsigned int _bfd_filnmlen;
1417 . bfd_boolean _bfd_coff_long_filenames;
1419 . bfd_boolean _bfd_coff_long_section_names;
1420 . bfd_boolean (*_bfd_coff_set_long_section_names)
1423 . unsigned int _bfd_coff_default_section_alignment_power;
1424 . bfd_boolean _bfd_coff_force_symnames_in_strings;
1425 . unsigned int _bfd_coff_debug_string_prefix_length;
1426 . unsigned int _bfd_coff_max_nscns;
1428 . void (*_bfd_coff_swap_filehdr_in)
1429 . (bfd *, void *, void *);
1431 . void (*_bfd_coff_swap_aouthdr_in)
1432 . (bfd *, void *, void *);
1434 . void (*_bfd_coff_swap_scnhdr_in)
1435 . (bfd *, void *, void *);
1437 . void (*_bfd_coff_swap_reloc_in)
1438 . (bfd *abfd, void *, void *);
1440 . bfd_boolean (*_bfd_coff_bad_format_hook)
1443 . bfd_boolean (*_bfd_coff_set_arch_mach_hook)
1446 . void * (*_bfd_coff_mkobject_hook)
1447 . (bfd *, void *, void *);
1449 . bfd_boolean (*_bfd_styp_to_sec_flags_hook)
1450 . (bfd *, void *, const char *, asection *, flagword *);
1452 . void (*_bfd_set_alignment_hook)
1453 . (bfd *, asection *, void *);
1455 . bfd_boolean (*_bfd_coff_slurp_symbol_table)
1458 . bfd_boolean (*_bfd_coff_symname_in_debug)
1459 . (bfd *, struct internal_syment *);
1461 . bfd_boolean (*_bfd_coff_pointerize_aux_hook)
1462 . (bfd *, combined_entry_type *, combined_entry_type *,
1463 . unsigned int, combined_entry_type *);
1465 . bfd_boolean (*_bfd_coff_print_aux)
1466 . (bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1467 . combined_entry_type *, unsigned int);
1469 . void (*_bfd_coff_reloc16_extra_cases)
1470 . (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1471 . bfd_byte *, unsigned int *, unsigned int *);
1473 . int (*_bfd_coff_reloc16_estimate)
1474 . (bfd *, asection *, arelent *, unsigned int,
1475 . struct bfd_link_info *);
1477 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1478 . (bfd *, struct internal_syment *);
1480 . bfd_boolean (*_bfd_coff_compute_section_file_positions)
1483 . bfd_boolean (*_bfd_coff_start_final_link)
1484 . (bfd *, struct bfd_link_info *);
1486 . bfd_boolean (*_bfd_coff_relocate_section)
1487 . (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1488 . struct internal_reloc *, struct internal_syment *, asection **);
1490 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1491 . (bfd *, asection *, struct internal_reloc *,
1492 . struct coff_link_hash_entry *, struct internal_syment *, bfd_vma *);
1494 . bfd_boolean (*_bfd_coff_adjust_symndx)
1495 . (bfd *, struct bfd_link_info *, bfd *, asection *,
1496 . struct internal_reloc *, bfd_boolean *);
1498 . bfd_boolean (*_bfd_coff_link_add_one_symbol)
1499 . (struct bfd_link_info *, bfd *, const char *, flagword,
1500 . asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
1501 . struct bfd_link_hash_entry **);
1503 . bfd_boolean (*_bfd_coff_link_output_has_begun)
1504 . (bfd *, struct coff_final_link_info *);
1506 . bfd_boolean (*_bfd_coff_final_link_postscript)
1507 . (bfd *, struct coff_final_link_info *);
1509 . bfd_boolean (*_bfd_coff_print_pdata)
1512 .} bfd_coff_backend_data;
1514 .#define coff_backend_info(abfd) \
1515 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1517 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1518 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1520 .#define bfd_coff_swap_sym_in(a,e,i) \
1521 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1523 .#define bfd_coff_swap_lineno_in(a,e,i) \
1524 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1526 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1527 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1529 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1530 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1532 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1533 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1535 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1536 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1538 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1539 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1541 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1542 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1544 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1545 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1547 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1548 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1549 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1550 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1551 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1552 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1553 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1554 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1555 .#define bfd_coff_long_filenames(abfd) \
1556 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1557 .#define bfd_coff_long_section_names(abfd) \
1558 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1559 .#define bfd_coff_set_long_section_names(abfd, enable) \
1560 . ((coff_backend_info (abfd)->_bfd_coff_set_long_section_names) (abfd, enable))
1561 .#define bfd_coff_default_section_alignment_power(abfd) \
1562 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1563 .#define bfd_coff_max_nscns(abfd) \
1564 . (coff_backend_info (abfd)->_bfd_coff_max_nscns)
1566 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1567 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1569 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1570 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1572 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1573 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1575 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1576 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1578 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1579 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1581 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1582 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1583 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1584 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1585 . (abfd, filehdr, aouthdr))
1587 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1588 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1589 . (abfd, scnhdr, name, section, flags_ptr))
1591 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1592 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1594 .#define bfd_coff_slurp_symbol_table(abfd)\
1595 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1597 .#define bfd_coff_symname_in_debug(abfd, sym)\
1598 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1600 .#define bfd_coff_force_symnames_in_strings(abfd)\
1601 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1603 .#define bfd_coff_debug_string_prefix_length(abfd)\
1604 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1606 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1607 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1608 . (abfd, file, base, symbol, aux, indaux))
1610 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1611 . reloc, data, src_ptr, dst_ptr)\
1612 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1613 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1615 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1616 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1617 . (abfd, section, reloc, shrink, link_info))
1619 .#define bfd_coff_classify_symbol(abfd, sym)\
1620 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1623 .#define bfd_coff_compute_section_file_positions(abfd)\
1624 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1627 .#define bfd_coff_start_final_link(obfd, info)\
1628 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1630 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1631 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1632 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1633 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1634 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1635 . (abfd, sec, rel, h, sym, addendp))
1636 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1637 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1638 . (obfd, info, ibfd, sec, rel, adjustedp))
1639 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1640 . value, string, cp, coll, hashp)\
1641 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1642 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1644 .#define bfd_coff_link_output_has_begun(a,p) \
1645 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p))
1646 .#define bfd_coff_final_link_postscript(a,p) \
1647 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p))
1649 .#define bfd_coff_have_print_pdata(a) \
1650 . (coff_backend_info (a)->_bfd_coff_print_pdata)
1651 .#define bfd_coff_print_pdata(a,p) \
1652 . ((coff_backend_info (a)->_bfd_coff_print_pdata) (a, p))
1654 .{* Macro: Returns true if the bfd is a PE executable as opposed to a
1655 . PE object file. *}
1656 .#define bfd_pei_p(abfd) \
1657 . (CONST_STRNEQ ((abfd)->xvec->name, "pei-"))
1660 /* See whether the magic number matches. */
1663 coff_bad_format_hook (bfd
* abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1665 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1667 if (BADMAG (*internal_f
))
1675 ticoff0_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1677 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1679 if (COFF0_BADMAG (*internal_f
))
1688 ticoff1_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1690 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1692 if (COFF1_BADMAG (*internal_f
))
1699 /* Check whether this section uses an alignment other than the
1703 coff_set_custom_section_alignment (bfd
*abfd ATTRIBUTE_UNUSED
,
1705 const struct coff_section_alignment_entry
*alignment_table
,
1706 const unsigned int table_size
)
1708 const unsigned int default_alignment
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1711 for (i
= 0; i
< table_size
; ++i
)
1713 const char *secname
= bfd_section_name (section
);
1715 if (alignment_table
[i
].comparison_length
== (unsigned int) -1
1716 ? strcmp (alignment_table
[i
].name
, secname
) == 0
1717 : strncmp (alignment_table
[i
].name
, secname
,
1718 alignment_table
[i
].comparison_length
) == 0)
1721 if (i
>= table_size
)
1724 if (alignment_table
[i
].default_alignment_min
!= COFF_ALIGNMENT_FIELD_EMPTY
1725 && default_alignment
< alignment_table
[i
].default_alignment_min
)
1728 if (alignment_table
[i
].default_alignment_max
!= COFF_ALIGNMENT_FIELD_EMPTY
1729 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1730 && default_alignment
> alignment_table
[i
].default_alignment_max
1735 section
->alignment_power
= alignment_table
[i
].alignment_power
;
1738 /* Custom section alignment records. */
1740 static const struct coff_section_alignment_entry
1741 coff_section_alignment_table
[] =
1743 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1744 COFF_SECTION_ALIGNMENT_ENTRIES
,
1746 /* There must not be any gaps between .stabstr sections. */
1747 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1748 1, COFF_ALIGNMENT_FIELD_EMPTY
, 0 },
1749 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1750 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1751 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1752 /* Similarly for the .ctors and .dtors sections. */
1753 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1754 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1755 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1756 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 }
1759 static const unsigned int coff_section_alignment_table_size
=
1760 sizeof coff_section_alignment_table
/ sizeof coff_section_alignment_table
[0];
1762 /* Initialize a section structure with information peculiar to this
1763 particular implementation of COFF. */
1766 coff_new_section_hook (bfd
* abfd
, asection
* section
)
1768 combined_entry_type
*native
;
1770 unsigned char sclass
= C_STAT
;
1772 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1775 if (bfd_xcoff_text_align_power (abfd
) != 0
1776 && strcmp (bfd_section_name (section
), ".text") == 0)
1777 section
->alignment_power
= bfd_xcoff_text_align_power (abfd
);
1778 else if (bfd_xcoff_data_align_power (abfd
) != 0
1779 && strcmp (bfd_section_name (section
), ".data") == 0)
1780 section
->alignment_power
= bfd_xcoff_data_align_power (abfd
);
1785 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
1786 if (strcmp (bfd_section_name (section
),
1787 xcoff_dwsect_names
[i
].name
) == 0)
1789 section
->alignment_power
= 0;
1796 /* Set up the section symbol. */
1797 if (!_bfd_generic_new_section_hook (abfd
, section
))
1800 /* Allocate aux records for section symbols, to store size and
1803 @@ The 10 is a guess at a plausible maximum number of aux entries
1804 (but shouldn't be a constant). */
1805 amt
= sizeof (combined_entry_type
) * 10;
1806 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
1810 /* We don't need to set up n_name, n_value, or n_scnum in the native
1811 symbol information, since they'll be overridden by the BFD symbol
1812 anyhow. However, we do need to set the type and storage class,
1813 in case this symbol winds up getting written out. The value 0
1814 for n_numaux is already correct. */
1816 native
->is_sym
= TRUE
;
1817 native
->u
.syment
.n_type
= T_NULL
;
1818 native
->u
.syment
.n_sclass
= sclass
;
1820 coffsymbol (section
->symbol
)->native
= native
;
1822 coff_set_custom_section_alignment (abfd
, section
,
1823 coff_section_alignment_table
,
1824 coff_section_alignment_table_size
);
1829 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1831 /* Set the alignment of a BFD section. */
1834 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1838 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1841 #ifdef COFF_DECODE_ALIGNMENT
1842 i
= COFF_DECODE_ALIGNMENT(hdr
->s_flags
);
1844 section
->alignment_power
= i
;
1846 #ifdef coff_set_section_load_page
1847 coff_set_section_load_page (section
, hdr
->s_page
);
1851 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1855 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1859 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1861 unsigned int alignment_power_const
1862 = hdr
->s_flags
& IMAGE_SCN_ALIGN_POWER_BIT_MASK
;
1864 switch (alignment_power_const
)
1866 case IMAGE_SCN_ALIGN_8192BYTES
:
1867 case IMAGE_SCN_ALIGN_4096BYTES
:
1868 case IMAGE_SCN_ALIGN_2048BYTES
:
1869 case IMAGE_SCN_ALIGN_1024BYTES
:
1870 case IMAGE_SCN_ALIGN_512BYTES
:
1871 case IMAGE_SCN_ALIGN_256BYTES
:
1872 case IMAGE_SCN_ALIGN_128BYTES
:
1873 case IMAGE_SCN_ALIGN_64BYTES
:
1874 case IMAGE_SCN_ALIGN_32BYTES
:
1875 case IMAGE_SCN_ALIGN_16BYTES
:
1876 case IMAGE_SCN_ALIGN_8BYTES
:
1877 case IMAGE_SCN_ALIGN_4BYTES
:
1878 case IMAGE_SCN_ALIGN_2BYTES
:
1879 case IMAGE_SCN_ALIGN_1BYTES
:
1880 section
->alignment_power
1881 = IMAGE_SCN_ALIGN_POWER_NUM (alignment_power_const
);
1887 /* In a PE image file, the s_paddr field holds the virtual size of a
1888 section, while the s_size field holds the raw size. We also keep
1889 the original section flag value, since not every bit can be
1890 mapped onto a generic BFD section bit. */
1891 if (coff_section_data (abfd
, section
) == NULL
)
1893 amt
= sizeof (struct coff_section_tdata
);
1894 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
1895 if (section
->used_by_bfd
== NULL
)
1896 /* FIXME: Return error. */
1900 if (pei_section_data (abfd
, section
) == NULL
)
1902 amt
= sizeof (struct pei_section_tdata
);
1903 coff_section_data (abfd
, section
)->tdata
= bfd_zalloc (abfd
, amt
);
1904 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1905 /* FIXME: Return error. */
1908 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1909 pei_section_data (abfd
, section
)->pe_flags
= hdr
->s_flags
;
1911 section
->lma
= hdr
->s_vaddr
;
1913 /* Check for extended relocs. */
1914 if (hdr
->s_flags
& IMAGE_SCN_LNK_NRELOC_OVFL
)
1916 struct external_reloc dst
;
1917 struct internal_reloc n
;
1918 file_ptr oldpos
= bfd_tell (abfd
);
1919 bfd_size_type relsz
= bfd_coff_relsz (abfd
);
1921 if (bfd_seek (abfd
, (file_ptr
) hdr
->s_relptr
, 0) != 0)
1923 if (bfd_bread (& dst
, relsz
, abfd
) != relsz
)
1926 coff_swap_reloc_in (abfd
, &dst
, &n
);
1927 if (bfd_seek (abfd
, oldpos
, 0) != 0)
1929 section
->reloc_count
= hdr
->s_nreloc
= n
.r_vaddr
- 1;
1930 section
->rel_filepos
+= relsz
;
1932 else if (hdr
->s_nreloc
== 0xffff)
1934 (_("%pB: warning: claims to have 0xffff relocs, without overflow"),
1938 #undef ELIFALIGN_SET
1940 #else /* ! COFF_WITH_PE */
1943 /* We grossly abuse this function to handle XCOFF overflow headers.
1944 When we see one, we correct the reloc and line number counts in the
1945 real header, and remove the section we just created. */
1948 coff_set_alignment_hook (bfd
*abfd
, asection
*section
, void * scnhdr
)
1950 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1953 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1956 real_sec
= coff_section_from_bfd_index (abfd
, (int) hdr
->s_nreloc
);
1957 if (real_sec
== NULL
)
1960 real_sec
->reloc_count
= hdr
->s_paddr
;
1961 real_sec
->lineno_count
= hdr
->s_vaddr
;
1963 if (!bfd_section_removed_from_list (abfd
, section
))
1965 bfd_section_list_remove (abfd
, section
);
1966 --abfd
->section_count
;
1970 #else /* ! RS6000COFF_C */
1971 #if defined (COFF_GO32_EXE) || defined (COFF_GO32)
1974 coff_set_alignment_hook (bfd
* abfd
, asection
* section
, void * scnhdr
)
1976 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1978 /* Check for extended relocs. */
1979 if (hdr
->s_flags
& IMAGE_SCN_LNK_NRELOC_OVFL
)
1981 struct external_reloc dst
;
1982 struct internal_reloc n
;
1983 const file_ptr oldpos
= bfd_tell (abfd
);
1984 const bfd_size_type relsz
= bfd_coff_relsz (abfd
);
1986 if (bfd_seek (abfd
, (file_ptr
) hdr
->s_relptr
, 0) != 0)
1988 if (bfd_bread (& dst
, relsz
, abfd
) != relsz
)
1991 coff_swap_reloc_in (abfd
, &dst
, &n
);
1992 if (bfd_seek (abfd
, oldpos
, 0) != 0)
1994 section
->reloc_count
= hdr
->s_nreloc
= n
.r_vaddr
- 1;
1995 section
->rel_filepos
+= relsz
;
1997 else if (hdr
->s_nreloc
== 0xffff)
1999 (_("%pB: warning: claims to have 0xffff relocs, without overflow"),
2003 #else /* ! COFF_GO32_EXE && ! COFF_GO32 */
2006 coff_set_alignment_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2007 asection
*section ATTRIBUTE_UNUSED
,
2008 void *scnhdr ATTRIBUTE_UNUSED
)
2012 #endif /* ! COFF_GO32_EXE && ! COFF_GO32 */
2013 #endif /* ! RS6000COFF_C */
2014 #endif /* ! COFF_WITH_PE */
2015 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
2017 #ifndef coff_mkobject
2020 coff_mkobject (bfd
* abfd
)
2022 coff_data_type
*coff
;
2023 size_t amt
= sizeof (coff_data_type
);
2025 abfd
->tdata
.coff_obj_data
= bfd_zalloc (abfd
, amt
);
2026 if (abfd
->tdata
.coff_obj_data
== NULL
)
2028 coff
= coff_data (abfd
);
2029 coff
->symbols
= NULL
;
2030 coff
->conversion_table
= NULL
;
2031 coff
->raw_syments
= NULL
;
2032 coff
->relocbase
= 0;
2033 coff
->local_toc_sym_map
= 0;
2035 /* make_abs_section(abfd);*/
2041 /* Create the COFF backend specific information. */
2043 #ifndef coff_mkobject_hook
2045 coff_mkobject_hook (bfd
* abfd
,
2047 void * aouthdr ATTRIBUTE_UNUSED
)
2049 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
2050 coff_data_type
*coff
;
2052 if (! coff_mkobject (abfd
))
2055 coff
= coff_data (abfd
);
2057 coff
->sym_filepos
= internal_f
->f_symptr
;
2059 /* These members communicate important constants about the symbol
2060 table to GDB's symbol-reading code. These `constants'
2061 unfortunately vary among coff implementations... */
2062 coff
->local_n_btmask
= N_BTMASK
;
2063 coff
->local_n_btshft
= N_BTSHFT
;
2064 coff
->local_n_tmask
= N_TMASK
;
2065 coff
->local_n_tshift
= N_TSHIFT
;
2066 coff
->local_symesz
= bfd_coff_symesz (abfd
);
2067 coff
->local_auxesz
= bfd_coff_auxesz (abfd
);
2068 coff
->local_linesz
= bfd_coff_linesz (abfd
);
2070 coff
->timestamp
= internal_f
->f_timdat
;
2072 obj_raw_syment_count (abfd
) =
2073 obj_conv_table_size (abfd
) =
2074 internal_f
->f_nsyms
;
2077 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
2078 abfd
->flags
|= DYNAMIC
;
2079 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= bfd_coff_aoutsz (abfd
))
2081 struct internal_aouthdr
*internal_a
=
2082 (struct internal_aouthdr
*) aouthdr
;
2083 struct xcoff_tdata
*xcoff
;
2085 xcoff
= xcoff_data (abfd
);
2086 # ifdef U803XTOCMAGIC
2087 xcoff
->xcoff64
= internal_f
->f_magic
== U803XTOCMAGIC
;
2091 xcoff
->full_aouthdr
= TRUE
;
2092 xcoff
->toc
= internal_a
->o_toc
;
2093 xcoff
->sntoc
= internal_a
->o_sntoc
;
2094 xcoff
->snentry
= internal_a
->o_snentry
;
2095 bfd_xcoff_text_align_power (abfd
) = internal_a
->o_algntext
;
2096 bfd_xcoff_data_align_power (abfd
) = internal_a
->o_algndata
;
2097 xcoff
->modtype
= internal_a
->o_modtype
;
2098 xcoff
->cputype
= internal_a
->o_cputype
;
2099 xcoff
->maxdata
= internal_a
->o_maxdata
;
2100 xcoff
->maxstack
= internal_a
->o_maxstack
;
2105 /* Set the flags field from the COFF header read in. */
2106 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
2111 /* FIXME: I'm not sure this is ever executed, since peicode.h
2112 defines coff_mkobject_hook. */
2113 if ((internal_f
->f_flags
& IMAGE_FILE_DEBUG_STRIPPED
) == 0)
2114 abfd
->flags
|= HAS_DEBUG
;
2121 /* Determine the machine architecture and type. FIXME: This is target
2122 dependent because the magic numbers are defined in the target
2123 dependent header files. But there is no particular need for this.
2124 If the magic numbers were moved to a separate file, this function
2125 would be target independent and would also be much more successful
2126 at linking together COFF files for different architectures. */
2129 coff_set_arch_mach_hook (bfd
*abfd
, void * filehdr
)
2131 unsigned long machine
;
2132 enum bfd_architecture arch
;
2133 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
2135 /* Zero selects the default machine for an arch. */
2137 switch (internal_f
->f_magic
)
2141 arch
= bfd_arch_powerpc
;
2147 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler. */
2149 case I386_APPLE_MAGIC
:
2150 case I386_FREEBSD_MAGIC
:
2151 case I386_LINUX_MAGIC
:
2152 case I386_NETBSD_MAGIC
:
2153 arch
= bfd_arch_i386
;
2158 case AMD64_APPLE_MAGIC
:
2159 case AMD64_FREEBSD_MAGIC
:
2160 case AMD64_LINUX_MAGIC
:
2161 case AMD64_NETBSD_MAGIC
:
2162 arch
= bfd_arch_i386
;
2163 machine
= bfd_mach_x86_64
;
2168 arch
= bfd_arch_ia64
;
2175 arch
= bfd_arch_arm
;
2176 machine
= bfd_arm_get_mach_from_notes (abfd
, ARM_NOTE_SECTION
);
2177 if (machine
== bfd_mach_arm_unknown
)
2179 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
2181 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
2182 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
2183 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
2185 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
2186 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
2187 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
2188 /* The COFF header does not have enough bits available
2189 to cover all the different ARM architectures. So
2190 we interpret F_ARM_5, the highest flag value to mean
2191 "the highest ARM architecture known to BFD" which is
2192 currently the XScale. */
2193 case F_ARM_5
: machine
= bfd_mach_arm_XScale
; break;
2200 arch
= bfd_arch_z80
;
2201 switch (internal_f
->f_flags
& F_MACHMASK
)
2203 case bfd_mach_z80strict
<< 12:
2204 case bfd_mach_z80
<< 12:
2205 case bfd_mach_z80n
<< 12:
2206 case bfd_mach_z80full
<< 12:
2207 case bfd_mach_r800
<< 12:
2208 case bfd_mach_gbz80
<< 12:
2209 case bfd_mach_z180
<< 12:
2210 case bfd_mach_ez80_z80
<< 12:
2211 case bfd_mach_ez80_adl
<< 12:
2212 machine
= ((unsigned)internal_f
->f_flags
& F_MACHMASK
) >> 12;
2221 arch
= bfd_arch_z8k
;
2222 switch (internal_f
->f_flags
& F_MACHMASK
)
2225 machine
= bfd_mach_z8001
;
2228 machine
= bfd_mach_z8002
;
2248 if (xcoff_data (abfd
)->cputype
!= -1)
2249 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
2252 /* We did not get a value from the a.out header. If the
2253 file has not been stripped, we may be able to get the
2254 architecture information from the first symbol, if it
2255 is a .file symbol. */
2256 if (obj_raw_syment_count (abfd
) == 0)
2261 struct internal_syment sym
;
2262 bfd_size_type amt
= bfd_coff_symesz (abfd
);
2264 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
2266 buf
= _bfd_malloc_and_read (abfd
, amt
, amt
);
2269 bfd_coff_swap_sym_in (abfd
, buf
, & sym
);
2270 if (sym
.n_sclass
== C_FILE
)
2271 cputype
= sym
.n_type
& 0xff;
2278 /* FIXME: We don't handle all cases here. */
2283 arch
= bfd_xcoff_architecture (abfd
);
2284 machine
= bfd_xcoff_machine (abfd
);
2288 arch
= bfd_arch_powerpc
;
2289 machine
= bfd_mach_ppc_601
;
2291 case 2: /* 64 bit PowerPC */
2292 arch
= bfd_arch_powerpc
;
2293 machine
= bfd_mach_ppc_620
;
2296 arch
= bfd_arch_powerpc
;
2297 machine
= bfd_mach_ppc
;
2300 arch
= bfd_arch_rs6000
;
2301 machine
= bfd_mach_rs6k
;
2308 #ifdef SH_ARCH_MAGIC_BIG
2309 case SH_ARCH_MAGIC_BIG
:
2310 case SH_ARCH_MAGIC_LITTLE
:
2312 case SH_ARCH_MAGIC_WINCE
:
2318 #ifdef MIPS_ARCH_MAGIC_WINCE
2319 case MIPS_ARCH_MAGIC_WINCE
:
2320 arch
= bfd_arch_mips
;
2326 #ifdef LYNXCOFFMAGIC
2329 arch
= bfd_arch_sparc
;
2335 arch
= bfd_arch_tic30
;
2340 #ifdef TICOFF_TARGET_ARCH
2341 /* This TI COFF section should be used by all new TI COFF v0 targets. */
2343 arch
= TICOFF_TARGET_ARCH
;
2344 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2350 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */
2351 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */
2354 switch (internal_f
->f_target_id
)
2358 arch
= TICOFF_TARGET_ARCH
;
2359 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2363 arch
= bfd_arch_obscure
;
2365 (_("unrecognized TI COFF target id '0x%x'"),
2366 internal_f
->f_target_id
);
2374 arch
= bfd_arch_mcore
;
2378 default: /* Unreadable input file type. */
2379 arch
= bfd_arch_obscure
;
2383 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2388 symname_in_debug_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2389 struct internal_syment
*sym ATTRIBUTE_UNUSED
)
2391 #ifdef SYMNAME_IN_DEBUG
2392 return SYMNAME_IN_DEBUG (sym
) != 0;
2401 #define FORCE_SYMNAMES_IN_STRINGS
2404 /* Handle the csect auxent of a C_EXT, C_AIX_WEAKEXT or C_HIDEXT symbol. */
2407 coff_pointerize_aux_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2408 combined_entry_type
*table_base
,
2409 combined_entry_type
*symbol
,
2410 unsigned int indaux
,
2411 combined_entry_type
*aux
)
2413 BFD_ASSERT (symbol
->is_sym
);
2414 int n_sclass
= symbol
->u
.syment
.n_sclass
;
2416 if (CSECT_SYM_P (n_sclass
)
2417 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2419 BFD_ASSERT (! aux
->is_sym
);
2420 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2422 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2423 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2424 aux
->fix_scnlen
= 1;
2427 /* Return TRUE to indicate that the caller should not do any
2428 further work on this auxent. */
2432 /* Return FALSE to indicate that this auxent should be handled by
2438 #define coff_pointerize_aux_hook 0
2439 #endif /* ! RS6000COFF_C */
2441 /* Print an aux entry. This returns TRUE if it has printed it. */
2444 coff_print_aux (bfd
*abfd ATTRIBUTE_UNUSED
,
2445 FILE *file ATTRIBUTE_UNUSED
,
2446 combined_entry_type
*table_base ATTRIBUTE_UNUSED
,
2447 combined_entry_type
*symbol ATTRIBUTE_UNUSED
,
2448 combined_entry_type
*aux ATTRIBUTE_UNUSED
,
2449 unsigned int indaux ATTRIBUTE_UNUSED
)
2451 BFD_ASSERT (symbol
->is_sym
);
2452 BFD_ASSERT (! aux
->is_sym
);
2454 if (CSECT_SYM_P (symbol
->u
.syment
.n_sclass
)
2455 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2457 /* This is a csect entry. */
2458 fprintf (file
, "AUX ");
2459 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2461 BFD_ASSERT (! aux
->fix_scnlen
);
2462 fprintf (file
, "val %5" BFD_VMA_FMT
"d",
2463 aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2467 fprintf (file
, "indx ");
2468 if (! aux
->fix_scnlen
)
2469 fprintf (file
, "%4" BFD_VMA_FMT
"d",
2470 aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2472 fprintf (file
, "%4ld",
2473 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2476 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2477 aux
->u
.auxent
.x_csect
.x_parmhash
,
2478 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2479 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2480 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2481 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2482 aux
->u
.auxent
.x_csect
.x_stab
,
2483 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2488 /* Return FALSE to indicate that no special action was taken. */
2496 To write relocations, the back end steps though the
2497 canonical relocation table and create an
2498 @code{internal_reloc}. The symbol index to use is removed from
2499 the @code{offset} field in the symbol table supplied. The
2500 address comes directly from the sum of the section base
2501 address and the relocation offset; the type is dug directly
2502 from the howto field. Then the @code{internal_reloc} is
2503 swapped into the shape of an @code{external_reloc} and written
2511 /* AUX's ld wants relocations to be sorted. */
2513 compare_arelent_ptr (const void * x
, const void * y
)
2515 const arelent
**a
= (const arelent
**) x
;
2516 const arelent
**b
= (const arelent
**) y
;
2517 bfd_size_type aadr
= (*a
)->address
;
2518 bfd_size_type badr
= (*b
)->address
;
2520 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2523 #endif /* TARG_AUX */
2526 coff_write_relocs (bfd
* abfd
, int first_undef
)
2530 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2533 struct external_reloc dst
;
2540 /* Sort relocations before we write them out. */
2543 amt
= s
->reloc_count
;
2544 amt
*= sizeof (arelent
*);
2545 p
= bfd_malloc (amt
);
2548 if (s
->reloc_count
> 0)
2553 memcpy (p
, s
->orelocation
, (size_t) amt
);
2554 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2559 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2562 #ifdef COFF_WITH_EXTENDED_RELOC_COUNTER
2563 if ((obj_pe (abfd
) || obj_go32 (abfd
)) && s
->reloc_count
>= 0xffff)
2565 /* Encode real count here as first reloc. */
2566 struct internal_reloc n
;
2568 memset (& n
, 0, sizeof (n
));
2569 /* Add one to count *this* reloc (grr). */
2570 n
.r_vaddr
= s
->reloc_count
+ 1;
2571 coff_swap_reloc_out (abfd
, &n
, &dst
);
2572 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2573 abfd
) != bfd_coff_relsz (abfd
))
2578 for (i
= 0; i
< s
->reloc_count
; i
++)
2580 struct internal_reloc n
;
2583 memset (& n
, 0, sizeof (n
));
2585 /* Now we've renumbered the symbols we know where the
2586 undefined symbols live in the table. Check the reloc
2587 entries for symbols who's output bfd isn't the right one.
2588 This is because the symbol was undefined (which means
2589 that all the pointers are never made to point to the same
2590 place). This is a bad thing,'cause the symbols attached
2591 to the output bfd are indexed, so that the relocation
2592 entries know which symbol index they point to. So we
2593 have to look up the output symbol here. */
2595 if (q
->sym_ptr_ptr
[0] != NULL
&& q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2598 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2599 asymbol
**outsyms
= abfd
->outsymbols
;
2601 for (j
= first_undef
; outsyms
[j
]; j
++)
2603 const char *intable
= outsyms
[j
]->name
;
2605 if (strcmp (intable
, sname
) == 0)
2607 /* Got a hit, so repoint the reloc. */
2608 q
->sym_ptr_ptr
= outsyms
+ j
;
2614 n
.r_vaddr
= q
->address
+ s
->vma
;
2617 /* The 29k const/consth reloc pair is a real kludge. The consth
2618 part doesn't have a symbol; it has an offset. So rebuilt
2620 if (q
->howto
->type
== R_IHCONST
)
2621 n
.r_symndx
= q
->addend
;
2624 if (q
->sym_ptr_ptr
&& q
->sym_ptr_ptr
[0] != NULL
)
2626 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2627 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
, s
))
2629 if ((*q
->sym_ptr_ptr
)->section
== bfd_abs_section_ptr
2630 && ((*q
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) != 0)
2632 /* This is a relocation relative to the absolute symbol. */
2636 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2637 /* Check to see if the symbol reloc points to a symbol
2638 we don't have in our symbol table. */
2639 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2641 bfd_set_error (bfd_error_bad_value
);
2642 /* xgettext:c-format */
2643 _bfd_error_handler (_("%pB: reloc against a non-existent"
2644 " symbol index: %ld"),
2651 #ifdef SWAP_OUT_RELOC_OFFSET
2652 n
.r_offset
= q
->addend
;
2656 /* Work out reloc type from what is required. */
2657 SELECT_RELOC (n
, q
->howto
);
2659 n
.r_type
= q
->howto
->type
;
2661 coff_swap_reloc_out (abfd
, &n
, &dst
);
2663 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2664 abfd
) != bfd_coff_relsz (abfd
))
2676 /* Set flags and magic number of a coff file from architecture and machine
2677 type. Result is TRUE if we can represent the arch&type, FALSE if not. */
2680 coff_set_flags (bfd
* abfd
,
2681 unsigned int *magicp ATTRIBUTE_UNUSED
,
2682 unsigned short *flagsp ATTRIBUTE_UNUSED
)
2684 switch (bfd_get_arch (abfd
))
2689 switch (bfd_get_mach (abfd
))
2691 case bfd_mach_z80strict
:
2694 case bfd_mach_z80full
:
2696 case bfd_mach_gbz80
:
2698 case bfd_mach_ez80_z80
:
2699 case bfd_mach_ez80_adl
:
2700 *flagsp
= bfd_get_mach (abfd
) << 12;
2712 switch (bfd_get_mach (abfd
))
2714 case bfd_mach_z8001
: *flagsp
= F_Z8001
; break;
2715 case bfd_mach_z8002
: *flagsp
= F_Z8002
; break;
2716 default: return FALSE
;
2722 case bfd_arch_tic30
:
2723 *magicp
= TIC30MAGIC
;
2727 #ifdef TICOFF_DEFAULT_MAGIC
2728 case TICOFF_TARGET_ARCH
:
2729 /* If there's no indication of which version we want, use the default. */
2731 *magicp
= TICOFF_DEFAULT_MAGIC
;
2734 /* We may want to output in a different COFF version. */
2735 switch (abfd
->xvec
->name
[4])
2738 *magicp
= TICOFF0MAGIC
;
2741 *magicp
= TICOFF1MAGIC
;
2744 *magicp
= TICOFF2MAGIC
;
2750 TICOFF_TARGET_MACHINE_SET (flagsp
, bfd_get_mach (abfd
));
2757 * magicp
= ARMPEMAGIC
;
2759 * magicp
= ARMMAGIC
;
2762 if (APCS_SET (abfd
))
2764 if (APCS_26_FLAG (abfd
))
2765 * flagsp
|= F_APCS26
;
2767 if (APCS_FLOAT_FLAG (abfd
))
2768 * flagsp
|= F_APCS_FLOAT
;
2770 if (PIC_FLAG (abfd
))
2773 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2774 * flagsp
|= F_INTERWORK
;
2775 switch (bfd_get_mach (abfd
))
2777 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2778 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2779 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2780 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2781 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2782 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2783 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2784 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2785 See also the comment in coff_set_arch_mach_hook(). */
2786 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break;
2787 case bfd_mach_arm_5TE
: * flagsp
|= F_ARM_5
; break;
2788 case bfd_mach_arm_XScale
: * flagsp
|= F_ARM_5
; break;
2794 case bfd_arch_powerpc
:
2799 #if defined(I386MAGIC) || defined(AMD64MAGIC)
2801 #if defined(I386MAGIC)
2802 *magicp
= I386MAGIC
;
2805 /* Just overwrite the usual value if we're doing Lynx. */
2806 *magicp
= LYNXCOFFMAGIC
;
2808 #if defined AMD64MAGIC
2809 *magicp
= AMD64MAGIC
;
2816 *magicp
= IA64MAGIC
;
2820 #ifdef SH_ARCH_MAGIC_BIG
2822 #ifdef COFF_IMAGE_WITH_PE
2823 *magicp
= SH_ARCH_MAGIC_WINCE
;
2825 if (bfd_big_endian (abfd
))
2826 *magicp
= SH_ARCH_MAGIC_BIG
;
2828 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2833 #ifdef MIPS_ARCH_MAGIC_WINCE
2835 *magicp
= MIPS_ARCH_MAGIC_WINCE
;
2840 case bfd_arch_sparc
:
2841 *magicp
= SPARCMAGIC
;
2843 /* Just overwrite the usual value if we're doing Lynx. */
2844 *magicp
= LYNXCOFFMAGIC
;
2850 case bfd_arch_rs6000
:
2852 case bfd_arch_powerpc
:
2854 BFD_ASSERT (bfd_get_flavour (abfd
) == bfd_target_xcoff_flavour
);
2855 *magicp
= bfd_xcoff_magic_number (abfd
);
2860 case bfd_arch_mcore
:
2861 * magicp
= MCOREMAGIC
;
2865 default: /* Unknown architecture. */
2866 /* Fall through to "return FALSE" below, to avoid
2867 "statement never reached" errors on the one below. */
2875 coff_set_arch_mach (bfd
* abfd
,
2876 enum bfd_architecture arch
,
2877 unsigned long machine
)
2880 unsigned short dummy2
;
2882 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
2885 if (arch
!= bfd_arch_unknown
2886 && ! coff_set_flags (abfd
, &dummy1
, &dummy2
))
2887 return FALSE
; /* We can't represent this type. */
2889 return TRUE
; /* We're easy... */
2892 #ifdef COFF_IMAGE_WITH_PE
2894 /* This is used to sort sections by VMA, as required by PE image
2898 sort_by_secaddr (const void * arg1
, const void * arg2
)
2900 const asection
*a
= *(const asection
**) arg1
;
2901 const asection
*b
= *(const asection
**) arg2
;
2903 if (a
->vma
< b
->vma
)
2905 else if (a
->vma
> b
->vma
)
2911 #endif /* COFF_IMAGE_WITH_PE */
2913 /* Calculate the file position for each section. */
2915 #define ALIGN_SECTIONS_IN_FILE
2917 #undef ALIGN_SECTIONS_IN_FILE
2921 coff_compute_section_file_positions (bfd
* abfd
)
2924 file_ptr sofar
= bfd_coff_filhsz (abfd
);
2925 bfd_boolean align_adjust
;
2926 unsigned int target_index
;
2927 #ifdef ALIGN_SECTIONS_IN_FILE
2928 asection
*previous
= NULL
;
2932 #ifdef COFF_IMAGE_WITH_PE
2935 if (coff_data (abfd
)->link_info
2936 || (pe_data (abfd
) && pe_data (abfd
)->pe_opthdr
.FileAlignment
))
2938 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
2940 /* If no file alignment has been set, default to one.
2941 This repairs 'ld -r' for arm-wince-pe target. */
2945 /* PR 17512: file: 0ac816d3. */
2948 bfd_set_error (bfd_error_file_too_big
);
2950 /* xgettext:c-format */
2951 (_("%pB: page size is too large (0x%x)"), abfd
, page_size
);
2956 page_size
= PE_DEF_FILE_ALIGNMENT
;
2958 #ifdef COFF_PAGE_SIZE
2959 int page_size
= COFF_PAGE_SIZE
;
2964 /* On XCOFF, if we have symbols, set up the .debug section. */
2965 if (bfd_get_symcount (abfd
) > 0)
2968 bfd_size_type i
, symcount
;
2972 symcount
= bfd_get_symcount (abfd
);
2973 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
2975 coff_symbol_type
*cf
;
2977 cf
= coff_symbol_from (*symp
);
2979 && cf
->native
!= NULL
2980 && cf
->native
->is_sym
2981 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
2985 len
= strlen (bfd_asymbol_name (*symp
));
2986 if (len
> SYMNMLEN
|| bfd_coff_force_symnames_in_strings (abfd
))
2987 sz
+= len
+ 1 + bfd_coff_debug_string_prefix_length (abfd
);
2994 dsec
= bfd_make_section_old_way (abfd
, DOT_DEBUG
);
2998 dsec
->flags
|= SEC_HAS_CONTENTS
;
3003 if (bfd_get_start_address (abfd
))
3004 /* A start address may have been added to the original file. In this
3005 case it will need an optional header to record it. */
3006 abfd
->flags
|= EXEC_P
;
3008 if (abfd
->flags
& EXEC_P
)
3009 sofar
+= bfd_coff_aoutsz (abfd
);
3011 else if (xcoff_data (abfd
)->full_aouthdr
)
3012 sofar
+= bfd_coff_aoutsz (abfd
);
3014 sofar
+= SMALL_AOUTSZ
;
3017 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
3020 /* XCOFF handles overflows in the reloc and line number count fields
3021 by allocating a new section header to hold the correct counts. */
3022 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3023 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3024 sofar
+= bfd_coff_scnhsz (abfd
);
3027 #ifdef COFF_IMAGE_WITH_PE
3029 /* PE requires the sections to be in memory order when listed in
3030 the section headers. It also does not like empty loadable
3031 sections. The sections apparently do not have to be in the
3032 right order in the image file itself, but we do need to get the
3033 target_index values right. */
3036 asection
**section_list
;
3040 #ifdef COFF_PAGE_SIZE
3041 /* Clear D_PAGED if section alignment is smaller than
3043 if (pe_data (abfd
)->pe_opthdr
.SectionAlignment
< COFF_PAGE_SIZE
)
3044 abfd
->flags
&= ~D_PAGED
;
3048 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3051 /* We allocate an extra cell to simplify the final loop. */
3052 amt
= sizeof (struct asection
*) * (count
+ 1);
3053 section_list
= (asection
**) bfd_malloc (amt
);
3054 if (section_list
== NULL
)
3058 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3060 section_list
[i
] = current
;
3063 section_list
[i
] = NULL
;
3065 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
3067 /* Rethread the linked list into sorted order; at the same time,
3068 assign target_index values. */
3070 abfd
->sections
= NULL
;
3071 abfd
->section_last
= NULL
;
3072 for (i
= 0; i
< count
; i
++)
3074 current
= section_list
[i
];
3075 bfd_section_list_append (abfd
, current
);
3077 /* Later, if the section has zero size, we'll be throwing it
3078 away, so we don't want to number it now. Note that having
3079 a zero size and having real contents are different
3080 concepts: .bss has no contents, but (usually) non-zero
3082 if (current
->size
== 0)
3084 /* Discard. However, it still might have (valid) symbols
3085 in it, so arbitrarily set it to section 1 (indexing is
3086 1-based here; usually .text). __end__ and other
3087 contents of .endsection really have this happen.
3088 FIXME: This seems somewhat dubious. */
3089 current
->target_index
= 1;
3092 current
->target_index
= target_index
++;
3095 free (section_list
);
3097 #else /* ! COFF_IMAGE_WITH_PE */
3099 /* Set the target_index field. */
3101 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3102 current
->target_index
= target_index
++;
3104 #endif /* ! COFF_IMAGE_WITH_PE */
3106 if (target_index
>= bfd_coff_max_nscns (abfd
))
3108 bfd_set_error (bfd_error_file_too_big
);
3110 /* xgettext:c-format */
3111 (_("%pB: too many sections (%d)"), abfd
, target_index
);
3115 align_adjust
= FALSE
;
3116 for (current
= abfd
->sections
;
3118 current
= current
->next
)
3120 #ifdef COFF_IMAGE_WITH_PE
3121 /* With PE we have to pad each section to be a multiple of its
3122 page size too, and remember both sizes. */
3123 if (coff_section_data (abfd
, current
) == NULL
)
3125 size_t amt
= sizeof (struct coff_section_tdata
);
3127 current
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
3128 if (current
->used_by_bfd
== NULL
)
3131 if (pei_section_data (abfd
, current
) == NULL
)
3133 size_t amt
= sizeof (struct pei_section_tdata
);
3135 coff_section_data (abfd
, current
)->tdata
= bfd_zalloc (abfd
, amt
);
3136 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
3139 if (pei_section_data (abfd
, current
)->virt_size
== 0)
3140 pei_section_data (abfd
, current
)->virt_size
= current
->size
;
3143 /* Only deal with sections which have contents. */
3144 if (!(current
->flags
& SEC_HAS_CONTENTS
))
3147 current
->rawsize
= current
->size
;
3149 #ifdef COFF_IMAGE_WITH_PE
3150 /* Make sure we skip empty sections in a PE image. */
3151 if (current
->size
== 0)
3155 /* Align the sections in the file to the same boundary on
3156 which they are aligned in virtual memory. */
3157 #ifdef ALIGN_SECTIONS_IN_FILE
3158 if ((abfd
->flags
& EXEC_P
) != 0)
3160 /* Make sure this section is aligned on the right boundary - by
3161 padding the previous section up if necessary. */
3164 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3167 /* Make sure the file offset and the vma of .text/.data are at the
3168 same page offset, so that the file can be mmap'ed without being
3169 relocated. Failing that, AIX is able to load and execute the
3170 program, but it will be silently relocated (possible as
3171 executables are PIE). But the relocation is slightly costly and
3172 complexify the use of addr2line or gdb. So better to avoid it,
3173 like does the native linker. Usually gnu ld makes sure that
3174 the vma of .text is the file offset so this issue shouldn't
3175 appear unless you are stripping such an executable.
3177 AIX loader checks the text section alignment of (vma - filepos),
3178 and the native linker doesn't try to align the text sections.
3181 0 .text 000054cc 10000128 10000128 00000128 2**5
3182 CONTENTS, ALLOC, LOAD, CODE
3185 if (!strcmp (current
->name
, _TEXT
)
3186 || !strcmp (current
->name
, _DATA
))
3188 bfd_vma align
= 4096;
3189 bfd_vma sofar_off
= sofar
% align
;
3190 bfd_vma vma_off
= current
->vma
% align
;
3192 if (vma_off
> sofar_off
)
3193 sofar
+= vma_off
- sofar_off
;
3194 else if (vma_off
< sofar_off
)
3195 sofar
+= align
+ vma_off
- sofar_off
;
3198 if (previous
!= NULL
)
3199 previous
->size
+= sofar
- old_sofar
;
3204 /* In demand paged files the low order bits of the file offset
3205 must match the low order bits of the virtual address. */
3206 #ifdef COFF_PAGE_SIZE
3207 if ((abfd
->flags
& D_PAGED
) != 0
3208 && (current
->flags
& SEC_ALLOC
) != 0)
3209 sofar
+= (current
->vma
- (bfd_vma
) sofar
) % page_size
;
3211 current
->filepos
= sofar
;
3213 #ifdef COFF_IMAGE_WITH_PE
3214 /* Set the padded size. */
3215 current
->size
= (current
->size
+ page_size
- 1) & -page_size
;
3218 sofar
+= current
->size
;
3220 #ifdef ALIGN_SECTIONS_IN_FILE
3221 /* Make sure that this section is of the right size too. */
3222 if ((abfd
->flags
& EXEC_P
) == 0)
3224 bfd_size_type old_size
;
3226 old_size
= current
->size
;
3227 current
->size
= BFD_ALIGN (current
->size
,
3228 1 << current
->alignment_power
);
3229 align_adjust
= current
->size
!= old_size
;
3230 sofar
+= current
->size
- old_size
;
3235 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3236 align_adjust
= sofar
!= old_sofar
;
3237 current
->size
+= sofar
- old_sofar
;
3241 #ifdef COFF_IMAGE_WITH_PE
3242 /* For PE we need to make sure we pad out to the aligned
3243 size, in case the caller only writes out data to the
3245 if (pei_section_data (abfd
, current
)->virt_size
< current
->size
)
3246 align_adjust
= TRUE
;
3250 /* Force .lib sections to start at zero. The vma is then
3251 incremented in coff_set_section_contents. This is right for
3253 if (strcmp (current
->name
, _LIB
) == 0)
3254 bfd_set_section_vma (current
, 0);
3257 #ifdef ALIGN_SECTIONS_IN_FILE
3262 /* It is now safe to write to the output file. If we needed an
3263 alignment adjustment for the last section, then make sure that
3264 there is a byte at offset sofar. If there are no symbols and no
3265 relocs, then nothing follows the last section. If we don't force
3266 the last byte out, then the file may appear to be truncated. */
3272 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
3273 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3277 /* Make sure the relocations are aligned. We don't need to make
3278 sure that this byte exists, because it will only matter if there
3279 really are relocs. */
3280 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
3282 obj_relocbase (abfd
) = sofar
;
3283 abfd
->output_has_begun
= TRUE
;
3288 #ifdef COFF_IMAGE_WITH_PE
3290 static unsigned int pelength
;
3291 static unsigned int peheader
;
3294 coff_read_word (bfd
*abfd
, unsigned int *value
)
3299 status
= bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3307 *value
= (unsigned int) b
[0];
3309 *value
= (unsigned int) (b
[0] + (b
[1] << 8));
3311 pelength
+= (unsigned int) status
;
3317 coff_compute_checksum (bfd
*abfd
)
3319 bfd_boolean more_data
;
3326 filepos
= (file_ptr
) 0;
3330 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
3333 more_data
= coff_read_word (abfd
, &value
);
3335 total
= 0xffff & (total
+ (total
>> 0x10));
3340 return (0xffff & (total
+ (total
>> 0x10)));
3344 coff_apply_checksum (bfd
*abfd
)
3346 unsigned int computed
;
3347 unsigned int checksum
= 0;
3349 if (bfd_seek (abfd
, 0x3c, SEEK_SET
) != 0)
3352 if (!coff_read_word (abfd
, &peheader
))
3355 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3359 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3361 if (bfd_seek (abfd
, peheader
, SEEK_SET
) != 0)
3364 computed
= coff_compute_checksum (abfd
);
3366 checksum
= computed
+ pelength
;
3368 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3371 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3376 #endif /* COFF_IMAGE_WITH_PE */
3379 coff_write_object_contents (bfd
* abfd
)
3382 bfd_boolean hasrelocs
= FALSE
;
3383 bfd_boolean haslinno
= FALSE
;
3384 #ifdef COFF_IMAGE_WITH_PE
3385 bfd_boolean hasdebug
= FALSE
;
3388 file_ptr reloc_base
;
3389 file_ptr lineno_base
;
3391 unsigned long reloc_size
= 0, reloc_count
= 0;
3392 unsigned long lnno_size
= 0;
3393 bfd_boolean long_section_names
;
3394 asection
*text_sec
= NULL
;
3395 asection
*data_sec
= NULL
;
3396 asection
*bss_sec
= NULL
;
3397 struct internal_filehdr internal_f
;
3398 struct internal_aouthdr internal_a
;
3399 #ifdef COFF_LONG_SECTION_NAMES
3400 size_t string_size
= STRING_SIZE_SIZE
;
3403 bfd_set_error (bfd_error_system_call
);
3405 /* Make a pass through the symbol table to count line number entries and
3406 put them into the correct asections. */
3407 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3409 if (! abfd
->output_has_begun
)
3411 if (! coff_compute_section_file_positions (abfd
))
3415 reloc_base
= obj_relocbase (abfd
);
3417 /* Work out the size of the reloc and linno areas. */
3419 for (current
= abfd
->sections
; current
!= NULL
; current
=
3422 #ifdef COFF_WITH_EXTENDED_RELOC_COUNTER
3423 /* We store the actual reloc count in the first reloc's addr. */
3424 if ((obj_pe (abfd
) || obj_go32 (abfd
)) && current
->reloc_count
>= 0xffff)
3427 reloc_count
+= current
->reloc_count
;
3430 reloc_size
= reloc_count
* bfd_coff_relsz (abfd
);
3432 lineno_base
= reloc_base
+ reloc_size
;
3433 sym_base
= lineno_base
+ lnno_size
;
3435 /* Indicate in each section->line_filepos its actual file address. */
3436 for (current
= abfd
->sections
; current
!= NULL
; current
=
3439 if (current
->lineno_count
)
3441 current
->line_filepos
= lineno_base
;
3442 current
->moving_line_filepos
= lineno_base
;
3443 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3446 current
->line_filepos
= 0;
3448 if (current
->reloc_count
)
3450 current
->rel_filepos
= reloc_base
;
3451 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3452 #ifdef COFF_WITH_EXTENDED_RELOC_COUNTER
3453 /* Extra reloc to hold real count. */
3454 if ((obj_pe (abfd
) || obj_go32 (abfd
)) && current
->reloc_count
>= 0xffff)
3455 reloc_base
+= bfd_coff_relsz (abfd
);
3459 current
->rel_filepos
= 0;
3462 /* Write section headers to the file. */
3463 internal_f
.f_nscns
= 0;
3465 if ((abfd
->flags
& EXEC_P
) != 0)
3466 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3469 scn_base
= bfd_coff_filhsz (abfd
);
3472 if (xcoff_data (abfd
)->full_aouthdr
)
3473 scn_base
+= bfd_coff_aoutsz (abfd
);
3475 scn_base
+= SMALL_AOUTSZ
;
3480 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3483 long_section_names
= FALSE
;
3484 for (current
= abfd
->sections
;
3486 current
= current
->next
)
3488 struct internal_scnhdr section
;
3489 #ifdef COFF_IMAGE_WITH_PE
3490 bfd_boolean is_reloc_section
= FALSE
;
3492 if (strcmp (current
->name
, DOT_RELOC
) == 0)
3494 is_reloc_section
= TRUE
;
3496 pe_data (abfd
)->has_reloc_section
= 1;
3500 internal_f
.f_nscns
++;
3502 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3504 #ifdef COFF_LONG_SECTION_NAMES
3505 /* Handle long section names as in PE. This must be compatible
3506 with the code in coff_write_symbols and _bfd_coff_final_link. */
3507 if (bfd_coff_long_section_names (abfd
))
3511 len
= strlen (current
->name
);
3514 /* The s_name field is defined to be NUL-padded but need not be
3515 NUL-terminated. We use a temporary buffer so that we can still
3516 sprintf all eight chars without splatting a terminating NUL
3517 over the first byte of the following member (s_paddr). */
3518 /* PR 21096: The +20 is to stop a bogus warning from gcc7 about
3519 a possible buffer overflow. */
3520 char s_name_buf
[SCNNMLEN
+ 1 + 20];
3522 /* An inherent limitation of the /nnnnnnn notation used to indicate
3523 the offset of the long name in the string table is that we
3524 cannot address entries beyone the ten million byte boundary. */
3525 if (string_size
>= 10000000)
3527 bfd_set_error (bfd_error_file_too_big
);
3529 /* xgettext:c-format */
3530 (_("%pB: section %pA: string table overflow at offset %ld"),
3531 abfd
, current
, (unsigned long) string_size
);
3535 /* We do not need to use snprintf here as we have already verfied
3536 that string_size is not too big, plus we have an overlarge
3537 buffer, just in case. */
3538 sprintf (s_name_buf
, "/%lu", (unsigned long) string_size
);
3539 /* Then strncpy takes care of any padding for us. */
3540 strncpy (section
.s_name
, s_name_buf
, SCNNMLEN
);
3541 string_size
+= len
+ 1;
3542 long_section_names
= TRUE
;
3548 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3549 Ian Taylor <ian@cygnus.com>. */
3550 if (strcmp (current
->name
, _LIB
) == 0)
3551 section
.s_vaddr
= 0;
3554 section
.s_vaddr
= current
->vma
;
3555 section
.s_paddr
= current
->lma
;
3556 section
.s_size
= current
->size
;
3557 #ifdef coff_get_section_load_page
3558 section
.s_page
= coff_get_section_load_page (current
);
3564 section
.s_paddr
= 0;
3566 #ifdef COFF_IMAGE_WITH_PE
3567 /* Reminder: s_paddr holds the virtual size of the section. */
3568 if (coff_section_data (abfd
, current
) != NULL
3569 && pei_section_data (abfd
, current
) != NULL
)
3570 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3572 section
.s_paddr
= 0;
3575 /* If this section has no size or is unloadable then the scnptr
3577 if (current
->size
== 0
3578 || (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3579 section
.s_scnptr
= 0;
3581 section
.s_scnptr
= current
->filepos
;
3583 section
.s_relptr
= current
->rel_filepos
;
3584 section
.s_lnnoptr
= current
->line_filepos
;
3585 section
.s_nreloc
= current
->reloc_count
;
3586 section
.s_nlnno
= current
->lineno_count
;
3587 #ifndef COFF_IMAGE_WITH_PE
3588 /* In PEI, relocs come in the .reloc section. */
3589 if (current
->reloc_count
!= 0)
3592 if (current
->lineno_count
!= 0)
3594 #ifdef COFF_IMAGE_WITH_PE
3595 if ((current
->flags
& SEC_DEBUGGING
) != 0
3596 && ! is_reloc_section
)
3602 /* Indicate the use of an XCOFF overflow section header. */
3603 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3605 section
.s_nreloc
= 0xffff;
3606 section
.s_nlnno
= 0xffff;
3611 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3613 if (!strcmp (current
->name
, _TEXT
))
3615 else if (!strcmp (current
->name
, _DATA
))
3617 else if (!strcmp (current
->name
, _BSS
))
3620 #ifdef COFF_ENCODE_ALIGNMENT
3621 COFF_ENCODE_ALIGNMENT(section
, current
->alignment_power
);
3622 if ((unsigned int)COFF_DECODE_ALIGNMENT(section
.s_flags
)
3623 != current
->alignment_power
)
3625 bfd_boolean warn
= coff_data (abfd
)->link_info
3626 && !bfd_link_relocatable (coff_data (abfd
)->link_info
);
3629 /* xgettext:c-format */
3630 (_("%pB:%s section %s: alignment 2**%u not representable"),
3631 abfd
, warn
? " warning:" : "", current
->name
,
3632 current
->alignment_power
);
3635 bfd_set_error (bfd_error_nonrepresentable_section
);
3641 #ifdef COFF_IMAGE_WITH_PE
3642 /* Suppress output of the sections if they are null. ld
3643 includes the bss and data sections even if there is no size
3644 assigned to them. NT loader doesn't like it if these section
3645 headers are included if the sections themselves are not
3646 needed. See also coff_compute_section_file_positions. */
3647 if (section
.s_size
== 0)
3648 internal_f
.f_nscns
--;
3653 bfd_size_type amt
= bfd_coff_scnhsz (abfd
);
3655 if (bfd_coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3656 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3661 /* PE stores COMDAT section information in the symbol table. If
3662 this section is supposed to have some COMDAT info, track down
3663 the symbol in the symbol table and modify it. */
3664 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3666 unsigned int i
, count
;
3668 coff_symbol_type
*csym
= NULL
;
3672 count
= bfd_get_symcount (abfd
);
3673 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3675 if ((*psym
)->section
!= current
)
3678 /* Remember the location of the first symbol in this
3680 if (psymsec
== NULL
)
3683 /* See if this is the section symbol. */
3684 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3686 csym
= coff_symbol_from (*psym
);
3688 || csym
->native
== NULL
3689 || ! csym
->native
->is_sym
3690 || csym
->native
->u
.syment
.n_numaux
< 1
3691 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3692 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3695 /* Here *PSYM is the section symbol for CURRENT. */
3702 Note that we might not if we're converting the file from
3703 some other object file format. */
3706 combined_entry_type
*aux
;
3708 /* We don't touch the x_checksum field. The
3709 x_associated field is not currently supported. */
3711 aux
= csym
->native
+ 1;
3712 BFD_ASSERT (! aux
->is_sym
);
3713 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3715 case SEC_LINK_DUPLICATES_DISCARD
:
3716 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3719 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3720 aux
->u
.auxent
.x_scn
.x_comdat
=
3721 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3724 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3725 aux
->u
.auxent
.x_scn
.x_comdat
=
3726 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3729 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3730 aux
->u
.auxent
.x_scn
.x_comdat
=
3731 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3735 /* The COMDAT symbol must be the first symbol from this
3736 section in the symbol table. In order to make this
3737 work, we move the COMDAT symbol before the first
3738 symbol we found in the search above. It's OK to
3739 rearrange the symbol table at this point, because
3740 coff_renumber_symbols is going to rearrange it
3741 further and fix up all the aux entries. */
3742 if (psym
!= psymsec
)
3748 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3749 pcopy
[0] = pcopy
[-1];
3754 #endif /* COFF_WITH_PE */
3759 /* XCOFF handles overflows in the reloc and line number count fields
3760 by creating a new section header to hold the correct values. */
3761 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3763 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3765 struct internal_scnhdr scnhdr
;
3769 internal_f
.f_nscns
++;
3770 memcpy (scnhdr
.s_name
, ".ovrflo", 8);
3771 scnhdr
.s_paddr
= current
->reloc_count
;
3772 scnhdr
.s_vaddr
= current
->lineno_count
;
3774 scnhdr
.s_scnptr
= 0;
3775 scnhdr
.s_relptr
= current
->rel_filepos
;
3776 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3777 scnhdr
.s_nreloc
= current
->target_index
;
3778 scnhdr
.s_nlnno
= current
->target_index
;
3779 scnhdr
.s_flags
= STYP_OVRFLO
;
3780 amt
= bfd_coff_scnhsz (abfd
);
3781 if (bfd_coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3782 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3789 #if defined (COFF_GO32_EXE) || defined (COFF_GO32)
3790 /* Pad section headers. */
3791 if ((abfd
->flags
& EXEC_P
) && abfd
->sections
!= NULL
)
3793 file_ptr cur_ptr
= scn_base
3794 + abfd
->section_count
* bfd_coff_scnhsz (abfd
);
3795 long fill_size
= (abfd
->sections
->filepos
- cur_ptr
);
3796 bfd_byte
*b
= bfd_zmalloc (fill_size
);
3799 bfd_bwrite ((PTR
)b
, fill_size
, abfd
);
3805 /* OK, now set up the filehdr... */
3807 /* Don't include the internal abs section in the section count */
3809 /* We will NOT put a fucking timestamp in the header here. Every time you
3810 put it back, I will come in and take it out again. I'm sorry. This
3811 field does not belong here. We fill it with a 0 so it compares the
3812 same but is not a reasonable time. -- gnu@cygnus.com */
3813 internal_f
.f_timdat
= 0;
3814 internal_f
.f_flags
= 0;
3816 if (abfd
->flags
& EXEC_P
)
3817 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3820 internal_f
.f_opthdr
= 0;
3823 if (xcoff_data (abfd
)->full_aouthdr
)
3824 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3826 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
3832 internal_f
.f_flags
|= F_RELFLG
;
3834 internal_f
.f_flags
|= F_LNNO
;
3835 if (abfd
->flags
& EXEC_P
)
3836 internal_f
.f_flags
|= F_EXEC
;
3837 #ifdef COFF_IMAGE_WITH_PE
3839 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
3840 if (pe_data (abfd
)->real_flags
& IMAGE_FILE_LARGE_ADDRESS_AWARE
)
3841 internal_f
.f_flags
|= IMAGE_FILE_LARGE_ADDRESS_AWARE
;
3844 #ifndef COFF_WITH_pex64
3846 internal_f
.f_flags
|= IMAGE_FILE_32BIT_MACHINE
;
3848 if (bfd_little_endian (abfd
))
3849 internal_f
.f_flags
|= F_AR32WR
;
3851 internal_f
.f_flags
|= F_AR32W
;
3856 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
3857 but it doesn't hurt to set it internally. */
3858 internal_f
.f_target_id
= TI_TARGET_ID
;
3861 /* FIXME, should do something about the other byte orders and
3865 if ((abfd
->flags
& DYNAMIC
) != 0)
3866 internal_f
.f_flags
|= F_SHROBJ
;
3867 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
3868 internal_f
.f_flags
|= F_DYNLOAD
;
3871 memset (&internal_a
, 0, sizeof internal_a
);
3873 /* Set up architecture-dependent stuff. */
3875 unsigned int magic
= 0;
3876 unsigned short flags
= 0;
3878 coff_set_flags (abfd
, &magic
, &flags
);
3879 internal_f
.f_magic
= magic
;
3880 internal_f
.f_flags
|= flags
;
3881 /* ...and the "opt"hdr... */
3883 #ifdef TICOFF_AOUT_MAGIC
3884 internal_a
.magic
= TICOFF_AOUT_MAGIC
;
3885 #define __A_MAGIC_SET__
3889 #define __A_MAGIC_SET__
3890 internal_a
.magic
= ZMAGIC
;
3894 #define __A_MAGIC_SET__
3895 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3898 #if defined MCORE_PE
3899 #define __A_MAGIC_SET__
3900 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3904 #define __A_MAGIC_SET__
3906 internal_a
.magic
= LYNXCOFFMAGIC
;
3908 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR64_MAGIC
;
3910 internal_a
.magic
= ZMAGIC
;
3915 #define __A_MAGIC_SET__
3916 internal_a
.magic
= PE32PMAGIC
;
3920 #define __A_MAGIC_SET__
3922 internal_a
.magic
= LYNXCOFFMAGIC
;
3927 #define __A_MAGIC_SET__
3928 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
3929 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
3930 RS6K_AOUTHDR_OMAGIC
;
3933 #if defined(SH) && defined(COFF_WITH_PE)
3934 #define __A_MAGIC_SET__
3935 internal_a
.magic
= SH_PE_MAGIC
;
3938 #if defined(MIPS) && defined(COFF_WITH_PE)
3939 #define __A_MAGIC_SET__
3940 internal_a
.magic
= MIPS_PE_MAGIC
;
3943 #ifndef __A_MAGIC_SET__
3944 #include "Your aouthdr magic number is not being set!"
3946 #undef __A_MAGIC_SET__
3950 /* FIXME: Does anybody ever set this to another value? */
3951 internal_a
.vstamp
= 0;
3953 /* Now should write relocs, strings, syms. */
3954 obj_sym_filepos (abfd
) = sym_base
;
3956 if (bfd_get_symcount (abfd
) != 0)
3960 if (!coff_renumber_symbols (abfd
, &firstundef
))
3962 coff_mangle_symbols (abfd
);
3963 if (! coff_write_symbols (abfd
))
3965 if (! coff_write_linenumbers (abfd
))
3967 if (! coff_write_relocs (abfd
, firstundef
))
3970 #ifdef COFF_LONG_SECTION_NAMES
3971 else if (long_section_names
&& ! obj_coff_strings_written (abfd
))
3973 /* If we have long section names we have to write out the string
3974 table even if there are no symbols. */
3975 if (! coff_write_symbols (abfd
))
3979 #ifdef COFF_IMAGE_WITH_PE
3981 else if ((abfd
->flags
& EXEC_P
) != 0)
3985 /* PowerPC PE appears to require that all executable files be
3986 rounded up to the page size. */
3989 (file_ptr
) BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
3991 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3997 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3998 backend linker, and obj_raw_syment_count is not valid until after
3999 coff_write_symbols is called. */
4000 if (obj_raw_syment_count (abfd
) != 0)
4002 internal_f
.f_symptr
= sym_base
;
4004 /* AIX appears to require that F_RELFLG not be set if there are
4005 local symbols but no relocations. */
4006 internal_f
.f_flags
&=~ F_RELFLG
;
4011 if (long_section_names
)
4012 internal_f
.f_symptr
= sym_base
;
4014 internal_f
.f_symptr
= 0;
4015 internal_f
.f_flags
|= F_LSYMS
;
4020 internal_a
.tsize
= text_sec
->size
;
4021 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
4025 internal_a
.dsize
= data_sec
->size
;
4026 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
4030 internal_a
.bsize
= bss_sec
->size
;
4031 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
4032 internal_a
.data_start
= bss_sec
->vma
;
4035 internal_a
.entry
= bfd_get_start_address (abfd
);
4036 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
4039 if (xcoff_data (abfd
)->full_aouthdr
)
4042 asection
*loader_sec
;
4044 internal_a
.vstamp
= 1;
4046 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
4047 if (internal_a
.o_snentry
== 0)
4048 internal_a
.entry
= (bfd_vma
) -1;
4050 if (text_sec
!= NULL
)
4052 internal_a
.o_sntext
= text_sec
->target_index
;
4053 internal_a
.o_algntext
= bfd_section_alignment (text_sec
);
4057 internal_a
.o_sntext
= 0;
4058 internal_a
.o_algntext
= 0;
4060 if (data_sec
!= NULL
)
4062 internal_a
.o_sndata
= data_sec
->target_index
;
4063 internal_a
.o_algndata
= bfd_section_alignment (data_sec
);
4067 internal_a
.o_sndata
= 0;
4068 internal_a
.o_algndata
= 0;
4070 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
4071 if (loader_sec
!= NULL
)
4072 internal_a
.o_snloader
= loader_sec
->target_index
;
4074 internal_a
.o_snloader
= 0;
4075 if (bss_sec
!= NULL
)
4076 internal_a
.o_snbss
= bss_sec
->target_index
;
4078 internal_a
.o_snbss
= 0;
4080 toc
= xcoff_data (abfd
)->toc
;
4081 internal_a
.o_toc
= toc
;
4082 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
4084 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
4085 if (xcoff_data (abfd
)->cputype
!= -1)
4086 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
4089 switch (bfd_get_arch (abfd
))
4091 case bfd_arch_rs6000
:
4092 internal_a
.o_cputype
= 4;
4094 case bfd_arch_powerpc
:
4095 if (bfd_get_mach (abfd
) == bfd_mach_ppc
)
4096 internal_a
.o_cputype
= 3;
4098 internal_a
.o_cputype
= 1;
4104 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
4105 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
4111 /* After object contents are finalized so we can compute a reasonable hash,
4112 but before header is written so we can update it to point to debug directory. */
4113 struct pe_tdata
*pe
= pe_data (abfd
);
4115 if (pe
->build_id
.after_write_object_contents
!= NULL
)
4116 (*pe
->build_id
.after_write_object_contents
) (abfd
);
4120 /* Now write header. */
4121 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
4126 bfd_size_type amount
= bfd_coff_filhsz (abfd
);
4128 buff
= (char *) bfd_malloc (amount
);
4132 bfd_coff_swap_filehdr_out (abfd
, & internal_f
, buff
);
4133 amount
= bfd_bwrite (buff
, amount
, abfd
);
4137 if (amount
!= bfd_coff_filhsz (abfd
))
4141 if (abfd
->flags
& EXEC_P
)
4143 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4144 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4146 bfd_size_type amount
= bfd_coff_aoutsz (abfd
);
4148 buff
= (char *) bfd_malloc (amount
);
4152 coff_swap_aouthdr_out (abfd
, & internal_a
, buff
);
4153 amount
= bfd_bwrite (buff
, amount
, abfd
);
4157 if (amount
!= bfd_coff_aoutsz (abfd
))
4160 #ifdef COFF_IMAGE_WITH_PE
4161 if (! coff_apply_checksum (abfd
))
4171 /* XCOFF seems to always write at least a small a.out header. */
4172 coff_swap_aouthdr_out (abfd
, & internal_a
, & buff
);
4173 if (xcoff_data (abfd
)->full_aouthdr
)
4174 size
= bfd_coff_aoutsz (abfd
);
4176 size
= SMALL_AOUTSZ
;
4177 if (bfd_bwrite (& buff
, (bfd_size_type
) size
, abfd
) != size
)
4186 coff_set_section_contents (bfd
* abfd
,
4188 const void * location
,
4190 bfd_size_type count
)
4192 if (! abfd
->output_has_begun
) /* Set by bfd.c handler. */
4194 if (! coff_compute_section_file_positions (abfd
))
4198 #if defined(_LIB) && !defined(TARG_AUX)
4199 /* The physical address field of a .lib section is used to hold the
4200 number of shared libraries in the section. This code counts the
4201 number of sections being written, and increments the lma field
4204 I have found no documentation on the contents of this section.
4205 Experimentation indicates that the section contains zero or more
4206 records, each of which has the following structure:
4208 - a (four byte) word holding the length of this record, in words,
4209 - a word that always seems to be set to "2",
4210 - the path to a shared library, null-terminated and then padded
4211 to a whole word boundary.
4213 bfd_assert calls have been added to alert if an attempt is made
4214 to write a section which doesn't follow these assumptions. The
4215 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4216 <robertl@arnet.com> (Thanks!).
4218 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4219 if (strcmp (section
->name
, _LIB
) == 0)
4221 bfd_byte
*rec
, *recend
;
4223 rec
= (bfd_byte
*) location
;
4224 recend
= rec
+ count
;
4225 while (rec
< recend
)
4228 rec
+= bfd_get_32 (abfd
, rec
) * 4;
4231 BFD_ASSERT (rec
== recend
);
4235 /* Don't write out bss sections - one way to do this is to
4236 see if the filepos has not been set. */
4237 if (section
->filepos
== 0)
4240 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0)
4246 return bfd_bwrite (location
, count
, abfd
) == count
;
4250 buy_and_read (bfd
*abfd
, file_ptr where
,
4251 bfd_size_type nmemb
, bfd_size_type size
)
4255 if (_bfd_mul_overflow (nmemb
, size
, &amt
))
4257 bfd_set_error (bfd_error_file_too_big
);
4260 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
4262 return _bfd_alloc_and_read (abfd
, amt
, amt
);
4269 Creating the linenumber table is done by reading in the entire
4270 coff linenumber table, and creating another table for internal use.
4272 A coff linenumber table is structured so that each function
4273 is marked as having a line number of 0. Each line within the
4274 function is an offset from the first line in the function. The
4275 base of the line number information for the table is stored in
4276 the symbol associated with the function.
4278 Note: The PE format uses line number 0 for a flag indicating a
4281 The information is copied from the external to the internal
4282 table, and each symbol which marks a function is marked by
4285 How does this work ?
4289 coff_sort_func_alent (const void * arg1
, const void * arg2
)
4291 const alent
*al1
= *(const alent
**) arg1
;
4292 const alent
*al2
= *(const alent
**) arg2
;
4293 const coff_symbol_type
*s1
= (const coff_symbol_type
*) (al1
->u
.sym
);
4294 const coff_symbol_type
*s2
= (const coff_symbol_type
*) (al2
->u
.sym
);
4296 if (s1
== NULL
|| s2
== NULL
)
4298 if (s1
->symbol
.value
< s2
->symbol
.value
)
4300 else if (s1
->symbol
.value
> s2
->symbol
.value
)
4307 coff_slurp_line_table (bfd
*abfd
, asection
*asect
)
4309 LINENO
*native_lineno
;
4310 alent
*lineno_cache
;
4311 unsigned int counter
;
4313 bfd_vma prev_offset
= 0;
4314 bfd_boolean ordered
= TRUE
;
4315 unsigned int nbr_func
;
4317 bfd_boolean have_func
;
4318 bfd_boolean ret
= TRUE
;
4321 if (asect
->lineno_count
== 0)
4324 BFD_ASSERT (asect
->lineno
== NULL
);
4326 if (asect
->lineno_count
> asect
->size
)
4329 (_("%pB: warning: line number count (%#lx) exceeds section size (%#lx)"),
4330 abfd
, (unsigned long) asect
->lineno_count
, (unsigned long) asect
->size
);
4334 if (_bfd_mul_overflow (asect
->lineno_count
+ 1, sizeof (alent
), &amt
))
4336 bfd_set_error (bfd_error_file_too_big
);
4339 lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
);
4340 if (lineno_cache
== NULL
)
4343 native_lineno
= (LINENO
*) buy_and_read (abfd
, asect
->line_filepos
,
4344 asect
->lineno_count
,
4345 bfd_coff_linesz (abfd
));
4346 if (native_lineno
== NULL
)
4349 (_("%pB: warning: line number table read failed"), abfd
);
4350 bfd_release (abfd
, lineno_cache
);
4354 cache_ptr
= lineno_cache
;
4355 asect
->lineno
= lineno_cache
;
4356 src
= native_lineno
;
4360 for (counter
= 0; counter
< asect
->lineno_count
; counter
++, src
++)
4362 struct internal_lineno dst
;
4364 bfd_coff_swap_lineno_in (abfd
, src
, &dst
);
4365 cache_ptr
->line_number
= dst
.l_lnno
;
4366 /* Appease memory checkers that get all excited about
4367 uninitialised memory when copying alents if u.offset is
4368 larger than u.sym. (64-bit BFD on 32-bit host.) */
4369 memset (&cache_ptr
->u
, 0, sizeof (cache_ptr
->u
));
4371 if (cache_ptr
->line_number
== 0)
4373 combined_entry_type
* ent
;
4374 unsigned long symndx
;
4375 coff_symbol_type
*sym
;
4378 symndx
= dst
.l_addr
.l_symndx
;
4379 if (symndx
>= obj_raw_syment_count (abfd
))
4382 /* xgettext:c-format */
4383 (_("%pB: warning: illegal symbol index 0x%lx in line number entry %d"),
4384 abfd
, symndx
, counter
);
4385 cache_ptr
->line_number
= -1;
4390 ent
= obj_raw_syments (abfd
) + symndx
;
4391 /* FIXME: We should not be casting between ints and
4392 pointers like this. */
4396 /* xgettext:c-format */
4397 (_("%pB: warning: illegal symbol index 0x%lx in line number entry %d"),
4398 abfd
, symndx
, counter
);
4399 cache_ptr
->line_number
= -1;
4403 sym
= (coff_symbol_type
*) (ent
->u
.syment
._n
._n_n
._n_zeroes
);
4405 /* PR 17512 file: 078-10659-0.004 */
4406 if (sym
< obj_symbols (abfd
)
4407 || sym
>= obj_symbols (abfd
) + bfd_get_symcount (abfd
))
4410 /* xgettext:c-format */
4411 (_("%pB: warning: illegal symbol in line number entry %d"),
4413 cache_ptr
->line_number
= -1;
4420 cache_ptr
->u
.sym
= (asymbol
*) sym
;
4421 if (sym
->lineno
!= NULL
)
4423 /* xgettext:c-format */
4424 (_("%pB: warning: duplicate line number information for `%s'"),
4425 abfd
, bfd_asymbol_name (&sym
->symbol
));
4427 sym
->lineno
= cache_ptr
;
4428 if (sym
->symbol
.value
< prev_offset
)
4430 prev_offset
= sym
->symbol
.value
;
4432 else if (!have_func
)
4433 /* Drop line information that has no associated function.
4434 PR 17521: file: 078-10659-0.004. */
4437 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
- bfd_section_vma (asect
);
4441 asect
->lineno_count
= cache_ptr
- lineno_cache
;
4442 memset (cache_ptr
, 0, sizeof (*cache_ptr
));
4443 bfd_release (abfd
, native_lineno
);
4445 /* On some systems (eg AIX5.3) the lineno table may not be sorted. */
4448 /* Sort the table. */
4450 alent
*n_lineno_cache
;
4452 /* Create a table of functions. */
4453 if (_bfd_mul_overflow (nbr_func
, sizeof (alent
*), &amt
))
4455 bfd_set_error (bfd_error_file_too_big
);
4458 else if ((func_table
= (alent
**) bfd_alloc (abfd
, amt
)) != NULL
)
4460 alent
**p
= func_table
;
4463 for (i
= 0; i
< asect
->lineno_count
; i
++)
4464 if (lineno_cache
[i
].line_number
== 0)
4465 *p
++ = &lineno_cache
[i
];
4467 BFD_ASSERT ((unsigned int) (p
- func_table
) == nbr_func
);
4469 /* Sort by functions. */
4470 qsort (func_table
, nbr_func
, sizeof (alent
*), coff_sort_func_alent
);
4472 /* Create the new sorted table. */
4473 if (_bfd_mul_overflow (asect
->lineno_count
, sizeof (alent
), &amt
))
4475 bfd_set_error (bfd_error_file_too_big
);
4478 else if ((n_lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
)) != NULL
)
4480 alent
*n_cache_ptr
= n_lineno_cache
;
4482 for (i
= 0; i
< nbr_func
; i
++)
4484 coff_symbol_type
*sym
;
4485 alent
*old_ptr
= func_table
[i
];
4487 /* Update the function entry. */
4488 sym
= (coff_symbol_type
*) old_ptr
->u
.sym
;
4489 /* PR binutils/17512: Point the lineno to where
4490 this entry will be after the memcpy below. */
4491 sym
->lineno
= lineno_cache
+ (n_cache_ptr
- n_lineno_cache
);
4492 /* Copy the function and line number entries. */
4494 *n_cache_ptr
++ = *old_ptr
++;
4495 while (old_ptr
->line_number
!= 0);
4498 memcpy (lineno_cache
, n_lineno_cache
,
4499 asect
->lineno_count
* sizeof (alent
));
4503 bfd_release (abfd
, func_table
);
4512 /* Slurp in the symbol table, converting it to generic form. Note
4513 that if coff_relocate_section is defined, the linker will read
4514 symbols via coff_link_add_symbols, rather than via this routine. */
4517 coff_slurp_symbol_table (bfd
* abfd
)
4519 combined_entry_type
*native_symbols
;
4520 coff_symbol_type
*cached_area
;
4521 unsigned int *table_ptr
;
4522 unsigned int number_of_symbols
= 0;
4523 bfd_boolean ret
= TRUE
;
4526 if (obj_symbols (abfd
))
4529 /* Read in the symbol table. */
4530 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4533 /* Allocate enough room for all the symbols in cached form. */
4534 if (_bfd_mul_overflow (obj_raw_syment_count (abfd
),
4535 sizeof (*cached_area
), &amt
))
4537 bfd_set_error (bfd_error_file_too_big
);
4540 cached_area
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
4541 if (cached_area
== NULL
)
4544 if (_bfd_mul_overflow (obj_raw_syment_count (abfd
),
4545 sizeof (*table_ptr
), &amt
))
4547 bfd_set_error (bfd_error_file_too_big
);
4550 table_ptr
= (unsigned int *) bfd_zalloc (abfd
, amt
);
4551 if (table_ptr
== NULL
)
4555 coff_symbol_type
*dst
= cached_area
;
4556 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4557 unsigned int this_index
= 0;
4559 while (this_index
< last_native_index
)
4561 combined_entry_type
*src
= native_symbols
+ this_index
;
4562 table_ptr
[this_index
] = number_of_symbols
;
4564 dst
->symbol
.the_bfd
= abfd
;
4565 BFD_ASSERT (src
->is_sym
);
4566 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4567 /* We use the native name field to point to the cached field. */
4568 src
->u
.syment
._n
._n_n
._n_zeroes
= (bfd_hostptr_t
) dst
;
4569 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4570 src
->u
.syment
.n_scnum
);
4571 dst
->symbol
.flags
= 0;
4572 /* PR 17512: file: 079-7098-0.001:0.1. */
4573 dst
->symbol
.value
= 0;
4574 dst
->done_lineno
= FALSE
;
4576 switch (src
->u
.syment
.n_sclass
)
4582 case C_THUMBEXTFUNC
:
4586 #if ! defined _AIX52 && ! defined AIX_WEAK_SUPPORT
4591 case C_SYSTEM
: /* System Wide variable. */
4594 /* In PE, 0x68 (104) denotes a section symbol. */
4596 /* In PE, 0x69 (105) denotes a weak external symbol. */
4599 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4601 case COFF_SYMBOL_GLOBAL
:
4602 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4603 #if defined COFF_WITH_PE
4604 /* PE sets the symbol to a value relative to the
4605 start of the section. */
4606 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4608 dst
->symbol
.value
= (src
->u
.syment
.n_value
4609 - dst
->symbol
.section
->vma
);
4611 if (ISFCN ((src
->u
.syment
.n_type
)))
4612 /* A function ext does not go at the end of a
4614 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4617 case COFF_SYMBOL_COMMON
:
4618 dst
->symbol
.section
= bfd_com_section_ptr
;
4619 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4622 case COFF_SYMBOL_UNDEFINED
:
4623 dst
->symbol
.section
= bfd_und_section_ptr
;
4624 dst
->symbol
.value
= 0;
4627 case COFF_SYMBOL_PE_SECTION
:
4628 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4629 dst
->symbol
.value
= 0;
4632 case COFF_SYMBOL_LOCAL
:
4633 dst
->symbol
.flags
= BSF_LOCAL
;
4634 #if defined COFF_WITH_PE
4635 /* PE sets the symbol to a value relative to the
4636 start of the section. */
4637 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4639 dst
->symbol
.value
= (src
->u
.syment
.n_value
4640 - dst
->symbol
.section
->vma
);
4642 if (ISFCN ((src
->u
.syment
.n_type
)))
4643 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4648 /* A symbol with a csect entry should not go at the end. */
4649 if (src
->u
.syment
.n_numaux
> 0)
4650 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4654 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4655 dst
->symbol
.flags
|= BSF_WEAK
;
4657 if (src
->u
.syment
.n_sclass
== C_SECTION
4658 && src
->u
.syment
.n_scnum
> 0)
4659 dst
->symbol
.flags
= BSF_LOCAL
;
4661 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
4663 || src
->u
.syment
.n_sclass
== C_AIX_WEAKEXT
4666 dst
->symbol
.flags
|= BSF_WEAK
;
4670 case C_STAT
: /* Static. */
4672 case C_THUMBSTAT
: /* Thumb static. */
4673 case C_THUMBLABEL
: /* Thumb label. */
4674 case C_THUMBSTATFUNC
:/* Thumb static function. */
4677 case C_DWARF
: /* A label in a dwarf section. */
4678 case C_INFO
: /* A label in a comment section. */
4680 case C_LABEL
: /* Label. */
4681 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4682 dst
->symbol
.flags
= BSF_DEBUGGING
;
4684 dst
->symbol
.flags
= BSF_LOCAL
;
4686 /* Base the value as an index from the base of the
4687 section, if there is one. */
4688 if (dst
->symbol
.section
)
4690 #if defined COFF_WITH_PE
4691 /* PE sets the symbol to a value relative to the
4692 start of the section. */
4693 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4695 dst
->symbol
.value
= (src
->u
.syment
.n_value
4696 - dst
->symbol
.section
->vma
);
4700 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4703 case C_MOS
: /* Member of structure. */
4704 case C_EOS
: /* End of structure. */
4705 case C_REGPARM
: /* Register parameter. */
4706 case C_REG
: /* register variable. */
4707 /* C_AUTOARG conflicts with TI COFF C_UEXT. */
4708 case C_TPDEF
: /* Type definition. */
4710 case C_AUTO
: /* Automatic variable. */
4711 case C_FIELD
: /* Bit field. */
4712 case C_ENTAG
: /* Enumeration tag. */
4713 case C_MOE
: /* Member of enumeration. */
4714 case C_MOU
: /* Member of union. */
4715 case C_UNTAG
: /* Union tag. */
4716 dst
->symbol
.flags
= BSF_DEBUGGING
;
4717 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4720 case C_FILE
: /* File name. */
4721 case C_STRTAG
: /* Structure tag. */
4738 dst
->symbol
.flags
= BSF_DEBUGGING
;
4739 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4743 case C_BINCL
: /* Beginning of include file. */
4744 case C_EINCL
: /* Ending of include file. */
4745 /* The value is actually a pointer into the line numbers
4746 of the file. We locate the line number entry, and
4747 set the section to the section which contains it, and
4748 the value to the index in that section. */
4752 dst
->symbol
.flags
= BSF_DEBUGGING
;
4753 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4754 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4755 && ((file_ptr
) (sec
->line_filepos
4756 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4757 > (file_ptr
) src
->u
.syment
.n_value
))
4760 dst
->symbol
.value
= 0;
4763 dst
->symbol
.section
= sec
;
4764 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4765 - sec
->line_filepos
)
4766 / bfd_coff_linesz (abfd
));
4773 dst
->symbol
.flags
= BSF_DEBUGGING
;
4775 /* The value is actually a symbol index. Save a pointer
4776 to the symbol instead of the index. FIXME: This
4777 should use a union. */
4778 src
->u
.syment
.n_value
=
4779 (long) (intptr_t) (native_symbols
+ src
->u
.syment
.n_value
);
4780 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4785 case C_BLOCK
: /* ".bb" or ".eb". */
4786 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf"). */
4787 case C_EFCN
: /* Physical end of function. */
4788 #if defined COFF_WITH_PE
4789 /* PE sets the symbol to a value relative to the start
4791 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4792 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4794 /* PE uses funny values for .ef and .lf; don't
4796 dst
->symbol
.flags
= BSF_DEBUGGING
;
4799 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4801 /* Base the value as an index from the base of the
4803 dst
->symbol
.flags
= BSF_LOCAL
;
4804 dst
->symbol
.value
= (src
->u
.syment
.n_value
4805 - dst
->symbol
.section
->vma
);
4809 case C_STATLAB
: /* Static load time label. */
4810 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4811 dst
->symbol
.flags
= BSF_GLOBAL
;
4815 /* PE DLLs sometimes have zeroed out symbols for some
4816 reason. Just ignore them without a warning. */
4817 if (src
->u
.syment
.n_type
== 0
4818 && src
->u
.syment
.n_value
== 0
4819 && src
->u
.syment
.n_scnum
== 0)
4822 /* XCOFF specific: deleted entry. */
4823 if (src
->u
.syment
.n_value
== C_NULL_VALUE
)
4827 case C_EXTDEF
: /* External definition. */
4828 case C_ULABEL
: /* Undefined label. */
4829 case C_USTATIC
: /* Undefined static. */
4830 #ifndef COFF_WITH_PE
4831 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4832 class to represent a section symbol. */
4833 case C_LINE
: /* line # reformatted as symbol table entry. */
4834 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4835 case C_ALIAS
: /* Duplicate tag. */
4837 /* New storage classes for TI COFF. */
4839 case C_UEXT
: /* Tentative external definition. */
4841 case C_EXTLAB
: /* External load time label. */
4844 /* xgettext:c-format */
4845 (_("%pB: unrecognized storage class %d for %s symbol `%s'"),
4846 abfd
, src
->u
.syment
.n_sclass
,
4847 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4850 case C_HIDDEN
: /* Ext symbol in dmert public lib. */
4851 /* PR 20722: These symbols can also be generated by
4852 building DLLs with --gc-sections enabled. */
4853 dst
->symbol
.flags
= BSF_DEBUGGING
;
4854 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4859 dst
->symbol
.udata
.i
= 0;
4862 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
4864 number_of_symbols
++;
4868 obj_symbols (abfd
) = cached_area
;
4869 obj_raw_syments (abfd
) = native_symbols
;
4871 abfd
->symcount
= number_of_symbols
;
4872 obj_convert (abfd
) = table_ptr
;
4873 /* Slurp the line tables for each section too. */
4880 if (! coff_slurp_line_table (abfd
, p
))
4889 /* Classify a COFF symbol. A couple of targets have globally visible
4890 symbols which are not class C_EXT, and this handles those. It also
4891 recognizes some special PE cases. */
4893 static enum coff_symbol_classification
4894 coff_classify_symbol (bfd
*abfd
,
4895 struct internal_syment
*syment
)
4897 /* FIXME: This partially duplicates the switch in
4898 coff_slurp_symbol_table. */
4899 switch (syment
->n_sclass
)
4905 case C_THUMBEXTFUNC
:
4913 if (syment
->n_scnum
== 0)
4915 if (syment
->n_value
== 0)
4916 return COFF_SYMBOL_UNDEFINED
;
4918 return COFF_SYMBOL_COMMON
;
4920 return COFF_SYMBOL_GLOBAL
;
4927 if (syment
->n_sclass
== C_STAT
)
4929 if (syment
->n_scnum
== 0)
4930 /* The Microsoft compiler sometimes generates these if a
4931 small static function is inlined every time it is used.
4932 The function is discarded, but the symbol table entry
4934 return COFF_SYMBOL_LOCAL
;
4936 #ifdef STRICT_PE_FORMAT
4937 /* This is correct for Microsoft generated objects, but it
4938 breaks gas generated objects. */
4939 if (syment
->n_value
== 0)
4943 char buf
[SYMNMLEN
+ 1];
4945 name
= _bfd_coff_internal_syment_name (abfd
, syment
, buf
)
4946 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
4947 if (sec
!= NULL
&& name
!= NULL
4948 && (strcmp (bfd_section_name (sec
), name
) == 0))
4949 return COFF_SYMBOL_PE_SECTION
;
4953 return COFF_SYMBOL_LOCAL
;
4956 if (syment
->n_sclass
== C_SECTION
)
4958 /* In some cases in a DLL generated by the Microsoft linker, the
4959 n_value field will contain garbage. FIXME: This should
4960 probably be handled by the swapping function instead. */
4961 syment
->n_value
= 0;
4962 if (syment
->n_scnum
== 0)
4963 return COFF_SYMBOL_UNDEFINED
;
4964 return COFF_SYMBOL_PE_SECTION
;
4966 #endif /* COFF_WITH_PE */
4968 /* If it is not a global symbol, we presume it is a local symbol. */
4969 if (syment
->n_scnum
== 0)
4971 char buf
[SYMNMLEN
+ 1];
4974 /* xgettext:c-format */
4975 (_("warning: %pB: local symbol `%s' has no section"),
4976 abfd
, _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
4979 return COFF_SYMBOL_LOCAL
;
4986 Coff relocations are easily transformed into the internal BFD form
4989 Reading a coff relocation table is done in the following stages:
4991 o Read the entire coff relocation table into memory.
4993 o Process each relocation in turn; first swap it from the
4994 external to the internal form.
4996 o Turn the symbol referenced in the relocation's symbol index
4997 into a pointer into the canonical symbol table.
4998 This table is the same as the one returned by a call to
4999 @code{bfd_canonicalize_symtab}. The back end will call that
5000 routine and save the result if a canonicalization hasn't been done.
5002 o The reloc index is turned into a pointer to a howto
5003 structure, in a back end specific way. For instance, the 386
5004 uses the @code{r_type} to directly produce an index
5005 into a howto table vector.
5009 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
5011 coff_symbol_type *coffsym = NULL; \
5013 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
5014 coffsym = (obj_symbols (abfd) \
5015 + (cache_ptr->sym_ptr_ptr - symbols)); \
5017 coffsym = coff_symbol_from (ptr); \
5018 if (coffsym != NULL \
5019 && coffsym->native->is_sym \
5020 && coffsym->native->u.syment.n_scnum == 0) \
5021 cache_ptr->addend = 0; \
5022 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
5023 && ptr->section != NULL) \
5024 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
5026 cache_ptr->addend = 0; \
5031 coff_slurp_reloc_table (bfd
* abfd
, sec_ptr asect
, asymbol
** symbols
)
5033 RELOC
*native_relocs
;
5034 arelent
*reloc_cache
;
5039 if (asect
->relocation
)
5041 if (asect
->reloc_count
== 0)
5043 if (asect
->flags
& SEC_CONSTRUCTOR
)
5045 if (!coff_slurp_symbol_table (abfd
))
5048 native_relocs
= (RELOC
*) buy_and_read (abfd
, asect
->rel_filepos
,
5050 bfd_coff_relsz (abfd
));
5051 if (_bfd_mul_overflow (asect
->reloc_count
, sizeof (arelent
), &amt
))
5053 bfd_set_error (bfd_error_file_too_big
);
5056 reloc_cache
= (arelent
*) bfd_alloc (abfd
, amt
);
5057 if (reloc_cache
== NULL
|| native_relocs
== NULL
)
5060 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
5062 struct internal_reloc dst
;
5063 struct external_reloc
*src
;
5064 #ifndef RELOC_PROCESSING
5068 cache_ptr
= reloc_cache
+ idx
;
5069 src
= native_relocs
+ idx
;
5072 coff_swap_reloc_in (abfd
, src
, &dst
);
5074 #ifdef RELOC_PROCESSING
5075 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
5077 cache_ptr
->address
= dst
.r_vaddr
;
5079 if (dst
.r_symndx
!= -1 && symbols
!= NULL
)
5081 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
5084 /* xgettext:c-format */
5085 (_("%pB: warning: illegal symbol index %ld in relocs"),
5086 abfd
, dst
.r_symndx
);
5087 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5092 cache_ptr
->sym_ptr_ptr
= (symbols
5093 + obj_convert (abfd
)[dst
.r_symndx
]);
5094 ptr
= *(cache_ptr
->sym_ptr_ptr
);
5099 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5103 /* The symbols definitions that we have read in have been
5104 relocated as if their sections started at 0. But the offsets
5105 refering to the symbols in the raw data have not been
5106 modified, so we have to have a negative addend to compensate.
5108 Note that symbols which used to be common must be left alone. */
5110 /* Calculate any reloc addend by looking at the symbol. */
5111 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
5114 cache_ptr
->address
-= asect
->vma
;
5115 /* !! cache_ptr->section = NULL;*/
5117 /* Fill in the cache_ptr->howto field from dst.r_type. */
5118 RTYPE2HOWTO (cache_ptr
, &dst
);
5119 #endif /* RELOC_PROCESSING */
5121 if (cache_ptr
->howto
== NULL
)
5124 /* xgettext:c-format */
5125 (_("%pB: illegal relocation type %d at address %#" PRIx64
),
5126 abfd
, dst
.r_type
, (uint64_t) dst
.r_vaddr
);
5127 bfd_set_error (bfd_error_bad_value
);
5132 asect
->relocation
= reloc_cache
;
5136 #ifndef coff_rtype_to_howto
5139 /* Get the howto structure for a reloc. This is only used if the file
5140 including this one defines coff_relocate_section to be
5141 _bfd_coff_generic_relocate_section, so it is OK if it does not
5142 always work. It is the responsibility of the including file to
5143 make sure it is reasonable if it is needed. */
5145 static reloc_howto_type
*
5146 coff_rtype_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
5147 asection
*sec ATTRIBUTE_UNUSED
,
5148 struct internal_reloc
*rel ATTRIBUTE_UNUSED
,
5149 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
,
5150 struct internal_syment
*sym ATTRIBUTE_UNUSED
,
5151 bfd_vma
*addendp ATTRIBUTE_UNUSED
)
5155 genrel
.howto
= NULL
;
5156 RTYPE2HOWTO (&genrel
, rel
);
5157 return genrel
.howto
;
5160 #else /* ! defined (RTYPE2HOWTO) */
5162 #define coff_rtype_to_howto NULL
5164 #endif /* ! defined (RTYPE2HOWTO) */
5165 #endif /* ! defined (coff_rtype_to_howto) */
5167 /* This is stupid. This function should be a boolean predicate. */
5170 coff_canonicalize_reloc (bfd
* abfd
,
5175 arelent
*tblptr
= section
->relocation
;
5176 unsigned int count
= 0;
5178 if (section
->flags
& SEC_CONSTRUCTOR
)
5180 /* This section has relocs made up by us, they are not in the
5181 file, so take them out of their chain and place them into
5182 the data area provided. */
5183 arelent_chain
*chain
= section
->constructor_chain
;
5185 for (count
= 0; count
< section
->reloc_count
; count
++)
5187 *relptr
++ = &chain
->relent
;
5188 chain
= chain
->next
;
5193 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
5196 tblptr
= section
->relocation
;
5198 for (; count
++ < section
->reloc_count
;)
5199 *relptr
++ = tblptr
++;
5202 return section
->reloc_count
;
5205 #ifndef coff_set_reloc
5206 #define coff_set_reloc _bfd_generic_set_reloc
5209 #ifndef coff_reloc16_estimate
5210 #define coff_reloc16_estimate dummy_reloc16_estimate
5213 dummy_reloc16_estimate (bfd
*abfd ATTRIBUTE_UNUSED
,
5214 asection
*input_section ATTRIBUTE_UNUSED
,
5215 arelent
*reloc ATTRIBUTE_UNUSED
,
5216 unsigned int shrink ATTRIBUTE_UNUSED
,
5217 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
)
5225 #ifndef coff_reloc16_extra_cases
5227 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5229 /* This works even if abort is not declared in any header file. */
5232 dummy_reloc16_extra_cases (bfd
*abfd ATTRIBUTE_UNUSED
,
5233 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
5234 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
,
5235 arelent
*reloc ATTRIBUTE_UNUSED
,
5236 bfd_byte
*data ATTRIBUTE_UNUSED
,
5237 unsigned int *src_ptr ATTRIBUTE_UNUSED
,
5238 unsigned int *dst_ptr ATTRIBUTE_UNUSED
)
5244 /* If coff_relocate_section is defined, we can use the optimized COFF
5245 backend linker. Otherwise we must continue to use the old linker. */
5247 #ifdef coff_relocate_section
5249 #ifndef coff_bfd_link_hash_table_create
5250 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5252 #ifndef coff_bfd_link_add_symbols
5253 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5255 #ifndef coff_bfd_final_link
5256 #define coff_bfd_final_link _bfd_coff_final_link
5259 #else /* ! defined (coff_relocate_section) */
5261 #define coff_relocate_section NULL
5262 #ifndef coff_bfd_link_hash_table_create
5263 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5265 #ifndef coff_bfd_link_add_symbols
5266 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5268 #define coff_bfd_final_link _bfd_generic_final_link
5270 #endif /* ! defined (coff_relocate_section) */
5272 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5273 #define coff_bfd_copy_link_hash_symbol_type \
5274 _bfd_generic_copy_link_hash_symbol_type
5275 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5277 #define coff_bfd_link_check_relocs _bfd_generic_link_check_relocs
5279 #ifndef coff_start_final_link
5280 #define coff_start_final_link NULL
5283 #ifndef coff_adjust_symndx
5284 #define coff_adjust_symndx NULL
5287 #ifndef coff_link_add_one_symbol
5288 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5291 #ifndef coff_link_output_has_begun
5294 coff_link_output_has_begun (bfd
* abfd
,
5295 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
)
5297 return abfd
->output_has_begun
;
5301 #ifndef coff_final_link_postscript
5304 coff_final_link_postscript (bfd
* abfd ATTRIBUTE_UNUSED
,
5305 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
)
5311 #ifndef coff_SWAP_aux_in
5312 #define coff_SWAP_aux_in coff_swap_aux_in
5314 #ifndef coff_SWAP_sym_in
5315 #define coff_SWAP_sym_in coff_swap_sym_in
5317 #ifndef coff_SWAP_lineno_in
5318 #define coff_SWAP_lineno_in coff_swap_lineno_in
5320 #ifndef coff_SWAP_aux_out
5321 #define coff_SWAP_aux_out coff_swap_aux_out
5323 #ifndef coff_SWAP_sym_out
5324 #define coff_SWAP_sym_out coff_swap_sym_out
5326 #ifndef coff_SWAP_lineno_out
5327 #define coff_SWAP_lineno_out coff_swap_lineno_out
5329 #ifndef coff_SWAP_reloc_out
5330 #define coff_SWAP_reloc_out coff_swap_reloc_out
5332 #ifndef coff_SWAP_filehdr_out
5333 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5335 #ifndef coff_SWAP_aouthdr_out
5336 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5338 #ifndef coff_SWAP_scnhdr_out
5339 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5341 #ifndef coff_SWAP_reloc_in
5342 #define coff_SWAP_reloc_in coff_swap_reloc_in
5344 #ifndef coff_SWAP_filehdr_in
5345 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5347 #ifndef coff_SWAP_aouthdr_in
5348 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5350 #ifndef coff_SWAP_scnhdr_in
5351 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5354 static bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED
=
5356 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5357 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5358 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5359 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5360 coff_SWAP_scnhdr_out
,
5361 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5362 #ifdef COFF_LONG_FILENAMES
5367 COFF_DEFAULT_LONG_SECTION_NAMES
,
5368 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5369 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5374 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5380 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5381 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5382 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5383 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5384 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5385 coff_classify_symbol
, coff_compute_section_file_positions
,
5386 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5387 coff_adjust_symndx
, coff_link_add_one_symbol
,
5388 coff_link_output_has_begun
, coff_final_link_postscript
,
5393 /* COFF0 differs in file/section header size and relocation entry size. */
5395 static bfd_coff_backend_data ticoff0_swap_table
=
5397 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5398 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5399 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5400 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5401 coff_SWAP_scnhdr_out
,
5402 FILHSZ_V0
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ_V0
, LINESZ
, FILNMLEN
,
5403 #ifdef COFF_LONG_FILENAMES
5408 COFF_DEFAULT_LONG_SECTION_NAMES
,
5409 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5410 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5415 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5421 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5422 coff_SWAP_reloc_in
, ticoff0_bad_format_hook
, coff_set_arch_mach_hook
,
5423 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5424 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5425 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5426 coff_classify_symbol
, coff_compute_section_file_positions
,
5427 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5428 coff_adjust_symndx
, coff_link_add_one_symbol
,
5429 coff_link_output_has_begun
, coff_final_link_postscript
,
5435 /* COFF1 differs in section header size. */
5437 static bfd_coff_backend_data ticoff1_swap_table
=
5439 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5440 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5441 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5442 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5443 coff_SWAP_scnhdr_out
,
5444 FILHSZ
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5445 #ifdef COFF_LONG_FILENAMES
5450 COFF_DEFAULT_LONG_SECTION_NAMES
,
5451 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5452 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5457 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5463 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5464 coff_SWAP_reloc_in
, ticoff1_bad_format_hook
, coff_set_arch_mach_hook
,
5465 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5466 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5467 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5468 coff_classify_symbol
, coff_compute_section_file_positions
,
5469 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5470 coff_adjust_symndx
, coff_link_add_one_symbol
,
5471 coff_link_output_has_begun
, coff_final_link_postscript
,
5472 bfd_pe_print_pdata
/* huh */
5476 #ifdef COFF_WITH_PE_BIGOBJ
5477 /* The UID for bigobj files. */
5479 static const char header_bigobj_classid
[16] =
5481 0xC7, 0xA1, 0xBA, 0xD1,
5485 0xFA, 0xF6, 0x6A, 0xA4, 0xDC, 0xB8
5488 /* Swap routines. */
5491 coff_bigobj_swap_filehdr_in (bfd
* abfd
, void * src
, void * dst
)
5493 struct external_ANON_OBJECT_HEADER_BIGOBJ
*filehdr_src
=
5494 (struct external_ANON_OBJECT_HEADER_BIGOBJ
*) src
;
5495 struct internal_filehdr
*filehdr_dst
= (struct internal_filehdr
*) dst
;
5497 filehdr_dst
->f_magic
= H_GET_16 (abfd
, filehdr_src
->Machine
);
5498 filehdr_dst
->f_nscns
= H_GET_32 (abfd
, filehdr_src
->NumberOfSections
);
5499 filehdr_dst
->f_timdat
= H_GET_32 (abfd
, filehdr_src
->TimeDateStamp
);
5500 filehdr_dst
->f_symptr
=
5501 GET_FILEHDR_SYMPTR (abfd
, filehdr_src
->PointerToSymbolTable
);
5502 filehdr_dst
->f_nsyms
= H_GET_32 (abfd
, filehdr_src
->NumberOfSymbols
);
5503 filehdr_dst
->f_opthdr
= 0;
5504 filehdr_dst
->f_flags
= 0;
5506 /* Check other magic numbers. */
5507 if (H_GET_16 (abfd
, filehdr_src
->Sig1
) != IMAGE_FILE_MACHINE_UNKNOWN
5508 || H_GET_16 (abfd
, filehdr_src
->Sig2
) != 0xffff
5509 || H_GET_16 (abfd
, filehdr_src
->Version
) != 2
5510 || memcmp (filehdr_src
->ClassID
, header_bigobj_classid
, 16) != 0)
5511 filehdr_dst
->f_opthdr
= 0xffff;
5513 /* Note that CLR metadata are ignored. */
5517 coff_bigobj_swap_filehdr_out (bfd
*abfd
, void * in
, void * out
)
5519 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
5520 struct external_ANON_OBJECT_HEADER_BIGOBJ
*filehdr_out
=
5521 (struct external_ANON_OBJECT_HEADER_BIGOBJ
*) out
;
5523 memset (filehdr_out
, 0, sizeof (*filehdr_out
));
5525 H_PUT_16 (abfd
, IMAGE_FILE_MACHINE_UNKNOWN
, filehdr_out
->Sig1
);
5526 H_PUT_16 (abfd
, 0xffff, filehdr_out
->Sig2
);
5527 H_PUT_16 (abfd
, 2, filehdr_out
->Version
);
5528 memcpy (filehdr_out
->ClassID
, header_bigobj_classid
, 16);
5529 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->Machine
);
5530 H_PUT_32 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->NumberOfSections
);
5531 H_PUT_32 (abfd
, filehdr_in
->f_timdat
, filehdr_out
->TimeDateStamp
);
5532 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
,
5533 filehdr_out
->PointerToSymbolTable
);
5534 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->NumberOfSymbols
);
5536 return bfd_coff_filhsz (abfd
);
5540 coff_bigobj_swap_sym_in (bfd
* abfd
, void * ext1
, void * in1
)
5542 SYMENT_BIGOBJ
*ext
= (SYMENT_BIGOBJ
*) ext1
;
5543 struct internal_syment
*in
= (struct internal_syment
*) in1
;
5545 if (ext
->e
.e_name
[0] == 0)
5547 in
->_n
._n_n
._n_zeroes
= 0;
5548 in
->_n
._n_n
._n_offset
= H_GET_32 (abfd
, ext
->e
.e
.e_offset
);
5552 #if SYMNMLEN != E_SYMNMLEN
5553 #error we need to cope with truncating or extending SYMNMLEN
5555 memcpy (in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
5559 in
->n_value
= H_GET_32 (abfd
, ext
->e_value
);
5560 BFD_ASSERT (sizeof (in
->n_scnum
) >= 4);
5561 in
->n_scnum
= H_GET_32 (abfd
, ext
->e_scnum
);
5562 in
->n_type
= H_GET_16 (abfd
, ext
->e_type
);
5563 in
->n_sclass
= H_GET_8 (abfd
, ext
->e_sclass
);
5564 in
->n_numaux
= H_GET_8 (abfd
, ext
->e_numaux
);
5568 coff_bigobj_swap_sym_out (bfd
* abfd
, void * inp
, void * extp
)
5570 struct internal_syment
*in
= (struct internal_syment
*) inp
;
5571 SYMENT_BIGOBJ
*ext
= (SYMENT_BIGOBJ
*) extp
;
5573 if (in
->_n
._n_name
[0] == 0)
5575 H_PUT_32 (abfd
, 0, ext
->e
.e
.e_zeroes
);
5576 H_PUT_32 (abfd
, in
->_n
._n_n
._n_offset
, ext
->e
.e
.e_offset
);
5580 #if SYMNMLEN != E_SYMNMLEN
5581 #error we need to cope with truncating or extending SYMNMLEN
5583 memcpy (ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
5587 H_PUT_32 (abfd
, in
->n_value
, ext
->e_value
);
5588 H_PUT_32 (abfd
, in
->n_scnum
, ext
->e_scnum
);
5590 H_PUT_16 (abfd
, in
->n_type
, ext
->e_type
);
5591 H_PUT_8 (abfd
, in
->n_sclass
, ext
->e_sclass
);
5592 H_PUT_8 (abfd
, in
->n_numaux
, ext
->e_numaux
);
5594 return SYMESZ_BIGOBJ
;
5598 coff_bigobj_swap_aux_in (bfd
*abfd
,
5606 AUXENT_BIGOBJ
*ext
= (AUXENT_BIGOBJ
*) ext1
;
5607 union internal_auxent
*in
= (union internal_auxent
*) in1
;
5609 /* Make sure that all fields in the aux structure are
5611 memset (in
, 0, sizeof * in
);
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_coff_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_group_name
5818 #define coff_bfd_group_name bfd_coff_group_name
5821 #ifndef coff_bfd_discard_group
5822 #define coff_bfd_discard_group bfd_generic_discard_group
5825 #ifndef coff_section_already_linked
5826 #define coff_section_already_linked \
5827 _bfd_coff_section_already_linked
5830 #ifndef coff_bfd_define_common_symbol
5831 #define coff_bfd_define_common_symbol bfd_generic_define_common_symbol
5834 #ifndef coff_bfd_link_hide_symbol
5835 #define coff_bfd_link_hide_symbol _bfd_generic_link_hide_symbol
5838 #ifndef coff_bfd_define_start_stop
5839 #define coff_bfd_define_start_stop bfd_generic_define_start_stop
5842 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5843 const bfd_target VAR = \
5846 bfd_target_coff_flavour, \
5847 BFD_ENDIAN_BIG, /* Data byte order is big. */ \
5848 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5849 /* object flags */ \
5850 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5851 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5852 /* section flags */ \
5853 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5854 UNDER, /* Leading symbol underscore. */ \
5855 '/', /* AR_pad_char. */ \
5856 15, /* AR_max_namelen. */ \
5857 0, /* match priority. */ \
5859 /* Data conversion functions. */ \
5860 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5861 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5862 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5864 /* Header conversion functions. */ \
5865 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5866 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5867 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5869 { /* bfd_check_format. */ \
5870 _bfd_dummy_target, \
5872 bfd_generic_archive_p, \
5875 { /* bfd_set_format. */ \
5876 _bfd_bool_bfd_false_error, \
5878 _bfd_generic_mkarchive, \
5879 _bfd_bool_bfd_false_error \
5881 { /* bfd_write_contents. */ \
5882 _bfd_bool_bfd_false_error, \
5883 coff_write_object_contents, \
5884 _bfd_write_archive_contents, \
5885 _bfd_bool_bfd_false_error \
5888 BFD_JUMP_TABLE_GENERIC (coff), \
5889 BFD_JUMP_TABLE_COPY (coff), \
5890 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5891 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5892 BFD_JUMP_TABLE_SYMBOLS (coff), \
5893 BFD_JUMP_TABLE_RELOCS (coff), \
5894 BFD_JUMP_TABLE_WRITE (coff), \
5895 BFD_JUMP_TABLE_LINK (coff), \
5896 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5903 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5904 const bfd_target VAR = \
5907 bfd_target_coff_flavour, \
5908 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5909 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5910 /* object flags */ \
5911 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5912 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5913 /* section flags */ \
5914 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5915 UNDER, /* Leading symbol underscore. */ \
5916 '/', /* AR_pad_char. */ \
5917 15, /* AR_max_namelen. */ \
5918 0, /* match priority. */ \
5920 /* Data conversion functions. */ \
5921 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5922 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5923 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5925 /* Header conversion functions. */ \
5926 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5927 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5928 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5930 { /* bfd_check_format. */ \
5931 _bfd_dummy_target, \
5933 bfd_generic_archive_p, \
5936 { /* bfd_set_format. */ \
5937 _bfd_bool_bfd_false_error, \
5939 _bfd_generic_mkarchive, \
5940 _bfd_bool_bfd_false_error \
5942 { /* bfd_write_contents. */ \
5943 _bfd_bool_bfd_false_error, \
5944 coff_write_object_contents, \
5945 _bfd_write_archive_contents, \
5946 _bfd_bool_bfd_false_error \
5949 BFD_JUMP_TABLE_GENERIC (coff), \
5950 BFD_JUMP_TABLE_COPY (coff), \
5951 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5952 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5953 BFD_JUMP_TABLE_SYMBOLS (coff), \
5954 BFD_JUMP_TABLE_RELOCS (coff), \
5955 BFD_JUMP_TABLE_WRITE (coff), \
5956 BFD_JUMP_TABLE_LINK (coff), \
5957 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5964 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5965 const bfd_target VAR = \
5968 bfd_target_coff_flavour, \
5969 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5970 BFD_ENDIAN_LITTLE, /* Header byte order is little. */ \
5971 /* object flags */ \
5972 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5973 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5974 /* section flags */ \
5975 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5976 UNDER, /* Leading symbol underscore. */ \
5977 '/', /* AR_pad_char. */ \
5978 15, /* AR_max_namelen. */ \
5979 0, /* match priority. */ \
5981 /* Data conversion functions. */ \
5982 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5983 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5984 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5985 /* Header conversion functions. */ \
5986 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5987 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5988 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5990 { /* bfd_check_format. */ \
5991 _bfd_dummy_target, \
5993 bfd_generic_archive_p, \
5996 { /* bfd_set_format. */ \
5997 _bfd_bool_bfd_false_error, \
5999 _bfd_generic_mkarchive, \
6000 _bfd_bool_bfd_false_error \
6002 { /* bfd_write_contents. */ \
6003 _bfd_bool_bfd_false_error, \
6004 coff_write_object_contents, \
6005 _bfd_write_archive_contents, \
6006 _bfd_bool_bfd_false_error \
6009 BFD_JUMP_TABLE_GENERIC (coff), \
6010 BFD_JUMP_TABLE_COPY (coff), \
6011 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
6012 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
6013 BFD_JUMP_TABLE_SYMBOLS (coff), \
6014 BFD_JUMP_TABLE_RELOCS (coff), \
6015 BFD_JUMP_TABLE_WRITE (coff), \
6016 BFD_JUMP_TABLE_LINK (coff), \
6017 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \