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 ((!strcmp (current
->name
, _TEXT
)
3180 || !strcmp (current
->name
, _DATA
))
3181 && (previous
== NULL
|| strcmp(previous
->name
, _TDATA
)))
3183 bfd_vma align
= 4096;
3184 bfd_vma sofar_off
= sofar
% align
;
3185 bfd_vma vma_off
= current
->vma
% align
;
3187 if (vma_off
> sofar_off
)
3188 sofar
+= vma_off
- sofar_off
;
3189 else if (vma_off
< sofar_off
)
3190 sofar
+= align
+ vma_off
- sofar_off
;
3193 if (previous
!= NULL
)
3194 previous
->size
+= sofar
- old_sofar
;
3199 /* In demand paged files the low order bits of the file offset
3200 must match the low order bits of the virtual address. */
3201 #ifdef COFF_PAGE_SIZE
3202 if ((abfd
->flags
& D_PAGED
) != 0
3203 && (current
->flags
& SEC_ALLOC
) != 0)
3204 sofar
+= (current
->vma
- (bfd_vma
) sofar
) % page_size
;
3206 current
->filepos
= sofar
;
3208 #ifdef COFF_IMAGE_WITH_PE
3209 /* Set the padded size. */
3210 current
->size
= (current
->size
+ page_size
- 1) & -page_size
;
3213 sofar
+= current
->size
;
3215 #ifdef ALIGN_SECTIONS_IN_FILE
3216 /* Make sure that this section is of the right size too. */
3217 if ((abfd
->flags
& EXEC_P
) == 0)
3219 bfd_size_type old_size
;
3221 old_size
= current
->size
;
3222 current
->size
= BFD_ALIGN (current
->size
,
3223 (bfd_vma
) 1 << current
->alignment_power
);
3224 align_adjust
= current
->size
!= old_size
;
3225 sofar
+= current
->size
- old_size
;
3230 #ifdef COFF_IMAGE_WITH_PE
3231 sofar
= BFD_ALIGN (sofar
, page_size
);
3233 sofar
= BFD_ALIGN (sofar
, (bfd_vma
) 1 << current
->alignment_power
);
3235 align_adjust
= sofar
!= old_sofar
;
3236 current
->size
+= sofar
- old_sofar
;
3240 #ifdef COFF_IMAGE_WITH_PE
3241 /* For PE we need to make sure we pad out to the aligned
3242 size, in case the caller only writes out data to the
3244 if (pei_section_data (abfd
, current
)->virt_size
< current
->size
)
3245 align_adjust
= true;
3249 /* Force .lib sections to start at zero. The vma is then
3250 incremented in coff_set_section_contents. This is right for
3252 if (strcmp (current
->name
, _LIB
) == 0)
3253 bfd_set_section_vma (current
, 0);
3256 #ifdef ALIGN_SECTIONS_IN_FILE
3261 /* It is now safe to write to the output file. If we needed an
3262 alignment adjustment for the last section, then make sure that
3263 there is a byte at offset sofar. If there are no symbols and no
3264 relocs, then nothing follows the last section. If we don't force
3265 the last byte out, then the file may appear to be truncated. */
3271 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
3272 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3276 /* Make sure the relocations are aligned. We don't need to make
3277 sure that this byte exists, because it will only matter if there
3278 really are relocs. */
3279 sofar
= BFD_ALIGN (sofar
,
3280 (bfd_vma
) 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
3282 obj_relocbase (abfd
) = sofar
;
3283 abfd
->output_has_begun
= true;
3288 #ifdef COFF_IMAGE_WITH_PE
3291 coff_read_word (bfd
*abfd
, unsigned int *value
, unsigned int *pelength
)
3296 status
= bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3304 *value
= (unsigned int) b
[0];
3306 *value
= (unsigned int) (b
[0] + (b
[1] << 8));
3308 *pelength
+= status
;
3313 /* Read a two byte number from buffer B returning the result in VALUE.
3314 No more than BUF_SIZE bytes will be read.
3315 Returns true upobn success, false otherwise.
3316 If successful, increases the value stored in PELENGTH by the number
3320 coff_read_word_from_buffer (unsigned char * b
,
3322 unsigned int * value
,
3323 unsigned int * pelength
)
3333 *value
= (unsigned int)b
[0];
3338 *value
= (unsigned int)(b
[0] + (b
[1] << 8));
3345 #define COFF_CHECKSUM_BUFFER_SIZE 0x800000
3348 coff_compute_checksum (bfd
*abfd
, unsigned int *pelength
)
3358 filepos
= (file_ptr
) 0;
3359 buf
= (unsigned char *) bfd_malloc (COFF_CHECKSUM_BUFFER_SIZE
);
3366 unsigned char *cur_buf
;
3369 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
3372 buf_size
= bfd_bread (buf
, COFF_CHECKSUM_BUFFER_SIZE
, abfd
);
3373 cur_buf_size
= buf_size
;
3376 while (cur_buf_size
> 0)
3378 coff_read_word_from_buffer (cur_buf
, cur_buf_size
, &value
, pelength
);
3382 total
= 0xffff & (total
+ (total
>> 0x10));
3385 filepos
+= buf_size
;
3387 while (buf_size
> 0);
3391 return (0xffff & (total
+ (total
>> 0x10)));
3395 coff_apply_checksum (bfd
*abfd
)
3397 unsigned int computed
;
3398 unsigned int checksum
= 0;
3399 unsigned int peheader
;
3400 unsigned int pelength
;
3402 if (bfd_seek (abfd
, 0x3c, SEEK_SET
) != 0)
3405 if (!coff_read_word (abfd
, &peheader
, &pelength
))
3408 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3412 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3414 if (bfd_seek (abfd
, peheader
, SEEK_SET
) != 0)
3417 computed
= coff_compute_checksum (abfd
, &pelength
);
3419 checksum
= computed
+ pelength
;
3421 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3424 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3429 #endif /* COFF_IMAGE_WITH_PE */
3432 coff_write_object_contents (bfd
* abfd
)
3435 bool hasrelocs
= false;
3436 bool haslinno
= false;
3437 #ifdef COFF_IMAGE_WITH_PE
3438 bool hasdebug
= false;
3441 file_ptr reloc_base
;
3442 file_ptr lineno_base
;
3444 unsigned long reloc_size
= 0, reloc_count
= 0;
3445 unsigned long lnno_size
= 0;
3446 bool long_section_names
;
3447 asection
*text_sec
= NULL
;
3448 asection
*data_sec
= NULL
;
3449 asection
*bss_sec
= NULL
;
3451 asection
*tdata_sec
= NULL
;
3452 asection
*tbss_sec
= NULL
;
3454 struct internal_filehdr internal_f
;
3455 struct internal_aouthdr internal_a
;
3456 #ifdef COFF_LONG_SECTION_NAMES
3457 size_t string_size
= STRING_SIZE_SIZE
;
3460 bfd_set_error (bfd_error_system_call
);
3462 /* Make a pass through the symbol table to count line number entries and
3463 put them into the correct asections. */
3464 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3466 if (! abfd
->output_has_begun
)
3468 if (! coff_compute_section_file_positions (abfd
))
3472 reloc_base
= obj_relocbase (abfd
);
3474 /* Work out the size of the reloc and linno areas. */
3476 for (current
= abfd
->sections
; current
!= NULL
; current
=
3479 #ifdef COFF_WITH_EXTENDED_RELOC_COUNTER
3480 /* We store the actual reloc count in the first reloc's addr. */
3481 if ((obj_pe (abfd
) || obj_go32 (abfd
)) && current
->reloc_count
>= 0xffff)
3484 reloc_count
+= current
->reloc_count
;
3487 reloc_size
= reloc_count
* bfd_coff_relsz (abfd
);
3489 lineno_base
= reloc_base
+ reloc_size
;
3490 sym_base
= lineno_base
+ lnno_size
;
3492 /* Indicate in each section->line_filepos its actual file address. */
3493 for (current
= abfd
->sections
; current
!= NULL
; current
=
3496 if (current
->lineno_count
)
3498 current
->line_filepos
= lineno_base
;
3499 current
->moving_line_filepos
= lineno_base
;
3500 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3503 current
->line_filepos
= 0;
3505 if (current
->reloc_count
)
3507 current
->rel_filepos
= reloc_base
;
3508 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3509 #ifdef COFF_WITH_EXTENDED_RELOC_COUNTER
3510 /* Extra reloc to hold real count. */
3511 if ((obj_pe (abfd
) || obj_go32 (abfd
)) && current
->reloc_count
>= 0xffff)
3512 reloc_base
+= bfd_coff_relsz (abfd
);
3516 current
->rel_filepos
= 0;
3519 /* Write section headers to the file. */
3520 internal_f
.f_nscns
= 0;
3522 if ((abfd
->flags
& EXEC_P
) != 0)
3523 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3526 scn_base
= bfd_coff_filhsz (abfd
);
3529 if (xcoff_data (abfd
)->full_aouthdr
)
3530 scn_base
+= bfd_coff_aoutsz (abfd
);
3532 scn_base
+= SMALL_AOUTSZ
;
3537 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3540 long_section_names
= false;
3541 for (current
= abfd
->sections
;
3543 current
= current
->next
)
3545 struct internal_scnhdr section
;
3546 #ifdef COFF_IMAGE_WITH_PE
3547 bool is_reloc_section
= false;
3549 if (strcmp (current
->name
, DOT_RELOC
) == 0)
3551 is_reloc_section
= true;
3553 pe_data (abfd
)->has_reloc_section
= 1;
3557 internal_f
.f_nscns
++;
3559 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3561 #ifdef COFF_LONG_SECTION_NAMES
3562 /* Handle long section names as in PE. This must be compatible
3563 with the code in coff_write_symbols and _bfd_coff_final_link. */
3564 if (bfd_coff_long_section_names (abfd
))
3568 len
= strlen (current
->name
);
3572 /* An inherent limitation of the /nnnnnnn notation used to indicate
3573 the offset of the long name in the string table is that we
3574 cannot address entries beyone the ten million byte boundary. */
3575 if (string_size
< 10000000)
3577 /* The s_name field is defined to be NUL-padded but need not
3578 be NUL-terminated. We use a temporary buffer so that we
3579 can still sprintf all eight chars without splatting a
3580 terminating NUL over the first byte of the following
3581 member (s_paddr). */
3582 /* PR 21096: The +20 is to stop a bogus warning from gcc7
3583 about a possible buffer overflow. */
3584 char s_name_buf
[SCNNMLEN
+ 1 + 20];
3586 /* We do not need to use snprintf here as we have already
3587 verified that string_size is not too big, plus we have
3588 an overlarge buffer, just in case. */
3589 sprintf (s_name_buf
, "/%lu", (unsigned long) string_size
);
3590 /* Then strncpy takes care of any padding for us. */
3591 strncpy (section
.s_name
, s_name_buf
, SCNNMLEN
);
3596 /* PE use a base 64 encoding for long section names whose
3597 index is very large. But contrary to RFC 4648, there is
3598 no padding: 6 characters must be generated. */
3599 static const char base64
[] =
3600 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
3601 "abcdefghijklmnopqrstuvwxyz"
3603 unsigned long off
= string_size
;
3606 section
.s_name
[0] = '/';
3607 section
.s_name
[1] = '/';
3608 for (i
= SCNNMLEN
- 1; i
>= 2; i
--)
3610 section
.s_name
[i
] = base64
[off
& 0x3f];
3615 if (string_size
> 0xffffffffUL
- (len
+ 1)
3616 #ifndef COFF_WITH_PE
3617 || string_size
>= 10000000
3621 bfd_set_error (bfd_error_file_too_big
);
3623 /* xgettext:c-format */
3624 (_("%pB: section %pA: string table overflow at offset %ld"),
3625 abfd
, current
, (unsigned long) string_size
);
3629 string_size
+= len
+ 1;
3630 long_section_names
= true;
3636 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3637 Ian Taylor <ian@cygnus.com>. */
3638 if (strcmp (current
->name
, _LIB
) == 0)
3639 section
.s_vaddr
= 0;
3642 section
.s_vaddr
= current
->vma
;
3643 section
.s_paddr
= current
->lma
;
3644 section
.s_size
= current
->size
;
3645 #ifdef coff_get_section_load_page
3646 section
.s_page
= coff_get_section_load_page (current
);
3652 section
.s_paddr
= 0;
3654 #ifdef COFF_IMAGE_WITH_PE
3655 /* Reminder: s_paddr holds the virtual size of the section. */
3656 if (coff_section_data (abfd
, current
) != NULL
3657 && pei_section_data (abfd
, current
) != NULL
)
3658 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3660 section
.s_paddr
= 0;
3663 /* If this section has no size or is unloadable then the scnptr
3665 if (current
->size
== 0
3666 || (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3667 section
.s_scnptr
= 0;
3669 section
.s_scnptr
= current
->filepos
;
3671 section
.s_relptr
= current
->rel_filepos
;
3672 section
.s_lnnoptr
= current
->line_filepos
;
3673 section
.s_nreloc
= current
->reloc_count
;
3674 section
.s_nlnno
= current
->lineno_count
;
3675 #ifndef COFF_IMAGE_WITH_PE
3676 /* In PEI, relocs come in the .reloc section. */
3677 if (current
->reloc_count
!= 0)
3680 if (current
->lineno_count
!= 0)
3682 #ifdef COFF_IMAGE_WITH_PE
3683 if ((current
->flags
& SEC_DEBUGGING
) != 0
3684 && ! is_reloc_section
)
3690 /* Indicate the use of an XCOFF overflow section header. */
3691 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3693 section
.s_nreloc
= 0xffff;
3694 section
.s_nlnno
= 0xffff;
3699 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3701 if (!strcmp (current
->name
, _TEXT
))
3703 else if (!strcmp (current
->name
, _DATA
))
3705 else if (!strcmp (current
->name
, _BSS
))
3708 else if (!strcmp (current
->name
, _TDATA
))
3709 tdata_sec
= current
;
3710 else if (!strcmp (current
->name
, _TBSS
))
3715 #ifdef COFF_ENCODE_ALIGNMENT
3716 if (COFF_ENCODE_ALIGNMENT (abfd
, section
, current
->alignment_power
)
3717 && (COFF_DECODE_ALIGNMENT (section
.s_flags
)
3718 != current
->alignment_power
))
3720 bool warn
= (coff_data (abfd
)->link_info
3721 && !bfd_link_relocatable (coff_data (abfd
)->link_info
));
3724 /* xgettext:c-format */
3725 (_("%pB:%s section %s: alignment 2**%u not representable"),
3726 abfd
, warn
? " warning:" : "", current
->name
,
3727 current
->alignment_power
);
3730 bfd_set_error (bfd_error_nonrepresentable_section
);
3736 #ifdef COFF_IMAGE_WITH_PE
3737 /* Suppress output of the sections if they are null. ld
3738 includes the bss and data sections even if there is no size
3739 assigned to them. NT loader doesn't like it if these section
3740 headers are included if the sections themselves are not
3741 needed. See also coff_compute_section_file_positions. */
3742 if (section
.s_size
== 0)
3743 internal_f
.f_nscns
--;
3748 bfd_size_type amt
= bfd_coff_scnhsz (abfd
);
3750 if (bfd_coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3751 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3756 /* PE stores COMDAT section information in the symbol table. If
3757 this section is supposed to have some COMDAT info, track down
3758 the symbol in the symbol table and modify it. */
3759 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3761 unsigned int i
, count
;
3763 coff_symbol_type
*csym
= NULL
;
3767 count
= bfd_get_symcount (abfd
);
3768 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3770 if ((*psym
)->section
!= current
)
3773 /* Remember the location of the first symbol in this
3775 if (psymsec
== NULL
)
3778 /* See if this is the section symbol. */
3779 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3781 csym
= coff_symbol_from (*psym
);
3783 || csym
->native
== NULL
3784 || ! csym
->native
->is_sym
3785 || csym
->native
->u
.syment
.n_numaux
< 1
3786 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3787 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3790 /* Here *PSYM is the section symbol for CURRENT. */
3797 Note that we might not if we're converting the file from
3798 some other object file format. */
3801 combined_entry_type
*aux
;
3803 /* We don't touch the x_checksum field. The
3804 x_associated field is not currently supported. */
3806 aux
= csym
->native
+ 1;
3807 BFD_ASSERT (! aux
->is_sym
);
3808 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3810 case SEC_LINK_DUPLICATES_DISCARD
:
3811 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3814 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3815 aux
->u
.auxent
.x_scn
.x_comdat
=
3816 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3819 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3820 aux
->u
.auxent
.x_scn
.x_comdat
=
3821 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3824 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3825 aux
->u
.auxent
.x_scn
.x_comdat
=
3826 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3830 /* The COMDAT symbol must be the first symbol from this
3831 section in the symbol table. In order to make this
3832 work, we move the COMDAT symbol before the first
3833 symbol we found in the search above. It's OK to
3834 rearrange the symbol table at this point, because
3835 coff_renumber_symbols is going to rearrange it
3836 further and fix up all the aux entries. */
3837 if (psym
!= psymsec
)
3843 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3844 pcopy
[0] = pcopy
[-1];
3849 #endif /* COFF_WITH_PE */
3854 /* XCOFF handles overflows in the reloc and line number count fields
3855 by creating a new section header to hold the correct values. */
3856 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3858 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3860 struct internal_scnhdr scnhdr
;
3864 internal_f
.f_nscns
++;
3865 memcpy (scnhdr
.s_name
, ".ovrflo", 8);
3866 scnhdr
.s_paddr
= current
->reloc_count
;
3867 scnhdr
.s_vaddr
= current
->lineno_count
;
3869 scnhdr
.s_scnptr
= 0;
3870 scnhdr
.s_relptr
= current
->rel_filepos
;
3871 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3872 scnhdr
.s_nreloc
= current
->target_index
;
3873 scnhdr
.s_nlnno
= current
->target_index
;
3874 scnhdr
.s_flags
= STYP_OVRFLO
;
3875 amt
= bfd_coff_scnhsz (abfd
);
3876 if (bfd_coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3877 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3884 #if defined (COFF_GO32_EXE) || defined (COFF_GO32)
3885 /* Pad section headers. */
3886 if ((abfd
->flags
& EXEC_P
) && abfd
->sections
!= NULL
)
3888 file_ptr cur_ptr
= scn_base
3889 + abfd
->section_count
* bfd_coff_scnhsz (abfd
);
3890 long fill_size
= (abfd
->sections
->filepos
- cur_ptr
);
3891 bfd_byte
*b
= bfd_zmalloc (fill_size
);
3894 bfd_bwrite (b
, fill_size
, abfd
);
3900 /* OK, now set up the filehdr... */
3902 /* Don't include the internal abs section in the section count */
3904 /* We will NOT put a fucking timestamp in the header here. Every time you
3905 put it back, I will come in and take it out again. I'm sorry. This
3906 field does not belong here. We fill it with a 0 so it compares the
3907 same but is not a reasonable time. -- gnu@cygnus.com */
3908 internal_f
.f_timdat
= 0;
3909 internal_f
.f_flags
= 0;
3911 if (abfd
->flags
& EXEC_P
)
3912 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3915 internal_f
.f_opthdr
= 0;
3918 if (xcoff_data (abfd
)->full_aouthdr
)
3919 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3921 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
3927 internal_f
.f_flags
|= F_RELFLG
;
3929 internal_f
.f_flags
|= F_LNNO
;
3930 if (abfd
->flags
& EXEC_P
)
3931 internal_f
.f_flags
|= F_EXEC
;
3932 #ifdef COFF_IMAGE_WITH_PE
3934 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
3935 if (pe_data (abfd
)->real_flags
& IMAGE_FILE_LARGE_ADDRESS_AWARE
)
3936 internal_f
.f_flags
|= IMAGE_FILE_LARGE_ADDRESS_AWARE
;
3939 #if !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
3941 internal_f
.f_flags
|= IMAGE_FILE_32BIT_MACHINE
;
3943 if (bfd_little_endian (abfd
))
3944 internal_f
.f_flags
|= F_AR32WR
;
3946 internal_f
.f_flags
|= F_AR32W
;
3951 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
3952 but it doesn't hurt to set it internally. */
3953 internal_f
.f_target_id
= TI_TARGET_ID
;
3956 /* FIXME, should do something about the other byte orders and
3960 if ((abfd
->flags
& DYNAMIC
) != 0)
3961 internal_f
.f_flags
|= F_SHROBJ
;
3962 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
3963 internal_f
.f_flags
|= F_DYNLOAD
;
3966 memset (&internal_a
, 0, sizeof internal_a
);
3968 /* Set up architecture-dependent stuff. */
3970 unsigned int magic
= 0;
3971 unsigned short flags
= 0;
3973 coff_set_flags (abfd
, &magic
, &flags
);
3974 internal_f
.f_magic
= magic
;
3975 internal_f
.f_flags
|= flags
;
3976 /* ...and the "opt"hdr... */
3978 #ifdef TICOFF_AOUT_MAGIC
3979 internal_a
.magic
= TICOFF_AOUT_MAGIC
;
3980 #define __A_MAGIC_SET__
3984 #define __A_MAGIC_SET__
3985 internal_a
.magic
= ZMAGIC
;
3988 #if defined(AARCH64)
3989 #define __A_MAGIC_SET__
3990 internal_a
.magic
= ZMAGIC
;
3993 #if defined(LOONGARCH64)
3994 #define __A_MAGIC_SET__
3995 internal_a
.magic
= ZMAGIC
;
3998 #if defined MCORE_PE
3999 #define __A_MAGIC_SET__
4000 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
4004 #define __A_MAGIC_SET__
4006 internal_a
.magic
= LYNXCOFFMAGIC
;
4008 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR64_MAGIC
;
4010 internal_a
.magic
= ZMAGIC
;
4015 #define __A_MAGIC_SET__
4016 internal_a
.magic
= PE32PMAGIC
;
4020 #define __A_MAGIC_SET__
4022 internal_a
.magic
= LYNXCOFFMAGIC
;
4027 #define __A_MAGIC_SET__
4028 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
4029 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
4030 RS6K_AOUTHDR_OMAGIC
;
4033 #if defined(SH) && defined(COFF_WITH_PE)
4034 #define __A_MAGIC_SET__
4035 internal_a
.magic
= SH_PE_MAGIC
;
4038 #if defined(MIPS) && defined(COFF_WITH_PE)
4039 #define __A_MAGIC_SET__
4040 internal_a
.magic
= MIPS_PE_MAGIC
;
4043 #ifndef __A_MAGIC_SET__
4044 #include "Your aouthdr magic number is not being set!"
4046 #undef __A_MAGIC_SET__
4051 /* XCOFF 32bit needs this to have new behaviour for n_type field. */
4052 internal_a
.vstamp
= 2;
4054 /* FIXME: Does anybody ever set this to another value? */
4055 internal_a
.vstamp
= 0;
4058 /* Now should write relocs, strings, syms. */
4059 obj_sym_filepos (abfd
) = sym_base
;
4061 if (bfd_get_symcount (abfd
) != 0)
4065 if (!coff_renumber_symbols (abfd
, &firstundef
))
4067 coff_mangle_symbols (abfd
);
4068 if (! coff_write_symbols (abfd
))
4070 if (! coff_write_linenumbers (abfd
))
4072 if (! coff_write_relocs (abfd
, firstundef
))
4075 #ifdef COFF_LONG_SECTION_NAMES
4076 else if (long_section_names
&& ! obj_coff_strings_written (abfd
))
4078 /* If we have long section names we have to write out the string
4079 table even if there are no symbols. */
4080 if (! coff_write_symbols (abfd
))
4084 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
4085 backend linker, and obj_raw_syment_count is not valid until after
4086 coff_write_symbols is called. */
4087 if (obj_raw_syment_count (abfd
) != 0)
4089 internal_f
.f_symptr
= sym_base
;
4091 /* AIX appears to require that F_RELFLG not be set if there are
4092 local symbols but no relocations. */
4093 internal_f
.f_flags
&=~ F_RELFLG
;
4098 if (long_section_names
)
4099 internal_f
.f_symptr
= sym_base
;
4101 internal_f
.f_symptr
= 0;
4102 internal_f
.f_flags
|= F_LSYMS
;
4107 internal_a
.tsize
= text_sec
->size
;
4108 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
4112 internal_a
.dsize
= data_sec
->size
;
4113 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
4117 internal_a
.bsize
= bss_sec
->size
;
4118 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
4119 internal_a
.data_start
= bss_sec
->vma
;
4122 internal_a
.entry
= bfd_get_start_address (abfd
);
4123 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
4126 if (xcoff_data (abfd
)->full_aouthdr
)
4129 asection
*loader_sec
;
4131 internal_a
.vstamp
= 2;
4133 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
4134 if (internal_a
.o_snentry
== 0)
4135 internal_a
.entry
= (bfd_vma
) -1;
4137 if (text_sec
!= NULL
)
4139 internal_a
.o_sntext
= text_sec
->target_index
;
4140 internal_a
.o_algntext
= bfd_section_alignment (text_sec
);
4144 internal_a
.o_sntext
= 0;
4145 internal_a
.o_algntext
= 0;
4147 if (data_sec
!= NULL
)
4149 internal_a
.o_sndata
= data_sec
->target_index
;
4150 internal_a
.o_algndata
= bfd_section_alignment (data_sec
);
4154 internal_a
.o_sndata
= 0;
4155 internal_a
.o_algndata
= 0;
4157 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
4158 if (loader_sec
!= NULL
)
4159 internal_a
.o_snloader
= loader_sec
->target_index
;
4161 internal_a
.o_snloader
= 0;
4162 if (bss_sec
!= NULL
)
4163 internal_a
.o_snbss
= bss_sec
->target_index
;
4165 internal_a
.o_snbss
= 0;
4167 if (tdata_sec
!= NULL
)
4169 internal_a
.o_sntdata
= tdata_sec
->target_index
;
4170 /* TODO: o_flags should be set to RS6K_AOUTHDR_TLS_LE
4171 if there is at least one R_TLS_LE relocations. */
4172 internal_a
.o_flags
= 0;
4174 internal_a
.o_x64flags
= 0;
4179 internal_a
.o_sntdata
= 0;
4180 internal_a
.o_flags
= 0;
4182 internal_a
.o_x64flags
= 0;
4185 if (tbss_sec
!= NULL
)
4186 internal_a
.o_sntbss
= tbss_sec
->target_index
;
4188 internal_a
.o_sntbss
= 0;
4190 toc
= xcoff_data (abfd
)->toc
;
4191 internal_a
.o_toc
= toc
;
4192 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
4194 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
4195 if (xcoff_data (abfd
)->cputype
!= -1)
4196 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
4199 switch (bfd_get_arch (abfd
))
4201 case bfd_arch_rs6000
:
4202 internal_a
.o_cputype
= 4;
4204 case bfd_arch_powerpc
:
4205 if (bfd_get_mach (abfd
) == bfd_mach_ppc
)
4206 internal_a
.o_cputype
= 3;
4207 else if (bfd_get_mach (abfd
) == bfd_mach_ppc_620
)
4208 internal_a
.o_cputype
= 2;
4210 internal_a
.o_cputype
= 1;
4216 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
4217 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
4223 /* After object contents are finalized so we can compute a reasonable hash,
4224 but before header is written so we can update it to point to debug directory. */
4225 struct pe_tdata
*pe
= pe_data (abfd
);
4227 if (pe
->build_id
.after_write_object_contents
!= NULL
)
4228 (*pe
->build_id
.after_write_object_contents
) (abfd
);
4232 /* Now write header. */
4233 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
4238 bfd_size_type amount
= bfd_coff_filhsz (abfd
);
4240 buff
= (char *) bfd_malloc (amount
);
4244 bfd_coff_swap_filehdr_out (abfd
, & internal_f
, buff
);
4245 amount
= bfd_bwrite (buff
, amount
, abfd
);
4249 if (amount
!= bfd_coff_filhsz (abfd
))
4253 if (abfd
->flags
& EXEC_P
)
4255 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4256 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4258 bfd_size_type amount
= bfd_coff_aoutsz (abfd
);
4260 buff
= (char *) bfd_malloc (amount
);
4264 coff_swap_aouthdr_out (abfd
, & internal_a
, buff
);
4265 amount
= bfd_bwrite (buff
, amount
, abfd
);
4269 if (amount
!= bfd_coff_aoutsz (abfd
))
4272 #ifdef COFF_IMAGE_WITH_PE
4273 if (! coff_apply_checksum (abfd
))
4284 /* XCOFF32 seems to always write at least a small a.out header. */
4285 coff_swap_aouthdr_out (abfd
, & internal_a
, & buff
);
4286 if (xcoff_data (abfd
)->full_aouthdr
)
4287 size
= bfd_coff_aoutsz (abfd
);
4289 size
= SMALL_AOUTSZ
;
4290 if (bfd_bwrite (& buff
, (bfd_size_type
) size
, abfd
) != size
)
4300 coff_set_section_contents (bfd
* abfd
,
4302 const void * location
,
4304 bfd_size_type count
)
4306 if (! abfd
->output_has_begun
) /* Set by bfd.c handler. */
4308 if (! coff_compute_section_file_positions (abfd
))
4312 #if defined(_LIB) && !defined(TARG_AUX)
4313 /* The physical address field of a .lib section is used to hold the
4314 number of shared libraries in the section. This code counts the
4315 number of sections being written, and increments the lma field
4318 I have found no documentation on the contents of this section.
4319 Experimentation indicates that the section contains zero or more
4320 records, each of which has the following structure:
4322 - a (four byte) word holding the length of this record, in words,
4323 - a word that always seems to be set to "2",
4324 - the path to a shared library, null-terminated and then padded
4325 to a whole word boundary.
4327 bfd_assert calls have been added to alert if an attempt is made
4328 to write a section which doesn't follow these assumptions. The
4329 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4330 <robertl@arnet.com> (Thanks!).
4332 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4333 if (strcmp (section
->name
, _LIB
) == 0)
4335 bfd_byte
*rec
, *recend
;
4337 rec
= (bfd_byte
*) location
;
4338 recend
= rec
+ count
;
4339 while (recend
- rec
>= 4)
4341 size_t len
= bfd_get_32 (abfd
, rec
);
4342 if (len
== 0 || len
> (size_t) (recend
- rec
) / 4)
4348 BFD_ASSERT (rec
== recend
);
4352 /* Don't write out bss sections - one way to do this is to
4353 see if the filepos has not been set. */
4354 if (section
->filepos
== 0)
4357 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0)
4363 return bfd_bwrite (location
, count
, abfd
) == count
;
4367 buy_and_read (bfd
*abfd
, file_ptr where
,
4368 bfd_size_type nmemb
, bfd_size_type size
)
4372 if (_bfd_mul_overflow (nmemb
, size
, &amt
))
4374 bfd_set_error (bfd_error_file_too_big
);
4377 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
4379 return _bfd_malloc_and_read (abfd
, amt
, amt
);
4386 Creating the linenumber table is done by reading in the entire
4387 coff linenumber table, and creating another table for internal use.
4389 A coff linenumber table is structured so that each function
4390 is marked as having a line number of 0. Each line within the
4391 function is an offset from the first line in the function. The
4392 base of the line number information for the table is stored in
4393 the symbol associated with the function.
4395 Note: The PE format uses line number 0 for a flag indicating a
4398 The information is copied from the external to the internal
4399 table, and each symbol which marks a function is marked by
4402 How does this work ?
4406 coff_sort_func_alent (const void * arg1
, const void * arg2
)
4408 const alent
*al1
= *(const alent
**) arg1
;
4409 const alent
*al2
= *(const alent
**) arg2
;
4410 const coff_symbol_type
*s1
= (const coff_symbol_type
*) (al1
->u
.sym
);
4411 const coff_symbol_type
*s2
= (const coff_symbol_type
*) (al2
->u
.sym
);
4413 if (s1
== NULL
|| s2
== NULL
)
4415 if (s1
->symbol
.value
< s2
->symbol
.value
)
4417 else if (s1
->symbol
.value
> s2
->symbol
.value
)
4424 coff_slurp_line_table (bfd
*abfd
, asection
*asect
)
4426 LINENO
*native_lineno
;
4427 alent
*lineno_cache
;
4428 unsigned int counter
;
4430 bfd_vma prev_offset
= 0;
4431 bool ordered
= true;
4432 unsigned int nbr_func
;
4438 if (asect
->lineno_count
== 0)
4441 BFD_ASSERT (asect
->lineno
== NULL
);
4443 native_lineno
= (LINENO
*) buy_and_read (abfd
, asect
->line_filepos
,
4444 asect
->lineno_count
,
4445 bfd_coff_linesz (abfd
));
4446 if (native_lineno
== NULL
)
4449 (_("%pB: warning: line number table read failed"), abfd
);
4453 if (_bfd_mul_overflow (asect
->lineno_count
+ 1, sizeof (alent
), &amt
))
4455 bfd_set_error (bfd_error_file_too_big
);
4456 free (native_lineno
);
4459 lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
);
4460 if (lineno_cache
== NULL
)
4462 free (native_lineno
);
4466 cache_ptr
= lineno_cache
;
4467 asect
->lineno
= lineno_cache
;
4468 src
= native_lineno
;
4472 for (counter
= 0; counter
< asect
->lineno_count
; counter
++, src
++)
4474 struct internal_lineno dst
;
4476 bfd_coff_swap_lineno_in (abfd
, src
, &dst
);
4477 cache_ptr
->line_number
= dst
.l_lnno
;
4478 /* Appease memory checkers that get all excited about
4479 uninitialised memory when copying alents if u.offset is
4480 larger than u.sym. (64-bit BFD on 32-bit host.) */
4481 memset (&cache_ptr
->u
, 0, sizeof (cache_ptr
->u
));
4483 if (cache_ptr
->line_number
== 0)
4485 combined_entry_type
* ent
;
4486 unsigned long symndx
;
4487 coff_symbol_type
*sym
;
4490 symndx
= dst
.l_addr
.l_symndx
;
4491 if (symndx
>= obj_raw_syment_count (abfd
))
4494 /* xgettext:c-format */
4495 (_("%pB: warning: illegal symbol index 0x%lx in line number entry %d"),
4496 abfd
, symndx
, counter
);
4497 cache_ptr
->line_number
= -1;
4502 ent
= obj_raw_syments (abfd
) + symndx
;
4503 /* FIXME: We should not be casting between ints and
4504 pointers like this. */
4508 /* xgettext:c-format */
4509 (_("%pB: warning: illegal symbol index 0x%lx in line number entry %d"),
4510 abfd
, symndx
, counter
);
4511 cache_ptr
->line_number
= -1;
4515 sym
= (coff_symbol_type
*) (ent
->u
.syment
._n
._n_n
._n_zeroes
);
4517 /* PR 17512 file: 078-10659-0.004 */
4518 if (sym
< obj_symbols (abfd
)
4519 || sym
>= obj_symbols (abfd
) + bfd_get_symcount (abfd
))
4522 /* xgettext:c-format */
4523 (_("%pB: warning: illegal symbol in line number entry %d"),
4525 cache_ptr
->line_number
= -1;
4532 cache_ptr
->u
.sym
= (asymbol
*) sym
;
4533 if (sym
->lineno
!= NULL
)
4535 /* xgettext:c-format */
4536 (_("%pB: warning: duplicate line number information for `%s'"),
4537 abfd
, bfd_asymbol_name (&sym
->symbol
));
4539 sym
->lineno
= cache_ptr
;
4540 if (sym
->symbol
.value
< prev_offset
)
4542 prev_offset
= sym
->symbol
.value
;
4544 else if (!have_func
)
4545 /* Drop line information that has no associated function.
4546 PR 17521: file: 078-10659-0.004. */
4549 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
- bfd_section_vma (asect
);
4553 asect
->lineno_count
= cache_ptr
- lineno_cache
;
4554 memset (cache_ptr
, 0, sizeof (*cache_ptr
));
4555 free (native_lineno
);
4557 /* On some systems (eg AIX5.3) the lineno table may not be sorted. */
4560 /* Sort the table. */
4562 alent
*n_lineno_cache
;
4564 /* Create a table of functions. */
4565 if (_bfd_mul_overflow (nbr_func
, sizeof (alent
*), &amt
))
4567 bfd_set_error (bfd_error_file_too_big
);
4570 else if ((func_table
= (alent
**) bfd_alloc (abfd
, amt
)) != NULL
)
4572 alent
**p
= func_table
;
4575 for (i
= 0; i
< asect
->lineno_count
; i
++)
4576 if (lineno_cache
[i
].line_number
== 0)
4577 *p
++ = &lineno_cache
[i
];
4579 BFD_ASSERT ((unsigned int) (p
- func_table
) == nbr_func
);
4581 /* Sort by functions. */
4582 qsort (func_table
, nbr_func
, sizeof (alent
*), coff_sort_func_alent
);
4584 /* Create the new sorted table. */
4585 if (_bfd_mul_overflow (asect
->lineno_count
, sizeof (alent
), &amt
))
4587 bfd_set_error (bfd_error_file_too_big
);
4590 else if ((n_lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
)) != NULL
)
4592 alent
*n_cache_ptr
= n_lineno_cache
;
4594 for (i
= 0; i
< nbr_func
; i
++)
4596 coff_symbol_type
*sym
;
4597 alent
*old_ptr
= func_table
[i
];
4599 /* Update the function entry. */
4600 sym
= (coff_symbol_type
*) old_ptr
->u
.sym
;
4601 /* PR binutils/17512: Point the lineno to where
4602 this entry will be after the memcpy below. */
4603 sym
->lineno
= lineno_cache
+ (n_cache_ptr
- n_lineno_cache
);
4604 /* Copy the function and line number entries. */
4606 *n_cache_ptr
++ = *old_ptr
++;
4607 while (old_ptr
->line_number
!= 0);
4610 memcpy (lineno_cache
, n_lineno_cache
,
4611 asect
->lineno_count
* sizeof (alent
));
4615 bfd_release (abfd
, func_table
);
4624 /* Slurp in the symbol table, converting it to generic form. Note
4625 that if coff_relocate_section is defined, the linker will read
4626 symbols via coff_link_add_symbols, rather than via this routine. */
4629 coff_slurp_symbol_table (bfd
* abfd
)
4631 combined_entry_type
*native_symbols
;
4632 coff_symbol_type
*cached_area
;
4633 unsigned int *table_ptr
;
4634 unsigned int number_of_symbols
= 0;
4638 if (obj_symbols (abfd
))
4641 /* Read in the symbol table. */
4642 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4645 /* Allocate enough room for all the symbols in cached form. */
4646 if (_bfd_mul_overflow (obj_raw_syment_count (abfd
),
4647 sizeof (*cached_area
), &amt
))
4649 bfd_set_error (bfd_error_file_too_big
);
4652 cached_area
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
4653 if (cached_area
== NULL
)
4656 if (_bfd_mul_overflow (obj_raw_syment_count (abfd
),
4657 sizeof (*table_ptr
), &amt
))
4659 bfd_set_error (bfd_error_file_too_big
);
4662 table_ptr
= (unsigned int *) bfd_zalloc (abfd
, amt
);
4663 if (table_ptr
== NULL
)
4667 coff_symbol_type
*dst
= cached_area
;
4668 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4669 unsigned int this_index
= 0;
4671 while (this_index
< last_native_index
)
4673 combined_entry_type
*src
= native_symbols
+ this_index
;
4674 table_ptr
[this_index
] = number_of_symbols
;
4676 dst
->symbol
.the_bfd
= abfd
;
4677 BFD_ASSERT (src
->is_sym
);
4678 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4679 /* We use the native name field to point to the cached field. */
4680 src
->u
.syment
._n
._n_n
._n_zeroes
= (uintptr_t) dst
;
4681 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4682 src
->u
.syment
.n_scnum
);
4683 dst
->symbol
.flags
= 0;
4684 /* PR 17512: file: 079-7098-0.001:0.1. */
4685 dst
->symbol
.value
= 0;
4686 dst
->done_lineno
= false;
4688 switch (src
->u
.syment
.n_sclass
)
4694 case C_THUMBEXTFUNC
:
4698 #if ! defined _AIX52 && ! defined AIX_WEAK_SUPPORT
4703 case C_SYSTEM
: /* System Wide variable. */
4706 /* In PE, 0x68 (104) denotes a section symbol. */
4708 /* In PE, 0x69 (105) denotes a weak external symbol. */
4711 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4713 case COFF_SYMBOL_GLOBAL
:
4714 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4715 #if defined COFF_WITH_PE
4716 /* PE sets the symbol to a value relative to the
4717 start of the section. */
4718 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4720 dst
->symbol
.value
= (src
->u
.syment
.n_value
4721 - dst
->symbol
.section
->vma
);
4723 if (ISFCN ((src
->u
.syment
.n_type
)))
4724 /* A function ext does not go at the end of a
4726 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4729 case COFF_SYMBOL_COMMON
:
4730 dst
->symbol
.section
= bfd_com_section_ptr
;
4731 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4734 case COFF_SYMBOL_UNDEFINED
:
4735 dst
->symbol
.section
= bfd_und_section_ptr
;
4736 dst
->symbol
.value
= 0;
4739 case COFF_SYMBOL_PE_SECTION
:
4740 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4741 dst
->symbol
.value
= 0;
4744 case COFF_SYMBOL_LOCAL
:
4745 dst
->symbol
.flags
= BSF_LOCAL
;
4746 #if defined COFF_WITH_PE
4747 /* PE sets the symbol to a value relative to the
4748 start of the section. */
4749 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4751 dst
->symbol
.value
= (src
->u
.syment
.n_value
4752 - dst
->symbol
.section
->vma
);
4754 if (ISFCN ((src
->u
.syment
.n_type
)))
4755 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4760 /* A symbol with a csect entry should not go at the end. */
4761 if (src
->u
.syment
.n_numaux
> 0)
4762 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4766 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4767 dst
->symbol
.flags
|= BSF_WEAK
;
4769 if (src
->u
.syment
.n_sclass
== C_SECTION
4770 && src
->u
.syment
.n_scnum
> 0)
4771 dst
->symbol
.flags
= BSF_LOCAL
;
4773 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
4775 || src
->u
.syment
.n_sclass
== C_AIX_WEAKEXT
4778 dst
->symbol
.flags
|= BSF_WEAK
;
4782 case C_STAT
: /* Static. */
4784 case C_THUMBSTAT
: /* Thumb static. */
4785 case C_THUMBLABEL
: /* Thumb label. */
4786 case C_THUMBSTATFUNC
:/* Thumb static function. */
4789 case C_DWARF
: /* A label in a dwarf section. */
4790 case C_INFO
: /* A label in a comment section. */
4792 case C_LABEL
: /* Label. */
4793 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4794 dst
->symbol
.flags
= BSF_DEBUGGING
;
4796 dst
->symbol
.flags
= BSF_LOCAL
;
4798 /* Base the value as an index from the base of the
4799 section, if there is one. */
4800 if (dst
->symbol
.section
)
4802 #if defined COFF_WITH_PE
4803 /* PE sets the symbol to a value relative to the
4804 start of the section. */
4805 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4807 dst
->symbol
.value
= (src
->u
.syment
.n_value
4808 - dst
->symbol
.section
->vma
);
4812 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4815 case C_FILE
: /* File name. */
4816 dst
->symbol
.flags
= BSF_FILE
;
4818 case C_MOS
: /* Member of structure. */
4819 case C_EOS
: /* End of structure. */
4820 case C_REGPARM
: /* Register parameter. */
4821 case C_REG
: /* register variable. */
4822 /* C_AUTOARG conflicts with TI COFF C_UEXT. */
4823 case C_TPDEF
: /* Type definition. */
4825 case C_AUTO
: /* Automatic variable. */
4826 case C_FIELD
: /* Bit field. */
4827 case C_ENTAG
: /* Enumeration tag. */
4828 case C_MOE
: /* Member of enumeration. */
4829 case C_MOU
: /* Member of union. */
4830 case C_UNTAG
: /* Union tag. */
4831 case C_STRTAG
: /* Structure tag. */
4848 dst
->symbol
.flags
|= BSF_DEBUGGING
;
4849 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4853 case C_BINCL
: /* Beginning of include file. */
4854 case C_EINCL
: /* Ending of include file. */
4855 /* The value is actually a pointer into the line numbers
4856 of the file. We locate the line number entry, and
4857 set the section to the section which contains it, and
4858 the value to the index in that section. */
4862 dst
->symbol
.flags
= BSF_DEBUGGING
;
4863 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4864 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4865 && ((file_ptr
) (sec
->line_filepos
4866 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4867 > (file_ptr
) src
->u
.syment
.n_value
))
4870 dst
->symbol
.value
= 0;
4873 dst
->symbol
.section
= sec
;
4874 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4875 - sec
->line_filepos
)
4876 / bfd_coff_linesz (abfd
));
4883 dst
->symbol
.flags
= BSF_DEBUGGING
;
4885 if (src
->u
.syment
.n_value
>= obj_raw_syment_count (abfd
))
4886 dst
->symbol
.value
= 0;
4889 /* The value is actually a symbol index. Save a pointer
4890 to the symbol instead of the index. FIXME: This
4891 should use a union. */
4892 src
->u
.syment
.n_value
4893 = (uintptr_t) (native_symbols
+ src
->u
.syment
.n_value
);
4894 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4900 case C_BLOCK
: /* ".bb" or ".eb". */
4901 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf"). */
4902 case C_EFCN
: /* Physical end of function. */
4903 #if defined COFF_WITH_PE
4904 /* PE sets the symbol to a value relative to the start
4906 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4907 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4909 /* PE uses funny values for .ef and .lf; don't
4911 dst
->symbol
.flags
= BSF_DEBUGGING
;
4914 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4916 /* Base the value as an index from the base of the
4918 dst
->symbol
.flags
= BSF_LOCAL
;
4919 dst
->symbol
.value
= (src
->u
.syment
.n_value
4920 - dst
->symbol
.section
->vma
);
4924 case C_STATLAB
: /* Static load time label. */
4925 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4926 dst
->symbol
.flags
= BSF_GLOBAL
;
4930 /* PE DLLs sometimes have zeroed out symbols for some
4931 reason. Just ignore them without a warning. */
4932 if (src
->u
.syment
.n_type
== 0
4933 && src
->u
.syment
.n_value
== 0
4934 && src
->u
.syment
.n_scnum
== 0)
4937 /* XCOFF specific: deleted entry. */
4938 if (src
->u
.syment
.n_value
== C_NULL_VALUE
)
4942 case C_EXTDEF
: /* External definition. */
4943 case C_ULABEL
: /* Undefined label. */
4944 case C_USTATIC
: /* Undefined static. */
4945 #ifndef COFF_WITH_PE
4946 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4947 class to represent a section symbol. */
4948 case C_LINE
: /* line # reformatted as symbol table entry. */
4949 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4950 case C_ALIAS
: /* Duplicate tag. */
4952 /* New storage classes for TI COFF. */
4954 case C_UEXT
: /* Tentative external definition. */
4956 case C_EXTLAB
: /* External load time label. */
4959 /* xgettext:c-format */
4960 (_("%pB: unrecognized storage class %d for %s symbol `%s'"),
4961 abfd
, src
->u
.syment
.n_sclass
,
4962 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4965 case C_HIDDEN
: /* Ext symbol in dmert public lib. */
4966 /* PR 20722: These symbols can also be generated by
4967 building DLLs with --gc-sections enabled. */
4968 dst
->symbol
.flags
= BSF_DEBUGGING
;
4969 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4974 dst
->symbol
.udata
.i
= 0;
4977 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
4979 number_of_symbols
++;
4983 obj_symbols (abfd
) = cached_area
;
4984 obj_raw_syments (abfd
) = native_symbols
;
4986 abfd
->symcount
= number_of_symbols
;
4987 obj_convert (abfd
) = table_ptr
;
4988 /* Slurp the line tables for each section too. */
4995 if (! coff_slurp_line_table (abfd
, p
))
5004 /* Classify a COFF symbol. A couple of targets have globally visible
5005 symbols which are not class C_EXT, and this handles those. It also
5006 recognizes some special PE cases. */
5008 static enum coff_symbol_classification
5009 coff_classify_symbol (bfd
*abfd
,
5010 struct internal_syment
*syment
)
5012 /* FIXME: This partially duplicates the switch in
5013 coff_slurp_symbol_table. */
5014 switch (syment
->n_sclass
)
5020 case C_THUMBEXTFUNC
:
5024 #if ! defined _AIX52 && ! defined AIX_WEAK_SUPPORT
5034 if (syment
->n_scnum
== 0)
5036 if (syment
->n_value
== 0)
5037 return COFF_SYMBOL_UNDEFINED
;
5039 return COFF_SYMBOL_COMMON
;
5042 if (syment
->n_sclass
== C_HIDEXT
)
5043 return COFF_SYMBOL_LOCAL
;
5045 return COFF_SYMBOL_GLOBAL
;
5052 if (syment
->n_sclass
== C_STAT
)
5054 if (syment
->n_scnum
== 0)
5055 /* The Microsoft compiler sometimes generates these if a
5056 small static function is inlined every time it is used.
5057 The function is discarded, but the symbol table entry
5059 return COFF_SYMBOL_LOCAL
;
5061 #ifdef STRICT_PE_FORMAT
5062 /* This is correct for Microsoft generated objects, but it
5063 breaks gas generated objects. */
5064 if (syment
->n_value
== 0)
5066 const asection
*sec
;
5068 char buf
[SYMNMLEN
+ 1];
5070 name
= _bfd_coff_internal_syment_name (abfd
, syment
, buf
);
5071 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
5072 if (sec
!= NULL
&& name
!= NULL
5073 && (strcmp (bfd_section_name (sec
), name
) == 0))
5074 return COFF_SYMBOL_PE_SECTION
;
5078 return COFF_SYMBOL_LOCAL
;
5081 if (syment
->n_sclass
== C_SECTION
)
5083 /* In some cases in a DLL generated by the Microsoft linker, the
5084 n_value field will contain garbage. FIXME: This should
5085 probably be handled by the swapping function instead. */
5086 syment
->n_value
= 0;
5087 if (syment
->n_scnum
== 0)
5088 return COFF_SYMBOL_UNDEFINED
;
5089 return COFF_SYMBOL_PE_SECTION
;
5091 #endif /* COFF_WITH_PE */
5093 /* If it is not a global symbol, we presume it is a local symbol. */
5094 if (syment
->n_scnum
== 0)
5096 char buf
[SYMNMLEN
+ 1];
5099 /* xgettext:c-format */
5100 (_("warning: %pB: local symbol `%s' has no section"),
5101 abfd
, _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
5104 return COFF_SYMBOL_LOCAL
;
5111 Coff relocations are easily transformed into the internal BFD form
5114 Reading a coff relocation table is done in the following stages:
5116 o Read the entire coff relocation table into memory.
5118 o Process each relocation in turn; first swap it from the
5119 external to the internal form.
5121 o Turn the symbol referenced in the relocation's symbol index
5122 into a pointer into the canonical symbol table.
5123 This table is the same as the one returned by a call to
5124 @code{bfd_canonicalize_symtab}. The back end will call that
5125 routine and save the result if a canonicalization hasn't been done.
5127 o The reloc index is turned into a pointer to a howto
5128 structure, in a back end specific way. For instance, the 386
5129 uses the @code{r_type} to directly produce an index
5130 into a howto table vector.
5132 o Note that @code{arelent.addend} for COFF is often not what
5133 most people understand as a relocation addend, but rather an
5134 adjustment to the relocation addend stored in section contents
5135 of relocatable object files. The value found in section
5136 contents may also be confusing, depending on both symbol value
5137 and addend somewhat similar to the field value for a
5138 final-linked object. See @code{CALC_ADDEND}.
5142 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
5144 coff_symbol_type *coffsym = NULL; \
5146 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
5147 coffsym = (obj_symbols (abfd) \
5148 + (cache_ptr->sym_ptr_ptr - symbols)); \
5150 coffsym = coff_symbol_from (ptr); \
5151 if (coffsym != NULL \
5152 && coffsym->native->is_sym \
5153 && coffsym->native->u.syment.n_scnum == 0) \
5154 cache_ptr->addend = 0; \
5155 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
5156 && ptr->section != NULL) \
5157 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
5159 cache_ptr->addend = 0; \
5164 coff_slurp_reloc_table (bfd
* abfd
, sec_ptr asect
, asymbol
** symbols
)
5166 bfd_byte
*native_relocs
;
5167 arelent
*reloc_cache
;
5172 if (asect
->relocation
)
5174 if (asect
->reloc_count
== 0)
5176 if (asect
->flags
& SEC_CONSTRUCTOR
)
5178 if (!coff_slurp_symbol_table (abfd
))
5181 native_relocs
= (bfd_byte
*) buy_and_read (abfd
, asect
->rel_filepos
,
5183 bfd_coff_relsz (abfd
));
5184 if (native_relocs
== NULL
)
5187 if (_bfd_mul_overflow (asect
->reloc_count
, sizeof (arelent
), &amt
))
5189 bfd_set_error (bfd_error_file_too_big
);
5192 reloc_cache
= (arelent
*) bfd_alloc (abfd
, amt
);
5193 if (reloc_cache
== NULL
)
5195 free (native_relocs
);
5199 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
5201 struct internal_reloc dst
;
5203 #ifndef RELOC_PROCESSING
5207 cache_ptr
= reloc_cache
+ idx
;
5208 src
= native_relocs
+ idx
* (size_t) bfd_coff_relsz (abfd
);
5211 bfd_coff_swap_reloc_in (abfd
, src
, &dst
);
5213 #ifdef RELOC_PROCESSING
5214 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
5216 cache_ptr
->address
= dst
.r_vaddr
;
5218 if (dst
.r_symndx
!= -1 && symbols
!= NULL
)
5220 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
5223 /* xgettext:c-format */
5224 (_("%pB: warning: illegal symbol index %ld in relocs"),
5225 abfd
, dst
.r_symndx
);
5226 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5231 cache_ptr
->sym_ptr_ptr
= (symbols
5232 + obj_convert (abfd
)[dst
.r_symndx
]);
5233 ptr
= *(cache_ptr
->sym_ptr_ptr
);
5238 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5242 /* The symbols definitions that we have read in have been
5243 relocated as if their sections started at 0. But the offsets
5244 refering to the symbols in the raw data have not been
5245 modified, so we have to have a negative addend to compensate.
5247 Note that symbols which used to be common must be left alone. */
5249 /* Calculate any reloc addend by looking at the symbol. */
5250 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
5253 cache_ptr
->address
-= asect
->vma
;
5254 /* !! cache_ptr->section = NULL;*/
5256 /* Fill in the cache_ptr->howto field from dst.r_type. */
5257 RTYPE2HOWTO (cache_ptr
, &dst
);
5258 #endif /* RELOC_PROCESSING */
5260 if (cache_ptr
->howto
== NULL
)
5263 /* xgettext:c-format */
5264 (_("%pB: illegal relocation type %d at address %#" PRIx64
),
5265 abfd
, dst
.r_type
, (uint64_t) dst
.r_vaddr
);
5266 bfd_set_error (bfd_error_bad_value
);
5267 free (native_relocs
);
5272 free (native_relocs
);
5273 asect
->relocation
= reloc_cache
;
5277 #ifndef coff_rtype_to_howto
5280 /* Get the howto structure for a reloc. This is only used if the file
5281 including this one defines coff_relocate_section to be
5282 _bfd_coff_generic_relocate_section, so it is OK if it does not
5283 always work. It is the responsibility of the including file to
5284 make sure it is reasonable if it is needed. */
5286 static reloc_howto_type
*
5287 coff_rtype_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
5288 asection
*sec ATTRIBUTE_UNUSED
,
5289 struct internal_reloc
*rel ATTRIBUTE_UNUSED
,
5290 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
,
5291 struct internal_syment
*sym ATTRIBUTE_UNUSED
,
5292 bfd_vma
*addendp ATTRIBUTE_UNUSED
)
5296 genrel
.howto
= NULL
;
5297 RTYPE2HOWTO (&genrel
, rel
);
5298 return genrel
.howto
;
5301 #else /* ! defined (RTYPE2HOWTO) */
5303 #define coff_rtype_to_howto NULL
5305 #endif /* ! defined (RTYPE2HOWTO) */
5306 #endif /* ! defined (coff_rtype_to_howto) */
5308 /* This is stupid. This function should be a boolean predicate. */
5311 coff_canonicalize_reloc (bfd
* abfd
,
5316 arelent
*tblptr
= section
->relocation
;
5317 unsigned int count
= 0;
5319 if (section
->flags
& SEC_CONSTRUCTOR
)
5321 /* This section has relocs made up by us, they are not in the
5322 file, so take them out of their chain and place them into
5323 the data area provided. */
5324 arelent_chain
*chain
= section
->constructor_chain
;
5326 for (count
= 0; count
< section
->reloc_count
; count
++)
5328 *relptr
++ = &chain
->relent
;
5329 chain
= chain
->next
;
5334 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
5337 tblptr
= section
->relocation
;
5339 for (; count
++ < section
->reloc_count
;)
5340 *relptr
++ = tblptr
++;
5343 return section
->reloc_count
;
5346 #ifndef coff_set_reloc
5347 #define coff_set_reloc _bfd_generic_set_reloc
5350 #ifndef coff_reloc16_estimate
5351 #define coff_reloc16_estimate dummy_reloc16_estimate
5354 dummy_reloc16_estimate (bfd
*abfd ATTRIBUTE_UNUSED
,
5355 asection
*input_section ATTRIBUTE_UNUSED
,
5356 arelent
*reloc ATTRIBUTE_UNUSED
,
5357 unsigned int shrink ATTRIBUTE_UNUSED
,
5358 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
)
5366 #ifndef coff_reloc16_extra_cases
5368 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5371 dummy_reloc16_extra_cases (bfd
*abfd ATTRIBUTE_UNUSED
,
5372 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
5373 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
,
5374 arelent
*reloc ATTRIBUTE_UNUSED
,
5375 bfd_byte
*data ATTRIBUTE_UNUSED
,
5376 size_t *src_ptr ATTRIBUTE_UNUSED
,
5377 size_t *dst_ptr ATTRIBUTE_UNUSED
)
5383 /* If coff_relocate_section is defined, we can use the optimized COFF
5384 backend linker. Otherwise we must continue to use the old linker. */
5386 #ifdef coff_relocate_section
5388 #ifndef coff_bfd_link_hash_table_create
5389 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5391 #ifndef coff_bfd_link_add_symbols
5392 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5394 #ifndef coff_bfd_final_link
5395 #define coff_bfd_final_link _bfd_coff_final_link
5398 #else /* ! defined (coff_relocate_section) */
5400 #define coff_relocate_section NULL
5401 #ifndef coff_bfd_link_hash_table_create
5402 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5404 #ifndef coff_bfd_link_add_symbols
5405 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5407 #define coff_bfd_final_link _bfd_generic_final_link
5409 #endif /* ! defined (coff_relocate_section) */
5411 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5412 #define coff_bfd_copy_link_hash_symbol_type \
5413 _bfd_generic_copy_link_hash_symbol_type
5414 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5416 #define coff_bfd_link_check_relocs _bfd_generic_link_check_relocs
5418 #ifndef coff_start_final_link
5419 #define coff_start_final_link NULL
5422 #ifndef coff_adjust_symndx
5423 #define coff_adjust_symndx NULL
5426 #ifndef coff_link_add_one_symbol
5427 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5430 #ifndef coff_link_output_has_begun
5433 coff_link_output_has_begun (bfd
* abfd
,
5434 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
)
5436 return abfd
->output_has_begun
;
5440 #ifndef coff_final_link_postscript
5443 coff_final_link_postscript (bfd
* abfd ATTRIBUTE_UNUSED
,
5444 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
)
5450 #ifndef coff_SWAP_aux_in
5451 #define coff_SWAP_aux_in coff_swap_aux_in
5453 #ifndef coff_SWAP_sym_in
5454 #define coff_SWAP_sym_in coff_swap_sym_in
5456 #ifndef coff_SWAP_lineno_in
5457 #define coff_SWAP_lineno_in coff_swap_lineno_in
5459 #ifndef coff_SWAP_aux_out
5460 #define coff_SWAP_aux_out coff_swap_aux_out
5462 #ifndef coff_SWAP_sym_out
5463 #define coff_SWAP_sym_out coff_swap_sym_out
5465 #ifndef coff_SWAP_lineno_out
5466 #define coff_SWAP_lineno_out coff_swap_lineno_out
5468 #ifndef coff_SWAP_reloc_out
5469 #define coff_SWAP_reloc_out coff_swap_reloc_out
5471 #ifndef coff_SWAP_filehdr_out
5472 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5474 #ifndef coff_SWAP_aouthdr_out
5475 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5477 #ifndef coff_SWAP_scnhdr_out
5478 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5480 #ifndef coff_SWAP_reloc_in
5481 #define coff_SWAP_reloc_in coff_swap_reloc_in
5483 #ifndef coff_SWAP_filehdr_in
5484 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5486 #ifndef coff_SWAP_aouthdr_in
5487 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5489 #ifndef coff_SWAP_scnhdr_in
5490 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5493 #define COFF_SWAP_TABLE (void *) &bfd_coff_std_swap_table
5495 static const bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED
=
5497 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5498 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5499 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5500 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5501 coff_SWAP_scnhdr_out
,
5502 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5503 #ifdef COFF_LONG_FILENAMES
5508 COFF_DEFAULT_LONG_SECTION_NAMES
,
5509 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5510 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5515 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5521 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5522 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5523 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5524 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5525 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5526 coff_classify_symbol
, coff_compute_section_file_positions
,
5527 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5528 coff_adjust_symndx
, coff_link_add_one_symbol
,
5529 coff_link_output_has_begun
, coff_final_link_postscript
,
5534 /* COFF0 differs in file/section header size and relocation entry size. */
5536 static const bfd_coff_backend_data ticoff0_swap_table
=
5538 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5539 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5540 coff_SWAP_lineno_out
, coff_swap_reloc_v0_out
,
5541 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5542 coff_SWAP_scnhdr_out
,
5543 FILHSZ_V0
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ_V0
, LINESZ
, FILNMLEN
,
5544 #ifdef COFF_LONG_FILENAMES
5549 COFF_DEFAULT_LONG_SECTION_NAMES
,
5550 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5551 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5556 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5562 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5563 coff_swap_reloc_v0_in
, ticoff0_bad_format_hook
, coff_set_arch_mach_hook
,
5564 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5565 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5566 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5567 coff_classify_symbol
, coff_compute_section_file_positions
,
5568 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5569 coff_adjust_symndx
, coff_link_add_one_symbol
,
5570 coff_link_output_has_begun
, coff_final_link_postscript
,
5576 /* COFF1 differs in section header size. */
5578 static const bfd_coff_backend_data ticoff1_swap_table
=
5580 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5581 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5582 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5583 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5584 coff_SWAP_scnhdr_out
,
5585 FILHSZ
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5586 #ifdef COFF_LONG_FILENAMES
5591 COFF_DEFAULT_LONG_SECTION_NAMES
,
5592 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5593 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5598 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5604 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5605 coff_SWAP_reloc_in
, ticoff1_bad_format_hook
, coff_set_arch_mach_hook
,
5606 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5607 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5608 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5609 coff_classify_symbol
, coff_compute_section_file_positions
,
5610 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5611 coff_adjust_symndx
, coff_link_add_one_symbol
,
5612 coff_link_output_has_begun
, coff_final_link_postscript
,
5613 bfd_pe_print_pdata
/* huh */
5617 #ifdef COFF_WITH_PE_BIGOBJ
5618 /* The UID for bigobj files. */
5620 static const char header_bigobj_classid
[16] =
5622 0xC7, 0xA1, 0xBA, 0xD1,
5626 0xFA, 0xF6, 0x6A, 0xA4, 0xDC, 0xB8
5629 /* Swap routines. */
5632 coff_bigobj_swap_filehdr_in (bfd
* abfd
, void * src
, void * dst
)
5634 struct external_ANON_OBJECT_HEADER_BIGOBJ
*filehdr_src
=
5635 (struct external_ANON_OBJECT_HEADER_BIGOBJ
*) src
;
5636 struct internal_filehdr
*filehdr_dst
= (struct internal_filehdr
*) dst
;
5638 filehdr_dst
->f_magic
= H_GET_16 (abfd
, filehdr_src
->Machine
);
5639 filehdr_dst
->f_nscns
= H_GET_32 (abfd
, filehdr_src
->NumberOfSections
);
5640 filehdr_dst
->f_timdat
= H_GET_32 (abfd
, filehdr_src
->TimeDateStamp
);
5641 filehdr_dst
->f_symptr
=
5642 GET_FILEHDR_SYMPTR (abfd
, filehdr_src
->PointerToSymbolTable
);
5643 filehdr_dst
->f_nsyms
= H_GET_32 (abfd
, filehdr_src
->NumberOfSymbols
);
5644 filehdr_dst
->f_opthdr
= 0;
5645 filehdr_dst
->f_flags
= 0;
5647 /* Check other magic numbers. */
5648 if (H_GET_16 (abfd
, filehdr_src
->Sig1
) != IMAGE_FILE_MACHINE_UNKNOWN
5649 || H_GET_16 (abfd
, filehdr_src
->Sig2
) != 0xffff
5650 || H_GET_16 (abfd
, filehdr_src
->Version
) != 2
5651 || memcmp (filehdr_src
->ClassID
, header_bigobj_classid
, 16) != 0)
5652 filehdr_dst
->f_opthdr
= 0xffff;
5654 /* Note that CLR metadata are ignored. */
5658 coff_bigobj_swap_filehdr_out (bfd
*abfd
, void * in
, void * out
)
5660 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
5661 struct external_ANON_OBJECT_HEADER_BIGOBJ
*filehdr_out
=
5662 (struct external_ANON_OBJECT_HEADER_BIGOBJ
*) out
;
5664 memset (filehdr_out
, 0, sizeof (*filehdr_out
));
5666 H_PUT_16 (abfd
, IMAGE_FILE_MACHINE_UNKNOWN
, filehdr_out
->Sig1
);
5667 H_PUT_16 (abfd
, 0xffff, filehdr_out
->Sig2
);
5668 H_PUT_16 (abfd
, 2, filehdr_out
->Version
);
5669 memcpy (filehdr_out
->ClassID
, header_bigobj_classid
, 16);
5670 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->Machine
);
5671 H_PUT_32 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->NumberOfSections
);
5672 H_PUT_32 (abfd
, filehdr_in
->f_timdat
, filehdr_out
->TimeDateStamp
);
5673 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
,
5674 filehdr_out
->PointerToSymbolTable
);
5675 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->NumberOfSymbols
);
5677 return bfd_coff_filhsz (abfd
);
5681 coff_bigobj_swap_sym_in (bfd
* abfd
, void * ext1
, void * in1
)
5683 SYMENT_BIGOBJ
*ext
= (SYMENT_BIGOBJ
*) ext1
;
5684 struct internal_syment
*in
= (struct internal_syment
*) in1
;
5686 if (ext
->e
.e_name
[0] == 0)
5688 in
->_n
._n_n
._n_zeroes
= 0;
5689 in
->_n
._n_n
._n_offset
= H_GET_32 (abfd
, ext
->e
.e
.e_offset
);
5693 #if SYMNMLEN != E_SYMNMLEN
5694 #error we need to cope with truncating or extending SYMNMLEN
5696 memcpy (in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
5700 in
->n_value
= H_GET_32 (abfd
, ext
->e_value
);
5701 BFD_ASSERT (sizeof (in
->n_scnum
) >= 4);
5702 in
->n_scnum
= H_GET_32 (abfd
, ext
->e_scnum
);
5703 in
->n_type
= H_GET_16 (abfd
, ext
->e_type
);
5704 in
->n_sclass
= H_GET_8 (abfd
, ext
->e_sclass
);
5705 in
->n_numaux
= H_GET_8 (abfd
, ext
->e_numaux
);
5709 coff_bigobj_swap_sym_out (bfd
* abfd
, void * inp
, void * extp
)
5711 struct internal_syment
*in
= (struct internal_syment
*) inp
;
5712 SYMENT_BIGOBJ
*ext
= (SYMENT_BIGOBJ
*) extp
;
5714 if (in
->_n
._n_name
[0] == 0)
5716 H_PUT_32 (abfd
, 0, ext
->e
.e
.e_zeroes
);
5717 H_PUT_32 (abfd
, in
->_n
._n_n
._n_offset
, ext
->e
.e
.e_offset
);
5721 #if SYMNMLEN != E_SYMNMLEN
5722 #error we need to cope with truncating or extending SYMNMLEN
5724 memcpy (ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
5728 H_PUT_32 (abfd
, in
->n_value
, ext
->e_value
);
5729 H_PUT_32 (abfd
, in
->n_scnum
, ext
->e_scnum
);
5731 H_PUT_16 (abfd
, in
->n_type
, ext
->e_type
);
5732 H_PUT_8 (abfd
, in
->n_sclass
, ext
->e_sclass
);
5733 H_PUT_8 (abfd
, in
->n_numaux
, ext
->e_numaux
);
5735 return SYMESZ_BIGOBJ
;
5739 coff_bigobj_swap_aux_in (bfd
*abfd
,
5747 AUXENT_BIGOBJ
*ext
= (AUXENT_BIGOBJ
*) ext1
;
5748 union internal_auxent
*in
= (union internal_auxent
*) in1
;
5750 /* Make sure that all fields in the aux structure are
5752 memset (in
, 0, sizeof * in
);
5759 memcpy (in
->x_file
.x_n
.x_fname
, ext
->File
.Name
,
5760 numaux
* sizeof (AUXENT_BIGOBJ
));
5763 memcpy (in
->x_file
.x_n
.x_fname
, ext
->File
.Name
, sizeof (ext
->File
.Name
));
5771 in
->x_scn
.x_scnlen
= H_GET_32 (abfd
, ext
->Section
.Length
);
5772 in
->x_scn
.x_nreloc
=
5773 H_GET_16 (abfd
, ext
->Section
.NumberOfRelocations
);
5774 in
->x_scn
.x_nlinno
=
5775 H_GET_16 (abfd
, ext
->Section
.NumberOfLinenumbers
);
5776 in
->x_scn
.x_checksum
= H_GET_32 (abfd
, ext
->Section
.Checksum
);
5777 in
->x_scn
.x_associated
= H_GET_16 (abfd
, ext
->Section
.Number
)
5778 | (H_GET_16 (abfd
, ext
->Section
.HighNumber
) << 16);
5779 in
->x_scn
.x_comdat
= H_GET_8 (abfd
, ext
->Section
.Selection
);
5785 in
->x_sym
.x_tagndx
.u32
= H_GET_32 (abfd
, ext
->Sym
.WeakDefaultSymIndex
);
5786 /* Characteristics is ignored. */
5792 coff_bigobj_swap_aux_out (bfd
* abfd
,
5796 int indx ATTRIBUTE_UNUSED
,
5797 int numaux ATTRIBUTE_UNUSED
,
5800 union internal_auxent
* in
= (union internal_auxent
*) inp
;
5801 AUXENT_BIGOBJ
*ext
= (AUXENT_BIGOBJ
*) extp
;
5803 memset (ext
, 0, AUXESZ
);
5808 memcpy (ext
->File
.Name
, in
->x_file
.x_n
.x_fname
, sizeof (ext
->File
.Name
));
5817 H_PUT_32 (abfd
, in
->x_scn
.x_scnlen
, ext
->Section
.Length
);
5818 H_PUT_16 (abfd
, in
->x_scn
.x_nreloc
,
5819 ext
->Section
.NumberOfRelocations
);
5820 H_PUT_16 (abfd
, in
->x_scn
.x_nlinno
,
5821 ext
->Section
.NumberOfLinenumbers
);
5822 H_PUT_32 (abfd
, in
->x_scn
.x_checksum
, ext
->Section
.Checksum
);
5823 H_PUT_16 (abfd
, in
->x_scn
.x_associated
& 0xffff,
5824 ext
->Section
.Number
);
5825 H_PUT_16 (abfd
, (in
->x_scn
.x_associated
>> 16),
5826 ext
->Section
.HighNumber
);
5827 H_PUT_8 (abfd
, in
->x_scn
.x_comdat
, ext
->Section
.Selection
);
5833 H_PUT_32 (abfd
, in
->x_sym
.x_tagndx
.u32
, ext
->Sym
.WeakDefaultSymIndex
);
5834 H_PUT_32 (abfd
, 1, ext
->Sym
.WeakSearchType
);
5839 static const bfd_coff_backend_data bigobj_swap_table
=
5841 coff_bigobj_swap_aux_in
, coff_bigobj_swap_sym_in
, coff_SWAP_lineno_in
,
5842 coff_bigobj_swap_aux_out
, coff_bigobj_swap_sym_out
,
5843 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5844 coff_bigobj_swap_filehdr_out
, coff_SWAP_aouthdr_out
,
5845 coff_SWAP_scnhdr_out
,
5846 FILHSZ_BIGOBJ
, AOUTSZ
, SCNHSZ
, SYMESZ_BIGOBJ
, AUXESZ_BIGOBJ
,
5847 RELSZ
, LINESZ
, FILNMLEN_BIGOBJ
,
5849 COFF_DEFAULT_LONG_SECTION_NAMES
,
5850 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5854 coff_bigobj_swap_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5855 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5856 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5857 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5858 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5859 coff_classify_symbol
, coff_compute_section_file_positions
,
5860 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5861 coff_adjust_symndx
, coff_link_add_one_symbol
,
5862 coff_link_output_has_begun
, coff_final_link_postscript
,
5863 bfd_pe_print_pdata
/* huh */
5866 #endif /* COFF_WITH_PE_BIGOBJ */
5868 #ifndef coff_close_and_cleanup
5869 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5872 #ifndef coff_bfd_free_cached_info
5873 #define coff_bfd_free_cached_info _bfd_coff_free_cached_info
5876 #ifndef coff_get_section_contents
5877 #define coff_get_section_contents _bfd_generic_get_section_contents
5880 #ifndef coff_bfd_copy_private_symbol_data
5881 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5884 #ifndef coff_bfd_copy_private_header_data
5885 #define coff_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
5888 #ifndef coff_bfd_copy_private_section_data
5889 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5892 #ifndef coff_bfd_copy_private_bfd_data
5893 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5896 #ifndef coff_bfd_merge_private_bfd_data
5897 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5900 #ifndef coff_bfd_set_private_flags
5901 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5904 #ifndef coff_bfd_print_private_bfd_data
5905 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5908 #ifndef coff_bfd_is_local_label_name
5909 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5912 #ifndef coff_bfd_is_target_special_symbol
5913 #define coff_bfd_is_target_special_symbol _bfd_bool_bfd_asymbol_false
5916 #ifndef coff_read_minisymbols
5917 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5920 #ifndef coff_minisymbol_to_symbol
5921 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5924 /* The reloc lookup routine must be supplied by each individual COFF
5926 #ifndef coff_bfd_reloc_type_lookup
5927 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5929 #ifndef coff_bfd_reloc_name_lookup
5930 #define coff_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5933 #ifndef coff_bfd_get_relocated_section_contents
5934 #define coff_bfd_get_relocated_section_contents \
5935 bfd_generic_get_relocated_section_contents
5938 #ifndef coff_bfd_relax_section
5939 #define coff_bfd_relax_section bfd_generic_relax_section
5942 #ifndef coff_bfd_gc_sections
5943 #define coff_bfd_gc_sections bfd_coff_gc_sections
5946 #ifndef coff_bfd_lookup_section_flags
5947 #define coff_bfd_lookup_section_flags bfd_generic_lookup_section_flags
5950 #ifndef coff_bfd_merge_sections
5951 #define coff_bfd_merge_sections bfd_generic_merge_sections
5954 #ifndef coff_bfd_is_group_section
5955 #define coff_bfd_is_group_section bfd_generic_is_group_section
5958 #ifndef coff_bfd_group_name
5959 #define coff_bfd_group_name bfd_coff_group_name
5962 #ifndef coff_bfd_discard_group
5963 #define coff_bfd_discard_group bfd_generic_discard_group
5966 #ifndef coff_section_already_linked
5967 #define coff_section_already_linked \
5968 _bfd_coff_section_already_linked
5971 #ifndef coff_bfd_define_common_symbol
5972 #define coff_bfd_define_common_symbol bfd_generic_define_common_symbol
5975 #ifndef coff_bfd_link_hide_symbol
5976 #define coff_bfd_link_hide_symbol _bfd_generic_link_hide_symbol
5979 #ifndef coff_bfd_define_start_stop
5980 #define coff_bfd_define_start_stop bfd_generic_define_start_stop
5983 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5984 const bfd_target VAR = \
5987 bfd_target_coff_flavour, \
5988 BFD_ENDIAN_BIG, /* Data byte order is big. */ \
5989 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5990 /* object flags */ \
5991 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5992 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5993 /* section flags */ \
5994 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5995 UNDER, /* Leading symbol underscore. */ \
5996 '/', /* AR_pad_char. */ \
5997 15, /* AR_max_namelen. */ \
5998 0, /* match priority. */ \
5999 TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols. */ \
6001 /* Data conversion functions. */ \
6002 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
6003 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
6004 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
6006 /* Header conversion functions. */ \
6007 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
6008 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
6009 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
6011 { /* bfd_check_format. */ \
6012 _bfd_dummy_target, \
6014 bfd_generic_archive_p, \
6017 { /* bfd_set_format. */ \
6018 _bfd_bool_bfd_false_error, \
6020 _bfd_generic_mkarchive, \
6021 _bfd_bool_bfd_false_error \
6023 { /* bfd_write_contents. */ \
6024 _bfd_bool_bfd_false_error, \
6025 coff_write_object_contents, \
6026 _bfd_write_archive_contents, \
6027 _bfd_bool_bfd_false_error \
6030 BFD_JUMP_TABLE_GENERIC (coff), \
6031 BFD_JUMP_TABLE_COPY (coff), \
6032 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
6033 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
6034 BFD_JUMP_TABLE_SYMBOLS (coff), \
6035 BFD_JUMP_TABLE_RELOCS (coff), \
6036 BFD_JUMP_TABLE_WRITE (coff), \
6037 BFD_JUMP_TABLE_LINK (coff), \
6038 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
6045 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
6046 const bfd_target VAR = \
6049 bfd_target_coff_flavour, \
6050 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
6051 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
6052 /* object flags */ \
6053 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
6054 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
6055 /* section flags */ \
6056 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
6057 UNDER, /* Leading symbol underscore. */ \
6058 '/', /* AR_pad_char. */ \
6059 15, /* AR_max_namelen. */ \
6060 0, /* match priority. */ \
6061 TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols. */ \
6063 /* Data conversion functions. */ \
6064 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
6065 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
6066 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
6068 /* Header conversion functions. */ \
6069 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
6070 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
6071 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
6073 { /* bfd_check_format. */ \
6074 _bfd_dummy_target, \
6076 bfd_generic_archive_p, \
6079 { /* bfd_set_format. */ \
6080 _bfd_bool_bfd_false_error, \
6082 _bfd_generic_mkarchive, \
6083 _bfd_bool_bfd_false_error \
6085 { /* bfd_write_contents. */ \
6086 _bfd_bool_bfd_false_error, \
6087 coff_write_object_contents, \
6088 _bfd_write_archive_contents, \
6089 _bfd_bool_bfd_false_error \
6092 BFD_JUMP_TABLE_GENERIC (coff), \
6093 BFD_JUMP_TABLE_COPY (coff), \
6094 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
6095 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
6096 BFD_JUMP_TABLE_SYMBOLS (coff), \
6097 BFD_JUMP_TABLE_RELOCS (coff), \
6098 BFD_JUMP_TABLE_WRITE (coff), \
6099 BFD_JUMP_TABLE_LINK (coff), \
6100 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
6107 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
6108 const bfd_target VAR = \
6111 bfd_target_coff_flavour, \
6112 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
6113 BFD_ENDIAN_LITTLE, /* Header byte order is little. */ \
6114 /* object flags */ \
6115 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
6116 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
6117 /* section flags */ \
6118 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
6119 UNDER, /* Leading symbol underscore. */ \
6120 '/', /* AR_pad_char. */ \
6121 15, /* AR_max_namelen. */ \
6122 0, /* match priority. */ \
6123 TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols. */ \
6125 /* Data conversion functions. */ \
6126 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
6127 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
6128 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
6129 /* Header conversion functions. */ \
6130 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
6131 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
6132 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
6134 { /* bfd_check_format. */ \
6135 _bfd_dummy_target, \
6137 bfd_generic_archive_p, \
6140 { /* bfd_set_format. */ \
6141 _bfd_bool_bfd_false_error, \
6143 _bfd_generic_mkarchive, \
6144 _bfd_bool_bfd_false_error \
6146 { /* bfd_write_contents. */ \
6147 _bfd_bool_bfd_false_error, \
6148 coff_write_object_contents, \
6149 _bfd_write_archive_contents, \
6150 _bfd_bool_bfd_false_error \
6153 BFD_JUMP_TABLE_GENERIC (coff), \
6154 BFD_JUMP_TABLE_COPY (coff), \
6155 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
6156 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
6157 BFD_JUMP_TABLE_SYMBOLS (coff), \
6158 BFD_JUMP_TABLE_RELOCS (coff), \
6159 BFD_JUMP_TABLE_WRITE (coff), \
6160 BFD_JUMP_TABLE_LINK (coff), \
6161 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \