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>>:
293 .typedef struct coff_ptr_struct
295 . {* Remembers the offset from the first symbol in the file for
296 . this symbol. Generated by coff_renumber_symbols. *}
297 . unsigned int offset;
299 . {* Selects between the elements of the union below. *}
300 . unsigned int is_sym : 1;
302 . {* Selects between the elements of the x_sym.x_tagndx union. If set,
303 . p is valid and the field will be renumbered. *}
304 . unsigned int fix_tag : 1;
306 . {* Selects between the elements of the x_sym.x_fcnary.x_fcn.x_endndx
307 . union. If set, p is valid and the field will be renumbered. *}
308 . unsigned int fix_end : 1;
310 . {* Selects between the elements of the x_csect.x_scnlen union. If set,
311 . p is valid and the field will be renumbered. *}
312 . unsigned int fix_scnlen : 1;
314 . {* If set, u.syment.n_value contains a pointer to a symbol. The final
315 . value will be the offset field. Used for XCOFF C_BSTAT symbols. *}
316 . unsigned int fix_value : 1;
318 . {* If set, u.syment.n_value is an index into the line number entries.
319 . Used for XCOFF C_BINCL/C_EINCL symbols. *}
320 . unsigned int fix_line : 1;
322 . {* The container for the symbol structure as read and translated
326 . union internal_auxent auxent;
327 . struct internal_syment syment;
330 . {* An extra pointer which can used by format based on COFF (like XCOFF)
331 . to provide extra information to their backend. *}
333 .} combined_entry_type;
335 .{* Each canonical asymbol really looks like this: *}
337 .typedef struct coff_symbol_struct
339 . {* The actual symbol which the rest of BFD works with *}
342 . {* A pointer to the hidden information for this symbol *}
343 . combined_entry_type *native;
345 . {* A pointer to the linenumber information for this symbol *}
346 . struct lineno_cache_entry *lineno;
348 . {* Have the line numbers been relocated yet ? *}
354 #include "libiberty.h"
359 #include "coffswap.h"
362 #define STRING_SIZE_SIZE 4
364 #define DOT_DEBUG ".debug"
365 #define DOT_ZDEBUG ".zdebug"
366 #define GNU_LINKONCE_WI ".gnu.linkonce.wi."
367 #define GNU_LINKONCE_WT ".gnu.linkonce.wt."
368 #define DOT_RELOC ".reloc"
370 #if defined(COFF_WITH_PE) || defined(COFF_GO32_EXE) || defined(COFF_GO32)
371 # define COFF_WITH_EXTENDED_RELOC_COUNTER
374 #if defined (COFF_LONG_SECTION_NAMES)
375 /* Needed to expand the inputs to BLANKOR1TOODD. */
376 #define COFFLONGSECTIONCATHELPER(x,y) x ## y
377 /* If the input macro Y is blank or '1', return an odd number; if it is
378 '0', return an even number. Result undefined in all other cases. */
379 #define BLANKOR1TOODD(y) COFFLONGSECTIONCATHELPER(1,y)
380 /* Defined to numerical 0 or 1 according to whether generation of long
381 section names is disabled or enabled by default. */
382 #define COFF_ENABLE_LONG_SECTION_NAMES (BLANKOR1TOODD(COFF_LONG_SECTION_NAMES) & 1)
383 /* Where long section names are supported, we allow them to be enabled
384 and disabled at runtime, so select an appropriate hook function for
385 _bfd_coff_set_long_section_names. */
386 #define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_allowed
387 #else /* !defined (COFF_LONG_SECTION_NAMES) */
388 /* If long section names are not supported, this stub disallows any
389 attempt to enable them at run-time. */
390 #define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_disallowed
391 #endif /* defined (COFF_LONG_SECTION_NAMES) */
393 /* Define a macro that can be used to initialise both the fields relating
394 to long section names in the backend data struct simultaneously. */
395 #if COFF_ENABLE_LONG_SECTION_NAMES
396 #define COFF_DEFAULT_LONG_SECTION_NAMES (true), COFF_LONG_SECTION_NAMES_SETTER
397 #else /* !COFF_ENABLE_LONG_SECTION_NAMES */
398 #define COFF_DEFAULT_LONG_SECTION_NAMES (false), COFF_LONG_SECTION_NAMES_SETTER
399 #endif /* COFF_ENABLE_LONG_SECTION_NAMES */
401 static enum coff_symbol_classification coff_classify_symbol
402 (bfd
*, struct internal_syment
*);
404 /* void warning(); */
406 #if defined (COFF_LONG_SECTION_NAMES)
408 bfd_coff_set_long_section_names_allowed (bfd
*abfd
, int enable
)
410 bfd_coff_long_section_names (abfd
) = enable
;
413 #else /* !defined (COFF_LONG_SECTION_NAMES) */
415 bfd_coff_set_long_section_names_disallowed (bfd
*abfd ATTRIBUTE_UNUSED
,
416 int enable ATTRIBUTE_UNUSED
)
420 #endif /* defined (COFF_LONG_SECTION_NAMES) */
422 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
423 the incoming SEC_* flags. The inverse of this function is
424 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
425 should probably mirror the changes in styp_to_sec_flags(). */
429 /* Macros for setting debugging flags. */
432 #define STYP_XCOFF_DEBUG STYP_DEBUG
434 #define STYP_XCOFF_DEBUG STYP_INFO
437 #ifdef COFF_ALIGN_IN_S_FLAGS
438 #define STYP_DEBUG_INFO STYP_DSECT
440 #define STYP_DEBUG_INFO STYP_INFO
444 sec_to_styp_flags (const char *sec_name
, flagword sec_flags
)
448 if (!strcmp (sec_name
, _TEXT
))
450 styp_flags
= STYP_TEXT
;
452 else if (!strcmp (sec_name
, _DATA
))
454 styp_flags
= STYP_DATA
;
456 else if (!strcmp (sec_name
, _BSS
))
458 styp_flags
= STYP_BSS
;
461 else if (!strcmp (sec_name
, _COMMENT
))
463 styp_flags
= STYP_INFO
;
464 #endif /* _COMMENT */
467 else if (!strcmp (sec_name
, _LIB
))
469 styp_flags
= STYP_LIB
;
473 else if (!strcmp (sec_name
, _LIT
))
475 styp_flags
= STYP_LIT
;
478 else if (startswith (sec_name
, DOT_DEBUG
)
479 || startswith (sec_name
, DOT_ZDEBUG
))
481 /* Handle the XCOFF debug section and DWARF2 debug sections. */
483 styp_flags
= STYP_XCOFF_DEBUG
;
485 styp_flags
= STYP_DEBUG_INFO
;
487 else if (startswith (sec_name
, ".stab"))
489 styp_flags
= STYP_DEBUG_INFO
;
491 #ifdef COFF_LONG_SECTION_NAMES
492 else if (startswith (sec_name
, GNU_LINKONCE_WI
)
493 || startswith (sec_name
, GNU_LINKONCE_WT
))
495 styp_flags
= STYP_DEBUG_INFO
;
499 else if (!strcmp (sec_name
, _TDATA
))
501 styp_flags
= STYP_TDATA
;
503 else if (!strcmp (sec_name
, _TBSS
))
505 styp_flags
= STYP_TBSS
;
507 else if (!strcmp (sec_name
, _PAD
))
509 styp_flags
= STYP_PAD
;
511 else if (!strcmp (sec_name
, _LOADER
))
513 styp_flags
= STYP_LOADER
;
515 else if (!strcmp (sec_name
, _EXCEPT
))
517 styp_flags
= STYP_EXCEPT
;
519 else if (!strcmp (sec_name
, _TYPCHK
))
521 styp_flags
= STYP_TYPCHK
;
523 else if (sec_flags
& SEC_DEBUGGING
)
527 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
528 if (!strcmp (sec_name
, xcoff_dwsect_names
[i
].xcoff_name
))
530 styp_flags
= STYP_DWARF
| xcoff_dwsect_names
[i
].flag
;
535 /* Try and figure out what it should be */
536 else if (sec_flags
& SEC_CODE
)
538 styp_flags
= STYP_TEXT
;
540 else if (sec_flags
& SEC_DATA
)
542 styp_flags
= STYP_DATA
;
544 else if (sec_flags
& SEC_READONLY
)
546 #ifdef STYP_LIT /* 29k readonly text/data section */
547 styp_flags
= STYP_LIT
;
549 styp_flags
= STYP_TEXT
;
550 #endif /* STYP_LIT */
552 else if (sec_flags
& SEC_LOAD
)
554 styp_flags
= STYP_TEXT
;
556 else if (sec_flags
& SEC_ALLOC
)
558 styp_flags
= STYP_BSS
;
562 if (sec_flags
& SEC_TIC54X_CLINK
)
563 styp_flags
|= STYP_CLINK
;
567 if (sec_flags
& SEC_TIC54X_BLOCK
)
568 styp_flags
|= STYP_BLOCK
;
572 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
573 styp_flags
|= STYP_NOLOAD
;
579 #else /* COFF_WITH_PE */
581 /* The PE version; see above for the general comments. The non-PE
582 case seems to be more guessing, and breaks PE format; specifically,
583 .rdata is readonly, but it sure ain't text. Really, all this
584 should be set up properly in gas (or whatever assembler is in use),
585 and honor whatever objcopy/strip, etc. sent us as input. */
588 sec_to_styp_flags (const char *sec_name
, flagword sec_flags
)
593 if (startswith (sec_name
, DOT_DEBUG
)
594 || startswith (sec_name
, DOT_ZDEBUG
)
595 #ifdef COFF_LONG_SECTION_NAMES
596 || startswith (sec_name
, GNU_LINKONCE_WI
)
597 || startswith (sec_name
, GNU_LINKONCE_WT
)
599 || startswith (sec_name
, ".stab"))
602 /* caution: there are at least three groups of symbols that have
603 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
604 SEC_* are the BFD internal flags, used for generic BFD
605 information. STYP_* are the COFF section flags which appear in
606 COFF files. IMAGE_SCN_* are the PE section flags which appear in
607 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
608 but there are more IMAGE_SCN_* flags. */
610 /* FIXME: There is no gas syntax to specify the debug section flag. */
613 sec_flags
&= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
614 | SEC_LINK_DUPLICATES_SAME_CONTENTS
615 | SEC_LINK_DUPLICATES_SAME_SIZE
);
616 sec_flags
|= SEC_DEBUGGING
| SEC_READONLY
;
622 if ((sec_flags
& SEC_CODE
) != 0)
623 styp_flags
|= IMAGE_SCN_CNT_CODE
;
624 if ((sec_flags
& (SEC_DATA
| SEC_DEBUGGING
)) != 0)
625 styp_flags
|= IMAGE_SCN_CNT_INITIALIZED_DATA
;
626 if ((sec_flags
& SEC_ALLOC
) != 0 && (sec_flags
& SEC_LOAD
) == 0)
627 styp_flags
|= IMAGE_SCN_CNT_UNINITIALIZED_DATA
; /* ==STYP_BSS */
629 /* skip constRUCTOR */
631 #ifndef COFF_IMAGE_WITH_PE
632 /* I don't think any of the IMAGE_SCN_LNK_* flags set below should be set
633 when the output is PE. Only object files should have them, for the linker
635 if ((sec_flags
& SEC_IS_COMMON
) != 0)
636 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
638 if ((sec_flags
& SEC_DEBUGGING
) != 0)
639 styp_flags
|= IMAGE_SCN_MEM_DISCARDABLE
;
640 if ((sec_flags
& (SEC_EXCLUDE
| SEC_NEVER_LOAD
)) != 0 && !is_dbg
)
641 #ifdef COFF_IMAGE_WITH_PE
642 styp_flags
|= IMAGE_SCN_MEM_DISCARDABLE
;
644 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
648 #ifndef COFF_IMAGE_WITH_PE
649 if (sec_flags
& SEC_LINK_ONCE
)
650 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
652 & (SEC_LINK_DUPLICATES_DISCARD
| SEC_LINK_DUPLICATES_SAME_CONTENTS
653 | SEC_LINK_DUPLICATES_SAME_SIZE
)) != 0)
654 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
657 /* skip LINKER_CREATED */
659 if ((sec_flags
& SEC_COFF_NOREAD
) == 0)
660 styp_flags
|= IMAGE_SCN_MEM_READ
; /* Invert NOREAD for read. */
661 if ((sec_flags
& SEC_READONLY
) == 0)
662 styp_flags
|= IMAGE_SCN_MEM_WRITE
; /* Invert READONLY for write. */
663 if (sec_flags
& SEC_CODE
)
664 styp_flags
|= IMAGE_SCN_MEM_EXECUTE
; /* CODE->EXECUTE. */
665 if (sec_flags
& SEC_COFF_SHARED
)
666 styp_flags
|= IMAGE_SCN_MEM_SHARED
; /* Shared remains meaningful. */
671 #endif /* COFF_WITH_PE */
673 /* Return a word with SEC_* flags set to represent the incoming STYP_*
674 flags (from scnhdr.s_flags). The inverse of this function is
675 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
676 should probably mirror the changes in sec_to_styp_flags(). */
681 styp_to_sec_flags (bfd
*abfd
,
684 asection
*section ATTRIBUTE_UNUSED
,
687 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
688 unsigned long styp_flags
= internal_s
->s_flags
;
689 flagword sec_flags
= 0;
692 if (styp_flags
& STYP_BLOCK
)
693 sec_flags
|= SEC_TIC54X_BLOCK
;
697 if (styp_flags
& STYP_CLINK
)
698 sec_flags
|= SEC_TIC54X_CLINK
;
702 if (styp_flags
& STYP_NOLOAD
)
703 sec_flags
|= SEC_NEVER_LOAD
;
704 #endif /* STYP_NOLOAD */
706 /* For 386 COFF, at least, an unloadable text or data section is
707 actually a shared library section. */
708 if (styp_flags
& STYP_TEXT
)
710 if (sec_flags
& SEC_NEVER_LOAD
)
711 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
713 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
715 else if (styp_flags
& STYP_DATA
)
717 if (sec_flags
& SEC_NEVER_LOAD
)
718 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
720 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
722 else if (styp_flags
& STYP_BSS
)
724 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
725 if (sec_flags
& SEC_NEVER_LOAD
)
726 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
729 sec_flags
|= SEC_ALLOC
;
731 else if (styp_flags
& STYP_INFO
)
733 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
734 defined. coff_compute_section_file_positions uses
735 COFF_PAGE_SIZE to ensure that the low order bits of the
736 section VMA and the file offset match. If we don't know
737 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
738 and demand page loading of the file will fail. */
739 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
740 sec_flags
|= SEC_DEBUGGING
;
743 else if (styp_flags
& STYP_PAD
)
746 else if (styp_flags
& STYP_TDATA
)
748 if (sec_flags
& SEC_NEVER_LOAD
)
749 sec_flags
|= SEC_DATA
| SEC_THREAD_LOCAL
| SEC_COFF_SHARED_LIBRARY
;
751 sec_flags
|= SEC_DATA
| SEC_THREAD_LOCAL
| SEC_LOAD
| SEC_ALLOC
;
753 else if (styp_flags
& STYP_TBSS
)
755 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
756 if (sec_flags
& SEC_NEVER_LOAD
)
757 sec_flags
|= SEC_ALLOC
| SEC_THREAD_LOCAL
| SEC_COFF_SHARED_LIBRARY
;
760 sec_flags
|= SEC_ALLOC
| SEC_THREAD_LOCAL
;
762 else if (styp_flags
& STYP_EXCEPT
)
763 sec_flags
|= SEC_LOAD
;
764 else if (styp_flags
& STYP_LOADER
)
765 sec_flags
|= SEC_LOAD
;
766 else if (styp_flags
& STYP_TYPCHK
)
767 sec_flags
|= SEC_LOAD
;
768 else if (styp_flags
& STYP_DWARF
)
769 sec_flags
|= SEC_DEBUGGING
;
771 else if (strcmp (name
, _TEXT
) == 0)
773 if (sec_flags
& SEC_NEVER_LOAD
)
774 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
776 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
778 else if (strcmp (name
, _DATA
) == 0)
780 if (sec_flags
& SEC_NEVER_LOAD
)
781 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
783 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
785 else if (strcmp (name
, _BSS
) == 0)
787 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
788 if (sec_flags
& SEC_NEVER_LOAD
)
789 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
792 sec_flags
|= SEC_ALLOC
;
794 else if (startswith (name
, DOT_DEBUG
)
795 || startswith (name
, DOT_ZDEBUG
)
797 || strcmp (name
, _COMMENT
) == 0
799 #ifdef COFF_LONG_SECTION_NAMES
800 || startswith (name
, GNU_LINKONCE_WI
)
801 || startswith (name
, GNU_LINKONCE_WT
)
803 || startswith (name
, ".stab"))
805 #ifdef COFF_PAGE_SIZE
806 sec_flags
|= SEC_DEBUGGING
;
810 else if (strcmp (name
, _LIB
) == 0)
814 else if (strcmp (name
, _LIT
) == 0)
815 sec_flags
= SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
818 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
820 #ifdef STYP_LIT /* A29k readonly text/data section type. */
821 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
822 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
823 #endif /* STYP_LIT */
825 #ifdef STYP_OTHER_LOAD /* Other loaded sections. */
826 if (styp_flags
& STYP_OTHER_LOAD
)
827 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
828 #endif /* STYP_SDATA */
830 if ((bfd_applicable_section_flags (abfd
) & SEC_SMALL_DATA
) != 0
831 && (startswith (name
, ".sbss")
832 || startswith (name
, ".sdata")))
833 sec_flags
|= SEC_SMALL_DATA
;
835 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
836 /* As a GNU extension, if the name begins with .gnu.linkonce, we
837 only link a single copy of the section. This is used to support
838 g++. g++ will emit each template expansion in its own section.
839 The symbols will be defined as weak, so that multiple definitions
840 are permitted. The GNU linker extension is to actually discard
841 all but one of the sections. */
842 if (startswith (name
, ".gnu.linkonce"))
843 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
846 if (flags_ptr
== NULL
)
849 * flags_ptr
= sec_flags
;
853 #else /* COFF_WITH_PE */
856 handle_COMDAT (bfd
* abfd
,
862 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
863 bfd_byte
*esymstart
, *esym
, *esymend
;
865 char *target_name
= NULL
;
867 *sec_flags
|= SEC_LINK_ONCE
;
869 /* Unfortunately, the PE format stores essential information in
870 the symbol table, of all places. We need to extract that
871 information now, so that objdump and the linker will know how
872 to handle the section without worrying about the symbols. We
873 can't call slurp_symtab, because the linker doesn't want the
876 /* COMDAT sections are special. The first symbol is the section
877 symbol, which tells what kind of COMDAT section it is. The
878 second symbol is the "comdat symbol" - the one with the
879 unique name. GNU uses the section symbol for the unique
880 name; MS uses ".text" for every comdat section. Sigh. - DJ */
882 /* This is not mirrored in sec_to_styp_flags(), but there
883 doesn't seem to be a need to, either, and it would at best be
886 if (! _bfd_coff_get_external_symbols (abfd
))
889 esymstart
= esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
890 esymend
= esym
+ obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
892 for (struct internal_syment isym
;
894 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
))
896 char buf
[SYMNMLEN
+ 1];
899 bfd_coff_swap_sym_in (abfd
, esym
, &isym
);
901 BFD_ASSERT (sizeof (internal_s
->s_name
) <= SYMNMLEN
);
903 if (isym
.n_scnum
== section
->target_index
)
905 /* According to the MSVC documentation, the first
906 TWO entries with the section # are both of
907 interest to us. The first one is the "section
908 symbol" (section name). The second is the comdat
909 symbol name. Here, we've found the first
910 qualifying entry; we distinguish it from the
911 second with a state flag.
913 In the case of gas-generated (at least until that
914 is fixed) .o files, it isn't necessarily the
915 second one. It may be some other later symbol.
917 Since gas also doesn't follow MS conventions and
918 emits the section similar to .text$<name>, where
919 <something> is the name we're looking for, we
920 distinguish the two as follows:
922 If the section name is simply a section name (no
923 $) we presume it's MS-generated, and look at
924 precisely the second symbol for the comdat name.
925 If the section name has a $, we assume it's
926 gas-generated, and look for <something> (whatever
927 follows the $) as the comdat symbol. */
929 /* All 3 branches use this. */
930 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
, buf
);
932 /* PR 17512 file: 078-11867-0.004 */
935 _bfd_error_handler (_("%pB: unable to load COMDAT section name"),
944 /* The first time we've seen the symbol. */
945 union internal_auxent aux
;
947 /* If it isn't the stuff we're expecting, die;
948 The MS documentation is vague, but it
949 appears that the second entry serves BOTH
950 as the comdat symbol and the defining
951 symbol record (either C_STAT or C_EXT,
952 possibly with an aux entry with debug
953 information if it's a function.) It
954 appears the only way to find the second one
955 is to count. (On Intel, they appear to be
956 adjacent, but on Alpha, they have been
959 Here, we think we've found the first one,
960 but there's some checking we can do to be
963 if (! ((isym
.n_sclass
== C_STAT
964 || isym
.n_sclass
== C_EXT
)
965 && BTYPE (isym
.n_type
) == T_NULL
966 && isym
.n_value
== 0))
968 /* Malformed input files can trigger this test.
970 _bfd_error_handler (_("%pB: error: unexpected symbol '%s' in COMDAT section"),
975 /* FIXME LATER: MSVC generates section names
976 like .text for comdats. Gas generates
977 names like .text$foo__Fv (in the case of a
978 function). See comment above for more. */
980 if (isym
.n_sclass
== C_STAT
&& strcmp (name
, symname
) != 0)
981 /* xgettext:c-format */
982 _bfd_error_handler (_("%pB: warning: COMDAT symbol '%s'"
983 " does not match section name '%s'"),
984 abfd
, symname
, name
);
986 /* This is the section symbol. */
988 target_name
= strchr (name
, '$');
989 if (target_name
!= NULL
)
997 if (isym
.n_numaux
== 0)
998 aux
.x_scn
.x_comdat
= 0;
1001 /* PR 17512: file: e2cfe54f. */
1002 if (esym
+ bfd_coff_symesz (abfd
) >= esymend
)
1004 /* xgettext:c-format */
1005 _bfd_error_handler (_("%pB: warning: no symbol for"
1006 " section '%s' found"),
1010 bfd_coff_swap_aux_in (abfd
, esym
+ bfd_coff_symesz (abfd
),
1011 isym
.n_type
, isym
.n_sclass
,
1012 0, isym
.n_numaux
, &aux
);
1015 /* FIXME: Microsoft uses NODUPLICATES and
1016 ASSOCIATIVE, but gnu uses ANY and
1017 SAME_SIZE. Unfortunately, gnu doesn't do
1018 the comdat symbols right. So, until we can
1019 fix it to do the right thing, we are
1020 temporarily disabling comdats for the MS
1021 types (they're used in DLLs and C++, but we
1022 don't support *their* C++ libraries anyway
1025 /* Cygwin does not follow the MS style, and
1026 uses ANY and SAME_SIZE where NODUPLICATES
1027 and ASSOCIATIVE should be used. For
1028 Interix, we just do the right thing up
1031 switch (aux
.x_scn
.x_comdat
)
1033 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
1034 #ifdef STRICT_PE_FORMAT
1035 *sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
1037 *sec_flags
&= ~SEC_LINK_ONCE
;
1041 case IMAGE_COMDAT_SELECT_ANY
:
1042 *sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1045 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
1046 *sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
1049 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
1050 /* Not yet fully implemented ??? */
1051 *sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
1054 /* debug$S gets this case; other
1057 /* There may be no symbol... we'll search
1058 the whole table... Is this the right
1059 place to play this game? Or should we do
1060 it when reading it in. */
1061 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
1062 #ifdef STRICT_PE_FORMAT
1063 /* FIXME: This is not currently implemented. */
1064 *sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1066 *sec_flags
&= ~SEC_LINK_ONCE
;
1070 default: /* 0 means "no symbol" */
1071 /* debug$F gets this case; other
1073 *sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1080 /* Gas mode: the first matching on partial name. */
1082 #ifndef TARGET_UNDERSCORE
1083 #define TARGET_UNDERSCORE 0
1085 /* Is this the name we're looking for ? */
1086 if (strcmp (target_name
,
1087 symname
+ (TARGET_UNDERSCORE
? 1 : 0)) != 0)
1089 /* Not the name we're looking for */
1094 /* MSVC mode: the lexically second symbol (or
1095 drop through from the above). */
1097 /* This must the second symbol with the
1098 section #. It is the actual symbol name.
1099 Intel puts the two adjacent, but Alpha (at
1100 least) spreads them out. */
1102 struct coff_comdat_info
*comdat
;
1103 size_t len
= strlen (symname
) + 1;
1105 comdat
= bfd_alloc (abfd
, sizeof (*comdat
) + len
);
1109 coff_section_data (abfd
, section
)->comdat
= comdat
;
1110 comdat
->symbol
= (esym
- esymstart
) / bfd_coff_symesz (abfd
);
1111 char *newname
= (char *) (comdat
+ 1);
1112 comdat
->name
= newname
;
1113 memcpy (newname
, symname
, len
);
1124 /* The PE version; see above for the general comments.
1126 Since to set the SEC_LINK_ONCE and associated flags, we have to
1127 look at the symbol table anyway, we return the symbol table index
1128 of the symbol being used as the COMDAT symbol. This is admittedly
1129 ugly, but there's really nowhere else that we have access to the
1130 required information. FIXME: Is the COMDAT symbol index used for
1131 any purpose other than objdump? */
1134 styp_to_sec_flags (bfd
*abfd
,
1138 flagword
*flags_ptr
)
1140 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
1141 unsigned long styp_flags
= internal_s
->s_flags
;
1144 bool is_dbg
= false;
1146 if (startswith (name
, DOT_DEBUG
)
1147 || startswith (name
, DOT_ZDEBUG
)
1148 #ifdef COFF_LONG_SECTION_NAMES
1149 || startswith (name
, GNU_LINKONCE_WI
)
1150 || startswith (name
, GNU_LINKONCE_WT
)
1151 /* FIXME: These definitions ought to be in a header file. */
1152 #define GNU_DEBUGLINK ".gnu_debuglink"
1153 #define GNU_DEBUGALTLINK ".gnu_debugaltlink"
1154 || startswith (name
, GNU_DEBUGLINK
)
1155 || startswith (name
, GNU_DEBUGALTLINK
)
1157 || startswith (name
, ".stab"))
1159 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
1160 sec_flags
= SEC_READONLY
;
1162 /* If section disallows read, then set the NOREAD flag. */
1163 if ((styp_flags
& IMAGE_SCN_MEM_READ
) == 0)
1164 sec_flags
|= SEC_COFF_NOREAD
;
1166 /* Process each flag bit in styp_flags in turn. */
1169 unsigned long flag
= styp_flags
& - styp_flags
;
1170 char * unhandled
= NULL
;
1172 styp_flags
&= ~ flag
;
1174 /* We infer from the distinct read/write/execute bits the settings
1175 of some of the bfd flags; the actual values, should we need them,
1176 are also in pei_section_data (abfd, section)->pe_flags. */
1181 unhandled
= "STYP_DSECT";
1184 unhandled
= "STYP_GROUP";
1187 unhandled
= "STYP_COPY";
1190 unhandled
= "STYP_OVER";
1192 #ifdef SEC_NEVER_LOAD
1194 sec_flags
|= SEC_NEVER_LOAD
;
1197 case IMAGE_SCN_MEM_READ
:
1198 sec_flags
&= ~SEC_COFF_NOREAD
;
1200 case IMAGE_SCN_TYPE_NO_PAD
:
1203 case IMAGE_SCN_LNK_OTHER
:
1204 unhandled
= "IMAGE_SCN_LNK_OTHER";
1206 case IMAGE_SCN_MEM_NOT_CACHED
:
1207 unhandled
= "IMAGE_SCN_MEM_NOT_CACHED";
1209 case IMAGE_SCN_MEM_NOT_PAGED
:
1210 /* Generate a warning message rather using the 'unhandled'
1211 variable as this will allow some .sys files generate by
1212 other toolchains to be processed. See bugzilla issue 196. */
1213 /* xgettext:c-format */
1214 _bfd_error_handler (_("%pB: warning: ignoring section flag"
1215 " %s in section %s"),
1216 abfd
, "IMAGE_SCN_MEM_NOT_PAGED", name
);
1218 case IMAGE_SCN_MEM_EXECUTE
:
1219 sec_flags
|= SEC_CODE
;
1221 case IMAGE_SCN_MEM_WRITE
:
1222 sec_flags
&= ~ SEC_READONLY
;
1224 case IMAGE_SCN_MEM_DISCARDABLE
:
1225 /* The MS PE spec says that debug sections are DISCARDABLE,
1226 but the presence of a DISCARDABLE flag does not necessarily
1227 mean that a given section contains debug information. Thus
1228 we only set the SEC_DEBUGGING flag on sections that we
1229 recognise as containing debug information. */
1232 || strcmp (name
, _COMMENT
) == 0
1236 sec_flags
|= SEC_DEBUGGING
| SEC_READONLY
;
1239 case IMAGE_SCN_MEM_SHARED
:
1240 sec_flags
|= SEC_COFF_SHARED
;
1242 case IMAGE_SCN_LNK_REMOVE
:
1244 sec_flags
|= SEC_EXCLUDE
;
1246 case IMAGE_SCN_CNT_CODE
:
1247 sec_flags
|= SEC_CODE
| SEC_ALLOC
| SEC_LOAD
;
1249 case IMAGE_SCN_CNT_INITIALIZED_DATA
:
1251 sec_flags
|= SEC_DEBUGGING
;
1253 sec_flags
|= SEC_DATA
| SEC_ALLOC
| SEC_LOAD
;
1255 case IMAGE_SCN_CNT_UNINITIALIZED_DATA
:
1256 sec_flags
|= SEC_ALLOC
;
1258 case IMAGE_SCN_LNK_INFO
:
1259 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1260 defined. coff_compute_section_file_positions uses
1261 COFF_PAGE_SIZE to ensure that the low order bits of the
1262 section VMA and the file offset match. If we don't know
1263 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1264 and demand page loading of the file will fail. */
1265 #ifdef COFF_PAGE_SIZE
1266 sec_flags
|= SEC_DEBUGGING
;
1269 case IMAGE_SCN_LNK_COMDAT
:
1270 /* COMDAT gets very special treatment. */
1271 if (!handle_COMDAT (abfd
, &sec_flags
, hdr
, name
, section
))
1275 /* Silently ignore for now. */
1279 /* If the section flag was not handled, report it here. */
1280 if (unhandled
!= NULL
)
1283 /* xgettext:c-format */
1284 (_("%pB (%s): section flag %s (%#lx) ignored"),
1285 abfd
, name
, unhandled
, flag
);
1290 if ((bfd_applicable_section_flags (abfd
) & SEC_SMALL_DATA
) != 0
1291 && (startswith (name
, ".sbss")
1292 || startswith (name
, ".sdata")))
1293 sec_flags
|= SEC_SMALL_DATA
;
1295 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1296 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1297 only link a single copy of the section. This is used to support
1298 g++. g++ will emit each template expansion in its own section.
1299 The symbols will be defined as weak, so that multiple definitions
1300 are permitted. The GNU linker extension is to actually discard
1301 all but one of the sections. */
1302 if (startswith (name
, ".gnu.linkonce"))
1303 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1307 * flags_ptr
= sec_flags
;
1312 #endif /* COFF_WITH_PE */
1314 #define get_index(symbol) ((symbol)->udata.i)
1318 bfd_coff_backend_data
1321 .{* COFF symbol classifications. *}
1323 .enum coff_symbol_classification
1325 . {* Global symbol. *}
1326 . COFF_SYMBOL_GLOBAL,
1327 . {* Common symbol. *}
1328 . COFF_SYMBOL_COMMON,
1329 . {* Undefined symbol. *}
1330 . COFF_SYMBOL_UNDEFINED,
1331 . {* Local symbol. *}
1332 . COFF_SYMBOL_LOCAL,
1333 . {* PE section symbol. *}
1334 . COFF_SYMBOL_PE_SECTION
1337 .typedef asection * (*coff_gc_mark_hook_fn)
1338 . (asection *, struct bfd_link_info *, struct internal_reloc *,
1339 . struct coff_link_hash_entry *, struct internal_syment *);
1342 Special entry points for gdb to swap in coff symbol table parts:
1347 . void (*_bfd_coff_swap_aux_in)
1348 . (bfd *, void *, int, int, int, int, void *);
1350 . void (*_bfd_coff_swap_sym_in)
1351 . (bfd *, void *, void *);
1353 . void (*_bfd_coff_swap_lineno_in)
1354 . (bfd *, void *, void *);
1356 . unsigned int (*_bfd_coff_swap_aux_out)
1357 . (bfd *, void *, int, int, int, int, void *);
1359 . unsigned int (*_bfd_coff_swap_sym_out)
1360 . (bfd *, void *, void *);
1362 . unsigned int (*_bfd_coff_swap_lineno_out)
1363 . (bfd *, void *, void *);
1365 . unsigned int (*_bfd_coff_swap_reloc_out)
1366 . (bfd *, void *, void *);
1368 . unsigned int (*_bfd_coff_swap_filehdr_out)
1369 . (bfd *, void *, void *);
1371 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1372 . (bfd *, void *, void *);
1374 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1375 . (bfd *, void *, void *);
1377 . unsigned int _bfd_filhsz;
1378 . unsigned int _bfd_aoutsz;
1379 . unsigned int _bfd_scnhsz;
1380 . unsigned int _bfd_symesz;
1381 . unsigned int _bfd_auxesz;
1382 . unsigned int _bfd_relsz;
1383 . unsigned int _bfd_linesz;
1384 . unsigned int _bfd_filnmlen;
1385 . bool _bfd_coff_long_filenames;
1387 . bool _bfd_coff_long_section_names;
1388 . bool (*_bfd_coff_set_long_section_names)
1391 . unsigned int _bfd_coff_default_section_alignment_power;
1392 . bool _bfd_coff_force_symnames_in_strings;
1393 . unsigned int _bfd_coff_debug_string_prefix_length;
1394 . unsigned int _bfd_coff_max_nscns;
1396 . void (*_bfd_coff_swap_filehdr_in)
1397 . (bfd *, void *, void *);
1399 . void (*_bfd_coff_swap_aouthdr_in)
1400 . (bfd *, void *, void *);
1402 . void (*_bfd_coff_swap_scnhdr_in)
1403 . (bfd *, void *, void *);
1405 . void (*_bfd_coff_swap_reloc_in)
1406 . (bfd *abfd, void *, void *);
1408 . bool (*_bfd_coff_bad_format_hook)
1411 . bool (*_bfd_coff_set_arch_mach_hook)
1414 . void * (*_bfd_coff_mkobject_hook)
1415 . (bfd *, void *, void *);
1417 . bool (*_bfd_styp_to_sec_flags_hook)
1418 . (bfd *, void *, const char *, asection *, flagword *);
1420 . void (*_bfd_set_alignment_hook)
1421 . (bfd *, asection *, void *);
1423 . bool (*_bfd_coff_slurp_symbol_table)
1426 . bool (*_bfd_coff_symname_in_debug)
1427 . (bfd *, struct internal_syment *);
1429 . bool (*_bfd_coff_pointerize_aux_hook)
1430 . (bfd *, combined_entry_type *, combined_entry_type *,
1431 . unsigned int, combined_entry_type *);
1433 . bool (*_bfd_coff_print_aux)
1434 . (bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1435 . combined_entry_type *, unsigned int);
1437 . bool (*_bfd_coff_reloc16_extra_cases)
1438 . (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1439 . bfd_byte *, size_t *, size_t *);
1441 . int (*_bfd_coff_reloc16_estimate)
1442 . (bfd *, asection *, arelent *, unsigned int,
1443 . struct bfd_link_info *);
1445 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1446 . (bfd *, struct internal_syment *);
1448 . bool (*_bfd_coff_compute_section_file_positions)
1451 . bool (*_bfd_coff_start_final_link)
1452 . (bfd *, struct bfd_link_info *);
1454 . bool (*_bfd_coff_relocate_section)
1455 . (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1456 . struct internal_reloc *, struct internal_syment *, asection **);
1458 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1459 . (bfd *, asection *, struct internal_reloc *,
1460 . struct coff_link_hash_entry *, struct internal_syment *, bfd_vma *);
1462 . bool (*_bfd_coff_adjust_symndx)
1463 . (bfd *, struct bfd_link_info *, bfd *, asection *,
1464 . struct internal_reloc *, bool *);
1466 . bool (*_bfd_coff_link_add_one_symbol)
1467 . (struct bfd_link_info *, bfd *, const char *, flagword,
1468 . asection *, bfd_vma, const char *, bool, bool,
1469 . struct bfd_link_hash_entry **);
1471 . bool (*_bfd_coff_link_output_has_begun)
1472 . (bfd *, struct coff_final_link_info *);
1474 . bool (*_bfd_coff_final_link_postscript)
1475 . (bfd *, struct coff_final_link_info *);
1477 . bool (*_bfd_coff_print_pdata)
1480 .} bfd_coff_backend_data;
1484 .#define coff_backend_info(abfd) \
1485 . ((const bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1487 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1488 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1490 .#define bfd_coff_swap_sym_in(a,e,i) \
1491 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1493 .#define bfd_coff_swap_lineno_in(a,e,i) \
1494 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1496 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1497 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1499 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1500 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1502 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1503 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1505 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1506 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1508 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1509 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1511 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1512 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1514 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1515 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1517 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1518 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1519 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1520 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1521 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1522 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1523 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1524 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1525 .#define bfd_coff_long_filenames(abfd) \
1526 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1527 .#define bfd_coff_long_section_names(abfd) \
1528 . (coff_data (abfd)->long_section_names)
1529 .#define bfd_coff_set_long_section_names(abfd, enable) \
1530 . ((coff_backend_info (abfd)->_bfd_coff_set_long_section_names) (abfd, enable))
1531 .#define bfd_coff_default_section_alignment_power(abfd) \
1532 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1533 .#define bfd_coff_max_nscns(abfd) \
1534 . (coff_backend_info (abfd)->_bfd_coff_max_nscns)
1536 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1537 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1539 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1540 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1542 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1543 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1545 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1546 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1548 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1549 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1551 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1552 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1553 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1554 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1555 . (abfd, filehdr, aouthdr))
1557 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1558 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1559 . (abfd, scnhdr, name, section, flags_ptr))
1561 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1562 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1564 .#define bfd_coff_slurp_symbol_table(abfd)\
1565 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1567 .#define bfd_coff_symname_in_debug(abfd, sym)\
1568 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1570 .#define bfd_coff_force_symnames_in_strings(abfd)\
1571 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1573 .#define bfd_coff_debug_string_prefix_length(abfd)\
1574 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1576 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1577 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1578 . (abfd, file, base, symbol, aux, indaux))
1580 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1581 . reloc, data, src_ptr, dst_ptr)\
1582 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1583 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1585 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1586 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1587 . (abfd, section, reloc, shrink, link_info))
1589 .#define bfd_coff_classify_symbol(abfd, sym)\
1590 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1593 .#define bfd_coff_compute_section_file_positions(abfd)\
1594 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1597 .#define bfd_coff_start_final_link(obfd, info)\
1598 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1600 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1601 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1602 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1603 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1604 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1605 . (abfd, sec, rel, h, sym, addendp))
1606 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1607 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1608 . (obfd, info, ibfd, sec, rel, adjustedp))
1609 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1610 . value, string, cp, coll, hashp)\
1611 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1612 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1614 .#define bfd_coff_link_output_has_begun(a,p) \
1615 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p))
1616 .#define bfd_coff_final_link_postscript(a,p) \
1617 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p))
1619 .#define bfd_coff_have_print_pdata(a) \
1620 . (coff_backend_info (a)->_bfd_coff_print_pdata)
1621 .#define bfd_coff_print_pdata(a,p) \
1622 . ((coff_backend_info (a)->_bfd_coff_print_pdata) (a, p))
1624 .{* Macro: Returns true if the bfd is a PE executable as opposed to a
1625 . PE object file. *}
1626 .#define bfd_pei_p(abfd) \
1627 . (startswith ((abfd)->xvec->name, "pei-"))
1630 /* See whether the magic number matches. */
1633 coff_bad_format_hook (bfd
* abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1635 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1637 if (BADMAG (*internal_f
))
1645 ticoff0_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1647 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1649 if (COFF0_BADMAG (*internal_f
))
1658 ticoff1_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1660 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1662 if (COFF1_BADMAG (*internal_f
))
1669 /* Check whether this section uses an alignment other than the
1673 coff_set_custom_section_alignment (bfd
*abfd ATTRIBUTE_UNUSED
,
1675 const struct coff_section_alignment_entry
*alignment_table
,
1676 const unsigned int table_size
)
1678 const unsigned int default_alignment
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1681 for (i
= 0; i
< table_size
; ++i
)
1683 const char *secname
= bfd_section_name (section
);
1685 if (alignment_table
[i
].comparison_length
== (unsigned int) -1
1686 ? strcmp (alignment_table
[i
].name
, secname
) == 0
1687 : strncmp (alignment_table
[i
].name
, secname
,
1688 alignment_table
[i
].comparison_length
) == 0)
1691 if (i
>= table_size
)
1694 if (alignment_table
[i
].default_alignment_min
!= COFF_ALIGNMENT_FIELD_EMPTY
1695 && default_alignment
< alignment_table
[i
].default_alignment_min
)
1698 if (alignment_table
[i
].default_alignment_max
!= COFF_ALIGNMENT_FIELD_EMPTY
1699 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1700 && default_alignment
> alignment_table
[i
].default_alignment_max
1705 section
->alignment_power
= alignment_table
[i
].alignment_power
;
1708 /* Custom section alignment records. */
1710 static const struct coff_section_alignment_entry
1711 coff_section_alignment_table
[] =
1713 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1714 COFF_SECTION_ALIGNMENT_ENTRIES
,
1716 /* There must not be any gaps between .stabstr sections. */
1717 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1718 1, COFF_ALIGNMENT_FIELD_EMPTY
, 0 },
1719 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1720 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1721 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1722 /* Similarly for the .ctors and .dtors sections. */
1723 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1724 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1725 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1726 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 }
1729 static const unsigned int coff_section_alignment_table_size
=
1730 sizeof coff_section_alignment_table
/ sizeof coff_section_alignment_table
[0];
1732 /* Initialize a section structure with information peculiar to this
1733 particular implementation of COFF. */
1736 coff_new_section_hook (bfd
* abfd
, asection
* section
)
1738 combined_entry_type
*native
;
1740 unsigned char sclass
= C_STAT
;
1742 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1745 if (bfd_xcoff_text_align_power (abfd
) != 0
1746 && strcmp (bfd_section_name (section
), ".text") == 0)
1747 section
->alignment_power
= bfd_xcoff_text_align_power (abfd
);
1748 else if (bfd_xcoff_data_align_power (abfd
) != 0
1749 && strcmp (bfd_section_name (section
), ".data") == 0)
1750 section
->alignment_power
= bfd_xcoff_data_align_power (abfd
);
1755 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
1756 if (strcmp (bfd_section_name (section
),
1757 xcoff_dwsect_names
[i
].xcoff_name
) == 0)
1759 section
->alignment_power
= 0;
1766 /* Set up the section symbol. */
1767 if (!_bfd_generic_new_section_hook (abfd
, section
))
1770 /* Allocate aux records for section symbols, to store size and
1773 @@ The 10 is a guess at a plausible maximum number of aux entries
1774 (but shouldn't be a constant). */
1775 amt
= sizeof (combined_entry_type
) * 10;
1776 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
1780 /* We don't need to set up n_name, n_value, or n_scnum in the native
1781 symbol information, since they'll be overridden by the BFD symbol
1782 anyhow. However, we do need to set the type and storage class,
1783 in case this symbol winds up getting written out. The value 0
1784 for n_numaux is already correct. */
1786 native
->is_sym
= true;
1787 native
->u
.syment
.n_type
= T_NULL
;
1788 native
->u
.syment
.n_sclass
= sclass
;
1790 coffsymbol (section
->symbol
)->native
= native
;
1792 coff_set_custom_section_alignment (abfd
, section
,
1793 coff_section_alignment_table
,
1794 coff_section_alignment_table_size
);
1799 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1801 /* Set the alignment of a BFD section. */
1804 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1808 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1811 #ifdef COFF_DECODE_ALIGNMENT
1812 i
= COFF_DECODE_ALIGNMENT(hdr
->s_flags
);
1814 section
->alignment_power
= i
;
1816 #ifdef coff_set_section_load_page
1817 coff_set_section_load_page (section
, hdr
->s_page
);
1821 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1825 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1829 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1831 unsigned int alignment_power_const
1832 = hdr
->s_flags
& IMAGE_SCN_ALIGN_POWER_BIT_MASK
;
1834 switch (alignment_power_const
)
1836 case IMAGE_SCN_ALIGN_8192BYTES
:
1837 case IMAGE_SCN_ALIGN_4096BYTES
:
1838 case IMAGE_SCN_ALIGN_2048BYTES
:
1839 case IMAGE_SCN_ALIGN_1024BYTES
:
1840 case IMAGE_SCN_ALIGN_512BYTES
:
1841 case IMAGE_SCN_ALIGN_256BYTES
:
1842 case IMAGE_SCN_ALIGN_128BYTES
:
1843 case IMAGE_SCN_ALIGN_64BYTES
:
1844 case IMAGE_SCN_ALIGN_32BYTES
:
1845 case IMAGE_SCN_ALIGN_16BYTES
:
1846 case IMAGE_SCN_ALIGN_8BYTES
:
1847 case IMAGE_SCN_ALIGN_4BYTES
:
1848 case IMAGE_SCN_ALIGN_2BYTES
:
1849 case IMAGE_SCN_ALIGN_1BYTES
:
1850 section
->alignment_power
1851 = IMAGE_SCN_ALIGN_POWER_NUM (alignment_power_const
);
1857 /* In a PE image file, the s_paddr field holds the virtual size of a
1858 section, while the s_size field holds the raw size. We also keep
1859 the original section flag value, since not every bit can be
1860 mapped onto a generic BFD section bit. */
1861 if (coff_section_data (abfd
, section
) == NULL
)
1863 amt
= sizeof (struct coff_section_tdata
);
1864 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
1865 if (section
->used_by_bfd
== NULL
)
1866 /* FIXME: Return error. */
1870 if (pei_section_data (abfd
, section
) == NULL
)
1872 amt
= sizeof (struct pei_section_tdata
);
1873 coff_section_data (abfd
, section
)->tdata
= bfd_zalloc (abfd
, amt
);
1874 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1875 /* FIXME: Return error. */
1878 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1879 pei_section_data (abfd
, section
)->pe_flags
= hdr
->s_flags
;
1881 section
->lma
= hdr
->s_vaddr
;
1883 /* Check for extended relocs. */
1884 if (hdr
->s_flags
& IMAGE_SCN_LNK_NRELOC_OVFL
)
1886 struct external_reloc dst
;
1887 struct internal_reloc n
;
1888 file_ptr oldpos
= bfd_tell (abfd
);
1889 bfd_size_type relsz
= bfd_coff_relsz (abfd
);
1891 if (bfd_seek (abfd
, (file_ptr
) hdr
->s_relptr
, 0) != 0)
1893 if (bfd_bread (& dst
, relsz
, abfd
) != relsz
)
1896 bfd_coff_swap_reloc_in (abfd
, &dst
, &n
);
1897 if (bfd_seek (abfd
, oldpos
, 0) != 0)
1899 if (n
.r_vaddr
< 0x10000)
1901 _bfd_error_handler (_("%pB: overflow reloc count too small"), abfd
);
1902 bfd_set_error (bfd_error_bad_value
);
1905 section
->reloc_count
= hdr
->s_nreloc
= n
.r_vaddr
- 1;
1906 section
->rel_filepos
+= relsz
;
1908 else if (hdr
->s_nreloc
== 0xffff)
1910 (_("%pB: warning: claims to have 0xffff relocs, without overflow"),
1914 #undef ELIFALIGN_SET
1916 #else /* ! COFF_WITH_PE */
1919 /* We grossly abuse this function to handle XCOFF overflow headers.
1920 When we see one, we correct the reloc and line number counts in the
1921 real header, and remove the section we just created. */
1924 coff_set_alignment_hook (bfd
*abfd
, asection
*section
, void * scnhdr
)
1926 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1929 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1932 real_sec
= coff_section_from_bfd_index (abfd
, (int) hdr
->s_nreloc
);
1933 if (real_sec
== NULL
)
1936 real_sec
->reloc_count
= hdr
->s_paddr
;
1937 real_sec
->lineno_count
= hdr
->s_vaddr
;
1939 if (!bfd_section_removed_from_list (abfd
, section
))
1941 bfd_section_list_remove (abfd
, section
);
1942 --abfd
->section_count
;
1946 #else /* ! RS6000COFF_C */
1947 #if defined (COFF_GO32_EXE) || defined (COFF_GO32)
1950 coff_set_alignment_hook (bfd
* abfd
, asection
* section
, void * scnhdr
)
1952 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1954 /* Check for extended relocs. */
1955 if (hdr
->s_flags
& IMAGE_SCN_LNK_NRELOC_OVFL
)
1957 struct external_reloc dst
;
1958 struct internal_reloc n
;
1959 const file_ptr oldpos
= bfd_tell (abfd
);
1960 const bfd_size_type relsz
= bfd_coff_relsz (abfd
);
1962 if (bfd_seek (abfd
, (file_ptr
) hdr
->s_relptr
, 0) != 0)
1964 if (bfd_bread (& dst
, relsz
, abfd
) != relsz
)
1967 bfd_coff_swap_reloc_in (abfd
, &dst
, &n
);
1968 if (bfd_seek (abfd
, oldpos
, 0) != 0)
1970 section
->reloc_count
= hdr
->s_nreloc
= n
.r_vaddr
- 1;
1971 section
->rel_filepos
+= relsz
;
1973 else if (hdr
->s_nreloc
== 0xffff)
1975 (_("%pB: warning: claims to have 0xffff relocs, without overflow"),
1979 #else /* ! COFF_GO32_EXE && ! COFF_GO32 */
1982 coff_set_alignment_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
1983 asection
*section ATTRIBUTE_UNUSED
,
1984 void *scnhdr ATTRIBUTE_UNUSED
)
1988 #endif /* ! COFF_GO32_EXE && ! COFF_GO32 */
1989 #endif /* ! RS6000COFF_C */
1990 #endif /* ! COFF_WITH_PE */
1991 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1993 #ifndef coff_mkobject
1996 coff_mkobject (bfd
* abfd
)
1998 coff_data_type
*coff
;
1999 size_t amt
= sizeof (coff_data_type
);
2001 abfd
->tdata
.coff_obj_data
= bfd_zalloc (abfd
, amt
);
2002 if (abfd
->tdata
.coff_obj_data
== NULL
)
2005 coff
= coff_data (abfd
);
2006 coff
->symbols
= NULL
;
2007 coff
->conversion_table
= NULL
;
2008 coff
->raw_syments
= NULL
;
2009 coff
->relocbase
= 0;
2010 coff
->local_toc_sym_map
= 0;
2012 bfd_coff_long_section_names (abfd
)
2013 = coff_backend_info (abfd
)->_bfd_coff_long_section_names
;
2015 /* make_abs_section(abfd);*/
2021 /* Create the COFF backend specific information. */
2023 #ifndef coff_mkobject_hook
2025 coff_mkobject_hook (bfd
* abfd
,
2027 void * aouthdr ATTRIBUTE_UNUSED
)
2029 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
2030 coff_data_type
*coff
;
2032 if (! coff_mkobject (abfd
))
2035 coff
= coff_data (abfd
);
2037 coff
->sym_filepos
= internal_f
->f_symptr
;
2039 /* These members communicate important constants about the symbol
2040 table to GDB's symbol-reading code. These `constants'
2041 unfortunately vary among coff implementations... */
2042 coff
->local_n_btmask
= N_BTMASK
;
2043 coff
->local_n_btshft
= N_BTSHFT
;
2044 coff
->local_n_tmask
= N_TMASK
;
2045 coff
->local_n_tshift
= N_TSHIFT
;
2046 coff
->local_symesz
= bfd_coff_symesz (abfd
);
2047 coff
->local_auxesz
= bfd_coff_auxesz (abfd
);
2048 coff
->local_linesz
= bfd_coff_linesz (abfd
);
2050 coff
->timestamp
= internal_f
->f_timdat
;
2052 obj_raw_syment_count (abfd
) =
2053 obj_conv_table_size (abfd
) =
2054 internal_f
->f_nsyms
;
2057 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
2058 abfd
->flags
|= DYNAMIC
;
2059 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= bfd_coff_aoutsz (abfd
))
2061 struct internal_aouthdr
*internal_a
=
2062 (struct internal_aouthdr
*) aouthdr
;
2063 struct xcoff_tdata
*xcoff
;
2065 xcoff
= xcoff_data (abfd
);
2066 # ifdef U803XTOCMAGIC
2067 xcoff
->xcoff64
= internal_f
->f_magic
== U803XTOCMAGIC
;
2071 xcoff
->full_aouthdr
= true;
2072 xcoff
->toc
= internal_a
->o_toc
;
2073 xcoff
->sntoc
= internal_a
->o_sntoc
;
2074 xcoff
->snentry
= internal_a
->o_snentry
;
2075 bfd_xcoff_text_align_power (abfd
) = internal_a
->o_algntext
;
2076 bfd_xcoff_data_align_power (abfd
) = internal_a
->o_algndata
;
2077 xcoff
->modtype
= internal_a
->o_modtype
;
2078 xcoff
->cputype
= internal_a
->o_cputype
;
2079 xcoff
->maxdata
= internal_a
->o_maxdata
;
2080 xcoff
->maxstack
= internal_a
->o_maxstack
;
2085 /* Set the flags field from the COFF header read in. */
2086 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
2091 /* FIXME: I'm not sure this is ever executed, since peicode.h
2092 defines coff_mkobject_hook. */
2093 if ((internal_f
->f_flags
& IMAGE_FILE_DEBUG_STRIPPED
) == 0)
2094 abfd
->flags
|= HAS_DEBUG
;
2101 /* Determine the machine architecture and type. FIXME: This is target
2102 dependent because the magic numbers are defined in the target
2103 dependent header files. But there is no particular need for this.
2104 If the magic numbers were moved to a separate file, this function
2105 would be target independent and would also be much more successful
2106 at linking together COFF files for different architectures. */
2109 coff_set_arch_mach_hook (bfd
*abfd
, void * filehdr
)
2111 unsigned long machine
;
2112 enum bfd_architecture arch
;
2113 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
2115 /* Zero selects the default machine for an arch. */
2117 switch (internal_f
->f_magic
)
2122 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler. */
2124 case I386_APPLE_MAGIC
:
2125 case I386_FREEBSD_MAGIC
:
2126 case I386_LINUX_MAGIC
:
2127 case I386_NETBSD_MAGIC
:
2128 arch
= bfd_arch_i386
;
2133 case AMD64_APPLE_MAGIC
:
2134 case AMD64_FREEBSD_MAGIC
:
2135 case AMD64_LINUX_MAGIC
:
2136 case AMD64_NETBSD_MAGIC
:
2137 arch
= bfd_arch_i386
;
2138 machine
= bfd_mach_x86_64
;
2143 arch
= bfd_arch_ia64
;
2150 arch
= bfd_arch_arm
;
2151 machine
= bfd_arm_get_mach_from_notes (abfd
, ARM_NOTE_SECTION
);
2152 if (machine
== bfd_mach_arm_unknown
)
2154 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
2156 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
2157 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
2158 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
2160 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
2161 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
2162 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
2163 /* The COFF header does not have enough bits available
2164 to cover all the different ARM architectures. So
2165 we interpret F_ARM_5, the highest flag value to mean
2166 "the highest ARM architecture known to BFD" which is
2167 currently the XScale. */
2168 case F_ARM_5
: machine
= bfd_mach_arm_XScale
; break;
2175 arch
= bfd_arch_aarch64
;
2176 machine
= internal_f
->f_flags
& F_AARCH64_ARCHITECTURE_MASK
;
2179 #ifdef LOONGARCH64MAGIC
2180 case LOONGARCH64MAGIC
:
2181 arch
= bfd_arch_loongarch
;
2182 machine
= internal_f
->f_flags
& F_LOONGARCH64_ARCHITECTURE_MASK
;
2187 arch
= bfd_arch_z80
;
2188 switch (internal_f
->f_flags
& F_MACHMASK
)
2190 case bfd_mach_z80strict
<< 12:
2191 case bfd_mach_z80
<< 12:
2192 case bfd_mach_z80n
<< 12:
2193 case bfd_mach_z80full
<< 12:
2194 case bfd_mach_r800
<< 12:
2195 case bfd_mach_gbz80
<< 12:
2196 case bfd_mach_z180
<< 12:
2197 case bfd_mach_ez80_z80
<< 12:
2198 case bfd_mach_ez80_adl
<< 12:
2199 machine
= ((unsigned)internal_f
->f_flags
& F_MACHMASK
) >> 12;
2208 arch
= bfd_arch_z8k
;
2209 switch (internal_f
->f_flags
& F_MACHMASK
)
2212 machine
= bfd_mach_z8001
;
2215 machine
= bfd_mach_z8002
;
2235 if (xcoff_data (abfd
)->cputype
!= -1)
2236 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
2239 /* We did not get a value from the a.out header. If the
2240 file has not been stripped, we may be able to get the
2241 architecture information from the first symbol, if it
2242 is a .file symbol. */
2243 if (obj_raw_syment_count (abfd
) == 0)
2248 struct internal_syment sym
;
2249 bfd_size_type amt
= bfd_coff_symesz (abfd
);
2251 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
2253 buf
= _bfd_malloc_and_read (abfd
, amt
, amt
);
2256 bfd_coff_swap_sym_in (abfd
, buf
, & sym
);
2257 if (sym
.n_sclass
== C_FILE
)
2258 cputype
= sym
.n_type
& 0xff;
2265 /* FIXME: We don't handle all cases here. */
2270 arch
= bfd_xcoff_architecture (abfd
);
2271 machine
= bfd_xcoff_machine (abfd
);
2275 arch
= bfd_arch_powerpc
;
2276 machine
= bfd_mach_ppc_601
;
2278 case 2: /* 64 bit PowerPC */
2279 arch
= bfd_arch_powerpc
;
2280 machine
= bfd_mach_ppc_620
;
2283 arch
= bfd_arch_powerpc
;
2284 machine
= bfd_mach_ppc
;
2287 arch
= bfd_arch_rs6000
;
2288 machine
= bfd_mach_rs6k
;
2295 #ifdef SH_ARCH_MAGIC_BIG
2296 case SH_ARCH_MAGIC_BIG
:
2297 case SH_ARCH_MAGIC_LITTLE
:
2299 case SH_ARCH_MAGIC_WINCE
:
2305 #ifdef MIPS_ARCH_MAGIC_WINCE
2306 case MIPS_ARCH_MAGIC_WINCE
:
2307 arch
= bfd_arch_mips
;
2313 #ifdef LYNXCOFFMAGIC
2316 arch
= bfd_arch_sparc
;
2322 arch
= bfd_arch_tic30
;
2327 #ifdef TICOFF_TARGET_ARCH
2328 /* This TI COFF section should be used by all new TI COFF v0 targets. */
2330 arch
= TICOFF_TARGET_ARCH
;
2331 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2337 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */
2338 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */
2341 switch (internal_f
->f_target_id
)
2345 arch
= TICOFF_TARGET_ARCH
;
2346 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2350 arch
= bfd_arch_obscure
;
2352 (_("unrecognized TI COFF target id '0x%x'"),
2353 internal_f
->f_target_id
);
2361 arch
= bfd_arch_mcore
;
2365 default: /* Unreadable input file type. */
2366 arch
= bfd_arch_obscure
;
2370 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2375 symname_in_debug_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2376 struct internal_syment
*sym ATTRIBUTE_UNUSED
)
2378 #ifdef SYMNAME_IN_DEBUG
2379 return SYMNAME_IN_DEBUG (sym
) != 0;
2388 #define FORCE_SYMNAMES_IN_STRINGS
2391 /* Handle the csect auxent of a C_EXT, C_AIX_WEAKEXT or C_HIDEXT symbol. */
2394 coff_pointerize_aux_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2395 combined_entry_type
*table_base
,
2396 combined_entry_type
*symbol
,
2397 unsigned int indaux
,
2398 combined_entry_type
*aux
)
2400 BFD_ASSERT (symbol
->is_sym
);
2401 int n_sclass
= symbol
->u
.syment
.n_sclass
;
2403 if (CSECT_SYM_P (n_sclass
)
2404 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2406 BFD_ASSERT (! aux
->is_sym
);
2407 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
2408 && aux
->u
.auxent
.x_csect
.x_scnlen
.u64
< obj_raw_syment_count (abfd
))
2410 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2411 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.u64
;
2412 aux
->fix_scnlen
= 1;
2415 /* Return TRUE to indicate that the caller should not do any
2416 further work on this auxent. */
2420 /* Return FALSE to indicate that this auxent should be handled by
2426 #define coff_pointerize_aux_hook 0
2427 #endif /* ! RS6000COFF_C */
2429 /* Print an aux entry. This returns TRUE if it has printed it. */
2432 coff_print_aux (bfd
*abfd ATTRIBUTE_UNUSED
,
2433 FILE *file ATTRIBUTE_UNUSED
,
2434 combined_entry_type
*table_base ATTRIBUTE_UNUSED
,
2435 combined_entry_type
*symbol ATTRIBUTE_UNUSED
,
2436 combined_entry_type
*aux ATTRIBUTE_UNUSED
,
2437 unsigned int indaux ATTRIBUTE_UNUSED
)
2439 BFD_ASSERT (symbol
->is_sym
);
2440 BFD_ASSERT (! aux
->is_sym
);
2442 if (CSECT_SYM_P (symbol
->u
.syment
.n_sclass
)
2443 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2445 /* This is a csect entry. */
2446 fprintf (file
, "AUX ");
2447 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2449 BFD_ASSERT (! aux
->fix_scnlen
);
2450 fprintf (file
, "val %5" PRIu64
,
2451 aux
->u
.auxent
.x_csect
.x_scnlen
.u64
);
2455 fprintf (file
, "indx ");
2456 if (! aux
->fix_scnlen
)
2457 fprintf (file
, "%4" PRIu64
,
2458 aux
->u
.auxent
.x_csect
.x_scnlen
.u64
);
2460 fprintf (file
, "%4ld",
2461 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2464 " prmhsh %u snhsh %u typ %d algn %d clss %u stb %u snstb %u",
2465 aux
->u
.auxent
.x_csect
.x_parmhash
,
2466 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2467 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2468 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2469 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2470 aux
->u
.auxent
.x_csect
.x_stab
,
2471 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2476 /* Return FALSE to indicate that no special action was taken. */
2484 To write relocations, the back end steps though the
2485 canonical relocation table and create an
2486 @code{internal_reloc}. The symbol index to use is removed from
2487 the @code{offset} field in the symbol table supplied. The
2488 address comes directly from the sum of the section base
2489 address and the relocation offset; the type is dug directly
2490 from the howto field. Then the @code{internal_reloc} is
2491 swapped into the shape of an @code{external_reloc} and written
2499 /* AUX's ld wants relocations to be sorted. */
2501 compare_arelent_ptr (const void * x
, const void * y
)
2503 const arelent
**a
= (const arelent
**) x
;
2504 const arelent
**b
= (const arelent
**) y
;
2505 bfd_size_type aadr
= (*a
)->address
;
2506 bfd_size_type badr
= (*b
)->address
;
2508 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2511 #endif /* TARG_AUX */
2514 coff_write_relocs (bfd
* abfd
, int first_undef
)
2518 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2521 struct external_reloc dst
;
2528 /* Sort relocations before we write them out. */
2531 amt
= s
->reloc_count
;
2532 amt
*= sizeof (arelent
*);
2533 p
= bfd_malloc (amt
);
2536 if (s
->reloc_count
> 0)
2541 memcpy (p
, s
->orelocation
, (size_t) amt
);
2542 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2547 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2550 #ifdef COFF_WITH_EXTENDED_RELOC_COUNTER
2551 if ((obj_pe (abfd
) || obj_go32 (abfd
)) && s
->reloc_count
>= 0xffff)
2553 /* Encode real count here as first reloc. */
2554 struct internal_reloc n
;
2556 memset (& n
, 0, sizeof (n
));
2557 /* Add one to count *this* reloc (grr). */
2558 n
.r_vaddr
= s
->reloc_count
+ 1;
2559 coff_swap_reloc_out (abfd
, &n
, &dst
);
2560 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2561 abfd
) != bfd_coff_relsz (abfd
))
2566 for (i
= 0; i
< s
->reloc_count
; i
++)
2568 struct internal_reloc n
;
2571 memset (& n
, 0, sizeof (n
));
2573 /* Now we've renumbered the symbols we know where the
2574 undefined symbols live in the table. Check the reloc
2575 entries for symbols who's output bfd isn't the right one.
2576 This is because the symbol was undefined (which means
2577 that all the pointers are never made to point to the same
2578 place). This is a bad thing,'cause the symbols attached
2579 to the output bfd are indexed, so that the relocation
2580 entries know which symbol index they point to. So we
2581 have to look up the output symbol here. */
2583 if (q
->sym_ptr_ptr
[0] != NULL
&& q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2586 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2587 asymbol
**outsyms
= abfd
->outsymbols
;
2589 for (j
= first_undef
; outsyms
[j
]; j
++)
2591 const char *intable
= outsyms
[j
]->name
;
2593 if (strcmp (intable
, sname
) == 0)
2595 /* Got a hit, so repoint the reloc. */
2596 q
->sym_ptr_ptr
= outsyms
+ j
;
2602 n
.r_vaddr
= q
->address
+ s
->vma
;
2605 /* The 29k const/consth reloc pair is a real kludge. The consth
2606 part doesn't have a symbol; it has an offset. So rebuilt
2608 if (q
->howto
->type
== R_IHCONST
)
2609 n
.r_symndx
= q
->addend
;
2612 if (q
->sym_ptr_ptr
&& q
->sym_ptr_ptr
[0] != NULL
)
2614 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2615 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
, s
))
2617 if ((*q
->sym_ptr_ptr
)->section
== bfd_abs_section_ptr
2618 && ((*q
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) != 0)
2620 /* This is a relocation relative to the absolute symbol. */
2624 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2625 /* Check to see if the symbol reloc points to a symbol
2626 we don't have in our symbol table. */
2627 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2629 bfd_set_error (bfd_error_bad_value
);
2630 /* xgettext:c-format */
2631 _bfd_error_handler (_("%pB: reloc against a non-existent"
2632 " symbol index: %ld"),
2639 #ifdef SWAP_OUT_RELOC_OFFSET
2640 n
.r_offset
= q
->addend
;
2644 /* Work out reloc type from what is required. */
2646 SELECT_RELOC (n
, q
->howto
);
2649 n
.r_type
= q
->howto
->type
;
2651 coff_swap_reloc_out (abfd
, &n
, &dst
);
2653 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2654 abfd
) != bfd_coff_relsz (abfd
))
2666 /* Set flags and magic number of a coff file from architecture and machine
2667 type. Result is TRUE if we can represent the arch&type, FALSE if not. */
2670 coff_set_flags (bfd
* abfd
,
2671 unsigned int *magicp ATTRIBUTE_UNUSED
,
2672 unsigned short *flagsp ATTRIBUTE_UNUSED
)
2674 switch (bfd_get_arch (abfd
))
2679 switch (bfd_get_mach (abfd
))
2681 case bfd_mach_z80strict
:
2684 case bfd_mach_z80full
:
2686 case bfd_mach_gbz80
:
2688 case bfd_mach_ez80_z80
:
2689 case bfd_mach_ez80_adl
:
2690 *flagsp
= bfd_get_mach (abfd
) << 12;
2702 switch (bfd_get_mach (abfd
))
2704 case bfd_mach_z8001
: *flagsp
= F_Z8001
; break;
2705 case bfd_mach_z8002
: *flagsp
= F_Z8002
; break;
2706 default: return false;
2712 case bfd_arch_tic30
:
2713 *magicp
= TIC30MAGIC
;
2717 #ifdef TICOFF_DEFAULT_MAGIC
2718 case TICOFF_TARGET_ARCH
:
2719 /* If there's no indication of which version we want, use the default. */
2721 *magicp
= TICOFF_DEFAULT_MAGIC
;
2724 /* We may want to output in a different COFF version. */
2725 switch (abfd
->xvec
->name
[4])
2728 *magicp
= TICOFF0MAGIC
;
2731 *magicp
= TICOFF1MAGIC
;
2734 *magicp
= TICOFF2MAGIC
;
2740 TICOFF_TARGET_MACHINE_SET (flagsp
, bfd_get_mach (abfd
));
2745 case bfd_arch_aarch64
:
2746 * magicp
= AARCH64MAGIC
;
2750 #ifdef LOONGARCH64MAGIC
2751 case bfd_arch_loongarch
:
2752 * magicp
= LOONGARCH64MAGIC
;
2759 * magicp
= ARMPEMAGIC
;
2761 * magicp
= ARMMAGIC
;
2764 if (APCS_SET (abfd
))
2766 if (APCS_26_FLAG (abfd
))
2767 * flagsp
|= F_APCS26
;
2769 if (APCS_FLOAT_FLAG (abfd
))
2770 * flagsp
|= F_APCS_FLOAT
;
2772 if (PIC_FLAG (abfd
))
2775 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2776 * flagsp
|= F_INTERWORK
;
2777 switch (bfd_get_mach (abfd
))
2779 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2780 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2781 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2782 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2783 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2784 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2785 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2786 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2787 See also the comment in coff_set_arch_mach_hook(). */
2788 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break;
2789 case bfd_mach_arm_5TE
: * flagsp
|= F_ARM_5
; break;
2790 case bfd_mach_arm_XScale
: * flagsp
|= F_ARM_5
; break;
2795 #if defined(I386MAGIC) || defined(AMD64MAGIC)
2797 #if defined(I386MAGIC)
2798 *magicp
= I386MAGIC
;
2801 /* Just overwrite the usual value if we're doing Lynx. */
2802 *magicp
= LYNXCOFFMAGIC
;
2804 #if defined AMD64MAGIC
2805 *magicp
= AMD64MAGIC
;
2812 *magicp
= IA64MAGIC
;
2816 #ifdef SH_ARCH_MAGIC_BIG
2818 #ifdef COFF_IMAGE_WITH_PE
2819 *magicp
= SH_ARCH_MAGIC_WINCE
;
2821 if (bfd_big_endian (abfd
))
2822 *magicp
= SH_ARCH_MAGIC_BIG
;
2824 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2829 #ifdef MIPS_ARCH_MAGIC_WINCE
2831 *magicp
= MIPS_ARCH_MAGIC_WINCE
;
2836 case bfd_arch_sparc
:
2837 *magicp
= SPARCMAGIC
;
2839 /* Just overwrite the usual value if we're doing Lynx. */
2840 *magicp
= LYNXCOFFMAGIC
;
2846 case bfd_arch_rs6000
:
2847 case bfd_arch_powerpc
:
2848 BFD_ASSERT (bfd_get_flavour (abfd
) == bfd_target_xcoff_flavour
);
2849 *magicp
= bfd_xcoff_magic_number (abfd
);
2854 case bfd_arch_mcore
:
2855 * magicp
= MCOREMAGIC
;
2859 default: /* Unknown architecture. */
2867 coff_set_arch_mach (bfd
* abfd
,
2868 enum bfd_architecture arch
,
2869 unsigned long machine
)
2872 unsigned short dummy2
;
2874 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
2877 if (arch
!= bfd_arch_unknown
2878 && ! coff_set_flags (abfd
, &dummy1
, &dummy2
))
2879 return false; /* We can't represent this type. */
2881 return true; /* We're easy... */
2884 #ifdef COFF_IMAGE_WITH_PE
2886 /* This is used to sort sections by VMA, as required by PE image
2890 sort_by_secaddr (const void * arg1
, const void * arg2
)
2892 const asection
*a
= *(const asection
**) arg1
;
2893 const asection
*b
= *(const asection
**) arg2
;
2895 if (a
->vma
< b
->vma
)
2897 else if (a
->vma
> b
->vma
)
2903 #endif /* COFF_IMAGE_WITH_PE */
2905 /* Calculate the file position for each section. */
2907 #define ALIGN_SECTIONS_IN_FILE
2909 #undef ALIGN_SECTIONS_IN_FILE
2913 coff_compute_section_file_positions (bfd
* abfd
)
2916 file_ptr sofar
= bfd_coff_filhsz (abfd
);
2918 unsigned int target_index
;
2919 #ifdef ALIGN_SECTIONS_IN_FILE
2920 asection
*previous
= NULL
;
2924 #ifdef COFF_IMAGE_WITH_PE
2925 unsigned int page_size
;
2927 if (coff_data (abfd
)->link_info
2928 || (pe_data (abfd
) && pe_data (abfd
)->pe_opthdr
.FileAlignment
))
2930 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
2932 /* If no file alignment has been set, default to one.
2933 This repairs 'ld -r' for arm-wince-pe target. */
2938 page_size
= PE_DEF_FILE_ALIGNMENT
;
2940 #ifdef COFF_PAGE_SIZE
2941 unsigned int page_size
= COFF_PAGE_SIZE
;
2946 /* On XCOFF, if we have symbols, set up the .debug section. */
2947 if (bfd_get_symcount (abfd
) > 0)
2950 bfd_size_type i
, symcount
;
2954 symcount
= bfd_get_symcount (abfd
);
2955 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
2957 coff_symbol_type
*cf
;
2959 cf
= coff_symbol_from (*symp
);
2961 && cf
->native
!= NULL
2962 && cf
->native
->is_sym
2963 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
2967 len
= strlen (bfd_asymbol_name (*symp
));
2968 if (len
> SYMNMLEN
|| bfd_coff_force_symnames_in_strings (abfd
))
2969 sz
+= len
+ 1 + bfd_coff_debug_string_prefix_length (abfd
);
2976 dsec
= bfd_make_section_old_way (abfd
, DOT_DEBUG
);
2980 dsec
->flags
|= SEC_HAS_CONTENTS
;
2985 if (bfd_get_start_address (abfd
))
2986 /* A start address may have been added to the original file. In this
2987 case it will need an optional header to record it. */
2988 abfd
->flags
|= EXEC_P
;
2990 if (abfd
->flags
& EXEC_P
)
2991 sofar
+= bfd_coff_aoutsz (abfd
);
2993 else if (xcoff_data (abfd
)->full_aouthdr
)
2994 sofar
+= bfd_coff_aoutsz (abfd
);
2996 sofar
+= SMALL_AOUTSZ
;
2999 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
3002 /* XCOFF handles overflows in the reloc and line number count fields
3003 by allocating a new section header to hold the correct counts. */
3004 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3005 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3006 sofar
+= bfd_coff_scnhsz (abfd
);
3009 if (coff_data (abfd
)->section_by_target_index
)
3010 htab_empty (coff_data (abfd
)->section_by_target_index
);
3012 #ifdef COFF_IMAGE_WITH_PE
3014 /* PE requires the sections to be in memory order when listed in
3015 the section headers. It also does not like empty loadable
3016 sections. The sections apparently do not have to be in the
3017 right order in the image file itself, but we do need to get the
3018 target_index values right. */
3021 asection
**section_list
;
3025 #ifdef COFF_PAGE_SIZE
3026 /* Clear D_PAGED if section / file alignment aren't suitable for
3027 paging at COFF_PAGE_SIZE granularity. */
3028 if (pe_data (abfd
)->pe_opthdr
.SectionAlignment
< COFF_PAGE_SIZE
3029 || page_size
< COFF_PAGE_SIZE
)
3030 abfd
->flags
&= ~D_PAGED
;
3034 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3037 /* We allocate an extra cell to simplify the final loop. */
3038 amt
= sizeof (struct asection
*) * (count
+ 1);
3039 section_list
= (asection
**) bfd_malloc (amt
);
3040 if (section_list
== NULL
)
3044 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3046 section_list
[i
] = current
;
3049 section_list
[i
] = NULL
;
3051 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
3053 /* Rethread the linked list into sorted order; at the same time,
3054 assign target_index values. */
3056 abfd
->sections
= NULL
;
3057 abfd
->section_last
= NULL
;
3058 for (i
= 0; i
< count
; i
++)
3060 current
= section_list
[i
];
3061 bfd_section_list_append (abfd
, current
);
3063 /* Later, if the section has zero size, we'll be throwing it
3064 away, so we don't want to number it now. Note that having
3065 a zero size and having real contents are different
3066 concepts: .bss has no contents, but (usually) non-zero
3068 if (current
->size
== 0)
3070 /* Discard. However, it still might have (valid) symbols
3071 in it, so arbitrarily set it to section 1 (indexing is
3072 1-based here; usually .text). __end__ and other
3073 contents of .endsection really have this happen.
3074 FIXME: This seems somewhat dubious. */
3075 current
->target_index
= 1;
3078 current
->target_index
= target_index
++;
3081 free (section_list
);
3083 #else /* ! COFF_IMAGE_WITH_PE */
3085 /* Set the target_index field. */
3087 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3088 current
->target_index
= target_index
++;
3090 #endif /* ! COFF_IMAGE_WITH_PE */
3092 if (target_index
>= bfd_coff_max_nscns (abfd
))
3094 bfd_set_error (bfd_error_file_too_big
);
3096 /* xgettext:c-format */
3097 (_("%pB: too many sections (%d)"), abfd
, target_index
);
3101 align_adjust
= false;
3102 for (current
= abfd
->sections
;
3104 current
= current
->next
)
3106 #ifdef COFF_IMAGE_WITH_PE
3107 /* With PE we have to pad each section to be a multiple of its
3108 page size too, and remember both sizes. */
3109 if (coff_section_data (abfd
, current
) == NULL
)
3111 size_t amt
= sizeof (struct coff_section_tdata
);
3113 current
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
3114 if (current
->used_by_bfd
== NULL
)
3117 if (pei_section_data (abfd
, current
) == NULL
)
3119 size_t amt
= sizeof (struct pei_section_tdata
);
3121 coff_section_data (abfd
, current
)->tdata
= bfd_zalloc (abfd
, amt
);
3122 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
3125 if (pei_section_data (abfd
, current
)->virt_size
== 0)
3126 pei_section_data (abfd
, current
)->virt_size
= current
->size
;
3129 /* Only deal with sections which have contents. */
3130 if (!(current
->flags
& SEC_HAS_CONTENTS
))
3133 current
->rawsize
= current
->size
;
3135 #ifdef COFF_IMAGE_WITH_PE
3136 /* Make sure we skip empty sections in a PE image. */
3137 if (current
->size
== 0)
3141 /* Align the sections in the file to the same boundary on
3142 which they are aligned in virtual memory. */
3143 #ifdef ALIGN_SECTIONS_IN_FILE
3144 if ((abfd
->flags
& EXEC_P
) != 0)
3146 /* Make sure this section is aligned on the right boundary - by
3147 padding the previous section up if necessary. */
3150 #ifdef COFF_IMAGE_WITH_PE
3151 sofar
= BFD_ALIGN (sofar
, page_size
);
3153 sofar
= BFD_ALIGN (sofar
, (bfd_vma
) 1 << current
->alignment_power
);
3157 /* Make sure the file offset and the vma of .text/.data are at the
3158 same page offset, so that the file can be mmap'ed without being
3159 relocated. Failing that, AIX is able to load and execute the
3160 program, but it will be silently relocated (possible as
3161 executables are PIE). But the relocation is slightly costly and
3162 complexify the use of addr2line or gdb. So better to avoid it,
3163 like does the native linker. Usually gnu ld makes sure that
3164 the vma of .text is the file offset so this issue shouldn't
3165 appear unless you are stripping such an executable.
3167 AIX loader checks the text section alignment of (vma - filepos),
3168 and the native linker doesn't try to align the text sections.
3171 0 .text 000054cc 10000128 10000128 00000128 2**5
3172 CONTENTS, ALLOC, LOAD, CODE
3174 Don't perform the above tweak if the previous one is .tdata,
3175 as it will increase the memory allocated for every threads
3176 created and not just improve performances with gdb.
3179 if ((current
->flags
& SEC_LOAD
) != 0
3180 && (!strcmp (current
->name
, _TEXT
)
3181 || !strcmp (current
->name
, _DATA
))
3182 && (previous
== NULL
|| strcmp(previous
->name
, _TDATA
)))
3184 bfd_vma align
= 4096;
3185 bfd_vma sofar_off
= sofar
% align
;
3186 bfd_vma vma_off
= current
->vma
% align
;
3188 if (vma_off
> sofar_off
)
3189 sofar
+= vma_off
- sofar_off
;
3190 else if (vma_off
< sofar_off
)
3191 sofar
+= align
+ vma_off
- sofar_off
;
3194 if (previous
!= NULL
3195 && (previous
->flags
& SEC_LOAD
) != 0)
3196 previous
->size
+= sofar
- old_sofar
;
3201 /* In demand paged files the low order bits of the file offset
3202 must match the low order bits of the virtual address. */
3203 #ifdef COFF_PAGE_SIZE
3204 if ((abfd
->flags
& D_PAGED
) != 0
3205 && (current
->flags
& SEC_ALLOC
) != 0)
3206 sofar
+= (current
->vma
- (bfd_vma
) sofar
) % page_size
;
3208 current
->filepos
= sofar
;
3210 #ifdef COFF_IMAGE_WITH_PE
3211 /* Set the padded size. */
3212 current
->size
= (current
->size
+ page_size
- 1) & -page_size
;
3215 sofar
+= current
->size
;
3217 #ifdef ALIGN_SECTIONS_IN_FILE
3218 /* Make sure that this section is of the right size too. */
3219 if ((abfd
->flags
& EXEC_P
) == 0)
3221 bfd_size_type old_size
;
3223 old_size
= current
->size
;
3224 current
->size
= BFD_ALIGN (current
->size
,
3225 (bfd_vma
) 1 << current
->alignment_power
);
3226 align_adjust
= current
->size
!= old_size
;
3227 sofar
+= current
->size
- old_size
;
3232 #ifdef COFF_IMAGE_WITH_PE
3233 sofar
= BFD_ALIGN (sofar
, page_size
);
3235 sofar
= BFD_ALIGN (sofar
, (bfd_vma
) 1 << current
->alignment_power
);
3237 align_adjust
= sofar
!= old_sofar
;
3238 current
->size
+= sofar
- old_sofar
;
3242 #ifdef COFF_IMAGE_WITH_PE
3243 /* For PE we need to make sure we pad out to the aligned
3244 size, in case the caller only writes out data to the
3246 if (pei_section_data (abfd
, current
)->virt_size
< current
->size
)
3247 align_adjust
= true;
3251 /* Force .lib sections to start at zero. The vma is then
3252 incremented in coff_set_section_contents. This is right for
3254 if (strcmp (current
->name
, _LIB
) == 0)
3255 bfd_set_section_vma (current
, 0);
3258 #ifdef ALIGN_SECTIONS_IN_FILE
3263 /* It is now safe to write to the output file. If we needed an
3264 alignment adjustment for the last section, then make sure that
3265 there is a byte at offset sofar. If there are no symbols and no
3266 relocs, then nothing follows the last section. If we don't force
3267 the last byte out, then the file may appear to be truncated. */
3273 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
3274 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3278 /* Make sure the relocations are aligned. We don't need to make
3279 sure that this byte exists, because it will only matter if there
3280 really are relocs. */
3281 sofar
= BFD_ALIGN (sofar
,
3282 (bfd_vma
) 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
3284 obj_relocbase (abfd
) = sofar
;
3285 abfd
->output_has_begun
= true;
3290 #ifdef COFF_IMAGE_WITH_PE
3293 coff_read_word (bfd
*abfd
, unsigned int *value
, unsigned int *pelength
)
3298 status
= bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3306 *value
= (unsigned int) b
[0];
3308 *value
= (unsigned int) (b
[0] + (b
[1] << 8));
3310 *pelength
+= status
;
3315 /* Read a two byte number from buffer B returning the result in VALUE.
3316 No more than BUF_SIZE bytes will be read.
3317 Returns true upobn success, false otherwise.
3318 If successful, increases the value stored in PELENGTH by the number
3322 coff_read_word_from_buffer (unsigned char * b
,
3324 unsigned int * value
,
3325 unsigned int * pelength
)
3335 *value
= (unsigned int)b
[0];
3340 *value
= (unsigned int)(b
[0] + (b
[1] << 8));
3347 #define COFF_CHECKSUM_BUFFER_SIZE 0x800000
3350 coff_compute_checksum (bfd
*abfd
, unsigned int *pelength
)
3360 filepos
= (file_ptr
) 0;
3361 buf
= (unsigned char *) bfd_malloc (COFF_CHECKSUM_BUFFER_SIZE
);
3368 unsigned char *cur_buf
;
3371 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
3374 buf_size
= bfd_bread (buf
, COFF_CHECKSUM_BUFFER_SIZE
, abfd
);
3375 cur_buf_size
= buf_size
;
3378 while (cur_buf_size
> 0)
3380 coff_read_word_from_buffer (cur_buf
, cur_buf_size
, &value
, pelength
);
3384 total
= 0xffff & (total
+ (total
>> 0x10));
3387 filepos
+= buf_size
;
3389 while (buf_size
> 0);
3393 return (0xffff & (total
+ (total
>> 0x10)));
3397 coff_apply_checksum (bfd
*abfd
)
3399 unsigned int computed
;
3400 unsigned int checksum
= 0;
3401 unsigned int peheader
;
3402 unsigned int pelength
;
3404 if (bfd_seek (abfd
, 0x3c, SEEK_SET
) != 0)
3407 if (!coff_read_word (abfd
, &peheader
, &pelength
))
3410 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3414 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3416 if (bfd_seek (abfd
, peheader
, SEEK_SET
) != 0)
3419 computed
= coff_compute_checksum (abfd
, &pelength
);
3421 checksum
= computed
+ pelength
;
3423 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3426 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3431 #endif /* COFF_IMAGE_WITH_PE */
3434 coff_write_object_contents (bfd
* abfd
)
3437 bool hasrelocs
= false;
3438 bool haslinno
= false;
3439 #ifdef COFF_IMAGE_WITH_PE
3440 bool hasdebug
= false;
3443 file_ptr reloc_base
;
3444 file_ptr lineno_base
;
3446 unsigned long reloc_size
= 0, reloc_count
= 0;
3447 unsigned long lnno_size
= 0;
3448 bool long_section_names
;
3449 asection
*text_sec
= NULL
;
3450 asection
*data_sec
= NULL
;
3451 asection
*bss_sec
= NULL
;
3453 asection
*tdata_sec
= NULL
;
3454 asection
*tbss_sec
= NULL
;
3456 struct internal_filehdr internal_f
;
3457 struct internal_aouthdr internal_a
;
3458 #ifdef COFF_LONG_SECTION_NAMES
3459 size_t string_size
= STRING_SIZE_SIZE
;
3462 bfd_set_error (bfd_error_system_call
);
3464 /* Make a pass through the symbol table to count line number entries and
3465 put them into the correct asections. */
3466 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3468 if (! abfd
->output_has_begun
)
3470 if (! coff_compute_section_file_positions (abfd
))
3474 reloc_base
= obj_relocbase (abfd
);
3476 /* Work out the size of the reloc and linno areas. */
3478 for (current
= abfd
->sections
; current
!= NULL
; current
=
3481 #ifdef COFF_WITH_EXTENDED_RELOC_COUNTER
3482 /* We store the actual reloc count in the first reloc's addr. */
3483 if ((obj_pe (abfd
) || obj_go32 (abfd
)) && current
->reloc_count
>= 0xffff)
3486 reloc_count
+= current
->reloc_count
;
3489 reloc_size
= reloc_count
* bfd_coff_relsz (abfd
);
3491 lineno_base
= reloc_base
+ reloc_size
;
3492 sym_base
= lineno_base
+ lnno_size
;
3494 /* Indicate in each section->line_filepos its actual file address. */
3495 for (current
= abfd
->sections
; current
!= NULL
; current
=
3498 if (current
->lineno_count
)
3500 current
->line_filepos
= lineno_base
;
3501 current
->moving_line_filepos
= lineno_base
;
3502 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3505 current
->line_filepos
= 0;
3507 if (current
->reloc_count
)
3509 current
->rel_filepos
= reloc_base
;
3510 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3511 #ifdef COFF_WITH_EXTENDED_RELOC_COUNTER
3512 /* Extra reloc to hold real count. */
3513 if ((obj_pe (abfd
) || obj_go32 (abfd
)) && current
->reloc_count
>= 0xffff)
3514 reloc_base
+= bfd_coff_relsz (abfd
);
3518 current
->rel_filepos
= 0;
3521 /* Write section headers to the file. */
3522 internal_f
.f_nscns
= 0;
3524 if ((abfd
->flags
& EXEC_P
) != 0)
3525 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3528 scn_base
= bfd_coff_filhsz (abfd
);
3531 if (xcoff_data (abfd
)->full_aouthdr
)
3532 scn_base
+= bfd_coff_aoutsz (abfd
);
3534 scn_base
+= SMALL_AOUTSZ
;
3539 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3542 long_section_names
= false;
3543 for (current
= abfd
->sections
;
3545 current
= current
->next
)
3547 struct internal_scnhdr section
;
3548 #ifdef COFF_IMAGE_WITH_PE
3549 bool is_reloc_section
= false;
3551 if (strcmp (current
->name
, DOT_RELOC
) == 0)
3553 is_reloc_section
= true;
3555 pe_data (abfd
)->has_reloc_section
= 1;
3559 internal_f
.f_nscns
++;
3561 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3563 #ifdef COFF_LONG_SECTION_NAMES
3564 /* Handle long section names as in PE. This must be compatible
3565 with the code in coff_write_symbols and _bfd_coff_final_link. */
3566 if (bfd_coff_long_section_names (abfd
))
3570 len
= strlen (current
->name
);
3574 /* An inherent limitation of the /nnnnnnn notation used to indicate
3575 the offset of the long name in the string table is that we
3576 cannot address entries beyone the ten million byte boundary. */
3577 if (string_size
< 10000000)
3579 /* The s_name field is defined to be NUL-padded but need not
3580 be NUL-terminated. We use a temporary buffer so that we
3581 can still sprintf all eight chars without splatting a
3582 terminating NUL over the first byte of the following
3583 member (s_paddr). */
3584 /* PR 21096: The +20 is to stop a bogus warning from gcc7
3585 about a possible buffer overflow. */
3586 char s_name_buf
[SCNNMLEN
+ 1 + 20];
3588 /* We do not need to use snprintf here as we have already
3589 verified that string_size is not too big, plus we have
3590 an overlarge buffer, just in case. */
3591 sprintf (s_name_buf
, "/%lu", (unsigned long) string_size
);
3592 /* Then strncpy takes care of any padding for us. */
3593 strncpy (section
.s_name
, s_name_buf
, SCNNMLEN
);
3598 /* PE use a base 64 encoding for long section names whose
3599 index is very large. But contrary to RFC 4648, there is
3600 no padding: 6 characters must be generated. */
3601 static const char base64
[] =
3602 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
3603 "abcdefghijklmnopqrstuvwxyz"
3605 unsigned long off
= string_size
;
3608 section
.s_name
[0] = '/';
3609 section
.s_name
[1] = '/';
3610 for (i
= SCNNMLEN
- 1; i
>= 2; i
--)
3612 section
.s_name
[i
] = base64
[off
& 0x3f];
3617 if (string_size
> 0xffffffffUL
- (len
+ 1)
3618 #ifndef COFF_WITH_PE
3619 || string_size
>= 10000000
3623 bfd_set_error (bfd_error_file_too_big
);
3625 /* xgettext:c-format */
3626 (_("%pB: section %pA: string table overflow at offset %ld"),
3627 abfd
, current
, (unsigned long) string_size
);
3631 string_size
+= len
+ 1;
3632 long_section_names
= true;
3638 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3639 Ian Taylor <ian@cygnus.com>. */
3640 if (strcmp (current
->name
, _LIB
) == 0)
3641 section
.s_vaddr
= 0;
3644 section
.s_vaddr
= current
->vma
;
3645 section
.s_paddr
= current
->lma
;
3646 section
.s_size
= current
->size
;
3647 #ifdef coff_get_section_load_page
3648 section
.s_page
= coff_get_section_load_page (current
);
3654 section
.s_paddr
= 0;
3656 #ifdef COFF_IMAGE_WITH_PE
3657 /* Reminder: s_paddr holds the virtual size of the section. */
3658 if (coff_section_data (abfd
, current
) != NULL
3659 && pei_section_data (abfd
, current
) != NULL
)
3660 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3662 section
.s_paddr
= 0;
3665 /* If this section has no size or is unloadable then the scnptr
3667 if (current
->size
== 0
3668 || (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3669 section
.s_scnptr
= 0;
3671 section
.s_scnptr
= current
->filepos
;
3673 section
.s_relptr
= current
->rel_filepos
;
3674 section
.s_lnnoptr
= current
->line_filepos
;
3675 section
.s_nreloc
= current
->reloc_count
;
3676 section
.s_nlnno
= current
->lineno_count
;
3677 #ifndef COFF_IMAGE_WITH_PE
3678 /* In PEI, relocs come in the .reloc section. */
3679 if (current
->reloc_count
!= 0)
3682 if (current
->lineno_count
!= 0)
3684 #ifdef COFF_IMAGE_WITH_PE
3685 if ((current
->flags
& SEC_DEBUGGING
) != 0
3686 && ! is_reloc_section
)
3692 /* Indicate the use of an XCOFF overflow section header. */
3693 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3695 section
.s_nreloc
= 0xffff;
3696 section
.s_nlnno
= 0xffff;
3701 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3703 if (!strcmp (current
->name
, _TEXT
))
3705 else if (!strcmp (current
->name
, _DATA
))
3707 else if (!strcmp (current
->name
, _BSS
))
3710 else if (!strcmp (current
->name
, _TDATA
))
3711 tdata_sec
= current
;
3712 else if (!strcmp (current
->name
, _TBSS
))
3717 #ifdef COFF_ENCODE_ALIGNMENT
3718 if (COFF_ENCODE_ALIGNMENT (abfd
, section
, current
->alignment_power
)
3719 && (COFF_DECODE_ALIGNMENT (section
.s_flags
)
3720 != current
->alignment_power
))
3722 bool warn
= (coff_data (abfd
)->link_info
3723 && !bfd_link_relocatable (coff_data (abfd
)->link_info
));
3726 /* xgettext:c-format */
3727 (_("%pB:%s section %s: alignment 2**%u not representable"),
3728 abfd
, warn
? " warning:" : "", current
->name
,
3729 current
->alignment_power
);
3732 bfd_set_error (bfd_error_nonrepresentable_section
);
3738 #ifdef COFF_IMAGE_WITH_PE
3739 /* Suppress output of the sections if they are null. ld
3740 includes the bss and data sections even if there is no size
3741 assigned to them. NT loader doesn't like it if these section
3742 headers are included if the sections themselves are not
3743 needed. See also coff_compute_section_file_positions. */
3744 if (section
.s_size
== 0)
3745 internal_f
.f_nscns
--;
3750 bfd_size_type amt
= bfd_coff_scnhsz (abfd
);
3752 if (bfd_coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3753 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3758 /* PE stores COMDAT section information in the symbol table. If
3759 this section is supposed to have some COMDAT info, track down
3760 the symbol in the symbol table and modify it. */
3761 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3763 unsigned int i
, count
;
3765 coff_symbol_type
*csym
= NULL
;
3769 count
= bfd_get_symcount (abfd
);
3770 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3772 if ((*psym
)->section
!= current
)
3775 /* Remember the location of the first symbol in this
3777 if (psymsec
== NULL
)
3780 /* See if this is the section symbol. */
3781 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3783 csym
= coff_symbol_from (*psym
);
3785 || csym
->native
== NULL
3786 || ! csym
->native
->is_sym
3787 || csym
->native
->u
.syment
.n_numaux
< 1
3788 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3789 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3792 /* Here *PSYM is the section symbol for CURRENT. */
3799 Note that we might not if we're converting the file from
3800 some other object file format. */
3803 combined_entry_type
*aux
;
3805 /* We don't touch the x_checksum field. The
3806 x_associated field is not currently supported. */
3808 aux
= csym
->native
+ 1;
3809 BFD_ASSERT (! aux
->is_sym
);
3810 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3812 case SEC_LINK_DUPLICATES_DISCARD
:
3813 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3816 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3817 aux
->u
.auxent
.x_scn
.x_comdat
=
3818 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3821 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3822 aux
->u
.auxent
.x_scn
.x_comdat
=
3823 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3826 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3827 aux
->u
.auxent
.x_scn
.x_comdat
=
3828 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3832 /* The COMDAT symbol must be the first symbol from this
3833 section in the symbol table. In order to make this
3834 work, we move the COMDAT symbol before the first
3835 symbol we found in the search above. It's OK to
3836 rearrange the symbol table at this point, because
3837 coff_renumber_symbols is going to rearrange it
3838 further and fix up all the aux entries. */
3839 if (psym
!= psymsec
)
3845 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3846 pcopy
[0] = pcopy
[-1];
3851 #endif /* COFF_WITH_PE */
3856 /* XCOFF handles overflows in the reloc and line number count fields
3857 by creating a new section header to hold the correct values. */
3858 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3860 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3862 struct internal_scnhdr scnhdr
;
3866 internal_f
.f_nscns
++;
3867 memcpy (scnhdr
.s_name
, ".ovrflo", 8);
3868 scnhdr
.s_paddr
= current
->reloc_count
;
3869 scnhdr
.s_vaddr
= current
->lineno_count
;
3871 scnhdr
.s_scnptr
= 0;
3872 scnhdr
.s_relptr
= current
->rel_filepos
;
3873 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3874 scnhdr
.s_nreloc
= current
->target_index
;
3875 scnhdr
.s_nlnno
= current
->target_index
;
3876 scnhdr
.s_flags
= STYP_OVRFLO
;
3877 amt
= bfd_coff_scnhsz (abfd
);
3878 if (bfd_coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3879 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3886 #if defined (COFF_GO32_EXE) || defined (COFF_GO32)
3887 /* Pad section headers. */
3888 if ((abfd
->flags
& EXEC_P
) && abfd
->sections
!= NULL
)
3890 file_ptr cur_ptr
= scn_base
3891 + abfd
->section_count
* bfd_coff_scnhsz (abfd
);
3892 long fill_size
= (abfd
->sections
->filepos
- cur_ptr
);
3893 bfd_byte
*b
= bfd_zmalloc (fill_size
);
3896 bfd_bwrite (b
, fill_size
, abfd
);
3902 /* OK, now set up the filehdr... */
3904 /* Don't include the internal abs section in the section count */
3906 /* We will NOT put a fucking timestamp in the header here. Every time you
3907 put it back, I will come in and take it out again. I'm sorry. This
3908 field does not belong here. We fill it with a 0 so it compares the
3909 same but is not a reasonable time. -- gnu@cygnus.com */
3910 internal_f
.f_timdat
= 0;
3911 internal_f
.f_flags
= 0;
3913 if (abfd
->flags
& EXEC_P
)
3914 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3917 internal_f
.f_opthdr
= 0;
3920 if (xcoff_data (abfd
)->full_aouthdr
)
3921 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3923 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
3929 internal_f
.f_flags
|= F_RELFLG
;
3931 internal_f
.f_flags
|= F_LNNO
;
3932 if (abfd
->flags
& EXEC_P
)
3933 internal_f
.f_flags
|= F_EXEC
;
3934 #ifdef COFF_IMAGE_WITH_PE
3936 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
3937 if (pe_data (abfd
)->real_flags
& IMAGE_FILE_LARGE_ADDRESS_AWARE
)
3938 internal_f
.f_flags
|= IMAGE_FILE_LARGE_ADDRESS_AWARE
;
3941 #if !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
3943 internal_f
.f_flags
|= IMAGE_FILE_32BIT_MACHINE
;
3945 if (bfd_little_endian (abfd
))
3946 internal_f
.f_flags
|= F_AR32WR
;
3948 internal_f
.f_flags
|= F_AR32W
;
3953 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
3954 but it doesn't hurt to set it internally. */
3955 internal_f
.f_target_id
= TI_TARGET_ID
;
3958 /* FIXME, should do something about the other byte orders and
3962 if ((abfd
->flags
& DYNAMIC
) != 0)
3963 internal_f
.f_flags
|= F_SHROBJ
;
3964 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
3965 internal_f
.f_flags
|= F_DYNLOAD
;
3968 memset (&internal_a
, 0, sizeof internal_a
);
3970 /* Set up architecture-dependent stuff. */
3972 unsigned int magic
= 0;
3973 unsigned short flags
= 0;
3975 coff_set_flags (abfd
, &magic
, &flags
);
3976 internal_f
.f_magic
= magic
;
3977 internal_f
.f_flags
|= flags
;
3978 /* ...and the "opt"hdr... */
3980 #ifdef TICOFF_AOUT_MAGIC
3981 internal_a
.magic
= TICOFF_AOUT_MAGIC
;
3982 #define __A_MAGIC_SET__
3986 #define __A_MAGIC_SET__
3987 internal_a
.magic
= ZMAGIC
;
3990 #if defined(AARCH64)
3991 #define __A_MAGIC_SET__
3992 internal_a
.magic
= ZMAGIC
;
3995 #if defined(LOONGARCH64)
3996 #define __A_MAGIC_SET__
3997 internal_a
.magic
= ZMAGIC
;
4000 #if defined MCORE_PE
4001 #define __A_MAGIC_SET__
4002 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
4006 #define __A_MAGIC_SET__
4008 internal_a
.magic
= LYNXCOFFMAGIC
;
4010 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR64_MAGIC
;
4012 internal_a
.magic
= ZMAGIC
;
4017 #define __A_MAGIC_SET__
4018 internal_a
.magic
= PE32PMAGIC
;
4022 #define __A_MAGIC_SET__
4024 internal_a
.magic
= LYNXCOFFMAGIC
;
4029 #define __A_MAGIC_SET__
4030 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
4031 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
4032 RS6K_AOUTHDR_OMAGIC
;
4035 #if defined(SH) && defined(COFF_WITH_PE)
4036 #define __A_MAGIC_SET__
4037 internal_a
.magic
= SH_PE_MAGIC
;
4040 #if defined(MIPS) && defined(COFF_WITH_PE)
4041 #define __A_MAGIC_SET__
4042 internal_a
.magic
= MIPS_PE_MAGIC
;
4045 #ifndef __A_MAGIC_SET__
4046 #include "Your aouthdr magic number is not being set!"
4048 #undef __A_MAGIC_SET__
4053 /* XCOFF 32bit needs this to have new behaviour for n_type field. */
4054 internal_a
.vstamp
= 2;
4056 /* FIXME: Does anybody ever set this to another value? */
4057 internal_a
.vstamp
= 0;
4060 /* Now should write relocs, strings, syms. */
4061 obj_sym_filepos (abfd
) = sym_base
;
4063 if (bfd_get_symcount (abfd
) != 0)
4067 if (!coff_renumber_symbols (abfd
, &firstundef
))
4069 coff_mangle_symbols (abfd
);
4070 if (! coff_write_symbols (abfd
))
4072 if (! coff_write_linenumbers (abfd
))
4074 if (! coff_write_relocs (abfd
, firstundef
))
4077 #ifdef COFF_LONG_SECTION_NAMES
4078 else if (long_section_names
&& ! obj_coff_strings_written (abfd
))
4080 /* If we have long section names we have to write out the string
4081 table even if there are no symbols. */
4082 if (! coff_write_symbols (abfd
))
4086 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
4087 backend linker, and obj_raw_syment_count is not valid until after
4088 coff_write_symbols is called. */
4089 if (obj_raw_syment_count (abfd
) != 0)
4091 internal_f
.f_symptr
= sym_base
;
4093 /* AIX appears to require that F_RELFLG not be set if there are
4094 local symbols but no relocations. */
4095 internal_f
.f_flags
&=~ F_RELFLG
;
4100 if (long_section_names
)
4101 internal_f
.f_symptr
= sym_base
;
4103 internal_f
.f_symptr
= 0;
4104 internal_f
.f_flags
|= F_LSYMS
;
4109 internal_a
.tsize
= text_sec
->size
;
4110 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
4114 internal_a
.dsize
= data_sec
->size
;
4115 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
4119 internal_a
.bsize
= bss_sec
->size
;
4120 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
4121 internal_a
.data_start
= bss_sec
->vma
;
4124 internal_a
.entry
= bfd_get_start_address (abfd
);
4125 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
4128 if (xcoff_data (abfd
)->full_aouthdr
)
4131 asection
*loader_sec
;
4133 internal_a
.vstamp
= 2;
4135 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
4136 if (internal_a
.o_snentry
== 0)
4137 internal_a
.entry
= (bfd_vma
) -1;
4139 if (text_sec
!= NULL
)
4141 internal_a
.o_sntext
= text_sec
->target_index
;
4142 internal_a
.o_algntext
= bfd_section_alignment (text_sec
);
4146 internal_a
.o_sntext
= 0;
4147 internal_a
.o_algntext
= 0;
4149 if (data_sec
!= NULL
)
4151 internal_a
.o_sndata
= data_sec
->target_index
;
4152 internal_a
.o_algndata
= bfd_section_alignment (data_sec
);
4156 internal_a
.o_sndata
= 0;
4157 internal_a
.o_algndata
= 0;
4159 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
4160 if (loader_sec
!= NULL
)
4161 internal_a
.o_snloader
= loader_sec
->target_index
;
4163 internal_a
.o_snloader
= 0;
4164 if (bss_sec
!= NULL
)
4165 internal_a
.o_snbss
= bss_sec
->target_index
;
4167 internal_a
.o_snbss
= 0;
4169 if (tdata_sec
!= NULL
)
4171 internal_a
.o_sntdata
= tdata_sec
->target_index
;
4172 /* TODO: o_flags should be set to RS6K_AOUTHDR_TLS_LE
4173 if there is at least one R_TLS_LE relocations. */
4174 internal_a
.o_flags
= 0;
4176 internal_a
.o_x64flags
= 0;
4181 internal_a
.o_sntdata
= 0;
4182 internal_a
.o_flags
= 0;
4184 internal_a
.o_x64flags
= 0;
4187 if (tbss_sec
!= NULL
)
4188 internal_a
.o_sntbss
= tbss_sec
->target_index
;
4190 internal_a
.o_sntbss
= 0;
4192 toc
= xcoff_data (abfd
)->toc
;
4193 internal_a
.o_toc
= toc
;
4194 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
4196 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
4197 if (xcoff_data (abfd
)->cputype
!= -1)
4198 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
4201 switch (bfd_get_arch (abfd
))
4203 case bfd_arch_rs6000
:
4204 internal_a
.o_cputype
= 4;
4206 case bfd_arch_powerpc
:
4207 if (bfd_get_mach (abfd
) == bfd_mach_ppc
)
4208 internal_a
.o_cputype
= 3;
4209 else if (bfd_get_mach (abfd
) == bfd_mach_ppc_620
)
4210 internal_a
.o_cputype
= 2;
4212 internal_a
.o_cputype
= 1;
4218 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
4219 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
4225 /* After object contents are finalized so we can compute a reasonable hash,
4226 but before header is written so we can update it to point to debug directory. */
4227 struct pe_tdata
*pe
= pe_data (abfd
);
4229 if (pe
->build_id
.after_write_object_contents
!= NULL
)
4230 (*pe
->build_id
.after_write_object_contents
) (abfd
);
4234 /* Now write header. */
4235 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
4240 bfd_size_type amount
= bfd_coff_filhsz (abfd
);
4242 buff
= (char *) bfd_malloc (amount
);
4246 bfd_coff_swap_filehdr_out (abfd
, & internal_f
, buff
);
4247 amount
= bfd_bwrite (buff
, amount
, abfd
);
4251 if (amount
!= bfd_coff_filhsz (abfd
))
4255 if (abfd
->flags
& EXEC_P
)
4257 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4258 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4260 bfd_size_type amount
= bfd_coff_aoutsz (abfd
);
4262 buff
= (char *) bfd_malloc (amount
);
4266 coff_swap_aouthdr_out (abfd
, & internal_a
, buff
);
4267 amount
= bfd_bwrite (buff
, amount
, abfd
);
4271 if (amount
!= bfd_coff_aoutsz (abfd
))
4274 #ifdef COFF_IMAGE_WITH_PE
4275 if (! coff_apply_checksum (abfd
))
4286 /* XCOFF32 seems to always write at least a small a.out header. */
4287 coff_swap_aouthdr_out (abfd
, & internal_a
, & buff
);
4288 if (xcoff_data (abfd
)->full_aouthdr
)
4289 size
= bfd_coff_aoutsz (abfd
);
4291 size
= SMALL_AOUTSZ
;
4292 if (bfd_bwrite (& buff
, (bfd_size_type
) size
, abfd
) != size
)
4302 coff_set_section_contents (bfd
* abfd
,
4304 const void * location
,
4306 bfd_size_type count
)
4308 if (! abfd
->output_has_begun
) /* Set by bfd.c handler. */
4310 if (! coff_compute_section_file_positions (abfd
))
4314 #if defined(_LIB) && !defined(TARG_AUX)
4315 /* The physical address field of a .lib section is used to hold the
4316 number of shared libraries in the section. This code counts the
4317 number of sections being written, and increments the lma field
4320 I have found no documentation on the contents of this section.
4321 Experimentation indicates that the section contains zero or more
4322 records, each of which has the following structure:
4324 - a (four byte) word holding the length of this record, in words,
4325 - a word that always seems to be set to "2",
4326 - the path to a shared library, null-terminated and then padded
4327 to a whole word boundary.
4329 bfd_assert calls have been added to alert if an attempt is made
4330 to write a section which doesn't follow these assumptions. The
4331 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4332 <robertl@arnet.com> (Thanks!).
4334 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4335 if (strcmp (section
->name
, _LIB
) == 0)
4337 bfd_byte
*rec
, *recend
;
4339 rec
= (bfd_byte
*) location
;
4340 recend
= rec
+ count
;
4341 while (recend
- rec
>= 4)
4343 size_t len
= bfd_get_32 (abfd
, rec
);
4344 if (len
== 0 || len
> (size_t) (recend
- rec
) / 4)
4350 BFD_ASSERT (rec
== recend
);
4354 /* Don't write out bss sections - one way to do this is to
4355 see if the filepos has not been set. */
4356 if (section
->filepos
== 0)
4359 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0)
4365 return bfd_bwrite (location
, count
, abfd
) == count
;
4369 buy_and_read (bfd
*abfd
, file_ptr where
,
4370 bfd_size_type nmemb
, bfd_size_type size
)
4374 if (_bfd_mul_overflow (nmemb
, size
, &amt
))
4376 bfd_set_error (bfd_error_file_too_big
);
4379 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
4381 return _bfd_malloc_and_read (abfd
, amt
, amt
);
4388 Creating the linenumber table is done by reading in the entire
4389 coff linenumber table, and creating another table for internal use.
4391 A coff linenumber table is structured so that each function
4392 is marked as having a line number of 0. Each line within the
4393 function is an offset from the first line in the function. The
4394 base of the line number information for the table is stored in
4395 the symbol associated with the function.
4397 Note: The PE format uses line number 0 for a flag indicating a
4400 The information is copied from the external to the internal
4401 table, and each symbol which marks a function is marked by
4404 How does this work ?
4408 coff_sort_func_alent (const void * arg1
, const void * arg2
)
4410 const alent
*al1
= *(const alent
**) arg1
;
4411 const alent
*al2
= *(const alent
**) arg2
;
4412 const coff_symbol_type
*s1
= (const coff_symbol_type
*) (al1
->u
.sym
);
4413 const coff_symbol_type
*s2
= (const coff_symbol_type
*) (al2
->u
.sym
);
4415 if (s1
== NULL
|| s2
== NULL
)
4417 if (s1
->symbol
.value
< s2
->symbol
.value
)
4419 else if (s1
->symbol
.value
> s2
->symbol
.value
)
4426 coff_slurp_line_table (bfd
*abfd
, asection
*asect
)
4428 LINENO
*native_lineno
;
4429 alent
*lineno_cache
;
4430 unsigned int counter
;
4432 bfd_vma prev_offset
= 0;
4433 bool ordered
= true;
4434 unsigned int nbr_func
;
4440 if (asect
->lineno_count
== 0)
4443 BFD_ASSERT (asect
->lineno
== NULL
);
4445 native_lineno
= (LINENO
*) buy_and_read (abfd
, asect
->line_filepos
,
4446 asect
->lineno_count
,
4447 bfd_coff_linesz (abfd
));
4448 if (native_lineno
== NULL
)
4451 (_("%pB: warning: line number table read failed"), abfd
);
4455 if (_bfd_mul_overflow (asect
->lineno_count
+ 1, sizeof (alent
), &amt
))
4457 bfd_set_error (bfd_error_file_too_big
);
4458 free (native_lineno
);
4461 lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
);
4462 if (lineno_cache
== NULL
)
4464 free (native_lineno
);
4468 cache_ptr
= lineno_cache
;
4469 asect
->lineno
= lineno_cache
;
4470 src
= native_lineno
;
4474 for (counter
= 0; counter
< asect
->lineno_count
; counter
++, src
++)
4476 struct internal_lineno dst
;
4478 bfd_coff_swap_lineno_in (abfd
, src
, &dst
);
4479 cache_ptr
->line_number
= dst
.l_lnno
;
4480 /* Appease memory checkers that get all excited about
4481 uninitialised memory when copying alents if u.offset is
4482 larger than u.sym. (64-bit BFD on 32-bit host.) */
4483 memset (&cache_ptr
->u
, 0, sizeof (cache_ptr
->u
));
4485 if (cache_ptr
->line_number
== 0)
4487 combined_entry_type
* ent
;
4488 unsigned long symndx
;
4489 coff_symbol_type
*sym
;
4492 symndx
= dst
.l_addr
.l_symndx
;
4493 if (symndx
>= obj_raw_syment_count (abfd
))
4496 /* xgettext:c-format */
4497 (_("%pB: warning: illegal symbol index 0x%lx in line number entry %d"),
4498 abfd
, symndx
, counter
);
4499 cache_ptr
->line_number
= -1;
4504 ent
= obj_raw_syments (abfd
) + symndx
;
4505 /* FIXME: We should not be casting between ints and
4506 pointers like this. */
4510 /* xgettext:c-format */
4511 (_("%pB: warning: illegal symbol index 0x%lx in line number entry %d"),
4512 abfd
, symndx
, counter
);
4513 cache_ptr
->line_number
= -1;
4517 sym
= (coff_symbol_type
*) (ent
->u
.syment
._n
._n_n
._n_zeroes
);
4519 /* PR 17512 file: 078-10659-0.004 */
4520 if (sym
< obj_symbols (abfd
)
4521 || sym
>= obj_symbols (abfd
) + bfd_get_symcount (abfd
))
4524 /* xgettext:c-format */
4525 (_("%pB: warning: illegal symbol in line number entry %d"),
4527 cache_ptr
->line_number
= -1;
4534 cache_ptr
->u
.sym
= (asymbol
*) sym
;
4535 if (sym
->lineno
!= NULL
)
4537 /* xgettext:c-format */
4538 (_("%pB: warning: duplicate line number information for `%s'"),
4539 abfd
, bfd_asymbol_name (&sym
->symbol
));
4541 sym
->lineno
= cache_ptr
;
4542 if (sym
->symbol
.value
< prev_offset
)
4544 prev_offset
= sym
->symbol
.value
;
4546 else if (!have_func
)
4547 /* Drop line information that has no associated function.
4548 PR 17521: file: 078-10659-0.004. */
4551 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
- bfd_section_vma (asect
);
4555 asect
->lineno_count
= cache_ptr
- lineno_cache
;
4556 memset (cache_ptr
, 0, sizeof (*cache_ptr
));
4557 free (native_lineno
);
4559 /* On some systems (eg AIX5.3) the lineno table may not be sorted. */
4562 /* Sort the table. */
4564 alent
*n_lineno_cache
;
4566 /* Create a table of functions. */
4567 if (_bfd_mul_overflow (nbr_func
, sizeof (alent
*), &amt
))
4569 bfd_set_error (bfd_error_file_too_big
);
4572 else if ((func_table
= (alent
**) bfd_alloc (abfd
, amt
)) != NULL
)
4574 alent
**p
= func_table
;
4577 for (i
= 0; i
< asect
->lineno_count
; i
++)
4578 if (lineno_cache
[i
].line_number
== 0)
4579 *p
++ = &lineno_cache
[i
];
4581 BFD_ASSERT ((unsigned int) (p
- func_table
) == nbr_func
);
4583 /* Sort by functions. */
4584 qsort (func_table
, nbr_func
, sizeof (alent
*), coff_sort_func_alent
);
4586 /* Create the new sorted table. */
4587 if (_bfd_mul_overflow (asect
->lineno_count
, sizeof (alent
), &amt
))
4589 bfd_set_error (bfd_error_file_too_big
);
4592 else if ((n_lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
)) != NULL
)
4594 alent
*n_cache_ptr
= n_lineno_cache
;
4596 for (i
= 0; i
< nbr_func
; i
++)
4598 coff_symbol_type
*sym
;
4599 alent
*old_ptr
= func_table
[i
];
4601 /* Update the function entry. */
4602 sym
= (coff_symbol_type
*) old_ptr
->u
.sym
;
4603 /* PR binutils/17512: Point the lineno to where
4604 this entry will be after the memcpy below. */
4605 sym
->lineno
= lineno_cache
+ (n_cache_ptr
- n_lineno_cache
);
4606 /* Copy the function and line number entries. */
4608 *n_cache_ptr
++ = *old_ptr
++;
4609 while (old_ptr
->line_number
!= 0);
4612 memcpy (lineno_cache
, n_lineno_cache
,
4613 asect
->lineno_count
* sizeof (alent
));
4617 bfd_release (abfd
, func_table
);
4626 /* Slurp in the symbol table, converting it to generic form. Note
4627 that if coff_relocate_section is defined, the linker will read
4628 symbols via coff_link_add_symbols, rather than via this routine. */
4631 coff_slurp_symbol_table (bfd
* abfd
)
4633 combined_entry_type
*native_symbols
;
4634 coff_symbol_type
*cached_area
;
4635 unsigned int *table_ptr
;
4636 unsigned int number_of_symbols
= 0;
4640 if (obj_symbols (abfd
))
4643 /* Read in the symbol table. */
4644 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4647 /* Allocate enough room for all the symbols in cached form. */
4648 if (_bfd_mul_overflow (obj_raw_syment_count (abfd
),
4649 sizeof (*cached_area
), &amt
))
4651 bfd_set_error (bfd_error_file_too_big
);
4654 cached_area
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
4655 if (cached_area
== NULL
)
4658 if (_bfd_mul_overflow (obj_raw_syment_count (abfd
),
4659 sizeof (*table_ptr
), &amt
))
4661 bfd_set_error (bfd_error_file_too_big
);
4664 table_ptr
= (unsigned int *) bfd_zalloc (abfd
, amt
);
4665 if (table_ptr
== NULL
)
4669 coff_symbol_type
*dst
= cached_area
;
4670 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4671 unsigned int this_index
= 0;
4673 while (this_index
< last_native_index
)
4675 combined_entry_type
*src
= native_symbols
+ this_index
;
4676 table_ptr
[this_index
] = number_of_symbols
;
4678 dst
->symbol
.the_bfd
= abfd
;
4679 BFD_ASSERT (src
->is_sym
);
4680 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4681 /* We use the native name field to point to the cached field. */
4682 src
->u
.syment
._n
._n_n
._n_zeroes
= (uintptr_t) dst
;
4683 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4684 src
->u
.syment
.n_scnum
);
4685 dst
->symbol
.flags
= 0;
4686 /* PR 17512: file: 079-7098-0.001:0.1. */
4687 dst
->symbol
.value
= 0;
4688 dst
->done_lineno
= false;
4690 switch (src
->u
.syment
.n_sclass
)
4696 case C_THUMBEXTFUNC
:
4700 #ifndef AIX_WEAK_SUPPORT
4705 case C_SYSTEM
: /* System Wide variable. */
4708 /* In PE, 0x68 (104) denotes a section symbol. */
4710 /* In PE, 0x69 (105) denotes a weak external symbol. */
4713 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4715 case COFF_SYMBOL_GLOBAL
:
4716 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4717 #if defined COFF_WITH_PE
4718 /* PE sets the symbol to a value relative to the
4719 start of the section. */
4720 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4722 dst
->symbol
.value
= (src
->u
.syment
.n_value
4723 - dst
->symbol
.section
->vma
);
4725 if (ISFCN ((src
->u
.syment
.n_type
)))
4726 /* A function ext does not go at the end of a
4728 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4731 case COFF_SYMBOL_COMMON
:
4732 dst
->symbol
.section
= bfd_com_section_ptr
;
4733 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4736 case COFF_SYMBOL_UNDEFINED
:
4737 dst
->symbol
.section
= bfd_und_section_ptr
;
4738 dst
->symbol
.value
= 0;
4741 case COFF_SYMBOL_PE_SECTION
:
4742 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4743 dst
->symbol
.value
= 0;
4746 case COFF_SYMBOL_LOCAL
:
4747 dst
->symbol
.flags
= BSF_LOCAL
;
4748 #if defined COFF_WITH_PE
4749 /* PE sets the symbol to a value relative to the
4750 start of the section. */
4751 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4753 dst
->symbol
.value
= (src
->u
.syment
.n_value
4754 - dst
->symbol
.section
->vma
);
4756 if (ISFCN ((src
->u
.syment
.n_type
)))
4757 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4762 /* A symbol with a csect entry should not go at the end. */
4763 if (src
->u
.syment
.n_numaux
> 0)
4764 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4768 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4769 dst
->symbol
.flags
|= BSF_WEAK
;
4771 if (src
->u
.syment
.n_sclass
== C_SECTION
4772 && src
->u
.syment
.n_scnum
> 0)
4773 dst
->symbol
.flags
= BSF_LOCAL
;
4775 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
4777 || src
->u
.syment
.n_sclass
== C_AIX_WEAKEXT
4780 dst
->symbol
.flags
|= BSF_WEAK
;
4784 case C_STAT
: /* Static. */
4786 case C_THUMBSTAT
: /* Thumb static. */
4787 case C_THUMBLABEL
: /* Thumb label. */
4788 case C_THUMBSTATFUNC
:/* Thumb static function. */
4791 case C_DWARF
: /* A label in a dwarf section. */
4792 case C_INFO
: /* A label in a comment section. */
4794 case C_LABEL
: /* Label. */
4795 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4796 dst
->symbol
.flags
= BSF_DEBUGGING
;
4798 dst
->symbol
.flags
= BSF_LOCAL
;
4800 /* Base the value as an index from the base of the
4801 section, if there is one. */
4802 if (dst
->symbol
.section
)
4804 #if defined COFF_WITH_PE
4805 /* PE sets the symbol to a value relative to the
4806 start of the section. */
4807 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4809 dst
->symbol
.value
= (src
->u
.syment
.n_value
4810 - dst
->symbol
.section
->vma
);
4814 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4817 case C_FILE
: /* File name. */
4818 dst
->symbol
.flags
= BSF_FILE
;
4820 case C_MOS
: /* Member of structure. */
4821 case C_EOS
: /* End of structure. */
4822 case C_REGPARM
: /* Register parameter. */
4823 case C_REG
: /* register variable. */
4824 /* C_AUTOARG conflicts with TI COFF C_UEXT. */
4825 case C_TPDEF
: /* Type definition. */
4827 case C_AUTO
: /* Automatic variable. */
4828 case C_FIELD
: /* Bit field. */
4829 case C_ENTAG
: /* Enumeration tag. */
4830 case C_MOE
: /* Member of enumeration. */
4831 case C_MOU
: /* Member of union. */
4832 case C_UNTAG
: /* Union tag. */
4833 case C_STRTAG
: /* Structure tag. */
4850 dst
->symbol
.flags
|= BSF_DEBUGGING
;
4851 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4855 case C_BINCL
: /* Beginning of include file. */
4856 case C_EINCL
: /* Ending of include file. */
4857 /* The value is actually a pointer into the line numbers
4858 of the file. We locate the line number entry, and
4859 set the section to the section which contains it, and
4860 the value to the index in that section. */
4864 dst
->symbol
.flags
= BSF_DEBUGGING
;
4865 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4866 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4867 && ((file_ptr
) (sec
->line_filepos
4868 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4869 > (file_ptr
) src
->u
.syment
.n_value
))
4872 dst
->symbol
.value
= 0;
4875 dst
->symbol
.section
= sec
;
4876 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4877 - sec
->line_filepos
)
4878 / bfd_coff_linesz (abfd
));
4885 dst
->symbol
.flags
= BSF_DEBUGGING
;
4887 if (src
->u
.syment
.n_value
>= obj_raw_syment_count (abfd
))
4888 dst
->symbol
.value
= 0;
4891 /* The value is actually a symbol index. Save a pointer
4892 to the symbol instead of the index. FIXME: This
4893 should use a union. */
4894 src
->u
.syment
.n_value
4895 = (uintptr_t) (native_symbols
+ src
->u
.syment
.n_value
);
4896 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4902 case C_BLOCK
: /* ".bb" or ".eb". */
4903 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf"). */
4904 case C_EFCN
: /* Physical end of function. */
4905 #if defined COFF_WITH_PE
4906 /* PE sets the symbol to a value relative to the start
4908 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4909 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4911 /* PE uses funny values for .ef and .lf; don't
4913 dst
->symbol
.flags
= BSF_DEBUGGING
;
4916 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4918 /* Base the value as an index from the base of the
4920 dst
->symbol
.flags
= BSF_LOCAL
;
4921 dst
->symbol
.value
= (src
->u
.syment
.n_value
4922 - dst
->symbol
.section
->vma
);
4926 case C_STATLAB
: /* Static load time label. */
4927 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4928 dst
->symbol
.flags
= BSF_GLOBAL
;
4932 /* PE DLLs sometimes have zeroed out symbols for some
4933 reason. Just ignore them without a warning. */
4934 if (src
->u
.syment
.n_type
== 0
4935 && src
->u
.syment
.n_value
== 0
4936 && src
->u
.syment
.n_scnum
== 0)
4939 /* XCOFF specific: deleted entry. */
4940 if (src
->u
.syment
.n_value
== C_NULL_VALUE
)
4944 case C_EXTDEF
: /* External definition. */
4945 case C_ULABEL
: /* Undefined label. */
4946 case C_USTATIC
: /* Undefined static. */
4947 #ifndef COFF_WITH_PE
4948 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4949 class to represent a section symbol. */
4950 case C_LINE
: /* line # reformatted as symbol table entry. */
4951 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4952 case C_ALIAS
: /* Duplicate tag. */
4954 /* New storage classes for TI COFF. */
4956 case C_UEXT
: /* Tentative external definition. */
4958 case C_EXTLAB
: /* External load time label. */
4961 /* xgettext:c-format */
4962 (_("%pB: unrecognized storage class %d for %s symbol `%s'"),
4963 abfd
, src
->u
.syment
.n_sclass
,
4964 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4967 case C_HIDDEN
: /* Ext symbol in dmert public lib. */
4968 /* PR 20722: These symbols can also be generated by
4969 building DLLs with --gc-sections enabled. */
4970 dst
->symbol
.flags
= BSF_DEBUGGING
;
4971 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4976 dst
->symbol
.udata
.i
= 0;
4979 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
4981 number_of_symbols
++;
4985 obj_symbols (abfd
) = cached_area
;
4986 obj_raw_syments (abfd
) = native_symbols
;
4988 abfd
->symcount
= number_of_symbols
;
4989 obj_convert (abfd
) = table_ptr
;
4990 /* Slurp the line tables for each section too. */
4997 if (! coff_slurp_line_table (abfd
, p
))
5006 /* Classify a COFF symbol. A couple of targets have globally visible
5007 symbols which are not class C_EXT, and this handles those. It also
5008 recognizes some special PE cases. */
5010 static enum coff_symbol_classification
5011 coff_classify_symbol (bfd
*abfd
,
5012 struct internal_syment
*syment
)
5014 /* FIXME: This partially duplicates the switch in
5015 coff_slurp_symbol_table. */
5016 switch (syment
->n_sclass
)
5022 case C_THUMBEXTFUNC
:
5026 #ifndef AIX_WEAK_SUPPORT
5036 if (syment
->n_scnum
== 0)
5038 if (syment
->n_value
== 0)
5039 return COFF_SYMBOL_UNDEFINED
;
5041 return COFF_SYMBOL_COMMON
;
5044 if (syment
->n_sclass
== C_HIDEXT
)
5045 return COFF_SYMBOL_LOCAL
;
5047 return COFF_SYMBOL_GLOBAL
;
5054 if (syment
->n_sclass
== C_STAT
)
5056 if (syment
->n_scnum
== 0)
5057 /* The Microsoft compiler sometimes generates these if a
5058 small static function is inlined every time it is used.
5059 The function is discarded, but the symbol table entry
5061 return COFF_SYMBOL_LOCAL
;
5063 #ifdef STRICT_PE_FORMAT
5064 /* This is correct for Microsoft generated objects, but it
5065 breaks gas generated objects. */
5066 if (syment
->n_value
== 0)
5068 const asection
*sec
;
5070 char buf
[SYMNMLEN
+ 1];
5072 name
= _bfd_coff_internal_syment_name (abfd
, syment
, buf
);
5073 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
5074 if (sec
!= NULL
&& name
!= NULL
5075 && (strcmp (bfd_section_name (sec
), name
) == 0))
5076 return COFF_SYMBOL_PE_SECTION
;
5080 return COFF_SYMBOL_LOCAL
;
5083 if (syment
->n_sclass
== C_SECTION
)
5085 /* In some cases in a DLL generated by the Microsoft linker, the
5086 n_value field will contain garbage. FIXME: This should
5087 probably be handled by the swapping function instead. */
5088 syment
->n_value
= 0;
5089 if (syment
->n_scnum
== 0)
5090 return COFF_SYMBOL_UNDEFINED
;
5091 return COFF_SYMBOL_PE_SECTION
;
5093 #endif /* COFF_WITH_PE */
5095 /* If it is not a global symbol, we presume it is a local symbol. */
5096 if (syment
->n_scnum
== 0)
5098 char buf
[SYMNMLEN
+ 1];
5101 /* xgettext:c-format */
5102 (_("warning: %pB: local symbol `%s' has no section"),
5103 abfd
, _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
5106 return COFF_SYMBOL_LOCAL
;
5113 Coff relocations are easily transformed into the internal BFD form
5116 Reading a coff relocation table is done in the following stages:
5118 o Read the entire coff relocation table into memory.
5120 o Process each relocation in turn; first swap it from the
5121 external to the internal form.
5123 o Turn the symbol referenced in the relocation's symbol index
5124 into a pointer into the canonical symbol table.
5125 This table is the same as the one returned by a call to
5126 @code{bfd_canonicalize_symtab}. The back end will call that
5127 routine and save the result if a canonicalization hasn't been done.
5129 o The reloc index is turned into a pointer to a howto
5130 structure, in a back end specific way. For instance, the 386
5131 uses the @code{r_type} to directly produce an index
5132 into a howto table vector.
5134 o Note that @code{arelent.addend} for COFF is often not what
5135 most people understand as a relocation addend, but rather an
5136 adjustment to the relocation addend stored in section contents
5137 of relocatable object files. The value found in section
5138 contents may also be confusing, depending on both symbol value
5139 and addend somewhat similar to the field value for a
5140 final-linked object. See @code{CALC_ADDEND}.
5144 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
5146 coff_symbol_type *coffsym = NULL; \
5148 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
5149 coffsym = (obj_symbols (abfd) \
5150 + (cache_ptr->sym_ptr_ptr - symbols)); \
5152 coffsym = coff_symbol_from (ptr); \
5153 if (coffsym != NULL \
5154 && coffsym->native->is_sym \
5155 && coffsym->native->u.syment.n_scnum == 0) \
5156 cache_ptr->addend = 0; \
5157 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
5158 && ptr->section != NULL) \
5159 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
5161 cache_ptr->addend = 0; \
5166 coff_slurp_reloc_table (bfd
* abfd
, sec_ptr asect
, asymbol
** symbols
)
5168 bfd_byte
*native_relocs
;
5169 arelent
*reloc_cache
;
5174 if (asect
->relocation
)
5176 if (asect
->reloc_count
== 0)
5178 if (asect
->flags
& SEC_CONSTRUCTOR
)
5180 if (!coff_slurp_symbol_table (abfd
))
5183 native_relocs
= (bfd_byte
*) buy_and_read (abfd
, asect
->rel_filepos
,
5185 bfd_coff_relsz (abfd
));
5186 if (native_relocs
== NULL
)
5189 if (_bfd_mul_overflow (asect
->reloc_count
, sizeof (arelent
), &amt
))
5191 bfd_set_error (bfd_error_file_too_big
);
5194 reloc_cache
= (arelent
*) bfd_alloc (abfd
, amt
);
5195 if (reloc_cache
== NULL
)
5197 free (native_relocs
);
5201 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
5203 struct internal_reloc dst
;
5205 #ifndef RELOC_PROCESSING
5209 cache_ptr
= reloc_cache
+ idx
;
5210 src
= native_relocs
+ idx
* (size_t) bfd_coff_relsz (abfd
);
5213 bfd_coff_swap_reloc_in (abfd
, src
, &dst
);
5215 #ifdef RELOC_PROCESSING
5216 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
5218 cache_ptr
->address
= dst
.r_vaddr
;
5220 if (dst
.r_symndx
!= -1 && symbols
!= NULL
)
5222 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
5225 /* xgettext:c-format */
5226 (_("%pB: warning: illegal symbol index %ld in relocs"),
5227 abfd
, dst
.r_symndx
);
5228 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5233 cache_ptr
->sym_ptr_ptr
= (symbols
5234 + obj_convert (abfd
)[dst
.r_symndx
]);
5235 ptr
= *(cache_ptr
->sym_ptr_ptr
);
5240 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5244 /* The symbols definitions that we have read in have been
5245 relocated as if their sections started at 0. But the offsets
5246 refering to the symbols in the raw data have not been
5247 modified, so we have to have a negative addend to compensate.
5249 Note that symbols which used to be common must be left alone. */
5251 /* Calculate any reloc addend by looking at the symbol. */
5252 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
5255 cache_ptr
->address
-= asect
->vma
;
5256 /* !! cache_ptr->section = NULL;*/
5258 /* Fill in the cache_ptr->howto field from dst.r_type. */
5259 RTYPE2HOWTO (cache_ptr
, &dst
);
5260 #endif /* RELOC_PROCESSING */
5262 if (cache_ptr
->howto
== NULL
)
5265 /* xgettext:c-format */
5266 (_("%pB: illegal relocation type %d at address %#" PRIx64
),
5267 abfd
, dst
.r_type
, (uint64_t) dst
.r_vaddr
);
5268 bfd_set_error (bfd_error_bad_value
);
5269 free (native_relocs
);
5274 free (native_relocs
);
5275 asect
->relocation
= reloc_cache
;
5279 #ifndef coff_rtype_to_howto
5282 /* Get the howto structure for a reloc. This is only used if the file
5283 including this one defines coff_relocate_section to be
5284 _bfd_coff_generic_relocate_section, so it is OK if it does not
5285 always work. It is the responsibility of the including file to
5286 make sure it is reasonable if it is needed. */
5288 static reloc_howto_type
*
5289 coff_rtype_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
5290 asection
*sec ATTRIBUTE_UNUSED
,
5291 struct internal_reloc
*rel ATTRIBUTE_UNUSED
,
5292 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
,
5293 struct internal_syment
*sym ATTRIBUTE_UNUSED
,
5294 bfd_vma
*addendp ATTRIBUTE_UNUSED
)
5298 genrel
.howto
= NULL
;
5299 RTYPE2HOWTO (&genrel
, rel
);
5300 return genrel
.howto
;
5303 #else /* ! defined (RTYPE2HOWTO) */
5305 #define coff_rtype_to_howto NULL
5307 #endif /* ! defined (RTYPE2HOWTO) */
5308 #endif /* ! defined (coff_rtype_to_howto) */
5310 /* This is stupid. This function should be a boolean predicate. */
5313 coff_canonicalize_reloc (bfd
* abfd
,
5318 arelent
*tblptr
= section
->relocation
;
5319 unsigned int count
= 0;
5321 if (section
->flags
& SEC_CONSTRUCTOR
)
5323 /* This section has relocs made up by us, they are not in the
5324 file, so take them out of their chain and place them into
5325 the data area provided. */
5326 arelent_chain
*chain
= section
->constructor_chain
;
5328 for (count
= 0; count
< section
->reloc_count
; count
++)
5330 *relptr
++ = &chain
->relent
;
5331 chain
= chain
->next
;
5336 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
5339 tblptr
= section
->relocation
;
5341 for (; count
++ < section
->reloc_count
;)
5342 *relptr
++ = tblptr
++;
5345 return section
->reloc_count
;
5348 #ifndef coff_set_reloc
5349 #define coff_set_reloc _bfd_generic_set_reloc
5352 #ifndef coff_reloc16_estimate
5353 #define coff_reloc16_estimate dummy_reloc16_estimate
5356 dummy_reloc16_estimate (bfd
*abfd ATTRIBUTE_UNUSED
,
5357 asection
*input_section ATTRIBUTE_UNUSED
,
5358 arelent
*reloc ATTRIBUTE_UNUSED
,
5359 unsigned int shrink ATTRIBUTE_UNUSED
,
5360 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
)
5368 #ifndef coff_reloc16_extra_cases
5370 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5373 dummy_reloc16_extra_cases (bfd
*abfd ATTRIBUTE_UNUSED
,
5374 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
5375 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
,
5376 arelent
*reloc ATTRIBUTE_UNUSED
,
5377 bfd_byte
*data ATTRIBUTE_UNUSED
,
5378 size_t *src_ptr ATTRIBUTE_UNUSED
,
5379 size_t *dst_ptr ATTRIBUTE_UNUSED
)
5385 /* If coff_relocate_section is defined, we can use the optimized COFF
5386 backend linker. Otherwise we must continue to use the old linker. */
5388 #ifdef coff_relocate_section
5390 #ifndef coff_bfd_link_hash_table_create
5391 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5393 #ifndef coff_bfd_link_add_symbols
5394 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5396 #ifndef coff_bfd_final_link
5397 #define coff_bfd_final_link _bfd_coff_final_link
5400 #else /* ! defined (coff_relocate_section) */
5402 #define coff_relocate_section NULL
5403 #ifndef coff_bfd_link_hash_table_create
5404 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5406 #ifndef coff_bfd_link_add_symbols
5407 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5409 #define coff_bfd_final_link _bfd_generic_final_link
5411 #endif /* ! defined (coff_relocate_section) */
5413 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5414 #define coff_bfd_copy_link_hash_symbol_type \
5415 _bfd_generic_copy_link_hash_symbol_type
5416 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5418 #define coff_bfd_link_check_relocs _bfd_generic_link_check_relocs
5420 #ifndef coff_start_final_link
5421 #define coff_start_final_link NULL
5424 #ifndef coff_adjust_symndx
5425 #define coff_adjust_symndx NULL
5428 #ifndef coff_link_add_one_symbol
5429 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5432 #ifndef coff_link_output_has_begun
5435 coff_link_output_has_begun (bfd
* abfd
,
5436 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
)
5438 return abfd
->output_has_begun
;
5442 #ifndef coff_final_link_postscript
5445 coff_final_link_postscript (bfd
* abfd ATTRIBUTE_UNUSED
,
5446 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
)
5452 #ifndef coff_SWAP_aux_in
5453 #define coff_SWAP_aux_in coff_swap_aux_in
5455 #ifndef coff_SWAP_sym_in
5456 #define coff_SWAP_sym_in coff_swap_sym_in
5458 #ifndef coff_SWAP_lineno_in
5459 #define coff_SWAP_lineno_in coff_swap_lineno_in
5461 #ifndef coff_SWAP_aux_out
5462 #define coff_SWAP_aux_out coff_swap_aux_out
5464 #ifndef coff_SWAP_sym_out
5465 #define coff_SWAP_sym_out coff_swap_sym_out
5467 #ifndef coff_SWAP_lineno_out
5468 #define coff_SWAP_lineno_out coff_swap_lineno_out
5470 #ifndef coff_SWAP_reloc_out
5471 #define coff_SWAP_reloc_out coff_swap_reloc_out
5473 #ifndef coff_SWAP_filehdr_out
5474 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5476 #ifndef coff_SWAP_aouthdr_out
5477 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5479 #ifndef coff_SWAP_scnhdr_out
5480 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5482 #ifndef coff_SWAP_reloc_in
5483 #define coff_SWAP_reloc_in coff_swap_reloc_in
5485 #ifndef coff_SWAP_filehdr_in
5486 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5488 #ifndef coff_SWAP_aouthdr_in
5489 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5491 #ifndef coff_SWAP_scnhdr_in
5492 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5495 #define COFF_SWAP_TABLE (void *) &bfd_coff_std_swap_table
5497 static const bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED
=
5499 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5500 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5501 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5502 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5503 coff_SWAP_scnhdr_out
,
5504 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5505 #ifdef COFF_LONG_FILENAMES
5510 COFF_DEFAULT_LONG_SECTION_NAMES
,
5511 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5512 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5517 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5523 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5524 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5525 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5526 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5527 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5528 coff_classify_symbol
, coff_compute_section_file_positions
,
5529 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5530 coff_adjust_symndx
, coff_link_add_one_symbol
,
5531 coff_link_output_has_begun
, coff_final_link_postscript
,
5536 /* COFF0 differs in file/section header size and relocation entry size. */
5538 static const bfd_coff_backend_data ticoff0_swap_table
=
5540 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5541 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5542 coff_SWAP_lineno_out
, coff_swap_reloc_v0_out
,
5543 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5544 coff_SWAP_scnhdr_out
,
5545 FILHSZ_V0
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ_V0
, LINESZ
, FILNMLEN
,
5546 #ifdef COFF_LONG_FILENAMES
5551 COFF_DEFAULT_LONG_SECTION_NAMES
,
5552 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5553 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5558 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5564 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5565 coff_swap_reloc_v0_in
, ticoff0_bad_format_hook
, coff_set_arch_mach_hook
,
5566 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5567 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5568 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5569 coff_classify_symbol
, coff_compute_section_file_positions
,
5570 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5571 coff_adjust_symndx
, coff_link_add_one_symbol
,
5572 coff_link_output_has_begun
, coff_final_link_postscript
,
5578 /* COFF1 differs in section header size. */
5580 static const bfd_coff_backend_data ticoff1_swap_table
=
5582 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5583 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5584 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5585 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5586 coff_SWAP_scnhdr_out
,
5587 FILHSZ
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5588 #ifdef COFF_LONG_FILENAMES
5593 COFF_DEFAULT_LONG_SECTION_NAMES
,
5594 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5595 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5600 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5606 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5607 coff_SWAP_reloc_in
, ticoff1_bad_format_hook
, coff_set_arch_mach_hook
,
5608 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5609 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5610 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5611 coff_classify_symbol
, coff_compute_section_file_positions
,
5612 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5613 coff_adjust_symndx
, coff_link_add_one_symbol
,
5614 coff_link_output_has_begun
, coff_final_link_postscript
,
5615 bfd_pe_print_pdata
/* huh */
5619 #ifdef COFF_WITH_PE_BIGOBJ
5620 /* The UID for bigobj files. */
5622 static const char header_bigobj_classid
[16] =
5624 0xC7, 0xA1, 0xBA, 0xD1,
5628 0xFA, 0xF6, 0x6A, 0xA4, 0xDC, 0xB8
5631 /* Swap routines. */
5634 coff_bigobj_swap_filehdr_in (bfd
* abfd
, void * src
, void * dst
)
5636 struct external_ANON_OBJECT_HEADER_BIGOBJ
*filehdr_src
=
5637 (struct external_ANON_OBJECT_HEADER_BIGOBJ
*) src
;
5638 struct internal_filehdr
*filehdr_dst
= (struct internal_filehdr
*) dst
;
5640 filehdr_dst
->f_magic
= H_GET_16 (abfd
, filehdr_src
->Machine
);
5641 filehdr_dst
->f_nscns
= H_GET_32 (abfd
, filehdr_src
->NumberOfSections
);
5642 filehdr_dst
->f_timdat
= H_GET_32 (abfd
, filehdr_src
->TimeDateStamp
);
5643 filehdr_dst
->f_symptr
=
5644 GET_FILEHDR_SYMPTR (abfd
, filehdr_src
->PointerToSymbolTable
);
5645 filehdr_dst
->f_nsyms
= H_GET_32 (abfd
, filehdr_src
->NumberOfSymbols
);
5646 filehdr_dst
->f_opthdr
= 0;
5647 filehdr_dst
->f_flags
= 0;
5649 /* Check other magic numbers. */
5650 if (H_GET_16 (abfd
, filehdr_src
->Sig1
) != IMAGE_FILE_MACHINE_UNKNOWN
5651 || H_GET_16 (abfd
, filehdr_src
->Sig2
) != 0xffff
5652 || H_GET_16 (abfd
, filehdr_src
->Version
) != 2
5653 || memcmp (filehdr_src
->ClassID
, header_bigobj_classid
, 16) != 0)
5654 filehdr_dst
->f_opthdr
= 0xffff;
5656 /* Note that CLR metadata are ignored. */
5660 coff_bigobj_swap_filehdr_out (bfd
*abfd
, void * in
, void * out
)
5662 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
5663 struct external_ANON_OBJECT_HEADER_BIGOBJ
*filehdr_out
=
5664 (struct external_ANON_OBJECT_HEADER_BIGOBJ
*) out
;
5666 memset (filehdr_out
, 0, sizeof (*filehdr_out
));
5668 H_PUT_16 (abfd
, IMAGE_FILE_MACHINE_UNKNOWN
, filehdr_out
->Sig1
);
5669 H_PUT_16 (abfd
, 0xffff, filehdr_out
->Sig2
);
5670 H_PUT_16 (abfd
, 2, filehdr_out
->Version
);
5671 memcpy (filehdr_out
->ClassID
, header_bigobj_classid
, 16);
5672 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->Machine
);
5673 H_PUT_32 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->NumberOfSections
);
5674 H_PUT_32 (abfd
, filehdr_in
->f_timdat
, filehdr_out
->TimeDateStamp
);
5675 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
,
5676 filehdr_out
->PointerToSymbolTable
);
5677 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->NumberOfSymbols
);
5679 return bfd_coff_filhsz (abfd
);
5683 coff_bigobj_swap_sym_in (bfd
* abfd
, void * ext1
, void * in1
)
5685 SYMENT_BIGOBJ
*ext
= (SYMENT_BIGOBJ
*) ext1
;
5686 struct internal_syment
*in
= (struct internal_syment
*) in1
;
5688 if (ext
->e
.e_name
[0] == 0)
5690 in
->_n
._n_n
._n_zeroes
= 0;
5691 in
->_n
._n_n
._n_offset
= H_GET_32 (abfd
, ext
->e
.e
.e_offset
);
5695 #if SYMNMLEN != E_SYMNMLEN
5696 #error we need to cope with truncating or extending SYMNMLEN
5698 memcpy (in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
5702 in
->n_value
= H_GET_32 (abfd
, ext
->e_value
);
5703 BFD_ASSERT (sizeof (in
->n_scnum
) >= 4);
5704 in
->n_scnum
= H_GET_32 (abfd
, ext
->e_scnum
);
5705 in
->n_type
= H_GET_16 (abfd
, ext
->e_type
);
5706 in
->n_sclass
= H_GET_8 (abfd
, ext
->e_sclass
);
5707 in
->n_numaux
= H_GET_8 (abfd
, ext
->e_numaux
);
5711 coff_bigobj_swap_sym_out (bfd
* abfd
, void * inp
, void * extp
)
5713 struct internal_syment
*in
= (struct internal_syment
*) inp
;
5714 SYMENT_BIGOBJ
*ext
= (SYMENT_BIGOBJ
*) extp
;
5716 if (in
->_n
._n_name
[0] == 0)
5718 H_PUT_32 (abfd
, 0, ext
->e
.e
.e_zeroes
);
5719 H_PUT_32 (abfd
, in
->_n
._n_n
._n_offset
, ext
->e
.e
.e_offset
);
5723 #if SYMNMLEN != E_SYMNMLEN
5724 #error we need to cope with truncating or extending SYMNMLEN
5726 memcpy (ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
5730 H_PUT_32 (abfd
, in
->n_value
, ext
->e_value
);
5731 H_PUT_32 (abfd
, in
->n_scnum
, ext
->e_scnum
);
5733 H_PUT_16 (abfd
, in
->n_type
, ext
->e_type
);
5734 H_PUT_8 (abfd
, in
->n_sclass
, ext
->e_sclass
);
5735 H_PUT_8 (abfd
, in
->n_numaux
, ext
->e_numaux
);
5737 return SYMESZ_BIGOBJ
;
5741 coff_bigobj_swap_aux_in (bfd
*abfd
,
5749 AUXENT_BIGOBJ
*ext
= (AUXENT_BIGOBJ
*) ext1
;
5750 union internal_auxent
*in
= (union internal_auxent
*) in1
;
5752 /* Make sure that all fields in the aux structure are
5754 memset (in
, 0, sizeof * in
);
5761 memcpy (in
->x_file
.x_n
.x_fname
, ext
->File
.Name
,
5762 numaux
* sizeof (AUXENT_BIGOBJ
));
5765 memcpy (in
->x_file
.x_n
.x_fname
, ext
->File
.Name
, sizeof (ext
->File
.Name
));
5773 in
->x_scn
.x_scnlen
= H_GET_32 (abfd
, ext
->Section
.Length
);
5774 in
->x_scn
.x_nreloc
=
5775 H_GET_16 (abfd
, ext
->Section
.NumberOfRelocations
);
5776 in
->x_scn
.x_nlinno
=
5777 H_GET_16 (abfd
, ext
->Section
.NumberOfLinenumbers
);
5778 in
->x_scn
.x_checksum
= H_GET_32 (abfd
, ext
->Section
.Checksum
);
5779 in
->x_scn
.x_associated
= H_GET_16 (abfd
, ext
->Section
.Number
)
5780 | (H_GET_16 (abfd
, ext
->Section
.HighNumber
) << 16);
5781 in
->x_scn
.x_comdat
= H_GET_8 (abfd
, ext
->Section
.Selection
);
5787 in
->x_sym
.x_tagndx
.u32
= H_GET_32 (abfd
, ext
->Sym
.WeakDefaultSymIndex
);
5788 /* Characteristics is ignored. */
5794 coff_bigobj_swap_aux_out (bfd
* abfd
,
5798 int indx ATTRIBUTE_UNUSED
,
5799 int numaux ATTRIBUTE_UNUSED
,
5802 union internal_auxent
* in
= (union internal_auxent
*) inp
;
5803 AUXENT_BIGOBJ
*ext
= (AUXENT_BIGOBJ
*) extp
;
5805 memset (ext
, 0, AUXESZ
);
5810 memcpy (ext
->File
.Name
, in
->x_file
.x_n
.x_fname
, sizeof (ext
->File
.Name
));
5819 H_PUT_32 (abfd
, in
->x_scn
.x_scnlen
, ext
->Section
.Length
);
5820 H_PUT_16 (abfd
, in
->x_scn
.x_nreloc
,
5821 ext
->Section
.NumberOfRelocations
);
5822 H_PUT_16 (abfd
, in
->x_scn
.x_nlinno
,
5823 ext
->Section
.NumberOfLinenumbers
);
5824 H_PUT_32 (abfd
, in
->x_scn
.x_checksum
, ext
->Section
.Checksum
);
5825 H_PUT_16 (abfd
, in
->x_scn
.x_associated
& 0xffff,
5826 ext
->Section
.Number
);
5827 H_PUT_16 (abfd
, (in
->x_scn
.x_associated
>> 16),
5828 ext
->Section
.HighNumber
);
5829 H_PUT_8 (abfd
, in
->x_scn
.x_comdat
, ext
->Section
.Selection
);
5835 H_PUT_32 (abfd
, in
->x_sym
.x_tagndx
.u32
, ext
->Sym
.WeakDefaultSymIndex
);
5836 H_PUT_32 (abfd
, 1, ext
->Sym
.WeakSearchType
);
5841 static const bfd_coff_backend_data bigobj_swap_table
=
5843 coff_bigobj_swap_aux_in
, coff_bigobj_swap_sym_in
, coff_SWAP_lineno_in
,
5844 coff_bigobj_swap_aux_out
, coff_bigobj_swap_sym_out
,
5845 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5846 coff_bigobj_swap_filehdr_out
, coff_SWAP_aouthdr_out
,
5847 coff_SWAP_scnhdr_out
,
5848 FILHSZ_BIGOBJ
, AOUTSZ
, SCNHSZ
, SYMESZ_BIGOBJ
, AUXESZ_BIGOBJ
,
5849 RELSZ
, LINESZ
, FILNMLEN_BIGOBJ
,
5851 COFF_DEFAULT_LONG_SECTION_NAMES
,
5852 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5856 coff_bigobj_swap_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5857 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5858 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5859 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5860 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5861 coff_classify_symbol
, coff_compute_section_file_positions
,
5862 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5863 coff_adjust_symndx
, coff_link_add_one_symbol
,
5864 coff_link_output_has_begun
, coff_final_link_postscript
,
5865 bfd_pe_print_pdata
/* huh */
5868 #endif /* COFF_WITH_PE_BIGOBJ */
5870 #ifndef coff_close_and_cleanup
5871 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5874 #ifndef coff_bfd_free_cached_info
5875 #define coff_bfd_free_cached_info _bfd_coff_free_cached_info
5878 #ifndef coff_get_section_contents
5879 #define coff_get_section_contents _bfd_generic_get_section_contents
5882 #ifndef coff_bfd_copy_private_symbol_data
5883 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5886 #ifndef coff_bfd_copy_private_header_data
5887 #define coff_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
5890 #ifndef coff_bfd_copy_private_section_data
5891 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5894 #ifndef coff_bfd_copy_private_bfd_data
5895 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5898 #ifndef coff_bfd_merge_private_bfd_data
5899 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5902 #ifndef coff_bfd_set_private_flags
5903 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5906 #ifndef coff_bfd_print_private_bfd_data
5907 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5910 #ifndef coff_bfd_is_local_label_name
5911 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5914 #ifndef coff_bfd_is_target_special_symbol
5915 #define coff_bfd_is_target_special_symbol _bfd_bool_bfd_asymbol_false
5918 #ifndef coff_read_minisymbols
5919 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5922 #ifndef coff_minisymbol_to_symbol
5923 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5926 /* The reloc lookup routine must be supplied by each individual COFF
5928 #ifndef coff_bfd_reloc_type_lookup
5929 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5931 #ifndef coff_bfd_reloc_name_lookup
5932 #define coff_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5935 #ifndef coff_bfd_get_relocated_section_contents
5936 #define coff_bfd_get_relocated_section_contents \
5937 bfd_generic_get_relocated_section_contents
5940 #ifndef coff_bfd_relax_section
5941 #define coff_bfd_relax_section bfd_generic_relax_section
5944 #ifndef coff_bfd_gc_sections
5945 #define coff_bfd_gc_sections bfd_coff_gc_sections
5948 #ifndef coff_bfd_lookup_section_flags
5949 #define coff_bfd_lookup_section_flags bfd_generic_lookup_section_flags
5952 #ifndef coff_bfd_merge_sections
5953 #define coff_bfd_merge_sections bfd_generic_merge_sections
5956 #ifndef coff_bfd_is_group_section
5957 #define coff_bfd_is_group_section bfd_generic_is_group_section
5960 #ifndef coff_bfd_group_name
5961 #define coff_bfd_group_name bfd_coff_group_name
5964 #ifndef coff_bfd_discard_group
5965 #define coff_bfd_discard_group bfd_generic_discard_group
5968 #ifndef coff_section_already_linked
5969 #define coff_section_already_linked \
5970 _bfd_coff_section_already_linked
5973 #ifndef coff_bfd_define_common_symbol
5974 #define coff_bfd_define_common_symbol bfd_generic_define_common_symbol
5977 #ifndef coff_bfd_link_hide_symbol
5978 #define coff_bfd_link_hide_symbol _bfd_generic_link_hide_symbol
5981 #ifndef coff_bfd_define_start_stop
5982 #define coff_bfd_define_start_stop bfd_generic_define_start_stop
5985 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5986 const bfd_target VAR = \
5989 bfd_target_coff_flavour, \
5990 BFD_ENDIAN_BIG, /* Data byte order is big. */ \
5991 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5992 /* object flags */ \
5993 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5994 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5995 /* section flags */ \
5996 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5997 UNDER, /* Leading symbol underscore. */ \
5998 '/', /* AR_pad_char. */ \
5999 15, /* AR_max_namelen. */ \
6000 0, /* match priority. */ \
6001 TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols. */ \
6003 /* Data conversion functions. */ \
6004 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
6005 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
6006 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
6008 /* Header conversion functions. */ \
6009 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
6010 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
6011 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
6013 { /* bfd_check_format. */ \
6014 _bfd_dummy_target, \
6016 bfd_generic_archive_p, \
6019 { /* bfd_set_format. */ \
6020 _bfd_bool_bfd_false_error, \
6022 _bfd_generic_mkarchive, \
6023 _bfd_bool_bfd_false_error \
6025 { /* bfd_write_contents. */ \
6026 _bfd_bool_bfd_false_error, \
6027 coff_write_object_contents, \
6028 _bfd_write_archive_contents, \
6029 _bfd_bool_bfd_false_error \
6032 BFD_JUMP_TABLE_GENERIC (coff), \
6033 BFD_JUMP_TABLE_COPY (coff), \
6034 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
6035 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
6036 BFD_JUMP_TABLE_SYMBOLS (coff), \
6037 BFD_JUMP_TABLE_RELOCS (coff), \
6038 BFD_JUMP_TABLE_WRITE (coff), \
6039 BFD_JUMP_TABLE_LINK (coff), \
6040 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
6047 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
6048 const bfd_target VAR = \
6051 bfd_target_coff_flavour, \
6052 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
6053 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
6054 /* object flags */ \
6055 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
6056 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
6057 /* section flags */ \
6058 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
6059 UNDER, /* Leading symbol underscore. */ \
6060 '/', /* AR_pad_char. */ \
6061 15, /* AR_max_namelen. */ \
6062 0, /* match priority. */ \
6063 TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols. */ \
6065 /* Data conversion functions. */ \
6066 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
6067 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
6068 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
6070 /* Header conversion functions. */ \
6071 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
6072 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
6073 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
6075 { /* bfd_check_format. */ \
6076 _bfd_dummy_target, \
6078 bfd_generic_archive_p, \
6081 { /* bfd_set_format. */ \
6082 _bfd_bool_bfd_false_error, \
6084 _bfd_generic_mkarchive, \
6085 _bfd_bool_bfd_false_error \
6087 { /* bfd_write_contents. */ \
6088 _bfd_bool_bfd_false_error, \
6089 coff_write_object_contents, \
6090 _bfd_write_archive_contents, \
6091 _bfd_bool_bfd_false_error \
6094 BFD_JUMP_TABLE_GENERIC (coff), \
6095 BFD_JUMP_TABLE_COPY (coff), \
6096 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
6097 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
6098 BFD_JUMP_TABLE_SYMBOLS (coff), \
6099 BFD_JUMP_TABLE_RELOCS (coff), \
6100 BFD_JUMP_TABLE_WRITE (coff), \
6101 BFD_JUMP_TABLE_LINK (coff), \
6102 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
6109 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
6110 const bfd_target VAR = \
6113 bfd_target_coff_flavour, \
6114 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
6115 BFD_ENDIAN_LITTLE, /* Header byte order is little. */ \
6116 /* object flags */ \
6117 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
6118 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
6119 /* section flags */ \
6120 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
6121 UNDER, /* Leading symbol underscore. */ \
6122 '/', /* AR_pad_char. */ \
6123 15, /* AR_max_namelen. */ \
6124 0, /* match priority. */ \
6125 TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols. */ \
6127 /* Data conversion functions. */ \
6128 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
6129 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
6130 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
6131 /* Header conversion functions. */ \
6132 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
6133 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
6134 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
6136 { /* bfd_check_format. */ \
6137 _bfd_dummy_target, \
6139 bfd_generic_archive_p, \
6142 { /* bfd_set_format. */ \
6143 _bfd_bool_bfd_false_error, \
6145 _bfd_generic_mkarchive, \
6146 _bfd_bool_bfd_false_error \
6148 { /* bfd_write_contents. */ \
6149 _bfd_bool_bfd_false_error, \
6150 coff_write_object_contents, \
6151 _bfd_write_archive_contents, \
6152 _bfd_bool_bfd_false_error \
6155 BFD_JUMP_TABLE_GENERIC (coff), \
6156 BFD_JUMP_TABLE_COPY (coff), \
6157 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
6158 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
6159 BFD_JUMP_TABLE_SYMBOLS (coff), \
6160 BFD_JUMP_TABLE_RELOCS (coff), \
6161 BFD_JUMP_TABLE_WRITE (coff), \
6162 BFD_JUMP_TABLE_LINK (coff), \
6163 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \