1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright (C) 1990-2023 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 a copy of the flag
138 in coff object tdata to be altered at runtime, on formats that
139 support long section names at all; on other formats it points
140 to a stub that returns an error indication.
142 With input BFDs, the flag is set according to whether any long section
143 names are detected while reading the section headers. For a completely
144 new BFD, the flag is set to the default for the target format. This
145 information can be used by a client of the BFD library when deciding
146 what output format to generate, and means that a BFD that is opened
147 for read and subsequently converted to a writeable BFD and modified
148 in-place will retain whatever format it had on input.
150 If @code{COFF_LONG_SECTION_NAMES} is simply defined (blank), or is
151 defined to the value "1", then long section names are enabled by
152 default; if it is defined to the value zero, they are disabled by
153 default (but still accepted in input BFDs). The header @file{coffcode.h}
154 defines a macro, @code{COFF_DEFAULT_LONG_SECTION_NAMES}, which is
155 used in the backends to initialise the backend data structure fields
156 appropriately; see the comments for further detail.
161 Each flavour of coff supported in BFD has its own header file
162 describing the external layout of the structures. There is also
163 an internal description of the coff layout, in
164 @file{coff/internal.h}. A major function of the
165 coff backend is swapping the bytes and twiddling the bits to
166 translate the external form of the structures into the normal
167 internal form. This is all performed in the
168 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
169 elements are different sizes between different versions of
170 coff; it is the duty of the coff version specific include file
171 to override the definitions of various packing routines in
172 @file{coffcode.h}. E.g., the size of line number entry in coff is
173 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
174 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
175 correct one. No doubt, some day someone will find a version of
176 coff which has a varying field size not catered to at the
177 moment. To port BFD, that person will have to add more @code{#defines}.
178 Three of the bit twiddling routines are exported to
179 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
180 and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol
181 table on its own, but uses BFD to fix things up. More of the
182 bit twiddlers are exported for @code{gas};
183 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
184 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
185 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
186 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
187 of all the symbol table and reloc drudgery itself, thereby
188 saving the internal BFD overhead, but uses BFD to swap things
189 on the way out, making cross ports much safer. Doing so also
190 allows BFD (and thus the linker) to use the same header files
191 as @code{gas}, which makes one avenue to disaster disappear.
196 The simple canonical form for symbols used by BFD is not rich
197 enough to keep all the information available in a coff symbol
198 table. The back end gets around this problem by keeping the original
199 symbol table around, "behind the scenes".
201 When a symbol table is requested (through a call to
202 @code{bfd_canonicalize_symtab}), a request gets through to
203 @code{coff_get_normalized_symtab}. This reads the symbol table from
204 the coff file and swaps all the structures inside into the
205 internal form. It also fixes up all the pointers in the table
206 (represented in the file by offsets from the first symbol in
207 the table) into physical pointers to elements in the new
208 internal table. This involves some work since the meanings of
209 fields change depending upon context: a field that is a
210 pointer to another structure in the symbol table at one moment
211 may be the size in bytes of a structure at the next. Another
212 pass is made over the table. All symbols which mark file names
213 (<<C_FILE>> symbols) are modified so that the internal
214 string points to the value in the auxent (the real filename)
215 rather than the normal text associated with the symbol
218 At this time the symbol names are moved around. Coff stores
219 all symbols less than nine characters long physically
220 within the symbol table; longer strings are kept at the end of
221 the file in the string table. This pass moves all strings
222 into memory and replaces them with pointers to the strings.
224 The symbol table is massaged once again, this time to create
225 the canonical table used by the BFD application. Each symbol
226 is inspected in turn, and a decision made (using the
227 @code{sclass} field) about the various flags to set in the
228 @code{asymbol}. @xref{Symbols}. The generated canonical table
229 shares strings with the hidden internal symbol table.
231 Any linenumbers are read from the coff file too, and attached
232 to the symbols which own the functions the linenumbers belong to.
237 Writing a symbol to a coff file which didn't come from a coff
238 file will lose any debugging information. The @code{asymbol}
239 structure remembers the BFD from which the symbol was taken, and on
240 output the back end makes sure that the same destination target as
241 source target is present.
243 When the symbols have come from a coff file then all the
244 debugging information is preserved.
246 Symbol tables are provided for writing to the back end in a
247 vector of pointers to pointers. This allows applications like
248 the linker to accumulate and output large symbol tables
249 without having to do too much byte copying.
251 This function runs through the provided symbol table and
252 patches each symbol marked as a file place holder
253 (@code{C_FILE}) to point to the next file place holder in the
254 list. It also marks each @code{offset} field in the list with
255 the offset from the first symbol of the current symbol.
257 Another function of this procedure is to turn the canonical
258 value form of BFD into the form used by coff. Internally, BFD
259 expects symbol values to be offsets from a section base; so a
260 symbol physically at 0x120, but in a section starting at
261 0x100, would have the value 0x20. Coff expects symbols to
262 contain their final value, so symbols have their values
263 changed at this point to reflect their sum with their owning
264 section. This transformation uses the
265 <<output_section>> field of the @code{asymbol}'s
266 @code{asection} @xref{Sections}.
268 o <<coff_mangle_symbols>>
270 This routine runs though the provided symbol table and uses
271 the offsets generated by the previous pass and the pointers
272 generated when the symbol table was read in to create the
273 structured hierarchy required by coff. It changes each pointer
274 to a symbol into the index into the symbol table of the asymbol.
276 o <<coff_write_symbols>>
278 This routine runs through the symbol table and patches up the
279 symbols from their internal form into the coff way, calls the
280 bit twiddlers, and writes out the table to the file.
289 The hidden information for an <<asymbol>> is described in a
290 <<combined_entry_type>>:
294 .typedef struct coff_ptr_struct
296 . {* Remembers the offset from the first symbol in the file for
297 . this symbol. Generated by coff_renumber_symbols. *}
298 . unsigned int offset;
300 . {* Should the value of this symbol be renumbered. Used for
301 . XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
302 . unsigned int fix_value : 1;
304 . {* Should the tag field of this symbol be renumbered.
305 . Created by coff_pointerize_aux. *}
306 . unsigned int fix_tag : 1;
308 . {* Should the endidx field of this symbol be renumbered.
309 . Created by coff_pointerize_aux. *}
310 . unsigned int fix_end : 1;
312 . {* Should the x_csect.x_scnlen field be renumbered.
313 . Created by coff_pointerize_aux. *}
314 . unsigned int fix_scnlen : 1;
316 . {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
317 . index into the line number entries. Set by coff_slurp_symbol_table. *}
318 . unsigned int fix_line : 1;
320 . {* The container for the symbol structure as read and translated
324 . union internal_auxent auxent;
325 . struct internal_syment syment;
328 . {* Selector for the union above. *}
331 . {* An extra pointer which can used by format based on COFF (like XCOFF)
332 . to provide extra information to their backend. *}
334 .} combined_entry_type;
337 .{* Each canonical asymbol really looks like this: *}
339 .typedef struct coff_symbol_struct
341 . {* The actual symbol which the rest of BFD works with *}
344 . {* A pointer to the hidden information for this symbol *}
345 . combined_entry_type *native;
347 . {* A pointer to the linenumber information for this symbol *}
348 . struct lineno_cache_entry *lineno;
350 . {* Have the line numbers been relocated yet ? *}
356 #include "libiberty.h"
361 #include "coffswap.h"
364 #define STRING_SIZE_SIZE 4
366 #define DOT_DEBUG ".debug"
367 #define DOT_ZDEBUG ".zdebug"
368 #define GNU_LINKONCE_WI ".gnu.linkonce.wi."
369 #define GNU_LINKONCE_WT ".gnu.linkonce.wt."
370 #define DOT_RELOC ".reloc"
372 #if defined(COFF_WITH_PE) || defined(COFF_GO32_EXE) || defined(COFF_GO32)
373 # define COFF_WITH_EXTENDED_RELOC_COUNTER
376 #if defined (COFF_LONG_SECTION_NAMES)
377 /* Needed to expand the inputs to BLANKOR1TOODD. */
378 #define COFFLONGSECTIONCATHELPER(x,y) x ## y
379 /* If the input macro Y is blank or '1', return an odd number; if it is
380 '0', return an even number. Result undefined in all other cases. */
381 #define BLANKOR1TOODD(y) COFFLONGSECTIONCATHELPER(1,y)
382 /* Defined to numerical 0 or 1 according to whether generation of long
383 section names is disabled or enabled by default. */
384 #define COFF_ENABLE_LONG_SECTION_NAMES (BLANKOR1TOODD(COFF_LONG_SECTION_NAMES) & 1)
385 /* Where long section names are supported, we allow them to be enabled
386 and disabled at runtime, so select an appropriate hook function for
387 _bfd_coff_set_long_section_names. */
388 #define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_allowed
389 #else /* !defined (COFF_LONG_SECTION_NAMES) */
390 /* If long section names are not supported, this stub disallows any
391 attempt to enable them at run-time. */
392 #define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_disallowed
393 #endif /* defined (COFF_LONG_SECTION_NAMES) */
395 /* Define a macro that can be used to initialise both the fields relating
396 to long section names in the backend data struct simultaneously. */
397 #if COFF_ENABLE_LONG_SECTION_NAMES
398 #define COFF_DEFAULT_LONG_SECTION_NAMES (true), COFF_LONG_SECTION_NAMES_SETTER
399 #else /* !COFF_ENABLE_LONG_SECTION_NAMES */
400 #define COFF_DEFAULT_LONG_SECTION_NAMES (false), COFF_LONG_SECTION_NAMES_SETTER
401 #endif /* COFF_ENABLE_LONG_SECTION_NAMES */
403 #if defined (COFF_LONG_SECTION_NAMES)
404 static bool bfd_coff_set_long_section_names_allowed
406 #else /* !defined (COFF_LONG_SECTION_NAMES) */
407 static bool bfd_coff_set_long_section_names_disallowed
409 #endif /* defined (COFF_LONG_SECTION_NAMES) */
410 static long sec_to_styp_flags
411 (const char *, flagword
);
412 static bool styp_to_sec_flags
413 (bfd
*, void *, const char *, asection
*, flagword
*);
414 static bool coff_bad_format_hook
416 static void coff_set_custom_section_alignment
417 (bfd
*, asection
*, const struct coff_section_alignment_entry
*,
419 static bool coff_new_section_hook
421 static bool coff_set_arch_mach_hook
423 static bool coff_write_relocs
425 static bool coff_set_flags
426 (bfd
*, unsigned int *, unsigned short *);
427 static bool coff_set_arch_mach
428 (bfd
*, enum bfd_architecture
, unsigned long) ATTRIBUTE_UNUSED
;
429 static bool coff_compute_section_file_positions
431 static bool coff_write_object_contents
432 (bfd
*) ATTRIBUTE_UNUSED
;
433 static bool coff_set_section_contents
434 (bfd
*, asection
*, const void *, file_ptr
, bfd_size_type
);
435 static bool coff_slurp_line_table
437 static bool coff_slurp_symbol_table
439 static enum coff_symbol_classification coff_classify_symbol
440 (bfd
*, struct internal_syment
*);
441 static bool coff_slurp_reloc_table
442 (bfd
*, asection
*, asymbol
**);
443 static long coff_canonicalize_reloc
444 (bfd
*, asection
*, arelent
**, asymbol
**);
445 #ifndef coff_mkobject_hook
446 static void * coff_mkobject_hook
447 (bfd
*, void *, void *);
450 static flagword handle_COMDAT
451 (bfd
*, flagword
, void *, const char *, asection
*);
454 static bool ticoff0_bad_format_hook
456 static bool ticoff1_bad_format_hook
460 /* void warning(); */
462 #if defined (COFF_LONG_SECTION_NAMES)
464 bfd_coff_set_long_section_names_allowed (bfd
*abfd
, int enable
)
466 bfd_coff_long_section_names (abfd
) = enable
;
469 #else /* !defined (COFF_LONG_SECTION_NAMES) */
471 bfd_coff_set_long_section_names_disallowed (bfd
*abfd ATTRIBUTE_UNUSED
,
472 int enable ATTRIBUTE_UNUSED
)
476 #endif /* defined (COFF_LONG_SECTION_NAMES) */
478 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
479 the incoming SEC_* flags. The inverse of this function is
480 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
481 should probably mirror the changes in styp_to_sec_flags(). */
485 /* Macros for setting debugging flags. */
488 #define STYP_XCOFF_DEBUG STYP_DEBUG
490 #define STYP_XCOFF_DEBUG STYP_INFO
493 #ifdef COFF_ALIGN_IN_S_FLAGS
494 #define STYP_DEBUG_INFO STYP_DSECT
496 #define STYP_DEBUG_INFO STYP_INFO
500 sec_to_styp_flags (const char *sec_name
, flagword sec_flags
)
504 if (!strcmp (sec_name
, _TEXT
))
506 styp_flags
= STYP_TEXT
;
508 else if (!strcmp (sec_name
, _DATA
))
510 styp_flags
= STYP_DATA
;
512 else if (!strcmp (sec_name
, _BSS
))
514 styp_flags
= STYP_BSS
;
517 else if (!strcmp (sec_name
, _COMMENT
))
519 styp_flags
= STYP_INFO
;
520 #endif /* _COMMENT */
523 else if (!strcmp (sec_name
, _LIB
))
525 styp_flags
= STYP_LIB
;
529 else if (!strcmp (sec_name
, _LIT
))
531 styp_flags
= STYP_LIT
;
534 else if (startswith (sec_name
, DOT_DEBUG
)
535 || startswith (sec_name
, DOT_ZDEBUG
))
537 /* Handle the XCOFF debug section and DWARF2 debug sections. */
539 styp_flags
= STYP_XCOFF_DEBUG
;
541 styp_flags
= STYP_DEBUG_INFO
;
543 else if (startswith (sec_name
, ".stab"))
545 styp_flags
= STYP_DEBUG_INFO
;
547 #ifdef COFF_LONG_SECTION_NAMES
548 else if (startswith (sec_name
, GNU_LINKONCE_WI
)
549 || startswith (sec_name
, GNU_LINKONCE_WT
))
551 styp_flags
= STYP_DEBUG_INFO
;
555 else if (!strcmp (sec_name
, _TDATA
))
557 styp_flags
= STYP_TDATA
;
559 else if (!strcmp (sec_name
, _TBSS
))
561 styp_flags
= STYP_TBSS
;
563 else if (!strcmp (sec_name
, _PAD
))
565 styp_flags
= STYP_PAD
;
567 else if (!strcmp (sec_name
, _LOADER
))
569 styp_flags
= STYP_LOADER
;
571 else if (!strcmp (sec_name
, _EXCEPT
))
573 styp_flags
= STYP_EXCEPT
;
575 else if (!strcmp (sec_name
, _TYPCHK
))
577 styp_flags
= STYP_TYPCHK
;
579 else if (sec_flags
& SEC_DEBUGGING
)
583 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
584 if (!strcmp (sec_name
, xcoff_dwsect_names
[i
].xcoff_name
))
586 styp_flags
= STYP_DWARF
| xcoff_dwsect_names
[i
].flag
;
591 /* Try and figure out what it should be */
592 else if (sec_flags
& SEC_CODE
)
594 styp_flags
= STYP_TEXT
;
596 else if (sec_flags
& SEC_DATA
)
598 styp_flags
= STYP_DATA
;
600 else if (sec_flags
& SEC_READONLY
)
602 #ifdef STYP_LIT /* 29k readonly text/data section */
603 styp_flags
= STYP_LIT
;
605 styp_flags
= STYP_TEXT
;
606 #endif /* STYP_LIT */
608 else if (sec_flags
& SEC_LOAD
)
610 styp_flags
= STYP_TEXT
;
612 else if (sec_flags
& SEC_ALLOC
)
614 styp_flags
= STYP_BSS
;
618 if (sec_flags
& SEC_TIC54X_CLINK
)
619 styp_flags
|= STYP_CLINK
;
623 if (sec_flags
& SEC_TIC54X_BLOCK
)
624 styp_flags
|= STYP_BLOCK
;
628 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
629 styp_flags
|= STYP_NOLOAD
;
635 #else /* COFF_WITH_PE */
637 /* The PE version; see above for the general comments. The non-PE
638 case seems to be more guessing, and breaks PE format; specifically,
639 .rdata is readonly, but it sure ain't text. Really, all this
640 should be set up properly in gas (or whatever assembler is in use),
641 and honor whatever objcopy/strip, etc. sent us as input. */
644 sec_to_styp_flags (const char *sec_name
, flagword sec_flags
)
649 if (startswith (sec_name
, DOT_DEBUG
)
650 || startswith (sec_name
, DOT_ZDEBUG
)
651 #ifdef COFF_LONG_SECTION_NAMES
652 || startswith (sec_name
, GNU_LINKONCE_WI
)
653 || startswith (sec_name
, GNU_LINKONCE_WT
)
655 || startswith (sec_name
, ".stab"))
658 /* caution: there are at least three groups of symbols that have
659 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
660 SEC_* are the BFD internal flags, used for generic BFD
661 information. STYP_* are the COFF section flags which appear in
662 COFF files. IMAGE_SCN_* are the PE section flags which appear in
663 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
664 but there are more IMAGE_SCN_* flags. */
666 /* FIXME: There is no gas syntax to specify the debug section flag. */
669 sec_flags
&= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
670 | SEC_LINK_DUPLICATES_SAME_CONTENTS
671 | SEC_LINK_DUPLICATES_SAME_SIZE
);
672 sec_flags
|= SEC_DEBUGGING
| SEC_READONLY
;
678 if ((sec_flags
& SEC_CODE
) != 0)
679 styp_flags
|= IMAGE_SCN_CNT_CODE
;
680 if ((sec_flags
& (SEC_DATA
| SEC_DEBUGGING
)) != 0)
681 styp_flags
|= IMAGE_SCN_CNT_INITIALIZED_DATA
;
682 if ((sec_flags
& SEC_ALLOC
) != 0 && (sec_flags
& SEC_LOAD
) == 0)
683 styp_flags
|= IMAGE_SCN_CNT_UNINITIALIZED_DATA
; /* ==STYP_BSS */
685 /* skip constRUCTOR */
687 #ifndef COFF_IMAGE_WITH_PE
688 /* I don't think any of the IMAGE_SCN_LNK_* flags set below should be set
689 when the output is PE. Only object files should have them, for the linker
691 if ((sec_flags
& SEC_IS_COMMON
) != 0)
692 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
694 if ((sec_flags
& SEC_DEBUGGING
) != 0)
695 styp_flags
|= IMAGE_SCN_MEM_DISCARDABLE
;
696 if ((sec_flags
& (SEC_EXCLUDE
| SEC_NEVER_LOAD
)) != 0 && !is_dbg
)
697 #ifdef COFF_IMAGE_WITH_PE
698 styp_flags
|= IMAGE_SCN_MEM_DISCARDABLE
;
700 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
704 #ifndef COFF_IMAGE_WITH_PE
705 if (sec_flags
& SEC_LINK_ONCE
)
706 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
708 & (SEC_LINK_DUPLICATES_DISCARD
| SEC_LINK_DUPLICATES_SAME_CONTENTS
709 | SEC_LINK_DUPLICATES_SAME_SIZE
)) != 0)
710 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
713 /* skip LINKER_CREATED */
715 if ((sec_flags
& SEC_COFF_NOREAD
) == 0)
716 styp_flags
|= IMAGE_SCN_MEM_READ
; /* Invert NOREAD for read. */
717 if ((sec_flags
& SEC_READONLY
) == 0)
718 styp_flags
|= IMAGE_SCN_MEM_WRITE
; /* Invert READONLY for write. */
719 if (sec_flags
& SEC_CODE
)
720 styp_flags
|= IMAGE_SCN_MEM_EXECUTE
; /* CODE->EXECUTE. */
721 if (sec_flags
& SEC_COFF_SHARED
)
722 styp_flags
|= IMAGE_SCN_MEM_SHARED
; /* Shared remains meaningful. */
727 #endif /* COFF_WITH_PE */
729 /* Return a word with SEC_* flags set to represent the incoming STYP_*
730 flags (from scnhdr.s_flags). The inverse of this function is
731 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
732 should probably mirror the changes in sec_to_styp_flags(). */
737 styp_to_sec_flags (bfd
*abfd
,
740 asection
*section ATTRIBUTE_UNUSED
,
743 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
744 unsigned long styp_flags
= internal_s
->s_flags
;
745 flagword sec_flags
= 0;
748 if (styp_flags
& STYP_BLOCK
)
749 sec_flags
|= SEC_TIC54X_BLOCK
;
753 if (styp_flags
& STYP_CLINK
)
754 sec_flags
|= SEC_TIC54X_CLINK
;
758 if (styp_flags
& STYP_NOLOAD
)
759 sec_flags
|= SEC_NEVER_LOAD
;
760 #endif /* STYP_NOLOAD */
762 /* For 386 COFF, at least, an unloadable text or data section is
763 actually a shared library section. */
764 if (styp_flags
& STYP_TEXT
)
766 if (sec_flags
& SEC_NEVER_LOAD
)
767 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
769 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
771 else if (styp_flags
& STYP_DATA
)
773 if (sec_flags
& SEC_NEVER_LOAD
)
774 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
776 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
778 else if (styp_flags
& STYP_BSS
)
780 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
781 if (sec_flags
& SEC_NEVER_LOAD
)
782 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
785 sec_flags
|= SEC_ALLOC
;
787 else if (styp_flags
& STYP_INFO
)
789 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
790 defined. coff_compute_section_file_positions uses
791 COFF_PAGE_SIZE to ensure that the low order bits of the
792 section VMA and the file offset match. If we don't know
793 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
794 and demand page loading of the file will fail. */
795 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
796 sec_flags
|= SEC_DEBUGGING
;
799 else if (styp_flags
& STYP_PAD
)
802 else if (styp_flags
& STYP_TDATA
)
804 if (sec_flags
& SEC_NEVER_LOAD
)
805 sec_flags
|= SEC_DATA
| SEC_THREAD_LOCAL
| SEC_COFF_SHARED_LIBRARY
;
807 sec_flags
|= SEC_DATA
| SEC_THREAD_LOCAL
| SEC_LOAD
| SEC_ALLOC
;
809 else if (styp_flags
& STYP_TBSS
)
811 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
812 if (sec_flags
& SEC_NEVER_LOAD
)
813 sec_flags
|= SEC_ALLOC
| SEC_THREAD_LOCAL
| SEC_COFF_SHARED_LIBRARY
;
816 sec_flags
|= SEC_ALLOC
| SEC_THREAD_LOCAL
;
818 else if (styp_flags
& STYP_EXCEPT
)
819 sec_flags
|= SEC_LOAD
;
820 else if (styp_flags
& STYP_LOADER
)
821 sec_flags
|= SEC_LOAD
;
822 else if (styp_flags
& STYP_TYPCHK
)
823 sec_flags
|= SEC_LOAD
;
824 else if (styp_flags
& STYP_DWARF
)
825 sec_flags
|= SEC_DEBUGGING
;
827 else if (strcmp (name
, _TEXT
) == 0)
829 if (sec_flags
& SEC_NEVER_LOAD
)
830 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
832 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
834 else if (strcmp (name
, _DATA
) == 0)
836 if (sec_flags
& SEC_NEVER_LOAD
)
837 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
839 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
841 else if (strcmp (name
, _BSS
) == 0)
843 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
844 if (sec_flags
& SEC_NEVER_LOAD
)
845 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
848 sec_flags
|= SEC_ALLOC
;
850 else if (startswith (name
, DOT_DEBUG
)
851 || startswith (name
, DOT_ZDEBUG
)
853 || strcmp (name
, _COMMENT
) == 0
855 #ifdef COFF_LONG_SECTION_NAMES
856 || startswith (name
, GNU_LINKONCE_WI
)
857 || startswith (name
, GNU_LINKONCE_WT
)
859 || startswith (name
, ".stab"))
861 #ifdef COFF_PAGE_SIZE
862 sec_flags
|= SEC_DEBUGGING
;
866 else if (strcmp (name
, _LIB
) == 0)
870 else if (strcmp (name
, _LIT
) == 0)
871 sec_flags
= SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
874 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
876 #ifdef STYP_LIT /* A29k readonly text/data section type. */
877 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
878 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
879 #endif /* STYP_LIT */
881 #ifdef STYP_OTHER_LOAD /* Other loaded sections. */
882 if (styp_flags
& STYP_OTHER_LOAD
)
883 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
884 #endif /* STYP_SDATA */
886 if ((bfd_applicable_section_flags (abfd
) & SEC_SMALL_DATA
) != 0
887 && (startswith (name
, ".sbss")
888 || startswith (name
, ".sdata")))
889 sec_flags
|= SEC_SMALL_DATA
;
891 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
892 /* As a GNU extension, if the name begins with .gnu.linkonce, we
893 only link a single copy of the section. This is used to support
894 g++. g++ will emit each template expansion in its own section.
895 The symbols will be defined as weak, so that multiple definitions
896 are permitted. The GNU linker extension is to actually discard
897 all but one of the sections. */
898 if (startswith (name
, ".gnu.linkonce"))
899 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
902 if (flags_ptr
== NULL
)
905 * flags_ptr
= sec_flags
;
909 #else /* COFF_WITH_PE */
912 handle_COMDAT (bfd
* abfd
,
918 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
919 bfd_byte
*esymstart
, *esym
, *esymend
;
921 char *target_name
= NULL
;
923 sec_flags
|= SEC_LINK_ONCE
;
925 /* Unfortunately, the PE format stores essential information in
926 the symbol table, of all places. We need to extract that
927 information now, so that objdump and the linker will know how
928 to handle the section without worrying about the symbols. We
929 can't call slurp_symtab, because the linker doesn't want the
932 /* COMDAT sections are special. The first symbol is the section
933 symbol, which tells what kind of COMDAT section it is. The
934 second symbol is the "comdat symbol" - the one with the
935 unique name. GNU uses the section symbol for the unique
936 name; MS uses ".text" for every comdat section. Sigh. - DJ */
938 /* This is not mirrored in sec_to_styp_flags(), but there
939 doesn't seem to be a need to, either, and it would at best be
942 if (! _bfd_coff_get_external_symbols (abfd
))
945 esymstart
= esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
946 esymend
= esym
+ obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
948 while (esym
< esymend
)
950 struct internal_syment isym
;
951 char buf
[SYMNMLEN
+ 1];
954 bfd_coff_swap_sym_in (abfd
, esym
, & isym
);
956 BFD_ASSERT (sizeof (internal_s
->s_name
) <= SYMNMLEN
);
958 if (isym
.n_scnum
== section
->target_index
)
960 /* According to the MSVC documentation, the first
961 TWO entries with the section # are both of
962 interest to us. The first one is the "section
963 symbol" (section name). The second is the comdat
964 symbol name. Here, we've found the first
965 qualifying entry; we distinguish it from the
966 second with a state flag.
968 In the case of gas-generated (at least until that
969 is fixed) .o files, it isn't necessarily the
970 second one. It may be some other later symbol.
972 Since gas also doesn't follow MS conventions and
973 emits the section similar to .text$<name>, where
974 <something> is the name we're looking for, we
975 distinguish the two as follows:
977 If the section name is simply a section name (no
978 $) we presume it's MS-generated, and look at
979 precisely the second symbol for the comdat name.
980 If the section name has a $, we assume it's
981 gas-generated, and look for <something> (whatever
982 follows the $) as the comdat symbol. */
984 /* All 3 branches use this. */
985 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
, buf
);
987 /* PR 17512 file: 078-11867-0.004 */
990 _bfd_error_handler (_("%pB: unable to load COMDAT section name"),
999 /* The first time we've seen the symbol. */
1000 union internal_auxent aux
;
1002 /* If it isn't the stuff we're expecting, die;
1003 The MS documentation is vague, but it
1004 appears that the second entry serves BOTH
1005 as the comdat symbol and the defining
1006 symbol record (either C_STAT or C_EXT,
1007 possibly with an aux entry with debug
1008 information if it's a function.) It
1009 appears the only way to find the second one
1010 is to count. (On Intel, they appear to be
1011 adjacent, but on Alpha, they have been
1014 Here, we think we've found the first one,
1015 but there's some checking we can do to be
1018 if (! ((isym
.n_sclass
== C_STAT
1019 || isym
.n_sclass
== C_EXT
)
1020 && BTYPE (isym
.n_type
) == T_NULL
1021 && isym
.n_value
== 0))
1023 /* Malformed input files can trigger this test.
1025 _bfd_error_handler (_("%pB: error: unexpected symbol '%s' in COMDAT section"),
1030 /* FIXME LATER: MSVC generates section names
1031 like .text for comdats. Gas generates
1032 names like .text$foo__Fv (in the case of a
1033 function). See comment above for more. */
1035 if (isym
.n_sclass
== C_STAT
&& strcmp (name
, symname
) != 0)
1036 /* xgettext:c-format */
1037 _bfd_error_handler (_("%pB: warning: COMDAT symbol '%s'"
1038 " does not match section name '%s'"),
1039 abfd
, symname
, name
);
1043 /* PR 17512: file: e2cfe54f. */
1044 if (esym
+ bfd_coff_symesz (abfd
) >= esymend
)
1046 /* xgettext:c-format */
1047 _bfd_error_handler (_("%pB: warning: no symbol for"
1048 " section '%s' found"),
1052 /* This is the section symbol. */
1053 bfd_coff_swap_aux_in (abfd
, (esym
+ bfd_coff_symesz (abfd
)),
1054 isym
.n_type
, isym
.n_sclass
,
1055 0, isym
.n_numaux
, & aux
);
1057 target_name
= strchr (name
, '$');
1058 if (target_name
!= NULL
)
1066 /* FIXME: Microsoft uses NODUPLICATES and
1067 ASSOCIATIVE, but gnu uses ANY and
1068 SAME_SIZE. Unfortunately, gnu doesn't do
1069 the comdat symbols right. So, until we can
1070 fix it to do the right thing, we are
1071 temporarily disabling comdats for the MS
1072 types (they're used in DLLs and C++, but we
1073 don't support *their* C++ libraries anyway
1076 /* Cygwin does not follow the MS style, and
1077 uses ANY and SAME_SIZE where NODUPLICATES
1078 and ASSOCIATIVE should be used. For
1079 Interix, we just do the right thing up
1082 switch (aux
.x_scn
.x_comdat
)
1084 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
1085 #ifdef STRICT_PE_FORMAT
1086 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
1088 sec_flags
&= ~SEC_LINK_ONCE
;
1092 case IMAGE_COMDAT_SELECT_ANY
:
1093 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1096 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
1097 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
1100 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
1101 /* Not yet fully implemented ??? */
1102 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
1105 /* debug$S gets this case; other
1108 /* There may be no symbol... we'll search
1109 the whole table... Is this the right
1110 place to play this game? Or should we do
1111 it when reading it in. */
1112 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
1113 #ifdef STRICT_PE_FORMAT
1114 /* FIXME: This is not currently implemented. */
1115 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1117 sec_flags
&= ~SEC_LINK_ONCE
;
1121 default: /* 0 means "no symbol" */
1122 /* debug$F gets this case; other
1124 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1131 /* Gas mode: the first matching on partial name. */
1133 #ifndef TARGET_UNDERSCORE
1134 #define TARGET_UNDERSCORE 0
1136 /* Is this the name we're looking for ? */
1137 if (strcmp (target_name
,
1138 symname
+ (TARGET_UNDERSCORE
? 1 : 0)) != 0)
1140 /* Not the name we're looking for */
1141 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1146 /* MSVC mode: the lexically second symbol (or
1147 drop through from the above). */
1152 /* This must the second symbol with the
1153 section #. It is the actual symbol name.
1154 Intel puts the two adjacent, but Alpha (at
1155 least) spreads them out. */
1157 amt
= sizeof (struct coff_comdat_info
);
1158 coff_section_data (abfd
, section
)->comdat
1159 = (struct coff_comdat_info
*) bfd_alloc (abfd
, amt
);
1160 if (coff_section_data (abfd
, section
)->comdat
== NULL
)
1163 coff_section_data (abfd
, section
)->comdat
->symbol
=
1164 (esym
- esymstart
) / bfd_coff_symesz (abfd
);
1166 amt
= strlen (symname
) + 1;
1167 newname
= (char *) bfd_alloc (abfd
, amt
);
1168 if (newname
== NULL
)
1171 strcpy (newname
, symname
);
1172 coff_section_data (abfd
, section
)->comdat
->name
1180 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1188 /* The PE version; see above for the general comments.
1190 Since to set the SEC_LINK_ONCE and associated flags, we have to
1191 look at the symbol table anyway, we return the symbol table index
1192 of the symbol being used as the COMDAT symbol. This is admittedly
1193 ugly, but there's really nowhere else that we have access to the
1194 required information. FIXME: Is the COMDAT symbol index used for
1195 any purpose other than objdump? */
1198 styp_to_sec_flags (bfd
*abfd
,
1202 flagword
*flags_ptr
)
1204 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
1205 unsigned long styp_flags
= internal_s
->s_flags
;
1208 bool is_dbg
= false;
1210 if (startswith (name
, DOT_DEBUG
)
1211 || startswith (name
, DOT_ZDEBUG
)
1212 #ifdef COFF_LONG_SECTION_NAMES
1213 || startswith (name
, GNU_LINKONCE_WI
)
1214 || startswith (name
, GNU_LINKONCE_WT
)
1215 /* FIXME: These definitions ought to be in a header file. */
1216 #define GNU_DEBUGLINK ".gnu_debuglink"
1217 #define GNU_DEBUGALTLINK ".gnu_debugaltlink"
1218 || startswith (name
, GNU_DEBUGLINK
)
1219 || startswith (name
, GNU_DEBUGALTLINK
)
1221 || startswith (name
, ".stab"))
1223 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
1224 sec_flags
= SEC_READONLY
;
1226 /* If section disallows read, then set the NOREAD flag. */
1227 if ((styp_flags
& IMAGE_SCN_MEM_READ
) == 0)
1228 sec_flags
|= SEC_COFF_NOREAD
;
1230 /* Process each flag bit in styp_flags in turn. */
1233 unsigned long flag
= styp_flags
& - styp_flags
;
1234 char * unhandled
= NULL
;
1236 styp_flags
&= ~ flag
;
1238 /* We infer from the distinct read/write/execute bits the settings
1239 of some of the bfd flags; the actual values, should we need them,
1240 are also in pei_section_data (abfd, section)->pe_flags. */
1245 unhandled
= "STYP_DSECT";
1248 unhandled
= "STYP_GROUP";
1251 unhandled
= "STYP_COPY";
1254 unhandled
= "STYP_OVER";
1256 #ifdef SEC_NEVER_LOAD
1258 sec_flags
|= SEC_NEVER_LOAD
;
1261 case IMAGE_SCN_MEM_READ
:
1262 sec_flags
&= ~SEC_COFF_NOREAD
;
1264 case IMAGE_SCN_TYPE_NO_PAD
:
1267 case IMAGE_SCN_LNK_OTHER
:
1268 unhandled
= "IMAGE_SCN_LNK_OTHER";
1270 case IMAGE_SCN_MEM_NOT_CACHED
:
1271 unhandled
= "IMAGE_SCN_MEM_NOT_CACHED";
1273 case IMAGE_SCN_MEM_NOT_PAGED
:
1274 /* Generate a warning message rather using the 'unhandled'
1275 variable as this will allow some .sys files generate by
1276 other toolchains to be processed. See bugzilla issue 196. */
1277 /* xgettext:c-format */
1278 _bfd_error_handler (_("%pB: warning: ignoring section flag"
1279 " %s in section %s"),
1280 abfd
, "IMAGE_SCN_MEM_NOT_PAGED", name
);
1282 case IMAGE_SCN_MEM_EXECUTE
:
1283 sec_flags
|= SEC_CODE
;
1285 case IMAGE_SCN_MEM_WRITE
:
1286 sec_flags
&= ~ SEC_READONLY
;
1288 case IMAGE_SCN_MEM_DISCARDABLE
:
1289 /* The MS PE spec says that debug sections are DISCARDABLE,
1290 but the presence of a DISCARDABLE flag does not necessarily
1291 mean that a given section contains debug information. Thus
1292 we only set the SEC_DEBUGGING flag on sections that we
1293 recognise as containing debug information. */
1296 || strcmp (name
, _COMMENT
) == 0
1300 sec_flags
|= SEC_DEBUGGING
| SEC_READONLY
;
1303 case IMAGE_SCN_MEM_SHARED
:
1304 sec_flags
|= SEC_COFF_SHARED
;
1306 case IMAGE_SCN_LNK_REMOVE
:
1308 sec_flags
|= SEC_EXCLUDE
;
1310 case IMAGE_SCN_CNT_CODE
:
1311 sec_flags
|= SEC_CODE
| SEC_ALLOC
| SEC_LOAD
;
1313 case IMAGE_SCN_CNT_INITIALIZED_DATA
:
1315 sec_flags
|= SEC_DEBUGGING
;
1317 sec_flags
|= SEC_DATA
| SEC_ALLOC
| SEC_LOAD
;
1319 case IMAGE_SCN_CNT_UNINITIALIZED_DATA
:
1320 sec_flags
|= SEC_ALLOC
;
1322 case IMAGE_SCN_LNK_INFO
:
1323 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1324 defined. coff_compute_section_file_positions uses
1325 COFF_PAGE_SIZE to ensure that the low order bits of the
1326 section VMA and the file offset match. If we don't know
1327 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1328 and demand page loading of the file will fail. */
1329 #ifdef COFF_PAGE_SIZE
1330 sec_flags
|= SEC_DEBUGGING
;
1333 case IMAGE_SCN_LNK_COMDAT
:
1334 /* COMDAT gets very special treatment. */
1335 sec_flags
= handle_COMDAT (abfd
, sec_flags
, hdr
, name
, section
);
1338 /* Silently ignore for now. */
1342 /* If the section flag was not handled, report it here. */
1343 if (unhandled
!= NULL
)
1346 /* xgettext:c-format */
1347 (_("%pB (%s): section flag %s (%#lx) ignored"),
1348 abfd
, name
, unhandled
, flag
);
1353 if ((bfd_applicable_section_flags (abfd
) & SEC_SMALL_DATA
) != 0
1354 && (startswith (name
, ".sbss")
1355 || startswith (name
, ".sdata")))
1356 sec_flags
|= SEC_SMALL_DATA
;
1358 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1359 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1360 only link a single copy of the section. This is used to support
1361 g++. g++ will emit each template expansion in its own section.
1362 The symbols will be defined as weak, so that multiple definitions
1363 are permitted. The GNU linker extension is to actually discard
1364 all but one of the sections. */
1365 if (startswith (name
, ".gnu.linkonce"))
1366 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1370 * flags_ptr
= sec_flags
;
1375 #endif /* COFF_WITH_PE */
1377 #define get_index(symbol) ((symbol)->udata.i)
1381 bfd_coff_backend_data
1385 .{* COFF symbol classifications. *}
1387 .enum coff_symbol_classification
1389 . {* Global symbol. *}
1390 . COFF_SYMBOL_GLOBAL,
1391 . {* Common symbol. *}
1392 . COFF_SYMBOL_COMMON,
1393 . {* Undefined symbol. *}
1394 . COFF_SYMBOL_UNDEFINED,
1395 . {* Local symbol. *}
1396 . COFF_SYMBOL_LOCAL,
1397 . {* PE section symbol. *}
1398 . COFF_SYMBOL_PE_SECTION
1401 .typedef asection * (*coff_gc_mark_hook_fn)
1402 . (asection *, struct bfd_link_info *, struct internal_reloc *,
1403 . struct coff_link_hash_entry *, struct internal_syment *);
1405 Special entry points for gdb to swap in coff symbol table parts:
1408 . void (*_bfd_coff_swap_aux_in)
1409 . (bfd *, void *, int, int, int, int, void *);
1411 . void (*_bfd_coff_swap_sym_in)
1412 . (bfd *, void *, void *);
1414 . void (*_bfd_coff_swap_lineno_in)
1415 . (bfd *, void *, void *);
1417 . unsigned int (*_bfd_coff_swap_aux_out)
1418 . (bfd *, void *, int, int, int, int, void *);
1420 . unsigned int (*_bfd_coff_swap_sym_out)
1421 . (bfd *, void *, void *);
1423 . unsigned int (*_bfd_coff_swap_lineno_out)
1424 . (bfd *, void *, void *);
1426 . unsigned int (*_bfd_coff_swap_reloc_out)
1427 . (bfd *, void *, void *);
1429 . unsigned int (*_bfd_coff_swap_filehdr_out)
1430 . (bfd *, void *, void *);
1432 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1433 . (bfd *, void *, void *);
1435 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1436 . (bfd *, void *, void *);
1438 . unsigned int _bfd_filhsz;
1439 . unsigned int _bfd_aoutsz;
1440 . unsigned int _bfd_scnhsz;
1441 . unsigned int _bfd_symesz;
1442 . unsigned int _bfd_auxesz;
1443 . unsigned int _bfd_relsz;
1444 . unsigned int _bfd_linesz;
1445 . unsigned int _bfd_filnmlen;
1446 . bool _bfd_coff_long_filenames;
1448 . bool _bfd_coff_long_section_names;
1449 . bool (*_bfd_coff_set_long_section_names)
1452 . unsigned int _bfd_coff_default_section_alignment_power;
1453 . bool _bfd_coff_force_symnames_in_strings;
1454 . unsigned int _bfd_coff_debug_string_prefix_length;
1455 . unsigned int _bfd_coff_max_nscns;
1457 . void (*_bfd_coff_swap_filehdr_in)
1458 . (bfd *, void *, void *);
1460 . void (*_bfd_coff_swap_aouthdr_in)
1461 . (bfd *, void *, void *);
1463 . void (*_bfd_coff_swap_scnhdr_in)
1464 . (bfd *, void *, void *);
1466 . void (*_bfd_coff_swap_reloc_in)
1467 . (bfd *abfd, void *, void *);
1469 . bool (*_bfd_coff_bad_format_hook)
1472 . bool (*_bfd_coff_set_arch_mach_hook)
1475 . void * (*_bfd_coff_mkobject_hook)
1476 . (bfd *, void *, void *);
1478 . bool (*_bfd_styp_to_sec_flags_hook)
1479 . (bfd *, void *, const char *, asection *, flagword *);
1481 . void (*_bfd_set_alignment_hook)
1482 . (bfd *, asection *, void *);
1484 . bool (*_bfd_coff_slurp_symbol_table)
1487 . bool (*_bfd_coff_symname_in_debug)
1488 . (bfd *, struct internal_syment *);
1490 . bool (*_bfd_coff_pointerize_aux_hook)
1491 . (bfd *, combined_entry_type *, combined_entry_type *,
1492 . unsigned int, combined_entry_type *);
1494 . bool (*_bfd_coff_print_aux)
1495 . (bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1496 . combined_entry_type *, unsigned int);
1498 . bool (*_bfd_coff_reloc16_extra_cases)
1499 . (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1500 . bfd_byte *, size_t *, size_t *);
1502 . int (*_bfd_coff_reloc16_estimate)
1503 . (bfd *, asection *, arelent *, unsigned int,
1504 . struct bfd_link_info *);
1506 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1507 . (bfd *, struct internal_syment *);
1509 . bool (*_bfd_coff_compute_section_file_positions)
1512 . bool (*_bfd_coff_start_final_link)
1513 . (bfd *, struct bfd_link_info *);
1515 . bool (*_bfd_coff_relocate_section)
1516 . (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1517 . struct internal_reloc *, struct internal_syment *, asection **);
1519 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1520 . (bfd *, asection *, struct internal_reloc *,
1521 . struct coff_link_hash_entry *, struct internal_syment *, bfd_vma *);
1523 . bool (*_bfd_coff_adjust_symndx)
1524 . (bfd *, struct bfd_link_info *, bfd *, asection *,
1525 . struct internal_reloc *, bool *);
1527 . bool (*_bfd_coff_link_add_one_symbol)
1528 . (struct bfd_link_info *, bfd *, const char *, flagword,
1529 . asection *, bfd_vma, const char *, bool, bool,
1530 . struct bfd_link_hash_entry **);
1532 . bool (*_bfd_coff_link_output_has_begun)
1533 . (bfd *, struct coff_final_link_info *);
1535 . bool (*_bfd_coff_final_link_postscript)
1536 . (bfd *, struct coff_final_link_info *);
1538 . bool (*_bfd_coff_print_pdata)
1541 .} bfd_coff_backend_data;
1543 .#define coff_backend_info(abfd) \
1544 . ((const bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1546 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1547 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1549 .#define bfd_coff_swap_sym_in(a,e,i) \
1550 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1552 .#define bfd_coff_swap_lineno_in(a,e,i) \
1553 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1555 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1556 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1558 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1559 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1561 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1562 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1564 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1565 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1567 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1568 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1570 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1571 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1573 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1574 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1576 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1577 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1578 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1579 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1580 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1581 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1582 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1583 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1584 .#define bfd_coff_long_filenames(abfd) \
1585 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1586 .#define bfd_coff_long_section_names(abfd) \
1587 . (coff_data (abfd)->long_section_names)
1588 .#define bfd_coff_set_long_section_names(abfd, enable) \
1589 . ((coff_backend_info (abfd)->_bfd_coff_set_long_section_names) (abfd, enable))
1590 .#define bfd_coff_default_section_alignment_power(abfd) \
1591 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1592 .#define bfd_coff_max_nscns(abfd) \
1593 . (coff_backend_info (abfd)->_bfd_coff_max_nscns)
1595 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1596 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1598 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1599 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1601 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1602 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1604 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1605 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1607 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1608 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1610 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1611 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1612 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1613 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1614 . (abfd, filehdr, aouthdr))
1616 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1617 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1618 . (abfd, scnhdr, name, section, flags_ptr))
1620 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1621 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1623 .#define bfd_coff_slurp_symbol_table(abfd)\
1624 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1626 .#define bfd_coff_symname_in_debug(abfd, sym)\
1627 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1629 .#define bfd_coff_force_symnames_in_strings(abfd)\
1630 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1632 .#define bfd_coff_debug_string_prefix_length(abfd)\
1633 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1635 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1636 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1637 . (abfd, file, base, symbol, aux, indaux))
1639 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1640 . reloc, data, src_ptr, dst_ptr)\
1641 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1642 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1644 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1645 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1646 . (abfd, section, reloc, shrink, link_info))
1648 .#define bfd_coff_classify_symbol(abfd, sym)\
1649 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1652 .#define bfd_coff_compute_section_file_positions(abfd)\
1653 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1656 .#define bfd_coff_start_final_link(obfd, info)\
1657 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1659 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1660 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1661 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1662 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1663 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1664 . (abfd, sec, rel, h, sym, addendp))
1665 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1666 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1667 . (obfd, info, ibfd, sec, rel, adjustedp))
1668 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1669 . value, string, cp, coll, hashp)\
1670 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1671 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1673 .#define bfd_coff_link_output_has_begun(a,p) \
1674 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p))
1675 .#define bfd_coff_final_link_postscript(a,p) \
1676 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p))
1678 .#define bfd_coff_have_print_pdata(a) \
1679 . (coff_backend_info (a)->_bfd_coff_print_pdata)
1680 .#define bfd_coff_print_pdata(a,p) \
1681 . ((coff_backend_info (a)->_bfd_coff_print_pdata) (a, p))
1683 .{* Macro: Returns true if the bfd is a PE executable as opposed to a
1684 . PE object file. *}
1685 .#define bfd_pei_p(abfd) \
1686 . (startswith ((abfd)->xvec->name, "pei-"))
1689 /* See whether the magic number matches. */
1692 coff_bad_format_hook (bfd
* abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1694 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1696 if (BADMAG (*internal_f
))
1704 ticoff0_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1706 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1708 if (COFF0_BADMAG (*internal_f
))
1717 ticoff1_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1719 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1721 if (COFF1_BADMAG (*internal_f
))
1728 /* Check whether this section uses an alignment other than the
1732 coff_set_custom_section_alignment (bfd
*abfd ATTRIBUTE_UNUSED
,
1734 const struct coff_section_alignment_entry
*alignment_table
,
1735 const unsigned int table_size
)
1737 const unsigned int default_alignment
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1740 for (i
= 0; i
< table_size
; ++i
)
1742 const char *secname
= bfd_section_name (section
);
1744 if (alignment_table
[i
].comparison_length
== (unsigned int) -1
1745 ? strcmp (alignment_table
[i
].name
, secname
) == 0
1746 : strncmp (alignment_table
[i
].name
, secname
,
1747 alignment_table
[i
].comparison_length
) == 0)
1750 if (i
>= table_size
)
1753 if (alignment_table
[i
].default_alignment_min
!= COFF_ALIGNMENT_FIELD_EMPTY
1754 && default_alignment
< alignment_table
[i
].default_alignment_min
)
1757 if (alignment_table
[i
].default_alignment_max
!= COFF_ALIGNMENT_FIELD_EMPTY
1758 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1759 && default_alignment
> alignment_table
[i
].default_alignment_max
1764 section
->alignment_power
= alignment_table
[i
].alignment_power
;
1767 /* Custom section alignment records. */
1769 static const struct coff_section_alignment_entry
1770 coff_section_alignment_table
[] =
1772 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1773 COFF_SECTION_ALIGNMENT_ENTRIES
,
1775 /* There must not be any gaps between .stabstr sections. */
1776 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1777 1, COFF_ALIGNMENT_FIELD_EMPTY
, 0 },
1778 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1779 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1780 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1781 /* Similarly for the .ctors and .dtors sections. */
1782 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1783 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1784 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1785 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 }
1788 static const unsigned int coff_section_alignment_table_size
=
1789 sizeof coff_section_alignment_table
/ sizeof coff_section_alignment_table
[0];
1791 /* Initialize a section structure with information peculiar to this
1792 particular implementation of COFF. */
1795 coff_new_section_hook (bfd
* abfd
, asection
* section
)
1797 combined_entry_type
*native
;
1799 unsigned char sclass
= C_STAT
;
1801 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1804 if (bfd_xcoff_text_align_power (abfd
) != 0
1805 && strcmp (bfd_section_name (section
), ".text") == 0)
1806 section
->alignment_power
= bfd_xcoff_text_align_power (abfd
);
1807 else if (bfd_xcoff_data_align_power (abfd
) != 0
1808 && strcmp (bfd_section_name (section
), ".data") == 0)
1809 section
->alignment_power
= bfd_xcoff_data_align_power (abfd
);
1814 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
1815 if (strcmp (bfd_section_name (section
),
1816 xcoff_dwsect_names
[i
].xcoff_name
) == 0)
1818 section
->alignment_power
= 0;
1825 /* Set up the section symbol. */
1826 if (!_bfd_generic_new_section_hook (abfd
, section
))
1829 /* Allocate aux records for section symbols, to store size and
1832 @@ The 10 is a guess at a plausible maximum number of aux entries
1833 (but shouldn't be a constant). */
1834 amt
= sizeof (combined_entry_type
) * 10;
1835 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
1839 /* We don't need to set up n_name, n_value, or n_scnum in the native
1840 symbol information, since they'll be overridden by the BFD symbol
1841 anyhow. However, we do need to set the type and storage class,
1842 in case this symbol winds up getting written out. The value 0
1843 for n_numaux is already correct. */
1845 native
->is_sym
= true;
1846 native
->u
.syment
.n_type
= T_NULL
;
1847 native
->u
.syment
.n_sclass
= sclass
;
1849 coffsymbol (section
->symbol
)->native
= native
;
1851 coff_set_custom_section_alignment (abfd
, section
,
1852 coff_section_alignment_table
,
1853 coff_section_alignment_table_size
);
1858 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1860 /* Set the alignment of a BFD section. */
1863 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1867 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1870 #ifdef COFF_DECODE_ALIGNMENT
1871 i
= COFF_DECODE_ALIGNMENT(hdr
->s_flags
);
1873 section
->alignment_power
= i
;
1875 #ifdef coff_set_section_load_page
1876 coff_set_section_load_page (section
, hdr
->s_page
);
1880 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1884 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1888 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1890 unsigned int alignment_power_const
1891 = hdr
->s_flags
& IMAGE_SCN_ALIGN_POWER_BIT_MASK
;
1893 switch (alignment_power_const
)
1895 case IMAGE_SCN_ALIGN_8192BYTES
:
1896 case IMAGE_SCN_ALIGN_4096BYTES
:
1897 case IMAGE_SCN_ALIGN_2048BYTES
:
1898 case IMAGE_SCN_ALIGN_1024BYTES
:
1899 case IMAGE_SCN_ALIGN_512BYTES
:
1900 case IMAGE_SCN_ALIGN_256BYTES
:
1901 case IMAGE_SCN_ALIGN_128BYTES
:
1902 case IMAGE_SCN_ALIGN_64BYTES
:
1903 case IMAGE_SCN_ALIGN_32BYTES
:
1904 case IMAGE_SCN_ALIGN_16BYTES
:
1905 case IMAGE_SCN_ALIGN_8BYTES
:
1906 case IMAGE_SCN_ALIGN_4BYTES
:
1907 case IMAGE_SCN_ALIGN_2BYTES
:
1908 case IMAGE_SCN_ALIGN_1BYTES
:
1909 section
->alignment_power
1910 = IMAGE_SCN_ALIGN_POWER_NUM (alignment_power_const
);
1916 /* In a PE image file, the s_paddr field holds the virtual size of a
1917 section, while the s_size field holds the raw size. We also keep
1918 the original section flag value, since not every bit can be
1919 mapped onto a generic BFD section bit. */
1920 if (coff_section_data (abfd
, section
) == NULL
)
1922 amt
= sizeof (struct coff_section_tdata
);
1923 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
1924 if (section
->used_by_bfd
== NULL
)
1925 /* FIXME: Return error. */
1929 if (pei_section_data (abfd
, section
) == NULL
)
1931 amt
= sizeof (struct pei_section_tdata
);
1932 coff_section_data (abfd
, section
)->tdata
= bfd_zalloc (abfd
, amt
);
1933 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1934 /* FIXME: Return error. */
1937 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1938 pei_section_data (abfd
, section
)->pe_flags
= hdr
->s_flags
;
1940 section
->lma
= hdr
->s_vaddr
;
1942 /* Check for extended relocs. */
1943 if (hdr
->s_flags
& IMAGE_SCN_LNK_NRELOC_OVFL
)
1945 struct external_reloc dst
;
1946 struct internal_reloc n
;
1947 file_ptr oldpos
= bfd_tell (abfd
);
1948 bfd_size_type relsz
= bfd_coff_relsz (abfd
);
1950 if (bfd_seek (abfd
, (file_ptr
) hdr
->s_relptr
, 0) != 0)
1952 if (bfd_bread (& dst
, relsz
, abfd
) != relsz
)
1955 bfd_coff_swap_reloc_in (abfd
, &dst
, &n
);
1956 if (bfd_seek (abfd
, oldpos
, 0) != 0)
1958 if (n
.r_vaddr
< 0x10000)
1960 _bfd_error_handler (_("%pB: overflow reloc count too small"), abfd
);
1961 bfd_set_error (bfd_error_bad_value
);
1964 section
->reloc_count
= hdr
->s_nreloc
= n
.r_vaddr
- 1;
1965 section
->rel_filepos
+= relsz
;
1967 else if (hdr
->s_nreloc
== 0xffff)
1969 (_("%pB: warning: claims to have 0xffff relocs, without overflow"),
1973 #undef ELIFALIGN_SET
1975 #else /* ! COFF_WITH_PE */
1978 /* We grossly abuse this function to handle XCOFF overflow headers.
1979 When we see one, we correct the reloc and line number counts in the
1980 real header, and remove the section we just created. */
1983 coff_set_alignment_hook (bfd
*abfd
, asection
*section
, void * scnhdr
)
1985 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1988 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1991 real_sec
= coff_section_from_bfd_index (abfd
, (int) hdr
->s_nreloc
);
1992 if (real_sec
== NULL
)
1995 real_sec
->reloc_count
= hdr
->s_paddr
;
1996 real_sec
->lineno_count
= hdr
->s_vaddr
;
1998 if (!bfd_section_removed_from_list (abfd
, section
))
2000 bfd_section_list_remove (abfd
, section
);
2001 --abfd
->section_count
;
2005 #else /* ! RS6000COFF_C */
2006 #if defined (COFF_GO32_EXE) || defined (COFF_GO32)
2009 coff_set_alignment_hook (bfd
* abfd
, asection
* section
, void * scnhdr
)
2011 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
2013 /* Check for extended relocs. */
2014 if (hdr
->s_flags
& IMAGE_SCN_LNK_NRELOC_OVFL
)
2016 struct external_reloc dst
;
2017 struct internal_reloc n
;
2018 const file_ptr oldpos
= bfd_tell (abfd
);
2019 const bfd_size_type relsz
= bfd_coff_relsz (abfd
);
2021 if (bfd_seek (abfd
, (file_ptr
) hdr
->s_relptr
, 0) != 0)
2023 if (bfd_bread (& dst
, relsz
, abfd
) != relsz
)
2026 bfd_coff_swap_reloc_in (abfd
, &dst
, &n
);
2027 if (bfd_seek (abfd
, oldpos
, 0) != 0)
2029 section
->reloc_count
= hdr
->s_nreloc
= n
.r_vaddr
- 1;
2030 section
->rel_filepos
+= relsz
;
2032 else if (hdr
->s_nreloc
== 0xffff)
2034 (_("%pB: warning: claims to have 0xffff relocs, without overflow"),
2038 #else /* ! COFF_GO32_EXE && ! COFF_GO32 */
2041 coff_set_alignment_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2042 asection
*section ATTRIBUTE_UNUSED
,
2043 void *scnhdr ATTRIBUTE_UNUSED
)
2047 #endif /* ! COFF_GO32_EXE && ! COFF_GO32 */
2048 #endif /* ! RS6000COFF_C */
2049 #endif /* ! COFF_WITH_PE */
2050 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
2052 #ifndef coff_mkobject
2055 coff_mkobject (bfd
* abfd
)
2057 coff_data_type
*coff
;
2058 size_t amt
= sizeof (coff_data_type
);
2060 abfd
->tdata
.coff_obj_data
= bfd_zalloc (abfd
, amt
);
2061 if (abfd
->tdata
.coff_obj_data
== NULL
)
2063 coff
= coff_data (abfd
);
2064 coff
->symbols
= NULL
;
2065 coff
->conversion_table
= NULL
;
2066 coff
->raw_syments
= NULL
;
2067 coff
->relocbase
= 0;
2068 coff
->local_toc_sym_map
= 0;
2070 bfd_coff_long_section_names (abfd
)
2071 = coff_backend_info (abfd
)->_bfd_coff_long_section_names
;
2073 /* make_abs_section(abfd);*/
2079 /* Create the COFF backend specific information. */
2081 #ifndef coff_mkobject_hook
2083 coff_mkobject_hook (bfd
* abfd
,
2085 void * aouthdr ATTRIBUTE_UNUSED
)
2087 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
2088 coff_data_type
*coff
;
2090 if (! coff_mkobject (abfd
))
2093 coff
= coff_data (abfd
);
2095 coff
->sym_filepos
= internal_f
->f_symptr
;
2097 /* These members communicate important constants about the symbol
2098 table to GDB's symbol-reading code. These `constants'
2099 unfortunately vary among coff implementations... */
2100 coff
->local_n_btmask
= N_BTMASK
;
2101 coff
->local_n_btshft
= N_BTSHFT
;
2102 coff
->local_n_tmask
= N_TMASK
;
2103 coff
->local_n_tshift
= N_TSHIFT
;
2104 coff
->local_symesz
= bfd_coff_symesz (abfd
);
2105 coff
->local_auxesz
= bfd_coff_auxesz (abfd
);
2106 coff
->local_linesz
= bfd_coff_linesz (abfd
);
2108 coff
->timestamp
= internal_f
->f_timdat
;
2110 obj_raw_syment_count (abfd
) =
2111 obj_conv_table_size (abfd
) =
2112 internal_f
->f_nsyms
;
2115 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
2116 abfd
->flags
|= DYNAMIC
;
2117 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= bfd_coff_aoutsz (abfd
))
2119 struct internal_aouthdr
*internal_a
=
2120 (struct internal_aouthdr
*) aouthdr
;
2121 struct xcoff_tdata
*xcoff
;
2123 xcoff
= xcoff_data (abfd
);
2124 # ifdef U803XTOCMAGIC
2125 xcoff
->xcoff64
= internal_f
->f_magic
== U803XTOCMAGIC
;
2129 xcoff
->full_aouthdr
= true;
2130 xcoff
->toc
= internal_a
->o_toc
;
2131 xcoff
->sntoc
= internal_a
->o_sntoc
;
2132 xcoff
->snentry
= internal_a
->o_snentry
;
2133 bfd_xcoff_text_align_power (abfd
) = internal_a
->o_algntext
;
2134 bfd_xcoff_data_align_power (abfd
) = internal_a
->o_algndata
;
2135 xcoff
->modtype
= internal_a
->o_modtype
;
2136 xcoff
->cputype
= internal_a
->o_cputype
;
2137 xcoff
->maxdata
= internal_a
->o_maxdata
;
2138 xcoff
->maxstack
= internal_a
->o_maxstack
;
2143 /* Set the flags field from the COFF header read in. */
2144 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
2149 /* FIXME: I'm not sure this is ever executed, since peicode.h
2150 defines coff_mkobject_hook. */
2151 if ((internal_f
->f_flags
& IMAGE_FILE_DEBUG_STRIPPED
) == 0)
2152 abfd
->flags
|= HAS_DEBUG
;
2159 /* Determine the machine architecture and type. FIXME: This is target
2160 dependent because the magic numbers are defined in the target
2161 dependent header files. But there is no particular need for this.
2162 If the magic numbers were moved to a separate file, this function
2163 would be target independent and would also be much more successful
2164 at linking together COFF files for different architectures. */
2167 coff_set_arch_mach_hook (bfd
*abfd
, void * filehdr
)
2169 unsigned long machine
;
2170 enum bfd_architecture arch
;
2171 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
2173 /* Zero selects the default machine for an arch. */
2175 switch (internal_f
->f_magic
)
2180 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler. */
2182 case I386_APPLE_MAGIC
:
2183 case I386_FREEBSD_MAGIC
:
2184 case I386_LINUX_MAGIC
:
2185 case I386_NETBSD_MAGIC
:
2186 arch
= bfd_arch_i386
;
2191 case AMD64_APPLE_MAGIC
:
2192 case AMD64_FREEBSD_MAGIC
:
2193 case AMD64_LINUX_MAGIC
:
2194 case AMD64_NETBSD_MAGIC
:
2195 arch
= bfd_arch_i386
;
2196 machine
= bfd_mach_x86_64
;
2201 arch
= bfd_arch_ia64
;
2208 arch
= bfd_arch_arm
;
2209 machine
= bfd_arm_get_mach_from_notes (abfd
, ARM_NOTE_SECTION
);
2210 if (machine
== bfd_mach_arm_unknown
)
2212 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
2214 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
2215 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
2216 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
2218 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
2219 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
2220 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
2221 /* The COFF header does not have enough bits available
2222 to cover all the different ARM architectures. So
2223 we interpret F_ARM_5, the highest flag value to mean
2224 "the highest ARM architecture known to BFD" which is
2225 currently the XScale. */
2226 case F_ARM_5
: machine
= bfd_mach_arm_XScale
; break;
2233 arch
= bfd_arch_aarch64
;
2234 machine
= internal_f
->f_flags
& F_AARCH64_ARCHITECTURE_MASK
;
2237 #ifdef LOONGARCH64MAGIC
2238 case LOONGARCH64MAGIC
:
2239 arch
= bfd_arch_loongarch
;
2240 machine
= internal_f
->f_flags
& F_LOONGARCH64_ARCHITECTURE_MASK
;
2245 arch
= bfd_arch_z80
;
2246 switch (internal_f
->f_flags
& F_MACHMASK
)
2248 case bfd_mach_z80strict
<< 12:
2249 case bfd_mach_z80
<< 12:
2250 case bfd_mach_z80n
<< 12:
2251 case bfd_mach_z80full
<< 12:
2252 case bfd_mach_r800
<< 12:
2253 case bfd_mach_gbz80
<< 12:
2254 case bfd_mach_z180
<< 12:
2255 case bfd_mach_ez80_z80
<< 12:
2256 case bfd_mach_ez80_adl
<< 12:
2257 machine
= ((unsigned)internal_f
->f_flags
& F_MACHMASK
) >> 12;
2266 arch
= bfd_arch_z8k
;
2267 switch (internal_f
->f_flags
& F_MACHMASK
)
2270 machine
= bfd_mach_z8001
;
2273 machine
= bfd_mach_z8002
;
2293 if (xcoff_data (abfd
)->cputype
!= -1)
2294 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
2297 /* We did not get a value from the a.out header. If the
2298 file has not been stripped, we may be able to get the
2299 architecture information from the first symbol, if it
2300 is a .file symbol. */
2301 if (obj_raw_syment_count (abfd
) == 0)
2306 struct internal_syment sym
;
2307 bfd_size_type amt
= bfd_coff_symesz (abfd
);
2309 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
2311 buf
= _bfd_malloc_and_read (abfd
, amt
, amt
);
2314 bfd_coff_swap_sym_in (abfd
, buf
, & sym
);
2315 if (sym
.n_sclass
== C_FILE
)
2316 cputype
= sym
.n_type
& 0xff;
2323 /* FIXME: We don't handle all cases here. */
2328 arch
= bfd_xcoff_architecture (abfd
);
2329 machine
= bfd_xcoff_machine (abfd
);
2333 arch
= bfd_arch_powerpc
;
2334 machine
= bfd_mach_ppc_601
;
2336 case 2: /* 64 bit PowerPC */
2337 arch
= bfd_arch_powerpc
;
2338 machine
= bfd_mach_ppc_620
;
2341 arch
= bfd_arch_powerpc
;
2342 machine
= bfd_mach_ppc
;
2345 arch
= bfd_arch_rs6000
;
2346 machine
= bfd_mach_rs6k
;
2353 #ifdef SH_ARCH_MAGIC_BIG
2354 case SH_ARCH_MAGIC_BIG
:
2355 case SH_ARCH_MAGIC_LITTLE
:
2357 case SH_ARCH_MAGIC_WINCE
:
2363 #ifdef MIPS_ARCH_MAGIC_WINCE
2364 case MIPS_ARCH_MAGIC_WINCE
:
2365 arch
= bfd_arch_mips
;
2371 #ifdef LYNXCOFFMAGIC
2374 arch
= bfd_arch_sparc
;
2380 arch
= bfd_arch_tic30
;
2385 #ifdef TICOFF_TARGET_ARCH
2386 /* This TI COFF section should be used by all new TI COFF v0 targets. */
2388 arch
= TICOFF_TARGET_ARCH
;
2389 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2395 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */
2396 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */
2399 switch (internal_f
->f_target_id
)
2403 arch
= TICOFF_TARGET_ARCH
;
2404 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2408 arch
= bfd_arch_obscure
;
2410 (_("unrecognized TI COFF target id '0x%x'"),
2411 internal_f
->f_target_id
);
2419 arch
= bfd_arch_mcore
;
2423 default: /* Unreadable input file type. */
2424 arch
= bfd_arch_obscure
;
2428 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2433 symname_in_debug_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2434 struct internal_syment
*sym ATTRIBUTE_UNUSED
)
2436 #ifdef SYMNAME_IN_DEBUG
2437 return SYMNAME_IN_DEBUG (sym
) != 0;
2446 #define FORCE_SYMNAMES_IN_STRINGS
2449 /* Handle the csect auxent of a C_EXT, C_AIX_WEAKEXT or C_HIDEXT symbol. */
2452 coff_pointerize_aux_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2453 combined_entry_type
*table_base
,
2454 combined_entry_type
*symbol
,
2455 unsigned int indaux
,
2456 combined_entry_type
*aux
)
2458 BFD_ASSERT (symbol
->is_sym
);
2459 int n_sclass
= symbol
->u
.syment
.n_sclass
;
2461 if (CSECT_SYM_P (n_sclass
)
2462 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2464 BFD_ASSERT (! aux
->is_sym
);
2465 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2467 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2468 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2469 aux
->fix_scnlen
= 1;
2472 /* Return TRUE to indicate that the caller should not do any
2473 further work on this auxent. */
2477 /* Return FALSE to indicate that this auxent should be handled by
2483 #define coff_pointerize_aux_hook 0
2484 #endif /* ! RS6000COFF_C */
2486 /* Print an aux entry. This returns TRUE if it has printed it. */
2489 coff_print_aux (bfd
*abfd ATTRIBUTE_UNUSED
,
2490 FILE *file ATTRIBUTE_UNUSED
,
2491 combined_entry_type
*table_base ATTRIBUTE_UNUSED
,
2492 combined_entry_type
*symbol ATTRIBUTE_UNUSED
,
2493 combined_entry_type
*aux ATTRIBUTE_UNUSED
,
2494 unsigned int indaux ATTRIBUTE_UNUSED
)
2496 BFD_ASSERT (symbol
->is_sym
);
2497 BFD_ASSERT (! aux
->is_sym
);
2499 if (CSECT_SYM_P (symbol
->u
.syment
.n_sclass
)
2500 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2502 /* This is a csect entry. */
2503 fprintf (file
, "AUX ");
2504 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2506 BFD_ASSERT (! aux
->fix_scnlen
);
2507 fprintf (file
, "val %5" PRId64
,
2508 (int64_t) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2512 fprintf (file
, "indx ");
2513 if (! aux
->fix_scnlen
)
2514 fprintf (file
, "%4" PRId64
,
2515 (int64_t) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2517 fprintf (file
, "%4ld",
2518 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2521 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2522 aux
->u
.auxent
.x_csect
.x_parmhash
,
2523 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2524 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2525 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2526 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2527 aux
->u
.auxent
.x_csect
.x_stab
,
2528 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2533 /* Return FALSE to indicate that no special action was taken. */
2541 To write relocations, the back end steps though the
2542 canonical relocation table and create an
2543 @code{internal_reloc}. The symbol index to use is removed from
2544 the @code{offset} field in the symbol table supplied. The
2545 address comes directly from the sum of the section base
2546 address and the relocation offset; the type is dug directly
2547 from the howto field. Then the @code{internal_reloc} is
2548 swapped into the shape of an @code{external_reloc} and written
2556 /* AUX's ld wants relocations to be sorted. */
2558 compare_arelent_ptr (const void * x
, const void * y
)
2560 const arelent
**a
= (const arelent
**) x
;
2561 const arelent
**b
= (const arelent
**) y
;
2562 bfd_size_type aadr
= (*a
)->address
;
2563 bfd_size_type badr
= (*b
)->address
;
2565 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2568 #endif /* TARG_AUX */
2571 coff_write_relocs (bfd
* abfd
, int first_undef
)
2575 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2578 struct external_reloc dst
;
2585 /* Sort relocations before we write them out. */
2588 amt
= s
->reloc_count
;
2589 amt
*= sizeof (arelent
*);
2590 p
= bfd_malloc (amt
);
2593 if (s
->reloc_count
> 0)
2598 memcpy (p
, s
->orelocation
, (size_t) amt
);
2599 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2604 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2607 #ifdef COFF_WITH_EXTENDED_RELOC_COUNTER
2608 if ((obj_pe (abfd
) || obj_go32 (abfd
)) && s
->reloc_count
>= 0xffff)
2610 /* Encode real count here as first reloc. */
2611 struct internal_reloc n
;
2613 memset (& n
, 0, sizeof (n
));
2614 /* Add one to count *this* reloc (grr). */
2615 n
.r_vaddr
= s
->reloc_count
+ 1;
2616 coff_swap_reloc_out (abfd
, &n
, &dst
);
2617 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2618 abfd
) != bfd_coff_relsz (abfd
))
2623 for (i
= 0; i
< s
->reloc_count
; i
++)
2625 struct internal_reloc n
;
2628 memset (& n
, 0, sizeof (n
));
2630 /* Now we've renumbered the symbols we know where the
2631 undefined symbols live in the table. Check the reloc
2632 entries for symbols who's output bfd isn't the right one.
2633 This is because the symbol was undefined (which means
2634 that all the pointers are never made to point to the same
2635 place). This is a bad thing,'cause the symbols attached
2636 to the output bfd are indexed, so that the relocation
2637 entries know which symbol index they point to. So we
2638 have to look up the output symbol here. */
2640 if (q
->sym_ptr_ptr
[0] != NULL
&& q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2643 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2644 asymbol
**outsyms
= abfd
->outsymbols
;
2646 for (j
= first_undef
; outsyms
[j
]; j
++)
2648 const char *intable
= outsyms
[j
]->name
;
2650 if (strcmp (intable
, sname
) == 0)
2652 /* Got a hit, so repoint the reloc. */
2653 q
->sym_ptr_ptr
= outsyms
+ j
;
2659 n
.r_vaddr
= q
->address
+ s
->vma
;
2662 /* The 29k const/consth reloc pair is a real kludge. The consth
2663 part doesn't have a symbol; it has an offset. So rebuilt
2665 if (q
->howto
->type
== R_IHCONST
)
2666 n
.r_symndx
= q
->addend
;
2669 if (q
->sym_ptr_ptr
&& q
->sym_ptr_ptr
[0] != NULL
)
2671 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2672 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
, s
))
2674 if ((*q
->sym_ptr_ptr
)->section
== bfd_abs_section_ptr
2675 && ((*q
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) != 0)
2677 /* This is a relocation relative to the absolute symbol. */
2681 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2682 /* Check to see if the symbol reloc points to a symbol
2683 we don't have in our symbol table. */
2684 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2686 bfd_set_error (bfd_error_bad_value
);
2687 /* xgettext:c-format */
2688 _bfd_error_handler (_("%pB: reloc against a non-existent"
2689 " symbol index: %ld"),
2696 #ifdef SWAP_OUT_RELOC_OFFSET
2697 n
.r_offset
= q
->addend
;
2701 /* Work out reloc type from what is required. */
2703 SELECT_RELOC (n
, q
->howto
);
2706 n
.r_type
= q
->howto
->type
;
2708 coff_swap_reloc_out (abfd
, &n
, &dst
);
2710 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2711 abfd
) != bfd_coff_relsz (abfd
))
2723 /* Set flags and magic number of a coff file from architecture and machine
2724 type. Result is TRUE if we can represent the arch&type, FALSE if not. */
2727 coff_set_flags (bfd
* abfd
,
2728 unsigned int *magicp ATTRIBUTE_UNUSED
,
2729 unsigned short *flagsp ATTRIBUTE_UNUSED
)
2731 switch (bfd_get_arch (abfd
))
2736 switch (bfd_get_mach (abfd
))
2738 case bfd_mach_z80strict
:
2741 case bfd_mach_z80full
:
2743 case bfd_mach_gbz80
:
2745 case bfd_mach_ez80_z80
:
2746 case bfd_mach_ez80_adl
:
2747 *flagsp
= bfd_get_mach (abfd
) << 12;
2759 switch (bfd_get_mach (abfd
))
2761 case bfd_mach_z8001
: *flagsp
= F_Z8001
; break;
2762 case bfd_mach_z8002
: *flagsp
= F_Z8002
; break;
2763 default: return false;
2769 case bfd_arch_tic30
:
2770 *magicp
= TIC30MAGIC
;
2774 #ifdef TICOFF_DEFAULT_MAGIC
2775 case TICOFF_TARGET_ARCH
:
2776 /* If there's no indication of which version we want, use the default. */
2778 *magicp
= TICOFF_DEFAULT_MAGIC
;
2781 /* We may want to output in a different COFF version. */
2782 switch (abfd
->xvec
->name
[4])
2785 *magicp
= TICOFF0MAGIC
;
2788 *magicp
= TICOFF1MAGIC
;
2791 *magicp
= TICOFF2MAGIC
;
2797 TICOFF_TARGET_MACHINE_SET (flagsp
, bfd_get_mach (abfd
));
2802 case bfd_arch_aarch64
:
2803 * magicp
= AARCH64MAGIC
;
2807 #ifdef LOONGARCH64MAGIC
2808 case bfd_arch_loongarch
:
2809 * magicp
= LOONGARCH64MAGIC
;
2816 * magicp
= ARMPEMAGIC
;
2818 * magicp
= ARMMAGIC
;
2821 if (APCS_SET (abfd
))
2823 if (APCS_26_FLAG (abfd
))
2824 * flagsp
|= F_APCS26
;
2826 if (APCS_FLOAT_FLAG (abfd
))
2827 * flagsp
|= F_APCS_FLOAT
;
2829 if (PIC_FLAG (abfd
))
2832 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2833 * flagsp
|= F_INTERWORK
;
2834 switch (bfd_get_mach (abfd
))
2836 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2837 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2838 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2839 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2840 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2841 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2842 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2843 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2844 See also the comment in coff_set_arch_mach_hook(). */
2845 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break;
2846 case bfd_mach_arm_5TE
: * flagsp
|= F_ARM_5
; break;
2847 case bfd_mach_arm_XScale
: * flagsp
|= F_ARM_5
; break;
2852 #if defined(I386MAGIC) || defined(AMD64MAGIC)
2854 #if defined(I386MAGIC)
2855 *magicp
= I386MAGIC
;
2858 /* Just overwrite the usual value if we're doing Lynx. */
2859 *magicp
= LYNXCOFFMAGIC
;
2861 #if defined AMD64MAGIC
2862 *magicp
= AMD64MAGIC
;
2869 *magicp
= IA64MAGIC
;
2873 #ifdef SH_ARCH_MAGIC_BIG
2875 #ifdef COFF_IMAGE_WITH_PE
2876 *magicp
= SH_ARCH_MAGIC_WINCE
;
2878 if (bfd_big_endian (abfd
))
2879 *magicp
= SH_ARCH_MAGIC_BIG
;
2881 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2886 #ifdef MIPS_ARCH_MAGIC_WINCE
2888 *magicp
= MIPS_ARCH_MAGIC_WINCE
;
2893 case bfd_arch_sparc
:
2894 *magicp
= SPARCMAGIC
;
2896 /* Just overwrite the usual value if we're doing Lynx. */
2897 *magicp
= LYNXCOFFMAGIC
;
2903 case bfd_arch_rs6000
:
2904 case bfd_arch_powerpc
:
2905 BFD_ASSERT (bfd_get_flavour (abfd
) == bfd_target_xcoff_flavour
);
2906 *magicp
= bfd_xcoff_magic_number (abfd
);
2911 case bfd_arch_mcore
:
2912 * magicp
= MCOREMAGIC
;
2916 default: /* Unknown architecture. */
2924 coff_set_arch_mach (bfd
* abfd
,
2925 enum bfd_architecture arch
,
2926 unsigned long machine
)
2929 unsigned short dummy2
;
2931 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
2934 if (arch
!= bfd_arch_unknown
2935 && ! coff_set_flags (abfd
, &dummy1
, &dummy2
))
2936 return false; /* We can't represent this type. */
2938 return true; /* We're easy... */
2941 #ifdef COFF_IMAGE_WITH_PE
2943 /* This is used to sort sections by VMA, as required by PE image
2947 sort_by_secaddr (const void * arg1
, const void * arg2
)
2949 const asection
*a
= *(const asection
**) arg1
;
2950 const asection
*b
= *(const asection
**) arg2
;
2952 if (a
->vma
< b
->vma
)
2954 else if (a
->vma
> b
->vma
)
2960 #endif /* COFF_IMAGE_WITH_PE */
2962 /* Calculate the file position for each section. */
2964 #define ALIGN_SECTIONS_IN_FILE
2966 #undef ALIGN_SECTIONS_IN_FILE
2970 coff_compute_section_file_positions (bfd
* abfd
)
2973 file_ptr sofar
= bfd_coff_filhsz (abfd
);
2975 unsigned int target_index
;
2976 #ifdef ALIGN_SECTIONS_IN_FILE
2977 asection
*previous
= NULL
;
2981 #ifdef COFF_IMAGE_WITH_PE
2982 unsigned int page_size
;
2984 if (coff_data (abfd
)->link_info
2985 || (pe_data (abfd
) && pe_data (abfd
)->pe_opthdr
.FileAlignment
))
2987 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
2989 /* If no file alignment has been set, default to one.
2990 This repairs 'ld -r' for arm-wince-pe target. */
2995 page_size
= PE_DEF_FILE_ALIGNMENT
;
2997 #ifdef COFF_PAGE_SIZE
2998 unsigned int page_size
= COFF_PAGE_SIZE
;
3003 /* On XCOFF, if we have symbols, set up the .debug section. */
3004 if (bfd_get_symcount (abfd
) > 0)
3007 bfd_size_type i
, symcount
;
3011 symcount
= bfd_get_symcount (abfd
);
3012 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
3014 coff_symbol_type
*cf
;
3016 cf
= coff_symbol_from (*symp
);
3018 && cf
->native
!= NULL
3019 && cf
->native
->is_sym
3020 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
3024 len
= strlen (bfd_asymbol_name (*symp
));
3025 if (len
> SYMNMLEN
|| bfd_coff_force_symnames_in_strings (abfd
))
3026 sz
+= len
+ 1 + bfd_coff_debug_string_prefix_length (abfd
);
3033 dsec
= bfd_make_section_old_way (abfd
, DOT_DEBUG
);
3037 dsec
->flags
|= SEC_HAS_CONTENTS
;
3042 if (bfd_get_start_address (abfd
))
3043 /* A start address may have been added to the original file. In this
3044 case it will need an optional header to record it. */
3045 abfd
->flags
|= EXEC_P
;
3047 if (abfd
->flags
& EXEC_P
)
3048 sofar
+= bfd_coff_aoutsz (abfd
);
3050 else if (xcoff_data (abfd
)->full_aouthdr
)
3051 sofar
+= bfd_coff_aoutsz (abfd
);
3053 sofar
+= SMALL_AOUTSZ
;
3056 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
3059 /* XCOFF handles overflows in the reloc and line number count fields
3060 by allocating a new section header to hold the correct counts. */
3061 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3062 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3063 sofar
+= bfd_coff_scnhsz (abfd
);
3066 #ifdef COFF_IMAGE_WITH_PE
3068 /* PE requires the sections to be in memory order when listed in
3069 the section headers. It also does not like empty loadable
3070 sections. The sections apparently do not have to be in the
3071 right order in the image file itself, but we do need to get the
3072 target_index values right. */
3075 asection
**section_list
;
3079 #ifdef COFF_PAGE_SIZE
3080 /* Clear D_PAGED if section / file alignment aren't suitable for
3081 paging at COFF_PAGE_SIZE granularity. */
3082 if (pe_data (abfd
)->pe_opthdr
.SectionAlignment
< COFF_PAGE_SIZE
3083 || page_size
< COFF_PAGE_SIZE
)
3084 abfd
->flags
&= ~D_PAGED
;
3088 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3091 /* We allocate an extra cell to simplify the final loop. */
3092 amt
= sizeof (struct asection
*) * (count
+ 1);
3093 section_list
= (asection
**) bfd_malloc (amt
);
3094 if (section_list
== NULL
)
3098 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3100 section_list
[i
] = current
;
3103 section_list
[i
] = NULL
;
3105 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
3107 /* Rethread the linked list into sorted order; at the same time,
3108 assign target_index values. */
3110 abfd
->sections
= NULL
;
3111 abfd
->section_last
= NULL
;
3112 for (i
= 0; i
< count
; i
++)
3114 current
= section_list
[i
];
3115 bfd_section_list_append (abfd
, current
);
3117 /* Later, if the section has zero size, we'll be throwing it
3118 away, so we don't want to number it now. Note that having
3119 a zero size and having real contents are different
3120 concepts: .bss has no contents, but (usually) non-zero
3122 if (current
->size
== 0)
3124 /* Discard. However, it still might have (valid) symbols
3125 in it, so arbitrarily set it to section 1 (indexing is
3126 1-based here; usually .text). __end__ and other
3127 contents of .endsection really have this happen.
3128 FIXME: This seems somewhat dubious. */
3129 current
->target_index
= 1;
3132 current
->target_index
= target_index
++;
3135 free (section_list
);
3137 #else /* ! COFF_IMAGE_WITH_PE */
3139 /* Set the target_index field. */
3141 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3142 current
->target_index
= target_index
++;
3144 #endif /* ! COFF_IMAGE_WITH_PE */
3146 if (target_index
>= bfd_coff_max_nscns (abfd
))
3148 bfd_set_error (bfd_error_file_too_big
);
3150 /* xgettext:c-format */
3151 (_("%pB: too many sections (%d)"), abfd
, target_index
);
3155 align_adjust
= false;
3156 for (current
= abfd
->sections
;
3158 current
= current
->next
)
3160 #ifdef COFF_IMAGE_WITH_PE
3161 /* With PE we have to pad each section to be a multiple of its
3162 page size too, and remember both sizes. */
3163 if (coff_section_data (abfd
, current
) == NULL
)
3165 size_t amt
= sizeof (struct coff_section_tdata
);
3167 current
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
3168 if (current
->used_by_bfd
== NULL
)
3171 if (pei_section_data (abfd
, current
) == NULL
)
3173 size_t amt
= sizeof (struct pei_section_tdata
);
3175 coff_section_data (abfd
, current
)->tdata
= bfd_zalloc (abfd
, amt
);
3176 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
3179 if (pei_section_data (abfd
, current
)->virt_size
== 0)
3180 pei_section_data (abfd
, current
)->virt_size
= current
->size
;
3183 /* Only deal with sections which have contents. */
3184 if (!(current
->flags
& SEC_HAS_CONTENTS
))
3187 current
->rawsize
= current
->size
;
3189 #ifdef COFF_IMAGE_WITH_PE
3190 /* Make sure we skip empty sections in a PE image. */
3191 if (current
->size
== 0)
3195 /* Align the sections in the file to the same boundary on
3196 which they are aligned in virtual memory. */
3197 #ifdef ALIGN_SECTIONS_IN_FILE
3198 if ((abfd
->flags
& EXEC_P
) != 0)
3200 /* Make sure this section is aligned on the right boundary - by
3201 padding the previous section up if necessary. */
3204 #ifdef COFF_IMAGE_WITH_PE
3205 sofar
= BFD_ALIGN (sofar
, page_size
);
3207 sofar
= BFD_ALIGN (sofar
, (bfd_vma
) 1 << current
->alignment_power
);
3211 /* Make sure the file offset and the vma of .text/.data are at the
3212 same page offset, so that the file can be mmap'ed without being
3213 relocated. Failing that, AIX is able to load and execute the
3214 program, but it will be silently relocated (possible as
3215 executables are PIE). But the relocation is slightly costly and
3216 complexify the use of addr2line or gdb. So better to avoid it,
3217 like does the native linker. Usually gnu ld makes sure that
3218 the vma of .text is the file offset so this issue shouldn't
3219 appear unless you are stripping such an executable.
3221 AIX loader checks the text section alignment of (vma - filepos),
3222 and the native linker doesn't try to align the text sections.
3225 0 .text 000054cc 10000128 10000128 00000128 2**5
3226 CONTENTS, ALLOC, LOAD, CODE
3228 Don't perform the above tweak if the previous one is .tdata,
3229 as it will increase the memory allocated for every threads
3230 created and not just improve performances with gdb.
3233 if ((!strcmp (current
->name
, _TEXT
)
3234 || !strcmp (current
->name
, _DATA
))
3235 && (previous
== NULL
|| strcmp(previous
->name
, _TDATA
)))
3237 bfd_vma align
= 4096;
3238 bfd_vma sofar_off
= sofar
% align
;
3239 bfd_vma vma_off
= current
->vma
% align
;
3241 if (vma_off
> sofar_off
)
3242 sofar
+= vma_off
- sofar_off
;
3243 else if (vma_off
< sofar_off
)
3244 sofar
+= align
+ vma_off
- sofar_off
;
3247 if (previous
!= NULL
)
3248 previous
->size
+= sofar
- old_sofar
;
3253 /* In demand paged files the low order bits of the file offset
3254 must match the low order bits of the virtual address. */
3255 #ifdef COFF_PAGE_SIZE
3256 if ((abfd
->flags
& D_PAGED
) != 0
3257 && (current
->flags
& SEC_ALLOC
) != 0)
3258 sofar
+= (current
->vma
- (bfd_vma
) sofar
) % page_size
;
3260 current
->filepos
= sofar
;
3262 #ifdef COFF_IMAGE_WITH_PE
3263 /* Set the padded size. */
3264 current
->size
= (current
->size
+ page_size
- 1) & -page_size
;
3267 sofar
+= current
->size
;
3269 #ifdef ALIGN_SECTIONS_IN_FILE
3270 /* Make sure that this section is of the right size too. */
3271 if ((abfd
->flags
& EXEC_P
) == 0)
3273 bfd_size_type old_size
;
3275 old_size
= current
->size
;
3276 current
->size
= BFD_ALIGN (current
->size
,
3277 (bfd_vma
) 1 << current
->alignment_power
);
3278 align_adjust
= current
->size
!= old_size
;
3279 sofar
+= current
->size
- old_size
;
3284 #ifdef COFF_IMAGE_WITH_PE
3285 sofar
= BFD_ALIGN (sofar
, page_size
);
3287 sofar
= BFD_ALIGN (sofar
, (bfd_vma
) 1 << current
->alignment_power
);
3289 align_adjust
= sofar
!= old_sofar
;
3290 current
->size
+= sofar
- old_sofar
;
3294 #ifdef COFF_IMAGE_WITH_PE
3295 /* For PE we need to make sure we pad out to the aligned
3296 size, in case the caller only writes out data to the
3298 if (pei_section_data (abfd
, current
)->virt_size
< current
->size
)
3299 align_adjust
= true;
3303 /* Force .lib sections to start at zero. The vma is then
3304 incremented in coff_set_section_contents. This is right for
3306 if (strcmp (current
->name
, _LIB
) == 0)
3307 bfd_set_section_vma (current
, 0);
3310 #ifdef ALIGN_SECTIONS_IN_FILE
3315 /* It is now safe to write to the output file. If we needed an
3316 alignment adjustment for the last section, then make sure that
3317 there is a byte at offset sofar. If there are no symbols and no
3318 relocs, then nothing follows the last section. If we don't force
3319 the last byte out, then the file may appear to be truncated. */
3325 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
3326 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3330 /* Make sure the relocations are aligned. We don't need to make
3331 sure that this byte exists, because it will only matter if there
3332 really are relocs. */
3333 sofar
= BFD_ALIGN (sofar
,
3334 (bfd_vma
) 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
3336 obj_relocbase (abfd
) = sofar
;
3337 abfd
->output_has_begun
= true;
3342 #ifdef COFF_IMAGE_WITH_PE
3345 coff_read_word (bfd
*abfd
, unsigned int *value
, unsigned int *pelength
)
3350 status
= bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3358 *value
= (unsigned int) b
[0];
3360 *value
= (unsigned int) (b
[0] + (b
[1] << 8));
3362 *pelength
+= status
;
3368 coff_compute_checksum (bfd
*abfd
, unsigned int *pelength
)
3377 filepos
= (file_ptr
) 0;
3381 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
3384 more_data
= coff_read_word (abfd
, &value
, pelength
);
3386 total
= 0xffff & (total
+ (total
>> 0x10));
3391 return (0xffff & (total
+ (total
>> 0x10)));
3395 coff_apply_checksum (bfd
*abfd
)
3397 unsigned int computed
;
3398 unsigned int checksum
= 0;
3399 unsigned int peheader
;
3400 unsigned int pelength
;
3402 if (bfd_seek (abfd
, 0x3c, SEEK_SET
) != 0)
3405 if (!coff_read_word (abfd
, &peheader
, &pelength
))
3408 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3412 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3414 if (bfd_seek (abfd
, peheader
, SEEK_SET
) != 0)
3417 computed
= coff_compute_checksum (abfd
, &pelength
);
3419 checksum
= computed
+ pelength
;
3421 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3424 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3429 #endif /* COFF_IMAGE_WITH_PE */
3432 coff_write_object_contents (bfd
* abfd
)
3435 bool hasrelocs
= false;
3436 bool haslinno
= false;
3437 #ifdef COFF_IMAGE_WITH_PE
3438 bool hasdebug
= false;
3441 file_ptr reloc_base
;
3442 file_ptr lineno_base
;
3444 unsigned long reloc_size
= 0, reloc_count
= 0;
3445 unsigned long lnno_size
= 0;
3446 bool long_section_names
;
3447 asection
*text_sec
= NULL
;
3448 asection
*data_sec
= NULL
;
3449 asection
*bss_sec
= NULL
;
3451 asection
*tdata_sec
= NULL
;
3452 asection
*tbss_sec
= NULL
;
3454 struct internal_filehdr internal_f
;
3455 struct internal_aouthdr internal_a
;
3456 #ifdef COFF_LONG_SECTION_NAMES
3457 size_t string_size
= STRING_SIZE_SIZE
;
3460 bfd_set_error (bfd_error_system_call
);
3462 /* Make a pass through the symbol table to count line number entries and
3463 put them into the correct asections. */
3464 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3466 if (! abfd
->output_has_begun
)
3468 if (! coff_compute_section_file_positions (abfd
))
3472 reloc_base
= obj_relocbase (abfd
);
3474 /* Work out the size of the reloc and linno areas. */
3476 for (current
= abfd
->sections
; current
!= NULL
; current
=
3479 #ifdef COFF_WITH_EXTENDED_RELOC_COUNTER
3480 /* We store the actual reloc count in the first reloc's addr. */
3481 if ((obj_pe (abfd
) || obj_go32 (abfd
)) && current
->reloc_count
>= 0xffff)
3484 reloc_count
+= current
->reloc_count
;
3487 reloc_size
= reloc_count
* bfd_coff_relsz (abfd
);
3489 lineno_base
= reloc_base
+ reloc_size
;
3490 sym_base
= lineno_base
+ lnno_size
;
3492 /* Indicate in each section->line_filepos its actual file address. */
3493 for (current
= abfd
->sections
; current
!= NULL
; current
=
3496 if (current
->lineno_count
)
3498 current
->line_filepos
= lineno_base
;
3499 current
->moving_line_filepos
= lineno_base
;
3500 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3503 current
->line_filepos
= 0;
3505 if (current
->reloc_count
)
3507 current
->rel_filepos
= reloc_base
;
3508 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3509 #ifdef COFF_WITH_EXTENDED_RELOC_COUNTER
3510 /* Extra reloc to hold real count. */
3511 if ((obj_pe (abfd
) || obj_go32 (abfd
)) && current
->reloc_count
>= 0xffff)
3512 reloc_base
+= bfd_coff_relsz (abfd
);
3516 current
->rel_filepos
= 0;
3519 /* Write section headers to the file. */
3520 internal_f
.f_nscns
= 0;
3522 if ((abfd
->flags
& EXEC_P
) != 0)
3523 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3526 scn_base
= bfd_coff_filhsz (abfd
);
3529 if (xcoff_data (abfd
)->full_aouthdr
)
3530 scn_base
+= bfd_coff_aoutsz (abfd
);
3532 scn_base
+= SMALL_AOUTSZ
;
3537 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3540 long_section_names
= false;
3541 for (current
= abfd
->sections
;
3543 current
= current
->next
)
3545 struct internal_scnhdr section
;
3546 #ifdef COFF_IMAGE_WITH_PE
3547 bool is_reloc_section
= false;
3549 if (strcmp (current
->name
, DOT_RELOC
) == 0)
3551 is_reloc_section
= true;
3553 pe_data (abfd
)->has_reloc_section
= 1;
3557 internal_f
.f_nscns
++;
3559 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3561 #ifdef COFF_LONG_SECTION_NAMES
3562 /* Handle long section names as in PE. This must be compatible
3563 with the code in coff_write_symbols and _bfd_coff_final_link. */
3564 if (bfd_coff_long_section_names (abfd
))
3568 len
= strlen (current
->name
);
3571 /* The s_name field is defined to be NUL-padded but need not be
3572 NUL-terminated. We use a temporary buffer so that we can still
3573 sprintf all eight chars without splatting a terminating NUL
3574 over the first byte of the following member (s_paddr). */
3575 /* PR 21096: The +20 is to stop a bogus warning from gcc7 about
3576 a possible buffer overflow. */
3577 char s_name_buf
[SCNNMLEN
+ 1 + 20];
3579 /* An inherent limitation of the /nnnnnnn notation used to indicate
3580 the offset of the long name in the string table is that we
3581 cannot address entries beyone the ten million byte boundary. */
3582 if (string_size
>= 10000000)
3584 bfd_set_error (bfd_error_file_too_big
);
3586 /* xgettext:c-format */
3587 (_("%pB: section %pA: string table overflow at offset %ld"),
3588 abfd
, current
, (unsigned long) string_size
);
3592 /* We do not need to use snprintf here as we have already verfied
3593 that string_size is not too big, plus we have an overlarge
3594 buffer, just in case. */
3595 sprintf (s_name_buf
, "/%lu", (unsigned long) string_size
);
3596 /* Then strncpy takes care of any padding for us. */
3597 strncpy (section
.s_name
, s_name_buf
, SCNNMLEN
);
3598 string_size
+= len
+ 1;
3599 long_section_names
= true;
3605 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3606 Ian Taylor <ian@cygnus.com>. */
3607 if (strcmp (current
->name
, _LIB
) == 0)
3608 section
.s_vaddr
= 0;
3611 section
.s_vaddr
= current
->vma
;
3612 section
.s_paddr
= current
->lma
;
3613 section
.s_size
= current
->size
;
3614 #ifdef coff_get_section_load_page
3615 section
.s_page
= coff_get_section_load_page (current
);
3621 section
.s_paddr
= 0;
3623 #ifdef COFF_IMAGE_WITH_PE
3624 /* Reminder: s_paddr holds the virtual size of the section. */
3625 if (coff_section_data (abfd
, current
) != NULL
3626 && pei_section_data (abfd
, current
) != NULL
)
3627 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3629 section
.s_paddr
= 0;
3632 /* If this section has no size or is unloadable then the scnptr
3634 if (current
->size
== 0
3635 || (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3636 section
.s_scnptr
= 0;
3638 section
.s_scnptr
= current
->filepos
;
3640 section
.s_relptr
= current
->rel_filepos
;
3641 section
.s_lnnoptr
= current
->line_filepos
;
3642 section
.s_nreloc
= current
->reloc_count
;
3643 section
.s_nlnno
= current
->lineno_count
;
3644 #ifndef COFF_IMAGE_WITH_PE
3645 /* In PEI, relocs come in the .reloc section. */
3646 if (current
->reloc_count
!= 0)
3649 if (current
->lineno_count
!= 0)
3651 #ifdef COFF_IMAGE_WITH_PE
3652 if ((current
->flags
& SEC_DEBUGGING
) != 0
3653 && ! is_reloc_section
)
3659 /* Indicate the use of an XCOFF overflow section header. */
3660 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3662 section
.s_nreloc
= 0xffff;
3663 section
.s_nlnno
= 0xffff;
3668 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3670 if (!strcmp (current
->name
, _TEXT
))
3672 else if (!strcmp (current
->name
, _DATA
))
3674 else if (!strcmp (current
->name
, _BSS
))
3677 else if (!strcmp (current
->name
, _TDATA
))
3678 tdata_sec
= current
;
3679 else if (!strcmp (current
->name
, _TBSS
))
3684 #ifdef COFF_ENCODE_ALIGNMENT
3685 if (COFF_ENCODE_ALIGNMENT (abfd
, section
, current
->alignment_power
)
3686 && (COFF_DECODE_ALIGNMENT (section
.s_flags
)
3687 != current
->alignment_power
))
3689 bool warn
= (coff_data (abfd
)->link_info
3690 && !bfd_link_relocatable (coff_data (abfd
)->link_info
));
3693 /* xgettext:c-format */
3694 (_("%pB:%s section %s: alignment 2**%u not representable"),
3695 abfd
, warn
? " warning:" : "", current
->name
,
3696 current
->alignment_power
);
3699 bfd_set_error (bfd_error_nonrepresentable_section
);
3705 #ifdef COFF_IMAGE_WITH_PE
3706 /* Suppress output of the sections if they are null. ld
3707 includes the bss and data sections even if there is no size
3708 assigned to them. NT loader doesn't like it if these section
3709 headers are included if the sections themselves are not
3710 needed. See also coff_compute_section_file_positions. */
3711 if (section
.s_size
== 0)
3712 internal_f
.f_nscns
--;
3717 bfd_size_type amt
= bfd_coff_scnhsz (abfd
);
3719 if (bfd_coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3720 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3725 /* PE stores COMDAT section information in the symbol table. If
3726 this section is supposed to have some COMDAT info, track down
3727 the symbol in the symbol table and modify it. */
3728 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3730 unsigned int i
, count
;
3732 coff_symbol_type
*csym
= NULL
;
3736 count
= bfd_get_symcount (abfd
);
3737 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3739 if ((*psym
)->section
!= current
)
3742 /* Remember the location of the first symbol in this
3744 if (psymsec
== NULL
)
3747 /* See if this is the section symbol. */
3748 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3750 csym
= coff_symbol_from (*psym
);
3752 || csym
->native
== NULL
3753 || ! csym
->native
->is_sym
3754 || csym
->native
->u
.syment
.n_numaux
< 1
3755 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3756 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3759 /* Here *PSYM is the section symbol for CURRENT. */
3766 Note that we might not if we're converting the file from
3767 some other object file format. */
3770 combined_entry_type
*aux
;
3772 /* We don't touch the x_checksum field. The
3773 x_associated field is not currently supported. */
3775 aux
= csym
->native
+ 1;
3776 BFD_ASSERT (! aux
->is_sym
);
3777 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3779 case SEC_LINK_DUPLICATES_DISCARD
:
3780 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3783 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3784 aux
->u
.auxent
.x_scn
.x_comdat
=
3785 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3788 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3789 aux
->u
.auxent
.x_scn
.x_comdat
=
3790 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3793 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3794 aux
->u
.auxent
.x_scn
.x_comdat
=
3795 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3799 /* The COMDAT symbol must be the first symbol from this
3800 section in the symbol table. In order to make this
3801 work, we move the COMDAT symbol before the first
3802 symbol we found in the search above. It's OK to
3803 rearrange the symbol table at this point, because
3804 coff_renumber_symbols is going to rearrange it
3805 further and fix up all the aux entries. */
3806 if (psym
!= psymsec
)
3812 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3813 pcopy
[0] = pcopy
[-1];
3818 #endif /* COFF_WITH_PE */
3823 /* XCOFF handles overflows in the reloc and line number count fields
3824 by creating a new section header to hold the correct values. */
3825 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3827 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3829 struct internal_scnhdr scnhdr
;
3833 internal_f
.f_nscns
++;
3834 memcpy (scnhdr
.s_name
, ".ovrflo", 8);
3835 scnhdr
.s_paddr
= current
->reloc_count
;
3836 scnhdr
.s_vaddr
= current
->lineno_count
;
3838 scnhdr
.s_scnptr
= 0;
3839 scnhdr
.s_relptr
= current
->rel_filepos
;
3840 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3841 scnhdr
.s_nreloc
= current
->target_index
;
3842 scnhdr
.s_nlnno
= current
->target_index
;
3843 scnhdr
.s_flags
= STYP_OVRFLO
;
3844 amt
= bfd_coff_scnhsz (abfd
);
3845 if (bfd_coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3846 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3853 #if defined (COFF_GO32_EXE) || defined (COFF_GO32)
3854 /* Pad section headers. */
3855 if ((abfd
->flags
& EXEC_P
) && abfd
->sections
!= NULL
)
3857 file_ptr cur_ptr
= scn_base
3858 + abfd
->section_count
* bfd_coff_scnhsz (abfd
);
3859 long fill_size
= (abfd
->sections
->filepos
- cur_ptr
);
3860 bfd_byte
*b
= bfd_zmalloc (fill_size
);
3863 bfd_bwrite (b
, fill_size
, abfd
);
3869 /* OK, now set up the filehdr... */
3871 /* Don't include the internal abs section in the section count */
3873 /* We will NOT put a fucking timestamp in the header here. Every time you
3874 put it back, I will come in and take it out again. I'm sorry. This
3875 field does not belong here. We fill it with a 0 so it compares the
3876 same but is not a reasonable time. -- gnu@cygnus.com */
3877 internal_f
.f_timdat
= 0;
3878 internal_f
.f_flags
= 0;
3880 if (abfd
->flags
& EXEC_P
)
3881 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3884 internal_f
.f_opthdr
= 0;
3887 if (xcoff_data (abfd
)->full_aouthdr
)
3888 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3890 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
3896 internal_f
.f_flags
|= F_RELFLG
;
3898 internal_f
.f_flags
|= F_LNNO
;
3899 if (abfd
->flags
& EXEC_P
)
3900 internal_f
.f_flags
|= F_EXEC
;
3901 #ifdef COFF_IMAGE_WITH_PE
3903 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
3904 if (pe_data (abfd
)->real_flags
& IMAGE_FILE_LARGE_ADDRESS_AWARE
)
3905 internal_f
.f_flags
|= IMAGE_FILE_LARGE_ADDRESS_AWARE
;
3908 #if !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
3910 internal_f
.f_flags
|= IMAGE_FILE_32BIT_MACHINE
;
3912 if (bfd_little_endian (abfd
))
3913 internal_f
.f_flags
|= F_AR32WR
;
3915 internal_f
.f_flags
|= F_AR32W
;
3920 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
3921 but it doesn't hurt to set it internally. */
3922 internal_f
.f_target_id
= TI_TARGET_ID
;
3925 /* FIXME, should do something about the other byte orders and
3929 if ((abfd
->flags
& DYNAMIC
) != 0)
3930 internal_f
.f_flags
|= F_SHROBJ
;
3931 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
3932 internal_f
.f_flags
|= F_DYNLOAD
;
3935 memset (&internal_a
, 0, sizeof internal_a
);
3937 /* Set up architecture-dependent stuff. */
3939 unsigned int magic
= 0;
3940 unsigned short flags
= 0;
3942 coff_set_flags (abfd
, &magic
, &flags
);
3943 internal_f
.f_magic
= magic
;
3944 internal_f
.f_flags
|= flags
;
3945 /* ...and the "opt"hdr... */
3947 #ifdef TICOFF_AOUT_MAGIC
3948 internal_a
.magic
= TICOFF_AOUT_MAGIC
;
3949 #define __A_MAGIC_SET__
3953 #define __A_MAGIC_SET__
3954 internal_a
.magic
= ZMAGIC
;
3957 #if defined(AARCH64)
3958 #define __A_MAGIC_SET__
3959 internal_a
.magic
= ZMAGIC
;
3962 #if defined(LOONGARCH64)
3963 #define __A_MAGIC_SET__
3964 internal_a
.magic
= ZMAGIC
;
3967 #if defined MCORE_PE
3968 #define __A_MAGIC_SET__
3969 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3973 #define __A_MAGIC_SET__
3975 internal_a
.magic
= LYNXCOFFMAGIC
;
3977 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR64_MAGIC
;
3979 internal_a
.magic
= ZMAGIC
;
3984 #define __A_MAGIC_SET__
3985 internal_a
.magic
= PE32PMAGIC
;
3989 #define __A_MAGIC_SET__
3991 internal_a
.magic
= LYNXCOFFMAGIC
;
3996 #define __A_MAGIC_SET__
3997 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
3998 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
3999 RS6K_AOUTHDR_OMAGIC
;
4002 #if defined(SH) && defined(COFF_WITH_PE)
4003 #define __A_MAGIC_SET__
4004 internal_a
.magic
= SH_PE_MAGIC
;
4007 #if defined(MIPS) && defined(COFF_WITH_PE)
4008 #define __A_MAGIC_SET__
4009 internal_a
.magic
= MIPS_PE_MAGIC
;
4012 #ifndef __A_MAGIC_SET__
4013 #include "Your aouthdr magic number is not being set!"
4015 #undef __A_MAGIC_SET__
4020 /* XCOFF 32bit needs this to have new behaviour for n_type field. */
4021 internal_a
.vstamp
= 2;
4023 /* FIXME: Does anybody ever set this to another value? */
4024 internal_a
.vstamp
= 0;
4027 /* Now should write relocs, strings, syms. */
4028 obj_sym_filepos (abfd
) = sym_base
;
4030 if (bfd_get_symcount (abfd
) != 0)
4034 if (!coff_renumber_symbols (abfd
, &firstundef
))
4036 coff_mangle_symbols (abfd
);
4037 if (! coff_write_symbols (abfd
))
4039 if (! coff_write_linenumbers (abfd
))
4041 if (! coff_write_relocs (abfd
, firstundef
))
4044 #ifdef COFF_LONG_SECTION_NAMES
4045 else if (long_section_names
&& ! obj_coff_strings_written (abfd
))
4047 /* If we have long section names we have to write out the string
4048 table even if there are no symbols. */
4049 if (! coff_write_symbols (abfd
))
4053 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
4054 backend linker, and obj_raw_syment_count is not valid until after
4055 coff_write_symbols is called. */
4056 if (obj_raw_syment_count (abfd
) != 0)
4058 internal_f
.f_symptr
= sym_base
;
4060 /* AIX appears to require that F_RELFLG not be set if there are
4061 local symbols but no relocations. */
4062 internal_f
.f_flags
&=~ F_RELFLG
;
4067 if (long_section_names
)
4068 internal_f
.f_symptr
= sym_base
;
4070 internal_f
.f_symptr
= 0;
4071 internal_f
.f_flags
|= F_LSYMS
;
4076 internal_a
.tsize
= text_sec
->size
;
4077 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
4081 internal_a
.dsize
= data_sec
->size
;
4082 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
4086 internal_a
.bsize
= bss_sec
->size
;
4087 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
4088 internal_a
.data_start
= bss_sec
->vma
;
4091 internal_a
.entry
= bfd_get_start_address (abfd
);
4092 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
4095 if (xcoff_data (abfd
)->full_aouthdr
)
4098 asection
*loader_sec
;
4100 internal_a
.vstamp
= 2;
4102 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
4103 if (internal_a
.o_snentry
== 0)
4104 internal_a
.entry
= (bfd_vma
) -1;
4106 if (text_sec
!= NULL
)
4108 internal_a
.o_sntext
= text_sec
->target_index
;
4109 internal_a
.o_algntext
= bfd_section_alignment (text_sec
);
4113 internal_a
.o_sntext
= 0;
4114 internal_a
.o_algntext
= 0;
4116 if (data_sec
!= NULL
)
4118 internal_a
.o_sndata
= data_sec
->target_index
;
4119 internal_a
.o_algndata
= bfd_section_alignment (data_sec
);
4123 internal_a
.o_sndata
= 0;
4124 internal_a
.o_algndata
= 0;
4126 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
4127 if (loader_sec
!= NULL
)
4128 internal_a
.o_snloader
= loader_sec
->target_index
;
4130 internal_a
.o_snloader
= 0;
4131 if (bss_sec
!= NULL
)
4132 internal_a
.o_snbss
= bss_sec
->target_index
;
4134 internal_a
.o_snbss
= 0;
4136 if (tdata_sec
!= NULL
)
4138 internal_a
.o_sntdata
= tdata_sec
->target_index
;
4139 /* TODO: o_flags should be set to RS6K_AOUTHDR_TLS_LE
4140 if there is at least one R_TLS_LE relocations. */
4141 internal_a
.o_flags
= 0;
4143 internal_a
.o_x64flags
= 0;
4148 internal_a
.o_sntdata
= 0;
4149 internal_a
.o_flags
= 0;
4151 internal_a
.o_x64flags
= 0;
4154 if (tbss_sec
!= NULL
)
4155 internal_a
.o_sntbss
= tbss_sec
->target_index
;
4157 internal_a
.o_sntbss
= 0;
4159 toc
= xcoff_data (abfd
)->toc
;
4160 internal_a
.o_toc
= toc
;
4161 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
4163 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
4164 if (xcoff_data (abfd
)->cputype
!= -1)
4165 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
4168 switch (bfd_get_arch (abfd
))
4170 case bfd_arch_rs6000
:
4171 internal_a
.o_cputype
= 4;
4173 case bfd_arch_powerpc
:
4174 if (bfd_get_mach (abfd
) == bfd_mach_ppc
)
4175 internal_a
.o_cputype
= 3;
4176 else if (bfd_get_mach (abfd
) == bfd_mach_ppc_620
)
4177 internal_a
.o_cputype
= 2;
4179 internal_a
.o_cputype
= 1;
4185 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
4186 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
4192 /* After object contents are finalized so we can compute a reasonable hash,
4193 but before header is written so we can update it to point to debug directory. */
4194 struct pe_tdata
*pe
= pe_data (abfd
);
4196 if (pe
->build_id
.after_write_object_contents
!= NULL
)
4197 (*pe
->build_id
.after_write_object_contents
) (abfd
);
4201 /* Now write header. */
4202 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
4207 bfd_size_type amount
= bfd_coff_filhsz (abfd
);
4209 buff
= (char *) bfd_malloc (amount
);
4213 bfd_coff_swap_filehdr_out (abfd
, & internal_f
, buff
);
4214 amount
= bfd_bwrite (buff
, amount
, abfd
);
4218 if (amount
!= bfd_coff_filhsz (abfd
))
4222 if (abfd
->flags
& EXEC_P
)
4224 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4225 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4227 bfd_size_type amount
= bfd_coff_aoutsz (abfd
);
4229 buff
= (char *) bfd_malloc (amount
);
4233 coff_swap_aouthdr_out (abfd
, & internal_a
, buff
);
4234 amount
= bfd_bwrite (buff
, amount
, abfd
);
4238 if (amount
!= bfd_coff_aoutsz (abfd
))
4241 #ifdef COFF_IMAGE_WITH_PE
4242 if (! coff_apply_checksum (abfd
))
4253 /* XCOFF32 seems to always write at least a small a.out header. */
4254 coff_swap_aouthdr_out (abfd
, & internal_a
, & buff
);
4255 if (xcoff_data (abfd
)->full_aouthdr
)
4256 size
= bfd_coff_aoutsz (abfd
);
4258 size
= SMALL_AOUTSZ
;
4259 if (bfd_bwrite (& buff
, (bfd_size_type
) size
, abfd
) != size
)
4269 coff_set_section_contents (bfd
* abfd
,
4271 const void * location
,
4273 bfd_size_type count
)
4275 if (! abfd
->output_has_begun
) /* Set by bfd.c handler. */
4277 if (! coff_compute_section_file_positions (abfd
))
4281 #if defined(_LIB) && !defined(TARG_AUX)
4282 /* The physical address field of a .lib section is used to hold the
4283 number of shared libraries in the section. This code counts the
4284 number of sections being written, and increments the lma field
4287 I have found no documentation on the contents of this section.
4288 Experimentation indicates that the section contains zero or more
4289 records, each of which has the following structure:
4291 - a (four byte) word holding the length of this record, in words,
4292 - a word that always seems to be set to "2",
4293 - the path to a shared library, null-terminated and then padded
4294 to a whole word boundary.
4296 bfd_assert calls have been added to alert if an attempt is made
4297 to write a section which doesn't follow these assumptions. The
4298 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4299 <robertl@arnet.com> (Thanks!).
4301 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4302 if (strcmp (section
->name
, _LIB
) == 0)
4304 bfd_byte
*rec
, *recend
;
4306 rec
= (bfd_byte
*) location
;
4307 recend
= rec
+ count
;
4308 while (recend
- rec
>= 4)
4310 size_t len
= bfd_get_32 (abfd
, rec
);
4311 if (len
== 0 || len
> (size_t) (recend
- rec
) / 4)
4317 BFD_ASSERT (rec
== recend
);
4321 /* Don't write out bss sections - one way to do this is to
4322 see if the filepos has not been set. */
4323 if (section
->filepos
== 0)
4326 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0)
4332 return bfd_bwrite (location
, count
, abfd
) == count
;
4336 buy_and_read (bfd
*abfd
, file_ptr where
,
4337 bfd_size_type nmemb
, bfd_size_type size
)
4341 if (_bfd_mul_overflow (nmemb
, size
, &amt
))
4343 bfd_set_error (bfd_error_file_too_big
);
4346 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
4348 return _bfd_malloc_and_read (abfd
, amt
, amt
);
4355 Creating the linenumber table is done by reading in the entire
4356 coff linenumber table, and creating another table for internal use.
4358 A coff linenumber table is structured so that each function
4359 is marked as having a line number of 0. Each line within the
4360 function is an offset from the first line in the function. The
4361 base of the line number information for the table is stored in
4362 the symbol associated with the function.
4364 Note: The PE format uses line number 0 for a flag indicating a
4367 The information is copied from the external to the internal
4368 table, and each symbol which marks a function is marked by
4371 How does this work ?
4375 coff_sort_func_alent (const void * arg1
, const void * arg2
)
4377 const alent
*al1
= *(const alent
**) arg1
;
4378 const alent
*al2
= *(const alent
**) arg2
;
4379 const coff_symbol_type
*s1
= (const coff_symbol_type
*) (al1
->u
.sym
);
4380 const coff_symbol_type
*s2
= (const coff_symbol_type
*) (al2
->u
.sym
);
4382 if (s1
== NULL
|| s2
== NULL
)
4384 if (s1
->symbol
.value
< s2
->symbol
.value
)
4386 else if (s1
->symbol
.value
> s2
->symbol
.value
)
4393 coff_slurp_line_table (bfd
*abfd
, asection
*asect
)
4395 LINENO
*native_lineno
;
4396 alent
*lineno_cache
;
4397 unsigned int counter
;
4399 bfd_vma prev_offset
= 0;
4400 bool ordered
= true;
4401 unsigned int nbr_func
;
4407 if (asect
->lineno_count
== 0)
4410 BFD_ASSERT (asect
->lineno
== NULL
);
4412 native_lineno
= (LINENO
*) buy_and_read (abfd
, asect
->line_filepos
,
4413 asect
->lineno_count
,
4414 bfd_coff_linesz (abfd
));
4415 if (native_lineno
== NULL
)
4418 (_("%pB: warning: line number table read failed"), abfd
);
4422 if (_bfd_mul_overflow (asect
->lineno_count
+ 1, sizeof (alent
), &amt
))
4424 bfd_set_error (bfd_error_file_too_big
);
4425 free (native_lineno
);
4428 lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
);
4429 if (lineno_cache
== NULL
)
4431 free (native_lineno
);
4435 cache_ptr
= lineno_cache
;
4436 asect
->lineno
= lineno_cache
;
4437 src
= native_lineno
;
4441 for (counter
= 0; counter
< asect
->lineno_count
; counter
++, src
++)
4443 struct internal_lineno dst
;
4445 bfd_coff_swap_lineno_in (abfd
, src
, &dst
);
4446 cache_ptr
->line_number
= dst
.l_lnno
;
4447 /* Appease memory checkers that get all excited about
4448 uninitialised memory when copying alents if u.offset is
4449 larger than u.sym. (64-bit BFD on 32-bit host.) */
4450 memset (&cache_ptr
->u
, 0, sizeof (cache_ptr
->u
));
4452 if (cache_ptr
->line_number
== 0)
4454 combined_entry_type
* ent
;
4455 unsigned long symndx
;
4456 coff_symbol_type
*sym
;
4459 symndx
= dst
.l_addr
.l_symndx
;
4460 if (symndx
>= obj_raw_syment_count (abfd
))
4463 /* xgettext:c-format */
4464 (_("%pB: warning: illegal symbol index 0x%lx in line number entry %d"),
4465 abfd
, symndx
, counter
);
4466 cache_ptr
->line_number
= -1;
4471 ent
= obj_raw_syments (abfd
) + symndx
;
4472 /* FIXME: We should not be casting between ints and
4473 pointers like this. */
4477 /* xgettext:c-format */
4478 (_("%pB: warning: illegal symbol index 0x%lx in line number entry %d"),
4479 abfd
, symndx
, counter
);
4480 cache_ptr
->line_number
= -1;
4484 sym
= (coff_symbol_type
*) (ent
->u
.syment
._n
._n_n
._n_zeroes
);
4486 /* PR 17512 file: 078-10659-0.004 */
4487 if (sym
< obj_symbols (abfd
)
4488 || sym
>= obj_symbols (abfd
) + bfd_get_symcount (abfd
))
4491 /* xgettext:c-format */
4492 (_("%pB: warning: illegal symbol in line number entry %d"),
4494 cache_ptr
->line_number
= -1;
4501 cache_ptr
->u
.sym
= (asymbol
*) sym
;
4502 if (sym
->lineno
!= NULL
)
4504 /* xgettext:c-format */
4505 (_("%pB: warning: duplicate line number information for `%s'"),
4506 abfd
, bfd_asymbol_name (&sym
->symbol
));
4508 sym
->lineno
= cache_ptr
;
4509 if (sym
->symbol
.value
< prev_offset
)
4511 prev_offset
= sym
->symbol
.value
;
4513 else if (!have_func
)
4514 /* Drop line information that has no associated function.
4515 PR 17521: file: 078-10659-0.004. */
4518 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
- bfd_section_vma (asect
);
4522 asect
->lineno_count
= cache_ptr
- lineno_cache
;
4523 memset (cache_ptr
, 0, sizeof (*cache_ptr
));
4524 free (native_lineno
);
4526 /* On some systems (eg AIX5.3) the lineno table may not be sorted. */
4529 /* Sort the table. */
4531 alent
*n_lineno_cache
;
4533 /* Create a table of functions. */
4534 if (_bfd_mul_overflow (nbr_func
, sizeof (alent
*), &amt
))
4536 bfd_set_error (bfd_error_file_too_big
);
4539 else if ((func_table
= (alent
**) bfd_alloc (abfd
, amt
)) != NULL
)
4541 alent
**p
= func_table
;
4544 for (i
= 0; i
< asect
->lineno_count
; i
++)
4545 if (lineno_cache
[i
].line_number
== 0)
4546 *p
++ = &lineno_cache
[i
];
4548 BFD_ASSERT ((unsigned int) (p
- func_table
) == nbr_func
);
4550 /* Sort by functions. */
4551 qsort (func_table
, nbr_func
, sizeof (alent
*), coff_sort_func_alent
);
4553 /* Create the new sorted table. */
4554 if (_bfd_mul_overflow (asect
->lineno_count
, sizeof (alent
), &amt
))
4556 bfd_set_error (bfd_error_file_too_big
);
4559 else if ((n_lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
)) != NULL
)
4561 alent
*n_cache_ptr
= n_lineno_cache
;
4563 for (i
= 0; i
< nbr_func
; i
++)
4565 coff_symbol_type
*sym
;
4566 alent
*old_ptr
= func_table
[i
];
4568 /* Update the function entry. */
4569 sym
= (coff_symbol_type
*) old_ptr
->u
.sym
;
4570 /* PR binutils/17512: Point the lineno to where
4571 this entry will be after the memcpy below. */
4572 sym
->lineno
= lineno_cache
+ (n_cache_ptr
- n_lineno_cache
);
4573 /* Copy the function and line number entries. */
4575 *n_cache_ptr
++ = *old_ptr
++;
4576 while (old_ptr
->line_number
!= 0);
4579 memcpy (lineno_cache
, n_lineno_cache
,
4580 asect
->lineno_count
* sizeof (alent
));
4584 bfd_release (abfd
, func_table
);
4593 /* Slurp in the symbol table, converting it to generic form. Note
4594 that if coff_relocate_section is defined, the linker will read
4595 symbols via coff_link_add_symbols, rather than via this routine. */
4598 coff_slurp_symbol_table (bfd
* abfd
)
4600 combined_entry_type
*native_symbols
;
4601 coff_symbol_type
*cached_area
;
4602 unsigned int *table_ptr
;
4603 unsigned int number_of_symbols
= 0;
4607 if (obj_symbols (abfd
))
4610 /* Read in the symbol table. */
4611 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4614 /* Allocate enough room for all the symbols in cached form. */
4615 if (_bfd_mul_overflow (obj_raw_syment_count (abfd
),
4616 sizeof (*cached_area
), &amt
))
4618 bfd_set_error (bfd_error_file_too_big
);
4621 cached_area
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
4622 if (cached_area
== NULL
)
4625 if (_bfd_mul_overflow (obj_raw_syment_count (abfd
),
4626 sizeof (*table_ptr
), &amt
))
4628 bfd_set_error (bfd_error_file_too_big
);
4631 table_ptr
= (unsigned int *) bfd_zalloc (abfd
, amt
);
4632 if (table_ptr
== NULL
)
4636 coff_symbol_type
*dst
= cached_area
;
4637 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4638 unsigned int this_index
= 0;
4640 while (this_index
< last_native_index
)
4642 combined_entry_type
*src
= native_symbols
+ this_index
;
4643 table_ptr
[this_index
] = number_of_symbols
;
4645 dst
->symbol
.the_bfd
= abfd
;
4646 BFD_ASSERT (src
->is_sym
);
4647 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4648 /* We use the native name field to point to the cached field. */
4649 src
->u
.syment
._n
._n_n
._n_zeroes
= (uintptr_t) dst
;
4650 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4651 src
->u
.syment
.n_scnum
);
4652 dst
->symbol
.flags
= 0;
4653 /* PR 17512: file: 079-7098-0.001:0.1. */
4654 dst
->symbol
.value
= 0;
4655 dst
->done_lineno
= false;
4657 switch (src
->u
.syment
.n_sclass
)
4663 case C_THUMBEXTFUNC
:
4667 #if ! defined _AIX52 && ! defined AIX_WEAK_SUPPORT
4672 case C_SYSTEM
: /* System Wide variable. */
4675 /* In PE, 0x68 (104) denotes a section symbol. */
4677 /* In PE, 0x69 (105) denotes a weak external symbol. */
4680 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4682 case COFF_SYMBOL_GLOBAL
:
4683 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4684 #if defined COFF_WITH_PE
4685 /* PE sets the symbol to a value relative to the
4686 start of the section. */
4687 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4689 dst
->symbol
.value
= (src
->u
.syment
.n_value
4690 - dst
->symbol
.section
->vma
);
4692 if (ISFCN ((src
->u
.syment
.n_type
)))
4693 /* A function ext does not go at the end of a
4695 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4698 case COFF_SYMBOL_COMMON
:
4699 dst
->symbol
.section
= bfd_com_section_ptr
;
4700 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4703 case COFF_SYMBOL_UNDEFINED
:
4704 dst
->symbol
.section
= bfd_und_section_ptr
;
4705 dst
->symbol
.value
= 0;
4708 case COFF_SYMBOL_PE_SECTION
:
4709 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4710 dst
->symbol
.value
= 0;
4713 case COFF_SYMBOL_LOCAL
:
4714 dst
->symbol
.flags
= BSF_LOCAL
;
4715 #if defined COFF_WITH_PE
4716 /* PE sets the symbol to a value relative to the
4717 start of the section. */
4718 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4720 dst
->symbol
.value
= (src
->u
.syment
.n_value
4721 - dst
->symbol
.section
->vma
);
4723 if (ISFCN ((src
->u
.syment
.n_type
)))
4724 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4729 /* A symbol with a csect entry should not go at the end. */
4730 if (src
->u
.syment
.n_numaux
> 0)
4731 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4735 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4736 dst
->symbol
.flags
|= BSF_WEAK
;
4738 if (src
->u
.syment
.n_sclass
== C_SECTION
4739 && src
->u
.syment
.n_scnum
> 0)
4740 dst
->symbol
.flags
= BSF_LOCAL
;
4742 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
4744 || src
->u
.syment
.n_sclass
== C_AIX_WEAKEXT
4747 dst
->symbol
.flags
|= BSF_WEAK
;
4751 case C_STAT
: /* Static. */
4753 case C_THUMBSTAT
: /* Thumb static. */
4754 case C_THUMBLABEL
: /* Thumb label. */
4755 case C_THUMBSTATFUNC
:/* Thumb static function. */
4758 case C_DWARF
: /* A label in a dwarf section. */
4759 case C_INFO
: /* A label in a comment section. */
4761 case C_LABEL
: /* Label. */
4762 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4763 dst
->symbol
.flags
= BSF_DEBUGGING
;
4765 dst
->symbol
.flags
= BSF_LOCAL
;
4767 /* Base the value as an index from the base of the
4768 section, if there is one. */
4769 if (dst
->symbol
.section
)
4771 #if defined COFF_WITH_PE
4772 /* PE sets the symbol to a value relative to the
4773 start of the section. */
4774 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4776 dst
->symbol
.value
= (src
->u
.syment
.n_value
4777 - dst
->symbol
.section
->vma
);
4781 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4784 case C_FILE
: /* File name. */
4785 dst
->symbol
.flags
= BSF_FILE
;
4787 case C_MOS
: /* Member of structure. */
4788 case C_EOS
: /* End of structure. */
4789 case C_REGPARM
: /* Register parameter. */
4790 case C_REG
: /* register variable. */
4791 /* C_AUTOARG conflicts with TI COFF C_UEXT. */
4792 case C_TPDEF
: /* Type definition. */
4794 case C_AUTO
: /* Automatic variable. */
4795 case C_FIELD
: /* Bit field. */
4796 case C_ENTAG
: /* Enumeration tag. */
4797 case C_MOE
: /* Member of enumeration. */
4798 case C_MOU
: /* Member of union. */
4799 case C_UNTAG
: /* Union tag. */
4800 case C_STRTAG
: /* Structure tag. */
4817 dst
->symbol
.flags
|= BSF_DEBUGGING
;
4818 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4822 case C_BINCL
: /* Beginning of include file. */
4823 case C_EINCL
: /* Ending of include file. */
4824 /* The value is actually a pointer into the line numbers
4825 of the file. We locate the line number entry, and
4826 set the section to the section which contains it, and
4827 the value to the index in that section. */
4831 dst
->symbol
.flags
= BSF_DEBUGGING
;
4832 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4833 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4834 && ((file_ptr
) (sec
->line_filepos
4835 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4836 > (file_ptr
) src
->u
.syment
.n_value
))
4839 dst
->symbol
.value
= 0;
4842 dst
->symbol
.section
= sec
;
4843 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4844 - sec
->line_filepos
)
4845 / bfd_coff_linesz (abfd
));
4852 dst
->symbol
.flags
= BSF_DEBUGGING
;
4854 /* The value is actually a symbol index. Save a pointer
4855 to the symbol instead of the index. FIXME: This
4856 should use a union. */
4857 src
->u
.syment
.n_value
4858 = (uintptr_t) (native_symbols
+ src
->u
.syment
.n_value
);
4859 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4864 case C_BLOCK
: /* ".bb" or ".eb". */
4865 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf"). */
4866 case C_EFCN
: /* Physical end of function. */
4867 #if defined COFF_WITH_PE
4868 /* PE sets the symbol to a value relative to the start
4870 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4871 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4873 /* PE uses funny values for .ef and .lf; don't
4875 dst
->symbol
.flags
= BSF_DEBUGGING
;
4878 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4880 /* Base the value as an index from the base of the
4882 dst
->symbol
.flags
= BSF_LOCAL
;
4883 dst
->symbol
.value
= (src
->u
.syment
.n_value
4884 - dst
->symbol
.section
->vma
);
4888 case C_STATLAB
: /* Static load time label. */
4889 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4890 dst
->symbol
.flags
= BSF_GLOBAL
;
4894 /* PE DLLs sometimes have zeroed out symbols for some
4895 reason. Just ignore them without a warning. */
4896 if (src
->u
.syment
.n_type
== 0
4897 && src
->u
.syment
.n_value
== 0
4898 && src
->u
.syment
.n_scnum
== 0)
4901 /* XCOFF specific: deleted entry. */
4902 if (src
->u
.syment
.n_value
== C_NULL_VALUE
)
4906 case C_EXTDEF
: /* External definition. */
4907 case C_ULABEL
: /* Undefined label. */
4908 case C_USTATIC
: /* Undefined static. */
4909 #ifndef COFF_WITH_PE
4910 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4911 class to represent a section symbol. */
4912 case C_LINE
: /* line # reformatted as symbol table entry. */
4913 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4914 case C_ALIAS
: /* Duplicate tag. */
4916 /* New storage classes for TI COFF. */
4918 case C_UEXT
: /* Tentative external definition. */
4920 case C_EXTLAB
: /* External load time label. */
4923 /* xgettext:c-format */
4924 (_("%pB: unrecognized storage class %d for %s symbol `%s'"),
4925 abfd
, src
->u
.syment
.n_sclass
,
4926 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4929 case C_HIDDEN
: /* Ext symbol in dmert public lib. */
4930 /* PR 20722: These symbols can also be generated by
4931 building DLLs with --gc-sections enabled. */
4932 dst
->symbol
.flags
= BSF_DEBUGGING
;
4933 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4938 dst
->symbol
.udata
.i
= 0;
4941 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
4943 number_of_symbols
++;
4947 obj_symbols (abfd
) = cached_area
;
4948 obj_raw_syments (abfd
) = native_symbols
;
4950 abfd
->symcount
= number_of_symbols
;
4951 obj_convert (abfd
) = table_ptr
;
4952 /* Slurp the line tables for each section too. */
4959 if (! coff_slurp_line_table (abfd
, p
))
4968 /* Classify a COFF symbol. A couple of targets have globally visible
4969 symbols which are not class C_EXT, and this handles those. It also
4970 recognizes some special PE cases. */
4972 static enum coff_symbol_classification
4973 coff_classify_symbol (bfd
*abfd
,
4974 struct internal_syment
*syment
)
4976 /* FIXME: This partially duplicates the switch in
4977 coff_slurp_symbol_table. */
4978 switch (syment
->n_sclass
)
4984 case C_THUMBEXTFUNC
:
4988 #if ! defined _AIX52 && ! defined AIX_WEAK_SUPPORT
4998 if (syment
->n_scnum
== 0)
5000 if (syment
->n_value
== 0)
5001 return COFF_SYMBOL_UNDEFINED
;
5003 return COFF_SYMBOL_COMMON
;
5006 if (syment
->n_sclass
== C_HIDEXT
)
5007 return COFF_SYMBOL_LOCAL
;
5009 return COFF_SYMBOL_GLOBAL
;
5016 if (syment
->n_sclass
== C_STAT
)
5018 if (syment
->n_scnum
== 0)
5019 /* The Microsoft compiler sometimes generates these if a
5020 small static function is inlined every time it is used.
5021 The function is discarded, but the symbol table entry
5023 return COFF_SYMBOL_LOCAL
;
5025 #ifdef STRICT_PE_FORMAT
5026 /* This is correct for Microsoft generated objects, but it
5027 breaks gas generated objects. */
5028 if (syment
->n_value
== 0)
5032 char buf
[SYMNMLEN
+ 1];
5034 name
= _bfd_coff_internal_syment_name (abfd
, syment
, buf
)
5035 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
5036 if (sec
!= NULL
&& name
!= NULL
5037 && (strcmp (bfd_section_name (sec
), name
) == 0))
5038 return COFF_SYMBOL_PE_SECTION
;
5042 return COFF_SYMBOL_LOCAL
;
5045 if (syment
->n_sclass
== C_SECTION
)
5047 /* In some cases in a DLL generated by the Microsoft linker, the
5048 n_value field will contain garbage. FIXME: This should
5049 probably be handled by the swapping function instead. */
5050 syment
->n_value
= 0;
5051 if (syment
->n_scnum
== 0)
5052 return COFF_SYMBOL_UNDEFINED
;
5053 return COFF_SYMBOL_PE_SECTION
;
5055 #endif /* COFF_WITH_PE */
5057 /* If it is not a global symbol, we presume it is a local symbol. */
5058 if (syment
->n_scnum
== 0)
5060 char buf
[SYMNMLEN
+ 1];
5063 /* xgettext:c-format */
5064 (_("warning: %pB: local symbol `%s' has no section"),
5065 abfd
, _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
5068 return COFF_SYMBOL_LOCAL
;
5075 Coff relocations are easily transformed into the internal BFD form
5078 Reading a coff relocation table is done in the following stages:
5080 o Read the entire coff relocation table into memory.
5082 o Process each relocation in turn; first swap it from the
5083 external to the internal form.
5085 o Turn the symbol referenced in the relocation's symbol index
5086 into a pointer into the canonical symbol table.
5087 This table is the same as the one returned by a call to
5088 @code{bfd_canonicalize_symtab}. The back end will call that
5089 routine and save the result if a canonicalization hasn't been done.
5091 o The reloc index is turned into a pointer to a howto
5092 structure, in a back end specific way. For instance, the 386
5093 uses the @code{r_type} to directly produce an index
5094 into a howto table vector.
5096 o Note that @code{arelent.addend} for COFF is often not what
5097 most people understand as a relocation addend, but rather an
5098 adjustment to the relocation addend stored in section contents
5099 of relocatable object files. The value found in section
5100 contents may also be confusing, depending on both symbol value
5101 and addend somewhat similar to the field value for a
5102 final-linked object. See @code{CALC_ADDEND}.
5106 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
5108 coff_symbol_type *coffsym = NULL; \
5110 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
5111 coffsym = (obj_symbols (abfd) \
5112 + (cache_ptr->sym_ptr_ptr - symbols)); \
5114 coffsym = coff_symbol_from (ptr); \
5115 if (coffsym != NULL \
5116 && coffsym->native->is_sym \
5117 && coffsym->native->u.syment.n_scnum == 0) \
5118 cache_ptr->addend = 0; \
5119 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
5120 && ptr->section != NULL) \
5121 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
5123 cache_ptr->addend = 0; \
5128 coff_slurp_reloc_table (bfd
* abfd
, sec_ptr asect
, asymbol
** symbols
)
5130 bfd_byte
*native_relocs
;
5131 arelent
*reloc_cache
;
5136 if (asect
->relocation
)
5138 if (asect
->reloc_count
== 0)
5140 if (asect
->flags
& SEC_CONSTRUCTOR
)
5142 if (!coff_slurp_symbol_table (abfd
))
5145 native_relocs
= (bfd_byte
*) buy_and_read (abfd
, asect
->rel_filepos
,
5147 bfd_coff_relsz (abfd
));
5148 if (native_relocs
== NULL
)
5151 if (_bfd_mul_overflow (asect
->reloc_count
, sizeof (arelent
), &amt
))
5153 bfd_set_error (bfd_error_file_too_big
);
5156 reloc_cache
= (arelent
*) bfd_alloc (abfd
, amt
);
5157 if (reloc_cache
== NULL
)
5159 free (native_relocs
);
5163 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
5165 struct internal_reloc dst
;
5167 #ifndef RELOC_PROCESSING
5171 cache_ptr
= reloc_cache
+ idx
;
5172 src
= native_relocs
+ idx
* (size_t) bfd_coff_relsz (abfd
);
5175 bfd_coff_swap_reloc_in (abfd
, src
, &dst
);
5177 #ifdef RELOC_PROCESSING
5178 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
5180 cache_ptr
->address
= dst
.r_vaddr
;
5182 if (dst
.r_symndx
!= -1 && symbols
!= NULL
)
5184 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
5187 /* xgettext:c-format */
5188 (_("%pB: warning: illegal symbol index %ld in relocs"),
5189 abfd
, dst
.r_symndx
);
5190 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5195 cache_ptr
->sym_ptr_ptr
= (symbols
5196 + obj_convert (abfd
)[dst
.r_symndx
]);
5197 ptr
= *(cache_ptr
->sym_ptr_ptr
);
5202 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5206 /* The symbols definitions that we have read in have been
5207 relocated as if their sections started at 0. But the offsets
5208 refering to the symbols in the raw data have not been
5209 modified, so we have to have a negative addend to compensate.
5211 Note that symbols which used to be common must be left alone. */
5213 /* Calculate any reloc addend by looking at the symbol. */
5214 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
5217 cache_ptr
->address
-= asect
->vma
;
5218 /* !! cache_ptr->section = NULL;*/
5220 /* Fill in the cache_ptr->howto field from dst.r_type. */
5221 RTYPE2HOWTO (cache_ptr
, &dst
);
5222 #endif /* RELOC_PROCESSING */
5224 if (cache_ptr
->howto
== NULL
)
5227 /* xgettext:c-format */
5228 (_("%pB: illegal relocation type %d at address %#" PRIx64
),
5229 abfd
, dst
.r_type
, (uint64_t) dst
.r_vaddr
);
5230 bfd_set_error (bfd_error_bad_value
);
5231 free (native_relocs
);
5236 free (native_relocs
);
5237 asect
->relocation
= reloc_cache
;
5241 #ifndef coff_rtype_to_howto
5244 /* Get the howto structure for a reloc. This is only used if the file
5245 including this one defines coff_relocate_section to be
5246 _bfd_coff_generic_relocate_section, so it is OK if it does not
5247 always work. It is the responsibility of the including file to
5248 make sure it is reasonable if it is needed. */
5250 static reloc_howto_type
*
5251 coff_rtype_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
5252 asection
*sec ATTRIBUTE_UNUSED
,
5253 struct internal_reloc
*rel ATTRIBUTE_UNUSED
,
5254 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
,
5255 struct internal_syment
*sym ATTRIBUTE_UNUSED
,
5256 bfd_vma
*addendp ATTRIBUTE_UNUSED
)
5260 genrel
.howto
= NULL
;
5261 RTYPE2HOWTO (&genrel
, rel
);
5262 return genrel
.howto
;
5265 #else /* ! defined (RTYPE2HOWTO) */
5267 #define coff_rtype_to_howto NULL
5269 #endif /* ! defined (RTYPE2HOWTO) */
5270 #endif /* ! defined (coff_rtype_to_howto) */
5272 /* This is stupid. This function should be a boolean predicate. */
5275 coff_canonicalize_reloc (bfd
* abfd
,
5280 arelent
*tblptr
= section
->relocation
;
5281 unsigned int count
= 0;
5283 if (section
->flags
& SEC_CONSTRUCTOR
)
5285 /* This section has relocs made up by us, they are not in the
5286 file, so take them out of their chain and place them into
5287 the data area provided. */
5288 arelent_chain
*chain
= section
->constructor_chain
;
5290 for (count
= 0; count
< section
->reloc_count
; count
++)
5292 *relptr
++ = &chain
->relent
;
5293 chain
= chain
->next
;
5298 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
5301 tblptr
= section
->relocation
;
5303 for (; count
++ < section
->reloc_count
;)
5304 *relptr
++ = tblptr
++;
5307 return section
->reloc_count
;
5310 #ifndef coff_set_reloc
5311 #define coff_set_reloc _bfd_generic_set_reloc
5314 #ifndef coff_reloc16_estimate
5315 #define coff_reloc16_estimate dummy_reloc16_estimate
5318 dummy_reloc16_estimate (bfd
*abfd ATTRIBUTE_UNUSED
,
5319 asection
*input_section ATTRIBUTE_UNUSED
,
5320 arelent
*reloc ATTRIBUTE_UNUSED
,
5321 unsigned int shrink ATTRIBUTE_UNUSED
,
5322 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
)
5330 #ifndef coff_reloc16_extra_cases
5332 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5335 dummy_reloc16_extra_cases (bfd
*abfd ATTRIBUTE_UNUSED
,
5336 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
5337 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
,
5338 arelent
*reloc ATTRIBUTE_UNUSED
,
5339 bfd_byte
*data ATTRIBUTE_UNUSED
,
5340 size_t *src_ptr ATTRIBUTE_UNUSED
,
5341 size_t *dst_ptr ATTRIBUTE_UNUSED
)
5347 /* If coff_relocate_section is defined, we can use the optimized COFF
5348 backend linker. Otherwise we must continue to use the old linker. */
5350 #ifdef coff_relocate_section
5352 #ifndef coff_bfd_link_hash_table_create
5353 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5355 #ifndef coff_bfd_link_add_symbols
5356 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5358 #ifndef coff_bfd_final_link
5359 #define coff_bfd_final_link _bfd_coff_final_link
5362 #else /* ! defined (coff_relocate_section) */
5364 #define coff_relocate_section NULL
5365 #ifndef coff_bfd_link_hash_table_create
5366 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5368 #ifndef coff_bfd_link_add_symbols
5369 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5371 #define coff_bfd_final_link _bfd_generic_final_link
5373 #endif /* ! defined (coff_relocate_section) */
5375 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5376 #define coff_bfd_copy_link_hash_symbol_type \
5377 _bfd_generic_copy_link_hash_symbol_type
5378 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5380 #define coff_bfd_link_check_relocs _bfd_generic_link_check_relocs
5382 #ifndef coff_start_final_link
5383 #define coff_start_final_link NULL
5386 #ifndef coff_adjust_symndx
5387 #define coff_adjust_symndx NULL
5390 #ifndef coff_link_add_one_symbol
5391 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5394 #ifndef coff_link_output_has_begun
5397 coff_link_output_has_begun (bfd
* abfd
,
5398 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
)
5400 return abfd
->output_has_begun
;
5404 #ifndef coff_final_link_postscript
5407 coff_final_link_postscript (bfd
* abfd ATTRIBUTE_UNUSED
,
5408 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
)
5414 #ifndef coff_SWAP_aux_in
5415 #define coff_SWAP_aux_in coff_swap_aux_in
5417 #ifndef coff_SWAP_sym_in
5418 #define coff_SWAP_sym_in coff_swap_sym_in
5420 #ifndef coff_SWAP_lineno_in
5421 #define coff_SWAP_lineno_in coff_swap_lineno_in
5423 #ifndef coff_SWAP_aux_out
5424 #define coff_SWAP_aux_out coff_swap_aux_out
5426 #ifndef coff_SWAP_sym_out
5427 #define coff_SWAP_sym_out coff_swap_sym_out
5429 #ifndef coff_SWAP_lineno_out
5430 #define coff_SWAP_lineno_out coff_swap_lineno_out
5432 #ifndef coff_SWAP_reloc_out
5433 #define coff_SWAP_reloc_out coff_swap_reloc_out
5435 #ifndef coff_SWAP_filehdr_out
5436 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5438 #ifndef coff_SWAP_aouthdr_out
5439 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5441 #ifndef coff_SWAP_scnhdr_out
5442 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5444 #ifndef coff_SWAP_reloc_in
5445 #define coff_SWAP_reloc_in coff_swap_reloc_in
5447 #ifndef coff_SWAP_filehdr_in
5448 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5450 #ifndef coff_SWAP_aouthdr_in
5451 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5453 #ifndef coff_SWAP_scnhdr_in
5454 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5457 static const bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED
=
5459 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5460 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5461 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5462 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5463 coff_SWAP_scnhdr_out
,
5464 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5465 #ifdef COFF_LONG_FILENAMES
5470 COFF_DEFAULT_LONG_SECTION_NAMES
,
5471 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5472 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5477 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5483 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5484 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5485 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5486 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5487 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5488 coff_classify_symbol
, coff_compute_section_file_positions
,
5489 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5490 coff_adjust_symndx
, coff_link_add_one_symbol
,
5491 coff_link_output_has_begun
, coff_final_link_postscript
,
5496 /* COFF0 differs in file/section header size and relocation entry size. */
5498 static const bfd_coff_backend_data ticoff0_swap_table
=
5500 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5501 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5502 coff_SWAP_lineno_out
, coff_swap_reloc_v0_out
,
5503 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5504 coff_SWAP_scnhdr_out
,
5505 FILHSZ_V0
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ_V0
, LINESZ
, FILNMLEN
,
5506 #ifdef COFF_LONG_FILENAMES
5511 COFF_DEFAULT_LONG_SECTION_NAMES
,
5512 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5513 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5518 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5524 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5525 coff_swap_reloc_v0_in
, ticoff0_bad_format_hook
, coff_set_arch_mach_hook
,
5526 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5527 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5528 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5529 coff_classify_symbol
, coff_compute_section_file_positions
,
5530 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5531 coff_adjust_symndx
, coff_link_add_one_symbol
,
5532 coff_link_output_has_begun
, coff_final_link_postscript
,
5538 /* COFF1 differs in section header size. */
5540 static const bfd_coff_backend_data ticoff1_swap_table
=
5542 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5543 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5544 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5545 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5546 coff_SWAP_scnhdr_out
,
5547 FILHSZ
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5548 #ifdef COFF_LONG_FILENAMES
5553 COFF_DEFAULT_LONG_SECTION_NAMES
,
5554 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5555 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5560 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5566 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5567 coff_SWAP_reloc_in
, ticoff1_bad_format_hook
, coff_set_arch_mach_hook
,
5568 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5569 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5570 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5571 coff_classify_symbol
, coff_compute_section_file_positions
,
5572 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5573 coff_adjust_symndx
, coff_link_add_one_symbol
,
5574 coff_link_output_has_begun
, coff_final_link_postscript
,
5575 bfd_pe_print_pdata
/* huh */
5579 #ifdef COFF_WITH_PE_BIGOBJ
5580 /* The UID for bigobj files. */
5582 static const char header_bigobj_classid
[16] =
5584 0xC7, 0xA1, 0xBA, 0xD1,
5588 0xFA, 0xF6, 0x6A, 0xA4, 0xDC, 0xB8
5591 /* Swap routines. */
5594 coff_bigobj_swap_filehdr_in (bfd
* abfd
, void * src
, void * dst
)
5596 struct external_ANON_OBJECT_HEADER_BIGOBJ
*filehdr_src
=
5597 (struct external_ANON_OBJECT_HEADER_BIGOBJ
*) src
;
5598 struct internal_filehdr
*filehdr_dst
= (struct internal_filehdr
*) dst
;
5600 filehdr_dst
->f_magic
= H_GET_16 (abfd
, filehdr_src
->Machine
);
5601 filehdr_dst
->f_nscns
= H_GET_32 (abfd
, filehdr_src
->NumberOfSections
);
5602 filehdr_dst
->f_timdat
= H_GET_32 (abfd
, filehdr_src
->TimeDateStamp
);
5603 filehdr_dst
->f_symptr
=
5604 GET_FILEHDR_SYMPTR (abfd
, filehdr_src
->PointerToSymbolTable
);
5605 filehdr_dst
->f_nsyms
= H_GET_32 (abfd
, filehdr_src
->NumberOfSymbols
);
5606 filehdr_dst
->f_opthdr
= 0;
5607 filehdr_dst
->f_flags
= 0;
5609 /* Check other magic numbers. */
5610 if (H_GET_16 (abfd
, filehdr_src
->Sig1
) != IMAGE_FILE_MACHINE_UNKNOWN
5611 || H_GET_16 (abfd
, filehdr_src
->Sig2
) != 0xffff
5612 || H_GET_16 (abfd
, filehdr_src
->Version
) != 2
5613 || memcmp (filehdr_src
->ClassID
, header_bigobj_classid
, 16) != 0)
5614 filehdr_dst
->f_opthdr
= 0xffff;
5616 /* Note that CLR metadata are ignored. */
5620 coff_bigobj_swap_filehdr_out (bfd
*abfd
, void * in
, void * out
)
5622 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
5623 struct external_ANON_OBJECT_HEADER_BIGOBJ
*filehdr_out
=
5624 (struct external_ANON_OBJECT_HEADER_BIGOBJ
*) out
;
5626 memset (filehdr_out
, 0, sizeof (*filehdr_out
));
5628 H_PUT_16 (abfd
, IMAGE_FILE_MACHINE_UNKNOWN
, filehdr_out
->Sig1
);
5629 H_PUT_16 (abfd
, 0xffff, filehdr_out
->Sig2
);
5630 H_PUT_16 (abfd
, 2, filehdr_out
->Version
);
5631 memcpy (filehdr_out
->ClassID
, header_bigobj_classid
, 16);
5632 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->Machine
);
5633 H_PUT_32 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->NumberOfSections
);
5634 H_PUT_32 (abfd
, filehdr_in
->f_timdat
, filehdr_out
->TimeDateStamp
);
5635 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
,
5636 filehdr_out
->PointerToSymbolTable
);
5637 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->NumberOfSymbols
);
5639 return bfd_coff_filhsz (abfd
);
5643 coff_bigobj_swap_sym_in (bfd
* abfd
, void * ext1
, void * in1
)
5645 SYMENT_BIGOBJ
*ext
= (SYMENT_BIGOBJ
*) ext1
;
5646 struct internal_syment
*in
= (struct internal_syment
*) in1
;
5648 if (ext
->e
.e_name
[0] == 0)
5650 in
->_n
._n_n
._n_zeroes
= 0;
5651 in
->_n
._n_n
._n_offset
= H_GET_32 (abfd
, ext
->e
.e
.e_offset
);
5655 #if SYMNMLEN != E_SYMNMLEN
5656 #error we need to cope with truncating or extending SYMNMLEN
5658 memcpy (in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
5662 in
->n_value
= H_GET_32 (abfd
, ext
->e_value
);
5663 BFD_ASSERT (sizeof (in
->n_scnum
) >= 4);
5664 in
->n_scnum
= H_GET_32 (abfd
, ext
->e_scnum
);
5665 in
->n_type
= H_GET_16 (abfd
, ext
->e_type
);
5666 in
->n_sclass
= H_GET_8 (abfd
, ext
->e_sclass
);
5667 in
->n_numaux
= H_GET_8 (abfd
, ext
->e_numaux
);
5671 coff_bigobj_swap_sym_out (bfd
* abfd
, void * inp
, void * extp
)
5673 struct internal_syment
*in
= (struct internal_syment
*) inp
;
5674 SYMENT_BIGOBJ
*ext
= (SYMENT_BIGOBJ
*) extp
;
5676 if (in
->_n
._n_name
[0] == 0)
5678 H_PUT_32 (abfd
, 0, ext
->e
.e
.e_zeroes
);
5679 H_PUT_32 (abfd
, in
->_n
._n_n
._n_offset
, ext
->e
.e
.e_offset
);
5683 #if SYMNMLEN != E_SYMNMLEN
5684 #error we need to cope with truncating or extending SYMNMLEN
5686 memcpy (ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
5690 H_PUT_32 (abfd
, in
->n_value
, ext
->e_value
);
5691 H_PUT_32 (abfd
, in
->n_scnum
, ext
->e_scnum
);
5693 H_PUT_16 (abfd
, in
->n_type
, ext
->e_type
);
5694 H_PUT_8 (abfd
, in
->n_sclass
, ext
->e_sclass
);
5695 H_PUT_8 (abfd
, in
->n_numaux
, ext
->e_numaux
);
5697 return SYMESZ_BIGOBJ
;
5701 coff_bigobj_swap_aux_in (bfd
*abfd
,
5709 AUXENT_BIGOBJ
*ext
= (AUXENT_BIGOBJ
*) ext1
;
5710 union internal_auxent
*in
= (union internal_auxent
*) in1
;
5712 /* Make sure that all fields in the aux structure are
5714 memset (in
, 0, sizeof * in
);
5721 memcpy (in
->x_file
.x_n
.x_fname
, ext
->File
.Name
,
5722 numaux
* sizeof (AUXENT_BIGOBJ
));
5725 memcpy (in
->x_file
.x_n
.x_fname
, ext
->File
.Name
, sizeof (ext
->File
.Name
));
5733 in
->x_scn
.x_scnlen
= H_GET_32 (abfd
, ext
->Section
.Length
);
5734 in
->x_scn
.x_nreloc
=
5735 H_GET_16 (abfd
, ext
->Section
.NumberOfRelocations
);
5736 in
->x_scn
.x_nlinno
=
5737 H_GET_16 (abfd
, ext
->Section
.NumberOfLinenumbers
);
5738 in
->x_scn
.x_checksum
= H_GET_32 (abfd
, ext
->Section
.Checksum
);
5739 in
->x_scn
.x_associated
= H_GET_16 (abfd
, ext
->Section
.Number
)
5740 | (H_GET_16 (abfd
, ext
->Section
.HighNumber
) << 16);
5741 in
->x_scn
.x_comdat
= H_GET_8 (abfd
, ext
->Section
.Selection
);
5747 in
->x_sym
.x_tagndx
.l
= H_GET_32 (abfd
, ext
->Sym
.WeakDefaultSymIndex
);
5748 /* Characteristics is ignored. */
5754 coff_bigobj_swap_aux_out (bfd
* abfd
,
5758 int indx ATTRIBUTE_UNUSED
,
5759 int numaux ATTRIBUTE_UNUSED
,
5762 union internal_auxent
* in
= (union internal_auxent
*) inp
;
5763 AUXENT_BIGOBJ
*ext
= (AUXENT_BIGOBJ
*) extp
;
5765 memset (ext
, 0, AUXESZ
);
5770 memcpy (ext
->File
.Name
, in
->x_file
.x_n
.x_fname
, sizeof (ext
->File
.Name
));
5779 H_PUT_32 (abfd
, in
->x_scn
.x_scnlen
, ext
->Section
.Length
);
5780 H_PUT_16 (abfd
, in
->x_scn
.x_nreloc
,
5781 ext
->Section
.NumberOfRelocations
);
5782 H_PUT_16 (abfd
, in
->x_scn
.x_nlinno
,
5783 ext
->Section
.NumberOfLinenumbers
);
5784 H_PUT_32 (abfd
, in
->x_scn
.x_checksum
, ext
->Section
.Checksum
);
5785 H_PUT_16 (abfd
, in
->x_scn
.x_associated
& 0xffff,
5786 ext
->Section
.Number
);
5787 H_PUT_16 (abfd
, (in
->x_scn
.x_associated
>> 16),
5788 ext
->Section
.HighNumber
);
5789 H_PUT_8 (abfd
, in
->x_scn
.x_comdat
, ext
->Section
.Selection
);
5795 H_PUT_32 (abfd
, in
->x_sym
.x_tagndx
.l
, ext
->Sym
.WeakDefaultSymIndex
);
5796 H_PUT_32 (abfd
, 1, ext
->Sym
.WeakSearchType
);
5801 static const bfd_coff_backend_data bigobj_swap_table
=
5803 coff_bigobj_swap_aux_in
, coff_bigobj_swap_sym_in
, coff_SWAP_lineno_in
,
5804 coff_bigobj_swap_aux_out
, coff_bigobj_swap_sym_out
,
5805 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5806 coff_bigobj_swap_filehdr_out
, coff_SWAP_aouthdr_out
,
5807 coff_SWAP_scnhdr_out
,
5808 FILHSZ_BIGOBJ
, AOUTSZ
, SCNHSZ
, SYMESZ_BIGOBJ
, AUXESZ_BIGOBJ
,
5809 RELSZ
, LINESZ
, FILNMLEN_BIGOBJ
,
5811 COFF_DEFAULT_LONG_SECTION_NAMES
,
5812 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5816 coff_bigobj_swap_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5817 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5818 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5819 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5820 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5821 coff_classify_symbol
, coff_compute_section_file_positions
,
5822 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5823 coff_adjust_symndx
, coff_link_add_one_symbol
,
5824 coff_link_output_has_begun
, coff_final_link_postscript
,
5825 bfd_pe_print_pdata
/* huh */
5828 #endif /* COFF_WITH_PE_BIGOBJ */
5830 #ifndef coff_close_and_cleanup
5831 #define coff_close_and_cleanup _bfd_coff_close_and_cleanup
5834 #ifndef coff_bfd_free_cached_info
5835 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5838 #ifndef coff_get_section_contents
5839 #define coff_get_section_contents _bfd_generic_get_section_contents
5842 #ifndef coff_bfd_copy_private_symbol_data
5843 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5846 #ifndef coff_bfd_copy_private_header_data
5847 #define coff_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
5850 #ifndef coff_bfd_copy_private_section_data
5851 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5854 #ifndef coff_bfd_copy_private_bfd_data
5855 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5858 #ifndef coff_bfd_merge_private_bfd_data
5859 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5862 #ifndef coff_bfd_set_private_flags
5863 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5866 #ifndef coff_bfd_print_private_bfd_data
5867 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5870 #ifndef coff_bfd_is_local_label_name
5871 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5874 #ifndef coff_bfd_is_target_special_symbol
5875 #define coff_bfd_is_target_special_symbol _bfd_bool_bfd_asymbol_false
5878 #ifndef coff_read_minisymbols
5879 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5882 #ifndef coff_minisymbol_to_symbol
5883 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5886 /* The reloc lookup routine must be supplied by each individual COFF
5888 #ifndef coff_bfd_reloc_type_lookup
5889 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5891 #ifndef coff_bfd_reloc_name_lookup
5892 #define coff_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5895 #ifndef coff_bfd_get_relocated_section_contents
5896 #define coff_bfd_get_relocated_section_contents \
5897 bfd_generic_get_relocated_section_contents
5900 #ifndef coff_bfd_relax_section
5901 #define coff_bfd_relax_section bfd_generic_relax_section
5904 #ifndef coff_bfd_gc_sections
5905 #define coff_bfd_gc_sections bfd_coff_gc_sections
5908 #ifndef coff_bfd_lookup_section_flags
5909 #define coff_bfd_lookup_section_flags bfd_generic_lookup_section_flags
5912 #ifndef coff_bfd_merge_sections
5913 #define coff_bfd_merge_sections bfd_generic_merge_sections
5916 #ifndef coff_bfd_is_group_section
5917 #define coff_bfd_is_group_section bfd_generic_is_group_section
5920 #ifndef coff_bfd_group_name
5921 #define coff_bfd_group_name bfd_coff_group_name
5924 #ifndef coff_bfd_discard_group
5925 #define coff_bfd_discard_group bfd_generic_discard_group
5928 #ifndef coff_section_already_linked
5929 #define coff_section_already_linked \
5930 _bfd_coff_section_already_linked
5933 #ifndef coff_bfd_define_common_symbol
5934 #define coff_bfd_define_common_symbol bfd_generic_define_common_symbol
5937 #ifndef coff_bfd_link_hide_symbol
5938 #define coff_bfd_link_hide_symbol _bfd_generic_link_hide_symbol
5941 #ifndef coff_bfd_define_start_stop
5942 #define coff_bfd_define_start_stop bfd_generic_define_start_stop
5945 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5946 const bfd_target VAR = \
5949 bfd_target_coff_flavour, \
5950 BFD_ENDIAN_BIG, /* Data byte order is big. */ \
5951 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5952 /* object flags */ \
5953 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5954 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5955 /* section flags */ \
5956 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5957 UNDER, /* Leading symbol underscore. */ \
5958 '/', /* AR_pad_char. */ \
5959 15, /* AR_max_namelen. */ \
5960 0, /* match priority. */ \
5961 TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols. */ \
5963 /* Data conversion functions. */ \
5964 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5965 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5966 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5968 /* Header conversion functions. */ \
5969 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5970 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5971 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5973 { /* bfd_check_format. */ \
5974 _bfd_dummy_target, \
5976 bfd_generic_archive_p, \
5979 { /* bfd_set_format. */ \
5980 _bfd_bool_bfd_false_error, \
5982 _bfd_generic_mkarchive, \
5983 _bfd_bool_bfd_false_error \
5985 { /* bfd_write_contents. */ \
5986 _bfd_bool_bfd_false_error, \
5987 coff_write_object_contents, \
5988 _bfd_write_archive_contents, \
5989 _bfd_bool_bfd_false_error \
5992 BFD_JUMP_TABLE_GENERIC (coff), \
5993 BFD_JUMP_TABLE_COPY (coff), \
5994 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5995 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5996 BFD_JUMP_TABLE_SYMBOLS (coff), \
5997 BFD_JUMP_TABLE_RELOCS (coff), \
5998 BFD_JUMP_TABLE_WRITE (coff), \
5999 BFD_JUMP_TABLE_LINK (coff), \
6000 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
6007 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
6008 const bfd_target VAR = \
6011 bfd_target_coff_flavour, \
6012 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
6013 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
6014 /* object flags */ \
6015 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
6016 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
6017 /* section flags */ \
6018 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
6019 UNDER, /* Leading symbol underscore. */ \
6020 '/', /* AR_pad_char. */ \
6021 15, /* AR_max_namelen. */ \
6022 0, /* match priority. */ \
6023 TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols. */ \
6025 /* Data conversion functions. */ \
6026 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
6027 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
6028 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
6030 /* Header conversion functions. */ \
6031 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
6032 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
6033 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
6035 { /* bfd_check_format. */ \
6036 _bfd_dummy_target, \
6038 bfd_generic_archive_p, \
6041 { /* bfd_set_format. */ \
6042 _bfd_bool_bfd_false_error, \
6044 _bfd_generic_mkarchive, \
6045 _bfd_bool_bfd_false_error \
6047 { /* bfd_write_contents. */ \
6048 _bfd_bool_bfd_false_error, \
6049 coff_write_object_contents, \
6050 _bfd_write_archive_contents, \
6051 _bfd_bool_bfd_false_error \
6054 BFD_JUMP_TABLE_GENERIC (coff), \
6055 BFD_JUMP_TABLE_COPY (coff), \
6056 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
6057 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
6058 BFD_JUMP_TABLE_SYMBOLS (coff), \
6059 BFD_JUMP_TABLE_RELOCS (coff), \
6060 BFD_JUMP_TABLE_WRITE (coff), \
6061 BFD_JUMP_TABLE_LINK (coff), \
6062 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
6069 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
6070 const bfd_target VAR = \
6073 bfd_target_coff_flavour, \
6074 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
6075 BFD_ENDIAN_LITTLE, /* Header byte order is little. */ \
6076 /* object flags */ \
6077 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
6078 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
6079 /* section flags */ \
6080 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
6081 UNDER, /* Leading symbol underscore. */ \
6082 '/', /* AR_pad_char. */ \
6083 15, /* AR_max_namelen. */ \
6084 0, /* match priority. */ \
6085 TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols. */ \
6087 /* Data conversion functions. */ \
6088 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
6089 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
6090 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
6091 /* Header conversion functions. */ \
6092 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
6093 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
6094 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
6096 { /* bfd_check_format. */ \
6097 _bfd_dummy_target, \
6099 bfd_generic_archive_p, \
6102 { /* bfd_set_format. */ \
6103 _bfd_bool_bfd_false_error, \
6105 _bfd_generic_mkarchive, \
6106 _bfd_bool_bfd_false_error \
6108 { /* bfd_write_contents. */ \
6109 _bfd_bool_bfd_false_error, \
6110 coff_write_object_contents, \
6111 _bfd_write_archive_contents, \
6112 _bfd_bool_bfd_false_error \
6115 BFD_JUMP_TABLE_GENERIC (coff), \
6116 BFD_JUMP_TABLE_COPY (coff), \
6117 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
6118 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
6119 BFD_JUMP_TABLE_SYMBOLS (coff), \
6120 BFD_JUMP_TABLE_RELOCS (coff), \
6121 BFD_JUMP_TABLE_WRITE (coff), \
6122 BFD_JUMP_TABLE_LINK (coff), \
6123 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \