1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright (C) 1990-2021 Free Software Foundation, Inc.
3 Written by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
22 /* Most of this hacked by Steve Chamberlain,
28 BFD supports a number of different flavours of coff format.
29 The major differences between formats are the sizes and
30 alignments of fields in structures on disk, and the occasional
33 Coff in all its varieties is implemented with a few common
34 files and a number of implementation specific files. For
35 example, the i386 coff format is implemented in the file
36 @file{coff-i386.c}. This file @code{#include}s
37 @file{coff/i386.h} which defines the external structure of the
38 coff format for the i386, and @file{coff/internal.h} which
39 defines the internal structure. @file{coff-i386.c} also
40 defines the relocations used by the i386 coff format
44 Porting to a new version of coff
46 The recommended method is to select from the existing
47 implementations the version of coff which is most like the one
48 you want to use. For example, we'll say that i386 coff is
49 the one you select, and that your coff flavour is called foo.
50 Copy @file{i386coff.c} to @file{foocoff.c}, copy
51 @file{../include/coff/i386.h} to @file{../include/coff/foo.h},
52 and add the lines to @file{targets.c} and @file{Makefile.in}
53 so that your new back end is used. Alter the shapes of the
54 structures in @file{../include/coff/foo.h} so that they match
55 what you need. You will probably also have to add
56 @code{#ifdef}s to the code in @file{coff/internal.h} and
57 @file{coffcode.h} if your version of coff is too wild.
59 You can verify that your new BFD backend works quite simply by
60 building @file{objdump} from the @file{binutils} directory,
61 and making sure that its version of what's going on and your
62 host system's idea (assuming it has the pretty standard coff
63 dump utility, usually called @code{att-dump} or just
64 @code{dump}) are the same. Then clean up your code, and send
65 what you've done to Cygnus. Then your stuff will be in the
66 next release, and you won't have to keep integrating it.
69 How the coff backend works
74 The Coff backend is split into generic routines that are
75 applicable to any Coff target and routines that are specific
76 to a particular target. The target-specific routines are
77 further split into ones which are basically the same for all
78 Coff targets except that they use the external symbol format
79 or use different values for certain constants.
81 The generic routines are in @file{coffgen.c}. These routines
82 work for any Coff target. They use some hooks into the target
83 specific code; the hooks are in a @code{bfd_coff_backend_data}
84 structure, one of which exists for each target.
86 The essentially similar target-specific routines are in
87 @file{coffcode.h}. This header file includes executable C code.
88 The various Coff targets first include the appropriate Coff
89 header file, make any special defines that are needed, and
90 then include @file{coffcode.h}.
92 Some of the Coff targets then also have additional routines in
93 the target source file itself.
96 Coff long section names
98 In the standard Coff object format, section names are limited to
99 the eight bytes available in the @code{s_name} field of the
100 @code{SCNHDR} section header structure. The format requires the
101 field to be NUL-padded, but not necessarily NUL-terminated, so
102 the longest section names permitted are a full eight characters.
104 The Microsoft PE variants of the Coff object file format add
105 an extension to support the use of long section names. This
106 extension is defined in section 4 of the Microsoft PE/COFF
107 specification (rev 8.1). If a section name is too long to fit
108 into the section header's @code{s_name} field, it is instead
109 placed into the string table, and the @code{s_name} field is
110 filled with a slash ("/") followed by the ASCII decimal
111 representation of the offset of the full name relative to the
114 Note that this implies that the extension can only be used in object
115 files, as executables do not contain a string table. The standard
116 specifies that long section names from objects emitted into executable
117 images are to be truncated.
119 However, as a GNU extension, BFD can generate executable images
120 that contain a string table and long section names. This
121 would appear to be technically valid, as the standard only says
122 that Coff debugging information is deprecated, not forbidden,
123 and in practice it works, although some tools that parse PE files
124 expecting the MS standard format may become confused; @file{PEview} is
127 The functionality is supported in BFD by code implemented under
128 the control of the macro @code{COFF_LONG_SECTION_NAMES}. If not
129 defined, the format does not support long section names in any way.
130 If defined, it is used to initialise a flag,
131 @code{_bfd_coff_long_section_names}, and a hook function pointer,
132 @code{_bfd_coff_set_long_section_names}, in the Coff backend data
133 structure. The flag controls the generation of long section names
134 in output BFDs at runtime; if it is false, as it will be by default
135 when generating an executable image, long section names are truncated;
136 if true, the long section names extension is employed. The hook
137 points to a function that allows the value of the flag to be altered
138 at runtime, on formats that support long section names at all; on
139 other formats it points to a stub that returns an error indication.
141 With input BFDs, the flag is set according to whether any long section
142 names are detected while reading the section headers. For a completely
143 new BFD, the flag is set to the default for the target format. This
144 information can be used by a client of the BFD library when deciding
145 what output format to generate, and means that a BFD that is opened
146 for read and subsequently converted to a writeable BFD and modified
147 in-place will retain whatever format it had on input.
149 If @code{COFF_LONG_SECTION_NAMES} is simply defined (blank), or is
150 defined to the value "1", then long section names are enabled by
151 default; if it is defined to the value zero, they are disabled by
152 default (but still accepted in input BFDs). The header @file{coffcode.h}
153 defines a macro, @code{COFF_DEFAULT_LONG_SECTION_NAMES}, which is
154 used in the backends to initialise the backend data structure fields
155 appropriately; see the comments for further detail.
160 Each flavour of coff supported in BFD has its own header file
161 describing the external layout of the structures. There is also
162 an internal description of the coff layout, in
163 @file{coff/internal.h}. A major function of the
164 coff backend is swapping the bytes and twiddling the bits to
165 translate the external form of the structures into the normal
166 internal form. This is all performed in the
167 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
168 elements are different sizes between different versions of
169 coff; it is the duty of the coff version specific include file
170 to override the definitions of various packing routines in
171 @file{coffcode.h}. E.g., the size of line number entry in coff is
172 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
173 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
174 correct one. No doubt, some day someone will find a version of
175 coff which has a varying field size not catered to at the
176 moment. To port BFD, that person will have to add more @code{#defines}.
177 Three of the bit twiddling routines are exported to
178 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
179 and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol
180 table on its own, but uses BFD to fix things up. More of the
181 bit twiddlers are exported for @code{gas};
182 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
183 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
184 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
185 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
186 of all the symbol table and reloc drudgery itself, thereby
187 saving the internal BFD overhead, but uses BFD to swap things
188 on the way out, making cross ports much safer. Doing so also
189 allows BFD (and thus the linker) to use the same header files
190 as @code{gas}, which makes one avenue to disaster disappear.
195 The simple canonical form for symbols used by BFD is not rich
196 enough to keep all the information available in a coff symbol
197 table. The back end gets around this problem by keeping the original
198 symbol table around, "behind the scenes".
200 When a symbol table is requested (through a call to
201 @code{bfd_canonicalize_symtab}), a request gets through to
202 @code{coff_get_normalized_symtab}. This reads the symbol table from
203 the coff file and swaps all the structures inside into the
204 internal form. It also fixes up all the pointers in the table
205 (represented in the file by offsets from the first symbol in
206 the table) into physical pointers to elements in the new
207 internal table. This involves some work since the meanings of
208 fields change depending upon context: a field that is a
209 pointer to another structure in the symbol table at one moment
210 may be the size in bytes of a structure at the next. Another
211 pass is made over the table. All symbols which mark file names
212 (<<C_FILE>> symbols) are modified so that the internal
213 string points to the value in the auxent (the real filename)
214 rather than the normal text associated with the symbol
217 At this time the symbol names are moved around. Coff stores
218 all symbols less than nine characters long physically
219 within the symbol table; longer strings are kept at the end of
220 the file in the string table. This pass moves all strings
221 into memory and replaces them with pointers to the strings.
223 The symbol table is massaged once again, this time to create
224 the canonical table used by the BFD application. Each symbol
225 is inspected in turn, and a decision made (using the
226 @code{sclass} field) about the various flags to set in the
227 @code{asymbol}. @xref{Symbols}. The generated canonical table
228 shares strings with the hidden internal symbol table.
230 Any linenumbers are read from the coff file too, and attached
231 to the symbols which own the functions the linenumbers belong to.
236 Writing a symbol to a coff file which didn't come from a coff
237 file will lose any debugging information. The @code{asymbol}
238 structure remembers the BFD from which the symbol was taken, and on
239 output the back end makes sure that the same destination target as
240 source target is present.
242 When the symbols have come from a coff file then all the
243 debugging information is preserved.
245 Symbol tables are provided for writing to the back end in a
246 vector of pointers to pointers. This allows applications like
247 the linker to accumulate and output large symbol tables
248 without having to do too much byte copying.
250 This function runs through the provided symbol table and
251 patches each symbol marked as a file place holder
252 (@code{C_FILE}) to point to the next file place holder in the
253 list. It also marks each @code{offset} field in the list with
254 the offset from the first symbol of the current symbol.
256 Another function of this procedure is to turn the canonical
257 value form of BFD into the form used by coff. Internally, BFD
258 expects symbol values to be offsets from a section base; so a
259 symbol physically at 0x120, but in a section starting at
260 0x100, would have the value 0x20. Coff expects symbols to
261 contain their final value, so symbols have their values
262 changed at this point to reflect their sum with their owning
263 section. This transformation uses the
264 <<output_section>> field of the @code{asymbol}'s
265 @code{asection} @xref{Sections}.
267 o <<coff_mangle_symbols>>
269 This routine runs though the provided symbol table and uses
270 the offsets generated by the previous pass and the pointers
271 generated when the symbol table was read in to create the
272 structured hierarchy required by coff. It changes each pointer
273 to a symbol into the index into the symbol table of the asymbol.
275 o <<coff_write_symbols>>
277 This routine runs through the symbol table and patches up the
278 symbols from their internal form into the coff way, calls the
279 bit twiddlers, and writes out the table to the file.
288 The hidden information for an <<asymbol>> is described in a
289 <<combined_entry_type>>:
293 .typedef struct coff_ptr_struct
295 . {* Remembers the offset from the first symbol in the file for
296 . this symbol. Generated by coff_renumber_symbols. *}
297 . unsigned int offset;
299 . {* Should the value of this symbol be renumbered. Used for
300 . XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
301 . unsigned int fix_value : 1;
303 . {* Should the tag field of this symbol be renumbered.
304 . Created by coff_pointerize_aux. *}
305 . unsigned int fix_tag : 1;
307 . {* Should the endidx field of this symbol be renumbered.
308 . Created by coff_pointerize_aux. *}
309 . unsigned int fix_end : 1;
311 . {* Should the x_csect.x_scnlen field be renumbered.
312 . Created by coff_pointerize_aux. *}
313 . unsigned int fix_scnlen : 1;
315 . {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
316 . index into the line number entries. Set by coff_slurp_symbol_table. *}
317 . unsigned int fix_line : 1;
319 . {* The container for the symbol structure as read and translated
323 . union internal_auxent auxent;
324 . struct internal_syment syment;
327 . {* Selector for the union above. *}
328 . bfd_boolean is_sym;
329 .} combined_entry_type;
332 .{* Each canonical asymbol really looks like this: *}
334 .typedef struct coff_symbol_struct
336 . {* The actual symbol which the rest of BFD works with *}
339 . {* A pointer to the hidden information for this symbol *}
340 . combined_entry_type *native;
342 . {* A pointer to the linenumber information for this symbol *}
343 . struct lineno_cache_entry *lineno;
345 . {* Have the line numbers been relocated yet ? *}
346 . bfd_boolean done_lineno;
351 #include "libiberty.h"
356 #include "coffswap.h"
359 #define STRING_SIZE_SIZE 4
361 #define DOT_DEBUG ".debug"
362 #define DOT_ZDEBUG ".zdebug"
363 #define GNU_LINKONCE_WI ".gnu.linkonce.wi."
364 #define GNU_LINKONCE_WT ".gnu.linkonce.wt."
365 #define DOT_RELOC ".reloc"
367 #if defined(COFF_WITH_PE) || defined(COFF_GO32_EXE) || defined(COFF_GO32)
368 # define COFF_WITH_EXTENDED_RELOC_COUNTER
371 #if defined (COFF_LONG_SECTION_NAMES)
372 /* Needed to expand the inputs to BLANKOR1TOODD. */
373 #define COFFLONGSECTIONCATHELPER(x,y) x ## y
374 /* If the input macro Y is blank or '1', return an odd number; if it is
375 '0', return an even number. Result undefined in all other cases. */
376 #define BLANKOR1TOODD(y) COFFLONGSECTIONCATHELPER(1,y)
377 /* Defined to numerical 0 or 1 according to whether generation of long
378 section names is disabled or enabled by default. */
379 #define COFF_ENABLE_LONG_SECTION_NAMES (BLANKOR1TOODD(COFF_LONG_SECTION_NAMES) & 1)
380 /* Where long section names are supported, we allow them to be enabled
381 and disabled at runtime, so select an appropriate hook function for
382 _bfd_coff_set_long_section_names. */
383 #define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_allowed
384 #else /* !defined (COFF_LONG_SECTION_NAMES) */
385 /* If long section names are not supported, this stub disallows any
386 attempt to enable them at run-time. */
387 #define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_disallowed
388 #endif /* defined (COFF_LONG_SECTION_NAMES) */
390 /* Define a macro that can be used to initialise both the fields relating
391 to long section names in the backend data struct simultaneously. */
392 #if COFF_ENABLE_LONG_SECTION_NAMES
393 #define COFF_DEFAULT_LONG_SECTION_NAMES (TRUE), COFF_LONG_SECTION_NAMES_SETTER
394 #else /* !COFF_ENABLE_LONG_SECTION_NAMES */
395 #define COFF_DEFAULT_LONG_SECTION_NAMES (FALSE), COFF_LONG_SECTION_NAMES_SETTER
396 #endif /* COFF_ENABLE_LONG_SECTION_NAMES */
398 #if defined (COFF_LONG_SECTION_NAMES)
399 static bfd_boolean bfd_coff_set_long_section_names_allowed
401 #else /* !defined (COFF_LONG_SECTION_NAMES) */
402 static bfd_boolean bfd_coff_set_long_section_names_disallowed
404 #endif /* defined (COFF_LONG_SECTION_NAMES) */
405 static long sec_to_styp_flags
406 (const char *, flagword
);
407 static bfd_boolean styp_to_sec_flags
408 (bfd
*, void *, const char *, asection
*, flagword
*);
409 static bfd_boolean coff_bad_format_hook
411 static void coff_set_custom_section_alignment
412 (bfd
*, asection
*, const struct coff_section_alignment_entry
*,
414 static bfd_boolean coff_new_section_hook
416 static bfd_boolean coff_set_arch_mach_hook
418 static bfd_boolean coff_write_relocs
420 static bfd_boolean coff_set_flags
421 (bfd
*, unsigned int *, unsigned short *);
422 static bfd_boolean coff_set_arch_mach
423 (bfd
*, enum bfd_architecture
, unsigned long) ATTRIBUTE_UNUSED
;
424 static bfd_boolean coff_compute_section_file_positions
426 static bfd_boolean coff_write_object_contents
427 (bfd
*) ATTRIBUTE_UNUSED
;
428 static bfd_boolean coff_set_section_contents
429 (bfd
*, asection
*, const void *, file_ptr
, bfd_size_type
);
430 static bfd_boolean coff_slurp_line_table
432 static bfd_boolean coff_slurp_symbol_table
434 static enum coff_symbol_classification coff_classify_symbol
435 (bfd
*, struct internal_syment
*);
436 static bfd_boolean coff_slurp_reloc_table
437 (bfd
*, asection
*, asymbol
**);
438 static long coff_canonicalize_reloc
439 (bfd
*, asection
*, arelent
**, asymbol
**);
440 #ifndef coff_mkobject_hook
441 static void * coff_mkobject_hook
442 (bfd
*, void *, void *);
445 static flagword handle_COMDAT
446 (bfd
*, flagword
, void *, const char *, asection
*);
449 static bfd_boolean ticoff0_bad_format_hook
451 static bfd_boolean ticoff1_bad_format_hook
455 /* void warning(); */
457 #if defined (COFF_LONG_SECTION_NAMES)
459 bfd_coff_set_long_section_names_allowed (bfd
*abfd
, int enable
)
461 coff_backend_info (abfd
)->_bfd_coff_long_section_names
= enable
;
464 #else /* !defined (COFF_LONG_SECTION_NAMES) */
466 bfd_coff_set_long_section_names_disallowed (bfd
*abfd
, int enable
)
472 #endif /* defined (COFF_LONG_SECTION_NAMES) */
474 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
475 the incoming SEC_* flags. The inverse of this function is
476 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
477 should probably mirror the changes in styp_to_sec_flags(). */
481 /* Macros for setting debugging flags. */
484 #define STYP_XCOFF_DEBUG STYP_DEBUG
486 #define STYP_XCOFF_DEBUG STYP_INFO
489 #ifdef COFF_ALIGN_IN_S_FLAGS
490 #define STYP_DEBUG_INFO STYP_DSECT
492 #define STYP_DEBUG_INFO STYP_INFO
496 sec_to_styp_flags (const char *sec_name
, flagword sec_flags
)
500 if (!strcmp (sec_name
, _TEXT
))
502 styp_flags
= STYP_TEXT
;
504 else if (!strcmp (sec_name
, _DATA
))
506 styp_flags
= STYP_DATA
;
508 else if (!strcmp (sec_name
, _BSS
))
510 styp_flags
= STYP_BSS
;
513 else if (!strcmp (sec_name
, _COMMENT
))
515 styp_flags
= STYP_INFO
;
516 #endif /* _COMMENT */
519 else if (!strcmp (sec_name
, _LIB
))
521 styp_flags
= STYP_LIB
;
525 else if (!strcmp (sec_name
, _LIT
))
527 styp_flags
= STYP_LIT
;
530 else if (CONST_STRNEQ (sec_name
, DOT_DEBUG
)
531 || CONST_STRNEQ (sec_name
, DOT_ZDEBUG
))
533 /* Handle the XCOFF debug section and DWARF2 debug sections. */
535 styp_flags
= STYP_XCOFF_DEBUG
;
537 styp_flags
= STYP_DEBUG_INFO
;
539 else if (CONST_STRNEQ (sec_name
, ".stab"))
541 styp_flags
= STYP_DEBUG_INFO
;
543 #ifdef COFF_LONG_SECTION_NAMES
544 else if (CONST_STRNEQ (sec_name
, GNU_LINKONCE_WI
)
545 || CONST_STRNEQ (sec_name
, GNU_LINKONCE_WT
))
547 styp_flags
= STYP_DEBUG_INFO
;
551 else if (!strcmp (sec_name
, _PAD
))
553 styp_flags
= STYP_PAD
;
555 else if (!strcmp (sec_name
, _LOADER
))
557 styp_flags
= STYP_LOADER
;
559 else if (!strcmp (sec_name
, _EXCEPT
))
561 styp_flags
= STYP_EXCEPT
;
563 else if (!strcmp (sec_name
, _TYPCHK
))
565 styp_flags
= STYP_TYPCHK
;
567 else if (sec_flags
& SEC_DEBUGGING
)
571 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
572 if (!strcmp (sec_name
, xcoff_dwsect_names
[i
].name
))
574 styp_flags
= STYP_DWARF
| xcoff_dwsect_names
[i
].flag
;
579 /* Try and figure out what it should be */
580 else if (sec_flags
& SEC_CODE
)
582 styp_flags
= STYP_TEXT
;
584 else if (sec_flags
& SEC_DATA
)
586 styp_flags
= STYP_DATA
;
588 else if (sec_flags
& SEC_READONLY
)
590 #ifdef STYP_LIT /* 29k readonly text/data section */
591 styp_flags
= STYP_LIT
;
593 styp_flags
= STYP_TEXT
;
594 #endif /* STYP_LIT */
596 else if (sec_flags
& SEC_LOAD
)
598 styp_flags
= STYP_TEXT
;
600 else if (sec_flags
& SEC_ALLOC
)
602 styp_flags
= STYP_BSS
;
606 if (sec_flags
& SEC_TIC54X_CLINK
)
607 styp_flags
|= STYP_CLINK
;
611 if (sec_flags
& SEC_TIC54X_BLOCK
)
612 styp_flags
|= STYP_BLOCK
;
616 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
617 styp_flags
|= STYP_NOLOAD
;
623 #else /* COFF_WITH_PE */
625 /* The PE version; see above for the general comments. The non-PE
626 case seems to be more guessing, and breaks PE format; specifically,
627 .rdata is readonly, but it sure ain't text. Really, all this
628 should be set up properly in gas (or whatever assembler is in use),
629 and honor whatever objcopy/strip, etc. sent us as input. */
632 sec_to_styp_flags (const char *sec_name
, flagword sec_flags
)
635 bfd_boolean is_dbg
= FALSE
;
637 if (CONST_STRNEQ (sec_name
, DOT_DEBUG
)
638 || CONST_STRNEQ (sec_name
, DOT_ZDEBUG
)
639 #ifdef COFF_LONG_SECTION_NAMES
640 || CONST_STRNEQ (sec_name
, GNU_LINKONCE_WI
)
641 || CONST_STRNEQ (sec_name
, GNU_LINKONCE_WT
)
643 || CONST_STRNEQ (sec_name
, ".stab"))
646 /* caution: there are at least three groups of symbols that have
647 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
648 SEC_* are the BFD internal flags, used for generic BFD
649 information. STYP_* are the COFF section flags which appear in
650 COFF files. IMAGE_SCN_* are the PE section flags which appear in
651 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
652 but there are more IMAGE_SCN_* flags. */
654 /* FIXME: There is no gas syntax to specify the debug section flag. */
657 sec_flags
&= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
658 | SEC_LINK_DUPLICATES_SAME_CONTENTS
659 | SEC_LINK_DUPLICATES_SAME_SIZE
);
660 sec_flags
|= SEC_DEBUGGING
| SEC_READONLY
;
666 if ((sec_flags
& SEC_CODE
) != 0)
667 styp_flags
|= IMAGE_SCN_CNT_CODE
;
668 if ((sec_flags
& (SEC_DATA
| SEC_DEBUGGING
)) != 0)
669 styp_flags
|= IMAGE_SCN_CNT_INITIALIZED_DATA
;
670 if ((sec_flags
& SEC_ALLOC
) != 0 && (sec_flags
& SEC_LOAD
) == 0)
671 styp_flags
|= IMAGE_SCN_CNT_UNINITIALIZED_DATA
; /* ==STYP_BSS */
673 /* skip constRUCTOR */
675 #ifndef COFF_IMAGE_WITH_PE
676 /* I don't think any of the IMAGE_SCN_LNK_* flags set below should be set
677 when the output is PE. Only object files should have them, for the linker
679 if ((sec_flags
& SEC_IS_COMMON
) != 0)
680 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
682 if ((sec_flags
& SEC_DEBUGGING
) != 0)
683 styp_flags
|= IMAGE_SCN_MEM_DISCARDABLE
;
684 if ((sec_flags
& (SEC_EXCLUDE
| SEC_NEVER_LOAD
)) != 0 && !is_dbg
)
685 #ifdef COFF_IMAGE_WITH_PE
686 styp_flags
|= IMAGE_SCN_MEM_DISCARDABLE
;
688 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
692 #ifndef COFF_IMAGE_WITH_PE
693 if (sec_flags
& SEC_LINK_ONCE
)
694 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
696 & (SEC_LINK_DUPLICATES_DISCARD
| SEC_LINK_DUPLICATES_SAME_CONTENTS
697 | SEC_LINK_DUPLICATES_SAME_SIZE
)) != 0)
698 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
701 /* skip LINKER_CREATED */
703 if ((sec_flags
& SEC_COFF_NOREAD
) == 0)
704 styp_flags
|= IMAGE_SCN_MEM_READ
; /* Invert NOREAD for read. */
705 if ((sec_flags
& SEC_READONLY
) == 0)
706 styp_flags
|= IMAGE_SCN_MEM_WRITE
; /* Invert READONLY for write. */
707 if (sec_flags
& SEC_CODE
)
708 styp_flags
|= IMAGE_SCN_MEM_EXECUTE
; /* CODE->EXECUTE. */
709 if (sec_flags
& SEC_COFF_SHARED
)
710 styp_flags
|= IMAGE_SCN_MEM_SHARED
; /* Shared remains meaningful. */
715 #endif /* COFF_WITH_PE */
717 /* Return a word with SEC_* flags set to represent the incoming STYP_*
718 flags (from scnhdr.s_flags). The inverse of this function is
719 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
720 should probably mirror the changes in sec_to_styp_flags(). */
725 styp_to_sec_flags (bfd
*abfd
,
728 asection
*section ATTRIBUTE_UNUSED
,
731 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
732 long styp_flags
= internal_s
->s_flags
;
733 flagword sec_flags
= 0;
736 if (styp_flags
& STYP_BLOCK
)
737 sec_flags
|= SEC_TIC54X_BLOCK
;
741 if (styp_flags
& STYP_CLINK
)
742 sec_flags
|= SEC_TIC54X_CLINK
;
746 if (styp_flags
& STYP_NOLOAD
)
747 sec_flags
|= SEC_NEVER_LOAD
;
748 #endif /* STYP_NOLOAD */
750 /* For 386 COFF, at least, an unloadable text or data section is
751 actually a shared library section. */
752 if (styp_flags
& STYP_TEXT
)
754 if (sec_flags
& SEC_NEVER_LOAD
)
755 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
757 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
759 else if (styp_flags
& STYP_DATA
)
761 if (sec_flags
& SEC_NEVER_LOAD
)
762 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
764 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
766 else if (styp_flags
& STYP_BSS
)
768 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
769 if (sec_flags
& SEC_NEVER_LOAD
)
770 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
773 sec_flags
|= SEC_ALLOC
;
775 else if (styp_flags
& STYP_INFO
)
777 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
778 defined. coff_compute_section_file_positions uses
779 COFF_PAGE_SIZE to ensure that the low order bits of the
780 section VMA and the file offset match. If we don't know
781 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
782 and demand page loading of the file will fail. */
783 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
784 sec_flags
|= SEC_DEBUGGING
;
787 else if (styp_flags
& STYP_PAD
)
790 else if (styp_flags
& STYP_EXCEPT
)
791 sec_flags
|= SEC_LOAD
;
792 else if (styp_flags
& STYP_LOADER
)
793 sec_flags
|= SEC_LOAD
;
794 else if (styp_flags
& STYP_TYPCHK
)
795 sec_flags
|= SEC_LOAD
;
796 else if (styp_flags
& STYP_DWARF
)
797 sec_flags
|= SEC_DEBUGGING
;
799 else if (strcmp (name
, _TEXT
) == 0)
801 if (sec_flags
& SEC_NEVER_LOAD
)
802 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
804 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
806 else if (strcmp (name
, _DATA
) == 0)
808 if (sec_flags
& SEC_NEVER_LOAD
)
809 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
811 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
813 else if (strcmp (name
, _BSS
) == 0)
815 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
816 if (sec_flags
& SEC_NEVER_LOAD
)
817 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
820 sec_flags
|= SEC_ALLOC
;
822 else if (CONST_STRNEQ (name
, DOT_DEBUG
)
823 || CONST_STRNEQ (name
, DOT_ZDEBUG
)
825 || strcmp (name
, _COMMENT
) == 0
827 #ifdef COFF_LONG_SECTION_NAMES
828 || CONST_STRNEQ (name
, GNU_LINKONCE_WI
)
829 || CONST_STRNEQ (name
, GNU_LINKONCE_WT
)
831 || CONST_STRNEQ (name
, ".stab"))
833 #ifdef COFF_PAGE_SIZE
834 sec_flags
|= SEC_DEBUGGING
;
838 else if (strcmp (name
, _LIB
) == 0)
842 else if (strcmp (name
, _LIT
) == 0)
843 sec_flags
= SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
846 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
848 #ifdef STYP_LIT /* A29k readonly text/data section type. */
849 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
850 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
851 #endif /* STYP_LIT */
853 #ifdef STYP_OTHER_LOAD /* Other loaded sections. */
854 if (styp_flags
& STYP_OTHER_LOAD
)
855 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
856 #endif /* STYP_SDATA */
858 if ((bfd_applicable_section_flags (abfd
) & SEC_SMALL_DATA
) != 0
859 && (CONST_STRNEQ (name
, ".sbss")
860 || CONST_STRNEQ (name
, ".sdata")))
861 sec_flags
|= SEC_SMALL_DATA
;
863 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
864 /* As a GNU extension, if the name begins with .gnu.linkonce, we
865 only link a single copy of the section. This is used to support
866 g++. g++ will emit each template expansion in its own section.
867 The symbols will be defined as weak, so that multiple definitions
868 are permitted. The GNU linker extension is to actually discard
869 all but one of the sections. */
870 if (CONST_STRNEQ (name
, ".gnu.linkonce"))
871 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
874 if (flags_ptr
== NULL
)
877 * flags_ptr
= sec_flags
;
881 #else /* COFF_WITH_PE */
884 handle_COMDAT (bfd
* abfd
,
890 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
891 bfd_byte
*esymstart
, *esym
, *esymend
;
893 char *target_name
= NULL
;
895 sec_flags
|= SEC_LINK_ONCE
;
897 /* Unfortunately, the PE format stores essential information in
898 the symbol table, of all places. We need to extract that
899 information now, so that objdump and the linker will know how
900 to handle the section without worrying about the symbols. We
901 can't call slurp_symtab, because the linker doesn't want the
904 /* COMDAT sections are special. The first symbol is the section
905 symbol, which tells what kind of COMDAT section it is. The
906 second symbol is the "comdat symbol" - the one with the
907 unique name. GNU uses the section symbol for the unique
908 name; MS uses ".text" for every comdat section. Sigh. - DJ */
910 /* This is not mirrored in sec_to_styp_flags(), but there
911 doesn't seem to be a need to, either, and it would at best be
914 if (! _bfd_coff_get_external_symbols (abfd
))
917 esymstart
= esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
918 esymend
= esym
+ obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
920 while (esym
< esymend
)
922 struct internal_syment isym
;
923 char buf
[SYMNMLEN
+ 1];
926 bfd_coff_swap_sym_in (abfd
, esym
, & isym
);
928 BFD_ASSERT (sizeof (internal_s
->s_name
) <= SYMNMLEN
);
930 if (isym
.n_scnum
== section
->target_index
)
932 /* According to the MSVC documentation, the first
933 TWO entries with the section # are both of
934 interest to us. The first one is the "section
935 symbol" (section name). The second is the comdat
936 symbol name. Here, we've found the first
937 qualifying entry; we distinguish it from the
938 second with a state flag.
940 In the case of gas-generated (at least until that
941 is fixed) .o files, it isn't necessarily the
942 second one. It may be some other later symbol.
944 Since gas also doesn't follow MS conventions and
945 emits the section similar to .text$<name>, where
946 <something> is the name we're looking for, we
947 distinguish the two as follows:
949 If the section name is simply a section name (no
950 $) we presume it's MS-generated, and look at
951 precisely the second symbol for the comdat name.
952 If the section name has a $, we assume it's
953 gas-generated, and look for <something> (whatever
954 follows the $) as the comdat symbol. */
956 /* All 3 branches use this. */
957 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
, buf
);
959 /* PR 17512 file: 078-11867-0.004 */
962 _bfd_error_handler (_("%pB: unable to load COMDAT section name"),
971 /* The first time we've seen the symbol. */
972 union internal_auxent aux
;
974 /* If it isn't the stuff we're expecting, die;
975 The MS documentation is vague, but it
976 appears that the second entry serves BOTH
977 as the comdat symbol and the defining
978 symbol record (either C_STAT or C_EXT,
979 possibly with an aux entry with debug
980 information if it's a function.) It
981 appears the only way to find the second one
982 is to count. (On Intel, they appear to be
983 adjacent, but on Alpha, they have been
986 Here, we think we've found the first one,
987 but there's some checking we can do to be
990 if (! ((isym
.n_sclass
== C_STAT
991 || isym
.n_sclass
== C_EXT
)
992 && BTYPE (isym
.n_type
) == T_NULL
993 && isym
.n_value
== 0))
995 /* Malformed input files can trigger this test.
997 _bfd_error_handler (_("%pB: error: unexpected symbol '%s' in COMDAT section"),
1002 /* FIXME LATER: MSVC generates section names
1003 like .text for comdats. Gas generates
1004 names like .text$foo__Fv (in the case of a
1005 function). See comment above for more. */
1007 if (isym
.n_sclass
== C_STAT
&& strcmp (name
, symname
) != 0)
1008 /* xgettext:c-format */
1009 _bfd_error_handler (_("%pB: warning: COMDAT symbol '%s'"
1010 " does not match section name '%s'"),
1011 abfd
, symname
, name
);
1015 /* PR 17512: file: e2cfe54f. */
1016 if (esym
+ bfd_coff_symesz (abfd
) >= esymend
)
1018 /* xgettext:c-format */
1019 _bfd_error_handler (_("%pB: warning: no symbol for"
1020 " section '%s' found"),
1024 /* This is the section symbol. */
1025 bfd_coff_swap_aux_in (abfd
, (esym
+ bfd_coff_symesz (abfd
)),
1026 isym
.n_type
, isym
.n_sclass
,
1027 0, isym
.n_numaux
, & aux
);
1029 target_name
= strchr (name
, '$');
1030 if (target_name
!= NULL
)
1038 /* FIXME: Microsoft uses NODUPLICATES and
1039 ASSOCIATIVE, but gnu uses ANY and
1040 SAME_SIZE. Unfortunately, gnu doesn't do
1041 the comdat symbols right. So, until we can
1042 fix it to do the right thing, we are
1043 temporarily disabling comdats for the MS
1044 types (they're used in DLLs and C++, but we
1045 don't support *their* C++ libraries anyway
1048 /* Cygwin does not follow the MS style, and
1049 uses ANY and SAME_SIZE where NODUPLICATES
1050 and ASSOCIATIVE should be used. For
1051 Interix, we just do the right thing up
1054 switch (aux
.x_scn
.x_comdat
)
1056 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
1057 #ifdef STRICT_PE_FORMAT
1058 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
1060 sec_flags
&= ~SEC_LINK_ONCE
;
1064 case IMAGE_COMDAT_SELECT_ANY
:
1065 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1068 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
1069 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
1072 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
1073 /* Not yet fully implemented ??? */
1074 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
1077 /* debug$S gets this case; other
1080 /* There may be no symbol... we'll search
1081 the whole table... Is this the right
1082 place to play this game? Or should we do
1083 it when reading it in. */
1084 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
1085 #ifdef STRICT_PE_FORMAT
1086 /* FIXME: This is not currently implemented. */
1087 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1089 sec_flags
&= ~SEC_LINK_ONCE
;
1093 default: /* 0 means "no symbol" */
1094 /* debug$F gets this case; other
1096 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1103 /* Gas mode: the first matching on partial name. */
1105 #ifndef TARGET_UNDERSCORE
1106 #define TARGET_UNDERSCORE 0
1108 /* Is this the name we're looking for ? */
1109 if (strcmp (target_name
,
1110 symname
+ (TARGET_UNDERSCORE
? 1 : 0)) != 0)
1112 /* Not the name we're looking for */
1113 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1118 /* MSVC mode: the lexically second symbol (or
1119 drop through from the above). */
1124 /* This must the second symbol with the
1125 section #. It is the actual symbol name.
1126 Intel puts the two adjacent, but Alpha (at
1127 least) spreads them out. */
1129 amt
= sizeof (struct coff_comdat_info
);
1130 coff_section_data (abfd
, section
)->comdat
1131 = (struct coff_comdat_info
*) bfd_alloc (abfd
, amt
);
1132 if (coff_section_data (abfd
, section
)->comdat
== NULL
)
1135 coff_section_data (abfd
, section
)->comdat
->symbol
=
1136 (esym
- esymstart
) / bfd_coff_symesz (abfd
);
1138 amt
= strlen (symname
) + 1;
1139 newname
= (char *) bfd_alloc (abfd
, amt
);
1140 if (newname
== NULL
)
1143 strcpy (newname
, symname
);
1144 coff_section_data (abfd
, section
)->comdat
->name
1152 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1160 /* The PE version; see above for the general comments.
1162 Since to set the SEC_LINK_ONCE and associated flags, we have to
1163 look at the symbol table anyway, we return the symbol table index
1164 of the symbol being used as the COMDAT symbol. This is admittedly
1165 ugly, but there's really nowhere else that we have access to the
1166 required information. FIXME: Is the COMDAT symbol index used for
1167 any purpose other than objdump? */
1170 styp_to_sec_flags (bfd
*abfd
,
1174 flagword
*flags_ptr
)
1176 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
1177 unsigned long styp_flags
= internal_s
->s_flags
;
1179 bfd_boolean result
= TRUE
;
1180 bfd_boolean is_dbg
= FALSE
;
1182 if (CONST_STRNEQ (name
, DOT_DEBUG
)
1183 || CONST_STRNEQ (name
, DOT_ZDEBUG
)
1184 #ifdef COFF_LONG_SECTION_NAMES
1185 || CONST_STRNEQ (name
, GNU_LINKONCE_WI
)
1186 || CONST_STRNEQ (name
, GNU_LINKONCE_WT
)
1187 /* FIXME: These definitions ought to be in a header file. */
1188 #define GNU_DEBUGLINK ".gnu_debuglink"
1189 #define GNU_DEBUGALTLINK ".gnu_debugaltlink"
1190 || CONST_STRNEQ (name
, GNU_DEBUGLINK
)
1191 || CONST_STRNEQ (name
, GNU_DEBUGALTLINK
)
1193 || CONST_STRNEQ (name
, ".stab"))
1195 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
1196 sec_flags
= SEC_READONLY
;
1198 /* If section disallows read, then set the NOREAD flag. */
1199 if ((styp_flags
& IMAGE_SCN_MEM_READ
) == 0)
1200 sec_flags
|= SEC_COFF_NOREAD
;
1202 /* Process each flag bit in styp_flags in turn. */
1205 unsigned long flag
= styp_flags
& - styp_flags
;
1206 char * unhandled
= NULL
;
1208 styp_flags
&= ~ flag
;
1210 /* We infer from the distinct read/write/execute bits the settings
1211 of some of the bfd flags; the actual values, should we need them,
1212 are also in pei_section_data (abfd, section)->pe_flags. */
1217 unhandled
= "STYP_DSECT";
1220 unhandled
= "STYP_GROUP";
1223 unhandled
= "STYP_COPY";
1226 unhandled
= "STYP_OVER";
1228 #ifdef SEC_NEVER_LOAD
1230 sec_flags
|= SEC_NEVER_LOAD
;
1233 case IMAGE_SCN_MEM_READ
:
1234 sec_flags
&= ~SEC_COFF_NOREAD
;
1236 case IMAGE_SCN_TYPE_NO_PAD
:
1239 case IMAGE_SCN_LNK_OTHER
:
1240 unhandled
= "IMAGE_SCN_LNK_OTHER";
1242 case IMAGE_SCN_MEM_NOT_CACHED
:
1243 unhandled
= "IMAGE_SCN_MEM_NOT_CACHED";
1245 case IMAGE_SCN_MEM_NOT_PAGED
:
1246 /* Generate a warning message rather using the 'unhandled'
1247 variable as this will allow some .sys files generate by
1248 other toolchains to be processed. See bugzilla issue 196. */
1249 /* xgettext:c-format */
1250 _bfd_error_handler (_("%pB: warning: ignoring section flag"
1251 " %s in section %s"),
1252 abfd
, "IMAGE_SCN_MEM_NOT_PAGED", name
);
1254 case IMAGE_SCN_MEM_EXECUTE
:
1255 sec_flags
|= SEC_CODE
;
1257 case IMAGE_SCN_MEM_WRITE
:
1258 sec_flags
&= ~ SEC_READONLY
;
1260 case IMAGE_SCN_MEM_DISCARDABLE
:
1261 /* The MS PE spec says that debug sections are DISCARDABLE,
1262 but the presence of a DISCARDABLE flag does not necessarily
1263 mean that a given section contains debug information. Thus
1264 we only set the SEC_DEBUGGING flag on sections that we
1265 recognise as containing debug information. */
1268 || strcmp (name
, _COMMENT
) == 0
1272 sec_flags
|= SEC_DEBUGGING
| SEC_READONLY
;
1275 case IMAGE_SCN_MEM_SHARED
:
1276 sec_flags
|= SEC_COFF_SHARED
;
1278 case IMAGE_SCN_LNK_REMOVE
:
1280 sec_flags
|= SEC_EXCLUDE
;
1282 case IMAGE_SCN_CNT_CODE
:
1283 sec_flags
|= SEC_CODE
| SEC_ALLOC
| SEC_LOAD
;
1285 case IMAGE_SCN_CNT_INITIALIZED_DATA
:
1287 sec_flags
|= SEC_DEBUGGING
;
1289 sec_flags
|= SEC_DATA
| SEC_ALLOC
| SEC_LOAD
;
1291 case IMAGE_SCN_CNT_UNINITIALIZED_DATA
:
1292 sec_flags
|= SEC_ALLOC
;
1294 case IMAGE_SCN_LNK_INFO
:
1295 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1296 defined. coff_compute_section_file_positions uses
1297 COFF_PAGE_SIZE to ensure that the low order bits of the
1298 section VMA and the file offset match. If we don't know
1299 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1300 and demand page loading of the file will fail. */
1301 #ifdef COFF_PAGE_SIZE
1302 sec_flags
|= SEC_DEBUGGING
;
1305 case IMAGE_SCN_LNK_COMDAT
:
1306 /* COMDAT gets very special treatment. */
1307 sec_flags
= handle_COMDAT (abfd
, sec_flags
, hdr
, name
, section
);
1310 /* Silently ignore for now. */
1314 /* If the section flag was not handled, report it here. */
1315 if (unhandled
!= NULL
)
1318 /* xgettext:c-format */
1319 (_("%pB (%s): section flag %s (%#lx) ignored"),
1320 abfd
, name
, unhandled
, flag
);
1325 if ((bfd_applicable_section_flags (abfd
) & SEC_SMALL_DATA
) != 0
1326 && (CONST_STRNEQ (name
, ".sbss")
1327 || CONST_STRNEQ (name
, ".sdata")))
1328 sec_flags
|= SEC_SMALL_DATA
;
1330 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1331 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1332 only link a single copy of the section. This is used to support
1333 g++. g++ will emit each template expansion in its own section.
1334 The symbols will be defined as weak, so that multiple definitions
1335 are permitted. The GNU linker extension is to actually discard
1336 all but one of the sections. */
1337 if (CONST_STRNEQ (name
, ".gnu.linkonce"))
1338 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1342 * flags_ptr
= sec_flags
;
1347 #endif /* COFF_WITH_PE */
1349 #define get_index(symbol) ((symbol)->udata.i)
1353 bfd_coff_backend_data
1357 .{* COFF symbol classifications. *}
1359 .enum coff_symbol_classification
1361 . {* Global symbol. *}
1362 . COFF_SYMBOL_GLOBAL,
1363 . {* Common symbol. *}
1364 . COFF_SYMBOL_COMMON,
1365 . {* Undefined symbol. *}
1366 . COFF_SYMBOL_UNDEFINED,
1367 . {* Local symbol. *}
1368 . COFF_SYMBOL_LOCAL,
1369 . {* PE section symbol. *}
1370 . COFF_SYMBOL_PE_SECTION
1373 .typedef asection * (*coff_gc_mark_hook_fn)
1374 . (asection *, struct bfd_link_info *, struct internal_reloc *,
1375 . struct coff_link_hash_entry *, struct internal_syment *);
1377 Special entry points for gdb to swap in coff symbol table parts:
1380 . void (*_bfd_coff_swap_aux_in)
1381 . (bfd *, void *, int, int, int, int, void *);
1383 . void (*_bfd_coff_swap_sym_in)
1384 . (bfd *, void *, void *);
1386 . void (*_bfd_coff_swap_lineno_in)
1387 . (bfd *, void *, void *);
1389 . unsigned int (*_bfd_coff_swap_aux_out)
1390 . (bfd *, void *, int, int, int, int, void *);
1392 . unsigned int (*_bfd_coff_swap_sym_out)
1393 . (bfd *, void *, void *);
1395 . unsigned int (*_bfd_coff_swap_lineno_out)
1396 . (bfd *, void *, void *);
1398 . unsigned int (*_bfd_coff_swap_reloc_out)
1399 . (bfd *, void *, void *);
1401 . unsigned int (*_bfd_coff_swap_filehdr_out)
1402 . (bfd *, void *, void *);
1404 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1405 . (bfd *, void *, void *);
1407 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1408 . (bfd *, void *, void *);
1410 . unsigned int _bfd_filhsz;
1411 . unsigned int _bfd_aoutsz;
1412 . unsigned int _bfd_scnhsz;
1413 . unsigned int _bfd_symesz;
1414 . unsigned int _bfd_auxesz;
1415 . unsigned int _bfd_relsz;
1416 . unsigned int _bfd_linesz;
1417 . unsigned int _bfd_filnmlen;
1418 . bfd_boolean _bfd_coff_long_filenames;
1420 . bfd_boolean _bfd_coff_long_section_names;
1421 . bfd_boolean (*_bfd_coff_set_long_section_names)
1424 . unsigned int _bfd_coff_default_section_alignment_power;
1425 . bfd_boolean _bfd_coff_force_symnames_in_strings;
1426 . unsigned int _bfd_coff_debug_string_prefix_length;
1427 . unsigned int _bfd_coff_max_nscns;
1429 . void (*_bfd_coff_swap_filehdr_in)
1430 . (bfd *, void *, void *);
1432 . void (*_bfd_coff_swap_aouthdr_in)
1433 . (bfd *, void *, void *);
1435 . void (*_bfd_coff_swap_scnhdr_in)
1436 . (bfd *, void *, void *);
1438 . void (*_bfd_coff_swap_reloc_in)
1439 . (bfd *abfd, void *, void *);
1441 . bfd_boolean (*_bfd_coff_bad_format_hook)
1444 . bfd_boolean (*_bfd_coff_set_arch_mach_hook)
1447 . void * (*_bfd_coff_mkobject_hook)
1448 . (bfd *, void *, void *);
1450 . bfd_boolean (*_bfd_styp_to_sec_flags_hook)
1451 . (bfd *, void *, const char *, asection *, flagword *);
1453 . void (*_bfd_set_alignment_hook)
1454 . (bfd *, asection *, void *);
1456 . bfd_boolean (*_bfd_coff_slurp_symbol_table)
1459 . bfd_boolean (*_bfd_coff_symname_in_debug)
1460 . (bfd *, struct internal_syment *);
1462 . bfd_boolean (*_bfd_coff_pointerize_aux_hook)
1463 . (bfd *, combined_entry_type *, combined_entry_type *,
1464 . unsigned int, combined_entry_type *);
1466 . bfd_boolean (*_bfd_coff_print_aux)
1467 . (bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1468 . combined_entry_type *, unsigned int);
1470 . void (*_bfd_coff_reloc16_extra_cases)
1471 . (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1472 . bfd_byte *, unsigned int *, unsigned int *);
1474 . int (*_bfd_coff_reloc16_estimate)
1475 . (bfd *, asection *, arelent *, unsigned int,
1476 . struct bfd_link_info *);
1478 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1479 . (bfd *, struct internal_syment *);
1481 . bfd_boolean (*_bfd_coff_compute_section_file_positions)
1484 . bfd_boolean (*_bfd_coff_start_final_link)
1485 . (bfd *, struct bfd_link_info *);
1487 . bfd_boolean (*_bfd_coff_relocate_section)
1488 . (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1489 . struct internal_reloc *, struct internal_syment *, asection **);
1491 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1492 . (bfd *, asection *, struct internal_reloc *,
1493 . struct coff_link_hash_entry *, struct internal_syment *, bfd_vma *);
1495 . bfd_boolean (*_bfd_coff_adjust_symndx)
1496 . (bfd *, struct bfd_link_info *, bfd *, asection *,
1497 . struct internal_reloc *, bfd_boolean *);
1499 . bfd_boolean (*_bfd_coff_link_add_one_symbol)
1500 . (struct bfd_link_info *, bfd *, const char *, flagword,
1501 . asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
1502 . struct bfd_link_hash_entry **);
1504 . bfd_boolean (*_bfd_coff_link_output_has_begun)
1505 . (bfd *, struct coff_final_link_info *);
1507 . bfd_boolean (*_bfd_coff_final_link_postscript)
1508 . (bfd *, struct coff_final_link_info *);
1510 . bfd_boolean (*_bfd_coff_print_pdata)
1513 .} bfd_coff_backend_data;
1515 .#define coff_backend_info(abfd) \
1516 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1518 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1519 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1521 .#define bfd_coff_swap_sym_in(a,e,i) \
1522 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1524 .#define bfd_coff_swap_lineno_in(a,e,i) \
1525 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1527 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1528 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1530 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1531 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1533 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1534 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1536 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1537 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1539 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1540 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1542 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1543 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1545 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1546 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1548 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1549 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1550 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1551 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1552 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1553 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1554 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1555 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1556 .#define bfd_coff_long_filenames(abfd) \
1557 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1558 .#define bfd_coff_long_section_names(abfd) \
1559 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1560 .#define bfd_coff_set_long_section_names(abfd, enable) \
1561 . ((coff_backend_info (abfd)->_bfd_coff_set_long_section_names) (abfd, enable))
1562 .#define bfd_coff_default_section_alignment_power(abfd) \
1563 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1564 .#define bfd_coff_max_nscns(abfd) \
1565 . (coff_backend_info (abfd)->_bfd_coff_max_nscns)
1567 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1568 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1570 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1571 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1573 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1574 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1576 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1577 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1579 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1580 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1582 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1583 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1584 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1585 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1586 . (abfd, filehdr, aouthdr))
1588 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1589 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1590 . (abfd, scnhdr, name, section, flags_ptr))
1592 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1593 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1595 .#define bfd_coff_slurp_symbol_table(abfd)\
1596 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1598 .#define bfd_coff_symname_in_debug(abfd, sym)\
1599 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1601 .#define bfd_coff_force_symnames_in_strings(abfd)\
1602 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1604 .#define bfd_coff_debug_string_prefix_length(abfd)\
1605 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1607 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1608 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1609 . (abfd, file, base, symbol, aux, indaux))
1611 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1612 . reloc, data, src_ptr, dst_ptr)\
1613 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1614 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1616 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1617 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1618 . (abfd, section, reloc, shrink, link_info))
1620 .#define bfd_coff_classify_symbol(abfd, sym)\
1621 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1624 .#define bfd_coff_compute_section_file_positions(abfd)\
1625 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1628 .#define bfd_coff_start_final_link(obfd, info)\
1629 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1631 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1632 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1633 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1634 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1635 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1636 . (abfd, sec, rel, h, sym, addendp))
1637 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1638 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1639 . (obfd, info, ibfd, sec, rel, adjustedp))
1640 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1641 . value, string, cp, coll, hashp)\
1642 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1643 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1645 .#define bfd_coff_link_output_has_begun(a,p) \
1646 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p))
1647 .#define bfd_coff_final_link_postscript(a,p) \
1648 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p))
1650 .#define bfd_coff_have_print_pdata(a) \
1651 . (coff_backend_info (a)->_bfd_coff_print_pdata)
1652 .#define bfd_coff_print_pdata(a,p) \
1653 . ((coff_backend_info (a)->_bfd_coff_print_pdata) (a, p))
1655 .{* Macro: Returns true if the bfd is a PE executable as opposed to a
1656 . PE object file. *}
1657 .#define bfd_pei_p(abfd) \
1658 . (CONST_STRNEQ ((abfd)->xvec->name, "pei-"))
1661 /* See whether the magic number matches. */
1664 coff_bad_format_hook (bfd
* abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1666 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1668 if (BADMAG (*internal_f
))
1676 ticoff0_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1678 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1680 if (COFF0_BADMAG (*internal_f
))
1689 ticoff1_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1691 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1693 if (COFF1_BADMAG (*internal_f
))
1700 /* Check whether this section uses an alignment other than the
1704 coff_set_custom_section_alignment (bfd
*abfd ATTRIBUTE_UNUSED
,
1706 const struct coff_section_alignment_entry
*alignment_table
,
1707 const unsigned int table_size
)
1709 const unsigned int default_alignment
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1712 for (i
= 0; i
< table_size
; ++i
)
1714 const char *secname
= bfd_section_name (section
);
1716 if (alignment_table
[i
].comparison_length
== (unsigned int) -1
1717 ? strcmp (alignment_table
[i
].name
, secname
) == 0
1718 : strncmp (alignment_table
[i
].name
, secname
,
1719 alignment_table
[i
].comparison_length
) == 0)
1722 if (i
>= table_size
)
1725 if (alignment_table
[i
].default_alignment_min
!= COFF_ALIGNMENT_FIELD_EMPTY
1726 && default_alignment
< alignment_table
[i
].default_alignment_min
)
1729 if (alignment_table
[i
].default_alignment_max
!= COFF_ALIGNMENT_FIELD_EMPTY
1730 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1731 && default_alignment
> alignment_table
[i
].default_alignment_max
1736 section
->alignment_power
= alignment_table
[i
].alignment_power
;
1739 /* Custom section alignment records. */
1741 static const struct coff_section_alignment_entry
1742 coff_section_alignment_table
[] =
1744 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1745 COFF_SECTION_ALIGNMENT_ENTRIES
,
1747 /* There must not be any gaps between .stabstr sections. */
1748 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1749 1, COFF_ALIGNMENT_FIELD_EMPTY
, 0 },
1750 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1751 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1752 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1753 /* Similarly for the .ctors and .dtors sections. */
1754 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1755 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1756 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1757 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 }
1760 static const unsigned int coff_section_alignment_table_size
=
1761 sizeof coff_section_alignment_table
/ sizeof coff_section_alignment_table
[0];
1763 /* Initialize a section structure with information peculiar to this
1764 particular implementation of COFF. */
1767 coff_new_section_hook (bfd
* abfd
, asection
* section
)
1769 combined_entry_type
*native
;
1771 unsigned char sclass
= C_STAT
;
1773 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1776 if (bfd_xcoff_text_align_power (abfd
) != 0
1777 && strcmp (bfd_section_name (section
), ".text") == 0)
1778 section
->alignment_power
= bfd_xcoff_text_align_power (abfd
);
1779 else if (bfd_xcoff_data_align_power (abfd
) != 0
1780 && strcmp (bfd_section_name (section
), ".data") == 0)
1781 section
->alignment_power
= bfd_xcoff_data_align_power (abfd
);
1786 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
1787 if (strcmp (bfd_section_name (section
),
1788 xcoff_dwsect_names
[i
].name
) == 0)
1790 section
->alignment_power
= 0;
1797 /* Set up the section symbol. */
1798 if (!_bfd_generic_new_section_hook (abfd
, section
))
1801 /* Allocate aux records for section symbols, to store size and
1804 @@ The 10 is a guess at a plausible maximum number of aux entries
1805 (but shouldn't be a constant). */
1806 amt
= sizeof (combined_entry_type
) * 10;
1807 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
1811 /* We don't need to set up n_name, n_value, or n_scnum in the native
1812 symbol information, since they'll be overridden by the BFD symbol
1813 anyhow. However, we do need to set the type and storage class,
1814 in case this symbol winds up getting written out. The value 0
1815 for n_numaux is already correct. */
1817 native
->is_sym
= TRUE
;
1818 native
->u
.syment
.n_type
= T_NULL
;
1819 native
->u
.syment
.n_sclass
= sclass
;
1821 coffsymbol (section
->symbol
)->native
= native
;
1823 coff_set_custom_section_alignment (abfd
, section
,
1824 coff_section_alignment_table
,
1825 coff_section_alignment_table_size
);
1830 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1832 /* Set the alignment of a BFD section. */
1835 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1839 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1842 #ifdef COFF_DECODE_ALIGNMENT
1843 i
= COFF_DECODE_ALIGNMENT(hdr
->s_flags
);
1845 section
->alignment_power
= i
;
1847 #ifdef coff_set_section_load_page
1848 coff_set_section_load_page (section
, hdr
->s_page
);
1852 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1856 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1860 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1862 unsigned int alignment_power_const
1863 = hdr
->s_flags
& IMAGE_SCN_ALIGN_POWER_BIT_MASK
;
1865 switch (alignment_power_const
)
1867 case IMAGE_SCN_ALIGN_8192BYTES
:
1868 case IMAGE_SCN_ALIGN_4096BYTES
:
1869 case IMAGE_SCN_ALIGN_2048BYTES
:
1870 case IMAGE_SCN_ALIGN_1024BYTES
:
1871 case IMAGE_SCN_ALIGN_512BYTES
:
1872 case IMAGE_SCN_ALIGN_256BYTES
:
1873 case IMAGE_SCN_ALIGN_128BYTES
:
1874 case IMAGE_SCN_ALIGN_64BYTES
:
1875 case IMAGE_SCN_ALIGN_32BYTES
:
1876 case IMAGE_SCN_ALIGN_16BYTES
:
1877 case IMAGE_SCN_ALIGN_8BYTES
:
1878 case IMAGE_SCN_ALIGN_4BYTES
:
1879 case IMAGE_SCN_ALIGN_2BYTES
:
1880 case IMAGE_SCN_ALIGN_1BYTES
:
1881 section
->alignment_power
1882 = IMAGE_SCN_ALIGN_POWER_NUM (alignment_power_const
);
1888 /* In a PE image file, the s_paddr field holds the virtual size of a
1889 section, while the s_size field holds the raw size. We also keep
1890 the original section flag value, since not every bit can be
1891 mapped onto a generic BFD section bit. */
1892 if (coff_section_data (abfd
, section
) == NULL
)
1894 amt
= sizeof (struct coff_section_tdata
);
1895 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
1896 if (section
->used_by_bfd
== NULL
)
1897 /* FIXME: Return error. */
1901 if (pei_section_data (abfd
, section
) == NULL
)
1903 amt
= sizeof (struct pei_section_tdata
);
1904 coff_section_data (abfd
, section
)->tdata
= bfd_zalloc (abfd
, amt
);
1905 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1906 /* FIXME: Return error. */
1909 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1910 pei_section_data (abfd
, section
)->pe_flags
= hdr
->s_flags
;
1912 section
->lma
= hdr
->s_vaddr
;
1914 /* Check for extended relocs. */
1915 if (hdr
->s_flags
& IMAGE_SCN_LNK_NRELOC_OVFL
)
1917 struct external_reloc dst
;
1918 struct internal_reloc n
;
1919 file_ptr oldpos
= bfd_tell (abfd
);
1920 bfd_size_type relsz
= bfd_coff_relsz (abfd
);
1922 if (bfd_seek (abfd
, (file_ptr
) hdr
->s_relptr
, 0) != 0)
1924 if (bfd_bread (& dst
, relsz
, abfd
) != relsz
)
1927 coff_swap_reloc_in (abfd
, &dst
, &n
);
1928 if (bfd_seek (abfd
, oldpos
, 0) != 0)
1930 section
->reloc_count
= hdr
->s_nreloc
= n
.r_vaddr
- 1;
1931 section
->rel_filepos
+= relsz
;
1933 else if (hdr
->s_nreloc
== 0xffff)
1935 (_("%pB: warning: claims to have 0xffff relocs, without overflow"),
1939 #undef ELIFALIGN_SET
1941 #else /* ! COFF_WITH_PE */
1944 /* We grossly abuse this function to handle XCOFF overflow headers.
1945 When we see one, we correct the reloc and line number counts in the
1946 real header, and remove the section we just created. */
1949 coff_set_alignment_hook (bfd
*abfd
, asection
*section
, void * scnhdr
)
1951 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1954 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1957 real_sec
= coff_section_from_bfd_index (abfd
, (int) hdr
->s_nreloc
);
1958 if (real_sec
== NULL
)
1961 real_sec
->reloc_count
= hdr
->s_paddr
;
1962 real_sec
->lineno_count
= hdr
->s_vaddr
;
1964 if (!bfd_section_removed_from_list (abfd
, section
))
1966 bfd_section_list_remove (abfd
, section
);
1967 --abfd
->section_count
;
1971 #else /* ! RS6000COFF_C */
1972 #if defined (COFF_GO32_EXE) || defined (COFF_GO32)
1975 coff_set_alignment_hook (bfd
* abfd
, asection
* section
, void * scnhdr
)
1977 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1979 /* Check for extended relocs. */
1980 if (hdr
->s_flags
& IMAGE_SCN_LNK_NRELOC_OVFL
)
1982 struct external_reloc dst
;
1983 struct internal_reloc n
;
1984 const file_ptr oldpos
= bfd_tell (abfd
);
1985 const bfd_size_type relsz
= bfd_coff_relsz (abfd
);
1987 if (bfd_seek (abfd
, (file_ptr
) hdr
->s_relptr
, 0) != 0)
1989 if (bfd_bread (& dst
, relsz
, abfd
) != relsz
)
1992 coff_swap_reloc_in (abfd
, &dst
, &n
);
1993 if (bfd_seek (abfd
, oldpos
, 0) != 0)
1995 section
->reloc_count
= hdr
->s_nreloc
= n
.r_vaddr
- 1;
1996 section
->rel_filepos
+= relsz
;
1998 else if (hdr
->s_nreloc
== 0xffff)
2000 (_("%pB: warning: claims to have 0xffff relocs, without overflow"),
2004 #else /* ! COFF_GO32_EXE && ! COFF_GO32 */
2007 coff_set_alignment_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2008 asection
*section ATTRIBUTE_UNUSED
,
2009 void *scnhdr ATTRIBUTE_UNUSED
)
2013 #endif /* ! COFF_GO32_EXE && ! COFF_GO32 */
2014 #endif /* ! RS6000COFF_C */
2015 #endif /* ! COFF_WITH_PE */
2016 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
2018 #ifndef coff_mkobject
2021 coff_mkobject (bfd
* abfd
)
2023 coff_data_type
*coff
;
2024 size_t amt
= sizeof (coff_data_type
);
2026 abfd
->tdata
.coff_obj_data
= bfd_zalloc (abfd
, amt
);
2027 if (abfd
->tdata
.coff_obj_data
== NULL
)
2029 coff
= coff_data (abfd
);
2030 coff
->symbols
= NULL
;
2031 coff
->conversion_table
= NULL
;
2032 coff
->raw_syments
= NULL
;
2033 coff
->relocbase
= 0;
2034 coff
->local_toc_sym_map
= 0;
2036 /* make_abs_section(abfd);*/
2042 /* Create the COFF backend specific information. */
2044 #ifndef coff_mkobject_hook
2046 coff_mkobject_hook (bfd
* abfd
,
2048 void * aouthdr ATTRIBUTE_UNUSED
)
2050 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
2051 coff_data_type
*coff
;
2053 if (! coff_mkobject (abfd
))
2056 coff
= coff_data (abfd
);
2058 coff
->sym_filepos
= internal_f
->f_symptr
;
2060 /* These members communicate important constants about the symbol
2061 table to GDB's symbol-reading code. These `constants'
2062 unfortunately vary among coff implementations... */
2063 coff
->local_n_btmask
= N_BTMASK
;
2064 coff
->local_n_btshft
= N_BTSHFT
;
2065 coff
->local_n_tmask
= N_TMASK
;
2066 coff
->local_n_tshift
= N_TSHIFT
;
2067 coff
->local_symesz
= bfd_coff_symesz (abfd
);
2068 coff
->local_auxesz
= bfd_coff_auxesz (abfd
);
2069 coff
->local_linesz
= bfd_coff_linesz (abfd
);
2071 coff
->timestamp
= internal_f
->f_timdat
;
2073 obj_raw_syment_count (abfd
) =
2074 obj_conv_table_size (abfd
) =
2075 internal_f
->f_nsyms
;
2078 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
2079 abfd
->flags
|= DYNAMIC
;
2080 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= bfd_coff_aoutsz (abfd
))
2082 struct internal_aouthdr
*internal_a
=
2083 (struct internal_aouthdr
*) aouthdr
;
2084 struct xcoff_tdata
*xcoff
;
2086 xcoff
= xcoff_data (abfd
);
2087 # ifdef U803XTOCMAGIC
2088 xcoff
->xcoff64
= internal_f
->f_magic
== U803XTOCMAGIC
;
2092 xcoff
->full_aouthdr
= TRUE
;
2093 xcoff
->toc
= internal_a
->o_toc
;
2094 xcoff
->sntoc
= internal_a
->o_sntoc
;
2095 xcoff
->snentry
= internal_a
->o_snentry
;
2096 bfd_xcoff_text_align_power (abfd
) = internal_a
->o_algntext
;
2097 bfd_xcoff_data_align_power (abfd
) = internal_a
->o_algndata
;
2098 xcoff
->modtype
= internal_a
->o_modtype
;
2099 xcoff
->cputype
= internal_a
->o_cputype
;
2100 xcoff
->maxdata
= internal_a
->o_maxdata
;
2101 xcoff
->maxstack
= internal_a
->o_maxstack
;
2106 /* Set the flags field from the COFF header read in. */
2107 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
2112 /* FIXME: I'm not sure this is ever executed, since peicode.h
2113 defines coff_mkobject_hook. */
2114 if ((internal_f
->f_flags
& IMAGE_FILE_DEBUG_STRIPPED
) == 0)
2115 abfd
->flags
|= HAS_DEBUG
;
2122 /* Determine the machine architecture and type. FIXME: This is target
2123 dependent because the magic numbers are defined in the target
2124 dependent header files. But there is no particular need for this.
2125 If the magic numbers were moved to a separate file, this function
2126 would be target independent and would also be much more successful
2127 at linking together COFF files for different architectures. */
2130 coff_set_arch_mach_hook (bfd
*abfd
, void * filehdr
)
2132 unsigned long machine
;
2133 enum bfd_architecture arch
;
2134 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
2136 /* Zero selects the default machine for an arch. */
2138 switch (internal_f
->f_magic
)
2143 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler. */
2145 case I386_APPLE_MAGIC
:
2146 case I386_FREEBSD_MAGIC
:
2147 case I386_LINUX_MAGIC
:
2148 case I386_NETBSD_MAGIC
:
2149 arch
= bfd_arch_i386
;
2154 case AMD64_APPLE_MAGIC
:
2155 case AMD64_FREEBSD_MAGIC
:
2156 case AMD64_LINUX_MAGIC
:
2157 case AMD64_NETBSD_MAGIC
:
2158 arch
= bfd_arch_i386
;
2159 machine
= bfd_mach_x86_64
;
2164 arch
= bfd_arch_ia64
;
2171 arch
= bfd_arch_arm
;
2172 machine
= bfd_arm_get_mach_from_notes (abfd
, ARM_NOTE_SECTION
);
2173 if (machine
== bfd_mach_arm_unknown
)
2175 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
2177 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
2178 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
2179 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
2181 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
2182 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
2183 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
2184 /* The COFF header does not have enough bits available
2185 to cover all the different ARM architectures. So
2186 we interpret F_ARM_5, the highest flag value to mean
2187 "the highest ARM architecture known to BFD" which is
2188 currently the XScale. */
2189 case F_ARM_5
: machine
= bfd_mach_arm_XScale
; break;
2196 arch
= bfd_arch_z80
;
2197 switch (internal_f
->f_flags
& F_MACHMASK
)
2199 case bfd_mach_z80strict
<< 12:
2200 case bfd_mach_z80
<< 12:
2201 case bfd_mach_z80n
<< 12:
2202 case bfd_mach_z80full
<< 12:
2203 case bfd_mach_r800
<< 12:
2204 case bfd_mach_gbz80
<< 12:
2205 case bfd_mach_z180
<< 12:
2206 case bfd_mach_ez80_z80
<< 12:
2207 case bfd_mach_ez80_adl
<< 12:
2208 machine
= ((unsigned)internal_f
->f_flags
& F_MACHMASK
) >> 12;
2217 arch
= bfd_arch_z8k
;
2218 switch (internal_f
->f_flags
& F_MACHMASK
)
2221 machine
= bfd_mach_z8001
;
2224 machine
= bfd_mach_z8002
;
2244 if (xcoff_data (abfd
)->cputype
!= -1)
2245 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
2248 /* We did not get a value from the a.out header. If the
2249 file has not been stripped, we may be able to get the
2250 architecture information from the first symbol, if it
2251 is a .file symbol. */
2252 if (obj_raw_syment_count (abfd
) == 0)
2257 struct internal_syment sym
;
2258 bfd_size_type amt
= bfd_coff_symesz (abfd
);
2260 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
2262 buf
= _bfd_malloc_and_read (abfd
, amt
, amt
);
2265 bfd_coff_swap_sym_in (abfd
, buf
, & sym
);
2266 if (sym
.n_sclass
== C_FILE
)
2267 cputype
= sym
.n_type
& 0xff;
2274 /* FIXME: We don't handle all cases here. */
2279 arch
= bfd_xcoff_architecture (abfd
);
2280 machine
= bfd_xcoff_machine (abfd
);
2284 arch
= bfd_arch_powerpc
;
2285 machine
= bfd_mach_ppc_601
;
2287 case 2: /* 64 bit PowerPC */
2288 arch
= bfd_arch_powerpc
;
2289 machine
= bfd_mach_ppc_620
;
2292 arch
= bfd_arch_powerpc
;
2293 machine
= bfd_mach_ppc
;
2296 arch
= bfd_arch_rs6000
;
2297 machine
= bfd_mach_rs6k
;
2304 #ifdef SH_ARCH_MAGIC_BIG
2305 case SH_ARCH_MAGIC_BIG
:
2306 case SH_ARCH_MAGIC_LITTLE
:
2308 case SH_ARCH_MAGIC_WINCE
:
2314 #ifdef MIPS_ARCH_MAGIC_WINCE
2315 case MIPS_ARCH_MAGIC_WINCE
:
2316 arch
= bfd_arch_mips
;
2322 #ifdef LYNXCOFFMAGIC
2325 arch
= bfd_arch_sparc
;
2331 arch
= bfd_arch_tic30
;
2336 #ifdef TICOFF_TARGET_ARCH
2337 /* This TI COFF section should be used by all new TI COFF v0 targets. */
2339 arch
= TICOFF_TARGET_ARCH
;
2340 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2346 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */
2347 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */
2350 switch (internal_f
->f_target_id
)
2354 arch
= TICOFF_TARGET_ARCH
;
2355 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2359 arch
= bfd_arch_obscure
;
2361 (_("unrecognized TI COFF target id '0x%x'"),
2362 internal_f
->f_target_id
);
2370 arch
= bfd_arch_mcore
;
2374 default: /* Unreadable input file type. */
2375 arch
= bfd_arch_obscure
;
2379 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2384 symname_in_debug_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2385 struct internal_syment
*sym ATTRIBUTE_UNUSED
)
2387 #ifdef SYMNAME_IN_DEBUG
2388 return SYMNAME_IN_DEBUG (sym
) != 0;
2397 #define FORCE_SYMNAMES_IN_STRINGS
2400 /* Handle the csect auxent of a C_EXT, C_AIX_WEAKEXT or C_HIDEXT symbol. */
2403 coff_pointerize_aux_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2404 combined_entry_type
*table_base
,
2405 combined_entry_type
*symbol
,
2406 unsigned int indaux
,
2407 combined_entry_type
*aux
)
2409 BFD_ASSERT (symbol
->is_sym
);
2410 int n_sclass
= symbol
->u
.syment
.n_sclass
;
2412 if (CSECT_SYM_P (n_sclass
)
2413 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2415 BFD_ASSERT (! aux
->is_sym
);
2416 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2418 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2419 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2420 aux
->fix_scnlen
= 1;
2423 /* Return TRUE to indicate that the caller should not do any
2424 further work on this auxent. */
2428 /* Return FALSE to indicate that this auxent should be handled by
2434 #define coff_pointerize_aux_hook 0
2435 #endif /* ! RS6000COFF_C */
2437 /* Print an aux entry. This returns TRUE if it has printed it. */
2440 coff_print_aux (bfd
*abfd ATTRIBUTE_UNUSED
,
2441 FILE *file ATTRIBUTE_UNUSED
,
2442 combined_entry_type
*table_base ATTRIBUTE_UNUSED
,
2443 combined_entry_type
*symbol ATTRIBUTE_UNUSED
,
2444 combined_entry_type
*aux ATTRIBUTE_UNUSED
,
2445 unsigned int indaux ATTRIBUTE_UNUSED
)
2447 BFD_ASSERT (symbol
->is_sym
);
2448 BFD_ASSERT (! aux
->is_sym
);
2450 if (CSECT_SYM_P (symbol
->u
.syment
.n_sclass
)
2451 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2453 /* This is a csect entry. */
2454 fprintf (file
, "AUX ");
2455 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2457 BFD_ASSERT (! aux
->fix_scnlen
);
2458 fprintf (file
, "val %5" BFD_VMA_FMT
"d",
2459 aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2463 fprintf (file
, "indx ");
2464 if (! aux
->fix_scnlen
)
2465 fprintf (file
, "%4" BFD_VMA_FMT
"d",
2466 aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2468 fprintf (file
, "%4ld",
2469 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2472 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2473 aux
->u
.auxent
.x_csect
.x_parmhash
,
2474 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2475 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2476 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2477 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2478 aux
->u
.auxent
.x_csect
.x_stab
,
2479 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2484 /* Return FALSE to indicate that no special action was taken. */
2492 To write relocations, the back end steps though the
2493 canonical relocation table and create an
2494 @code{internal_reloc}. The symbol index to use is removed from
2495 the @code{offset} field in the symbol table supplied. The
2496 address comes directly from the sum of the section base
2497 address and the relocation offset; the type is dug directly
2498 from the howto field. Then the @code{internal_reloc} is
2499 swapped into the shape of an @code{external_reloc} and written
2507 /* AUX's ld wants relocations to be sorted. */
2509 compare_arelent_ptr (const void * x
, const void * y
)
2511 const arelent
**a
= (const arelent
**) x
;
2512 const arelent
**b
= (const arelent
**) y
;
2513 bfd_size_type aadr
= (*a
)->address
;
2514 bfd_size_type badr
= (*b
)->address
;
2516 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2519 #endif /* TARG_AUX */
2522 coff_write_relocs (bfd
* abfd
, int first_undef
)
2526 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2529 struct external_reloc dst
;
2536 /* Sort relocations before we write them out. */
2539 amt
= s
->reloc_count
;
2540 amt
*= sizeof (arelent
*);
2541 p
= bfd_malloc (amt
);
2544 if (s
->reloc_count
> 0)
2549 memcpy (p
, s
->orelocation
, (size_t) amt
);
2550 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2555 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2558 #ifdef COFF_WITH_EXTENDED_RELOC_COUNTER
2559 if ((obj_pe (abfd
) || obj_go32 (abfd
)) && s
->reloc_count
>= 0xffff)
2561 /* Encode real count here as first reloc. */
2562 struct internal_reloc n
;
2564 memset (& n
, 0, sizeof (n
));
2565 /* Add one to count *this* reloc (grr). */
2566 n
.r_vaddr
= s
->reloc_count
+ 1;
2567 coff_swap_reloc_out (abfd
, &n
, &dst
);
2568 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2569 abfd
) != bfd_coff_relsz (abfd
))
2574 for (i
= 0; i
< s
->reloc_count
; i
++)
2576 struct internal_reloc n
;
2579 memset (& n
, 0, sizeof (n
));
2581 /* Now we've renumbered the symbols we know where the
2582 undefined symbols live in the table. Check the reloc
2583 entries for symbols who's output bfd isn't the right one.
2584 This is because the symbol was undefined (which means
2585 that all the pointers are never made to point to the same
2586 place). This is a bad thing,'cause the symbols attached
2587 to the output bfd are indexed, so that the relocation
2588 entries know which symbol index they point to. So we
2589 have to look up the output symbol here. */
2591 if (q
->sym_ptr_ptr
[0] != NULL
&& q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2594 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2595 asymbol
**outsyms
= abfd
->outsymbols
;
2597 for (j
= first_undef
; outsyms
[j
]; j
++)
2599 const char *intable
= outsyms
[j
]->name
;
2601 if (strcmp (intable
, sname
) == 0)
2603 /* Got a hit, so repoint the reloc. */
2604 q
->sym_ptr_ptr
= outsyms
+ j
;
2610 n
.r_vaddr
= q
->address
+ s
->vma
;
2613 /* The 29k const/consth reloc pair is a real kludge. The consth
2614 part doesn't have a symbol; it has an offset. So rebuilt
2616 if (q
->howto
->type
== R_IHCONST
)
2617 n
.r_symndx
= q
->addend
;
2620 if (q
->sym_ptr_ptr
&& q
->sym_ptr_ptr
[0] != NULL
)
2622 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2623 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
, s
))
2625 if ((*q
->sym_ptr_ptr
)->section
== bfd_abs_section_ptr
2626 && ((*q
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) != 0)
2628 /* This is a relocation relative to the absolute symbol. */
2632 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2633 /* Check to see if the symbol reloc points to a symbol
2634 we don't have in our symbol table. */
2635 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2637 bfd_set_error (bfd_error_bad_value
);
2638 /* xgettext:c-format */
2639 _bfd_error_handler (_("%pB: reloc against a non-existent"
2640 " symbol index: %ld"),
2647 #ifdef SWAP_OUT_RELOC_OFFSET
2648 n
.r_offset
= q
->addend
;
2652 /* Work out reloc type from what is required. */
2653 SELECT_RELOC (n
, q
->howto
);
2655 n
.r_type
= q
->howto
->type
;
2657 coff_swap_reloc_out (abfd
, &n
, &dst
);
2659 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2660 abfd
) != bfd_coff_relsz (abfd
))
2672 /* Set flags and magic number of a coff file from architecture and machine
2673 type. Result is TRUE if we can represent the arch&type, FALSE if not. */
2676 coff_set_flags (bfd
* abfd
,
2677 unsigned int *magicp ATTRIBUTE_UNUSED
,
2678 unsigned short *flagsp ATTRIBUTE_UNUSED
)
2680 switch (bfd_get_arch (abfd
))
2685 switch (bfd_get_mach (abfd
))
2687 case bfd_mach_z80strict
:
2690 case bfd_mach_z80full
:
2692 case bfd_mach_gbz80
:
2694 case bfd_mach_ez80_z80
:
2695 case bfd_mach_ez80_adl
:
2696 *flagsp
= bfd_get_mach (abfd
) << 12;
2708 switch (bfd_get_mach (abfd
))
2710 case bfd_mach_z8001
: *flagsp
= F_Z8001
; break;
2711 case bfd_mach_z8002
: *flagsp
= F_Z8002
; break;
2712 default: return FALSE
;
2718 case bfd_arch_tic30
:
2719 *magicp
= TIC30MAGIC
;
2723 #ifdef TICOFF_DEFAULT_MAGIC
2724 case TICOFF_TARGET_ARCH
:
2725 /* If there's no indication of which version we want, use the default. */
2727 *magicp
= TICOFF_DEFAULT_MAGIC
;
2730 /* We may want to output in a different COFF version. */
2731 switch (abfd
->xvec
->name
[4])
2734 *magicp
= TICOFF0MAGIC
;
2737 *magicp
= TICOFF1MAGIC
;
2740 *magicp
= TICOFF2MAGIC
;
2746 TICOFF_TARGET_MACHINE_SET (flagsp
, bfd_get_mach (abfd
));
2753 * magicp
= ARMPEMAGIC
;
2755 * magicp
= ARMMAGIC
;
2758 if (APCS_SET (abfd
))
2760 if (APCS_26_FLAG (abfd
))
2761 * flagsp
|= F_APCS26
;
2763 if (APCS_FLOAT_FLAG (abfd
))
2764 * flagsp
|= F_APCS_FLOAT
;
2766 if (PIC_FLAG (abfd
))
2769 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2770 * flagsp
|= F_INTERWORK
;
2771 switch (bfd_get_mach (abfd
))
2773 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2774 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2775 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2776 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2777 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2778 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2779 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2780 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2781 See also the comment in coff_set_arch_mach_hook(). */
2782 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break;
2783 case bfd_mach_arm_5TE
: * flagsp
|= F_ARM_5
; break;
2784 case bfd_mach_arm_XScale
: * flagsp
|= F_ARM_5
; break;
2789 #if defined(I386MAGIC) || defined(AMD64MAGIC)
2791 #if defined(I386MAGIC)
2792 *magicp
= I386MAGIC
;
2795 /* Just overwrite the usual value if we're doing Lynx. */
2796 *magicp
= LYNXCOFFMAGIC
;
2798 #if defined AMD64MAGIC
2799 *magicp
= AMD64MAGIC
;
2806 *magicp
= IA64MAGIC
;
2810 #ifdef SH_ARCH_MAGIC_BIG
2812 #ifdef COFF_IMAGE_WITH_PE
2813 *magicp
= SH_ARCH_MAGIC_WINCE
;
2815 if (bfd_big_endian (abfd
))
2816 *magicp
= SH_ARCH_MAGIC_BIG
;
2818 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2823 #ifdef MIPS_ARCH_MAGIC_WINCE
2825 *magicp
= MIPS_ARCH_MAGIC_WINCE
;
2830 case bfd_arch_sparc
:
2831 *magicp
= SPARCMAGIC
;
2833 /* Just overwrite the usual value if we're doing Lynx. */
2834 *magicp
= LYNXCOFFMAGIC
;
2840 case bfd_arch_rs6000
:
2841 case bfd_arch_powerpc
:
2842 BFD_ASSERT (bfd_get_flavour (abfd
) == bfd_target_xcoff_flavour
);
2843 *magicp
= bfd_xcoff_magic_number (abfd
);
2848 case bfd_arch_mcore
:
2849 * magicp
= MCOREMAGIC
;
2853 default: /* Unknown architecture. */
2854 /* Fall through to "return FALSE" below, to avoid
2855 "statement never reached" errors on the one below. */
2863 coff_set_arch_mach (bfd
* abfd
,
2864 enum bfd_architecture arch
,
2865 unsigned long machine
)
2868 unsigned short dummy2
;
2870 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
2873 if (arch
!= bfd_arch_unknown
2874 && ! coff_set_flags (abfd
, &dummy1
, &dummy2
))
2875 return FALSE
; /* We can't represent this type. */
2877 return TRUE
; /* We're easy... */
2880 #ifdef COFF_IMAGE_WITH_PE
2882 /* This is used to sort sections by VMA, as required by PE image
2886 sort_by_secaddr (const void * arg1
, const void * arg2
)
2888 const asection
*a
= *(const asection
**) arg1
;
2889 const asection
*b
= *(const asection
**) arg2
;
2891 if (a
->vma
< b
->vma
)
2893 else if (a
->vma
> b
->vma
)
2899 #endif /* COFF_IMAGE_WITH_PE */
2901 /* Calculate the file position for each section. */
2903 #define ALIGN_SECTIONS_IN_FILE
2905 #undef ALIGN_SECTIONS_IN_FILE
2909 coff_compute_section_file_positions (bfd
* abfd
)
2912 file_ptr sofar
= bfd_coff_filhsz (abfd
);
2913 bfd_boolean align_adjust
;
2914 unsigned int target_index
;
2915 #ifdef ALIGN_SECTIONS_IN_FILE
2916 asection
*previous
= NULL
;
2920 #ifdef COFF_IMAGE_WITH_PE
2923 if (coff_data (abfd
)->link_info
2924 || (pe_data (abfd
) && pe_data (abfd
)->pe_opthdr
.FileAlignment
))
2926 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
2928 /* If no file alignment has been set, default to one.
2929 This repairs 'ld -r' for arm-wince-pe target. */
2933 /* PR 17512: file: 0ac816d3. */
2936 bfd_set_error (bfd_error_file_too_big
);
2938 /* xgettext:c-format */
2939 (_("%pB: page size is too large (0x%x)"), abfd
, page_size
);
2944 page_size
= PE_DEF_FILE_ALIGNMENT
;
2946 #ifdef COFF_PAGE_SIZE
2947 int page_size
= COFF_PAGE_SIZE
;
2952 /* On XCOFF, if we have symbols, set up the .debug section. */
2953 if (bfd_get_symcount (abfd
) > 0)
2956 bfd_size_type i
, symcount
;
2960 symcount
= bfd_get_symcount (abfd
);
2961 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
2963 coff_symbol_type
*cf
;
2965 cf
= coff_symbol_from (*symp
);
2967 && cf
->native
!= NULL
2968 && cf
->native
->is_sym
2969 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
2973 len
= strlen (bfd_asymbol_name (*symp
));
2974 if (len
> SYMNMLEN
|| bfd_coff_force_symnames_in_strings (abfd
))
2975 sz
+= len
+ 1 + bfd_coff_debug_string_prefix_length (abfd
);
2982 dsec
= bfd_make_section_old_way (abfd
, DOT_DEBUG
);
2986 dsec
->flags
|= SEC_HAS_CONTENTS
;
2991 if (bfd_get_start_address (abfd
))
2992 /* A start address may have been added to the original file. In this
2993 case it will need an optional header to record it. */
2994 abfd
->flags
|= EXEC_P
;
2996 if (abfd
->flags
& EXEC_P
)
2997 sofar
+= bfd_coff_aoutsz (abfd
);
2999 else if (xcoff_data (abfd
)->full_aouthdr
)
3000 sofar
+= bfd_coff_aoutsz (abfd
);
3002 sofar
+= SMALL_AOUTSZ
;
3005 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
3008 /* XCOFF handles overflows in the reloc and line number count fields
3009 by allocating a new section header to hold the correct counts. */
3010 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3011 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3012 sofar
+= bfd_coff_scnhsz (abfd
);
3015 #ifdef COFF_IMAGE_WITH_PE
3017 /* PE requires the sections to be in memory order when listed in
3018 the section headers. It also does not like empty loadable
3019 sections. The sections apparently do not have to be in the
3020 right order in the image file itself, but we do need to get the
3021 target_index values right. */
3024 asection
**section_list
;
3028 #ifdef COFF_PAGE_SIZE
3029 /* Clear D_PAGED if section alignment is smaller than
3031 if (pe_data (abfd
)->pe_opthdr
.SectionAlignment
< COFF_PAGE_SIZE
)
3032 abfd
->flags
&= ~D_PAGED
;
3036 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3039 /* We allocate an extra cell to simplify the final loop. */
3040 amt
= sizeof (struct asection
*) * (count
+ 1);
3041 section_list
= (asection
**) bfd_malloc (amt
);
3042 if (section_list
== NULL
)
3046 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3048 section_list
[i
] = current
;
3051 section_list
[i
] = NULL
;
3053 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
3055 /* Rethread the linked list into sorted order; at the same time,
3056 assign target_index values. */
3058 abfd
->sections
= NULL
;
3059 abfd
->section_last
= NULL
;
3060 for (i
= 0; i
< count
; i
++)
3062 current
= section_list
[i
];
3063 bfd_section_list_append (abfd
, current
);
3065 /* Later, if the section has zero size, we'll be throwing it
3066 away, so we don't want to number it now. Note that having
3067 a zero size and having real contents are different
3068 concepts: .bss has no contents, but (usually) non-zero
3070 if (current
->size
== 0)
3072 /* Discard. However, it still might have (valid) symbols
3073 in it, so arbitrarily set it to section 1 (indexing is
3074 1-based here; usually .text). __end__ and other
3075 contents of .endsection really have this happen.
3076 FIXME: This seems somewhat dubious. */
3077 current
->target_index
= 1;
3080 current
->target_index
= target_index
++;
3083 free (section_list
);
3085 #else /* ! COFF_IMAGE_WITH_PE */
3087 /* Set the target_index field. */
3089 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3090 current
->target_index
= target_index
++;
3092 #endif /* ! COFF_IMAGE_WITH_PE */
3094 if (target_index
>= bfd_coff_max_nscns (abfd
))
3096 bfd_set_error (bfd_error_file_too_big
);
3098 /* xgettext:c-format */
3099 (_("%pB: too many sections (%d)"), abfd
, target_index
);
3103 align_adjust
= FALSE
;
3104 for (current
= abfd
->sections
;
3106 current
= current
->next
)
3108 #ifdef COFF_IMAGE_WITH_PE
3109 /* With PE we have to pad each section to be a multiple of its
3110 page size too, and remember both sizes. */
3111 if (coff_section_data (abfd
, current
) == NULL
)
3113 size_t amt
= sizeof (struct coff_section_tdata
);
3115 current
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
3116 if (current
->used_by_bfd
== NULL
)
3119 if (pei_section_data (abfd
, current
) == NULL
)
3121 size_t amt
= sizeof (struct pei_section_tdata
);
3123 coff_section_data (abfd
, current
)->tdata
= bfd_zalloc (abfd
, amt
);
3124 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
3127 if (pei_section_data (abfd
, current
)->virt_size
== 0)
3128 pei_section_data (abfd
, current
)->virt_size
= current
->size
;
3131 /* Only deal with sections which have contents. */
3132 if (!(current
->flags
& SEC_HAS_CONTENTS
))
3135 current
->rawsize
= current
->size
;
3137 #ifdef COFF_IMAGE_WITH_PE
3138 /* Make sure we skip empty sections in a PE image. */
3139 if (current
->size
== 0)
3143 /* Align the sections in the file to the same boundary on
3144 which they are aligned in virtual memory. */
3145 #ifdef ALIGN_SECTIONS_IN_FILE
3146 if ((abfd
->flags
& EXEC_P
) != 0)
3148 /* Make sure this section is aligned on the right boundary - by
3149 padding the previous section up if necessary. */
3152 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3155 /* Make sure the file offset and the vma of .text/.data are at the
3156 same page offset, so that the file can be mmap'ed without being
3157 relocated. Failing that, AIX is able to load and execute the
3158 program, but it will be silently relocated (possible as
3159 executables are PIE). But the relocation is slightly costly and
3160 complexify the use of addr2line or gdb. So better to avoid it,
3161 like does the native linker. Usually gnu ld makes sure that
3162 the vma of .text is the file offset so this issue shouldn't
3163 appear unless you are stripping such an executable.
3165 AIX loader checks the text section alignment of (vma - filepos),
3166 and the native linker doesn't try to align the text sections.
3169 0 .text 000054cc 10000128 10000128 00000128 2**5
3170 CONTENTS, ALLOC, LOAD, CODE
3173 if (!strcmp (current
->name
, _TEXT
)
3174 || !strcmp (current
->name
, _DATA
))
3176 bfd_vma align
= 4096;
3177 bfd_vma sofar_off
= sofar
% align
;
3178 bfd_vma vma_off
= current
->vma
% align
;
3180 if (vma_off
> sofar_off
)
3181 sofar
+= vma_off
- sofar_off
;
3182 else if (vma_off
< sofar_off
)
3183 sofar
+= align
+ vma_off
- sofar_off
;
3186 if (previous
!= NULL
)
3187 previous
->size
+= sofar
- old_sofar
;
3192 /* In demand paged files the low order bits of the file offset
3193 must match the low order bits of the virtual address. */
3194 #ifdef COFF_PAGE_SIZE
3195 if ((abfd
->flags
& D_PAGED
) != 0
3196 && (current
->flags
& SEC_ALLOC
) != 0)
3197 sofar
+= (current
->vma
- (bfd_vma
) sofar
) % page_size
;
3199 current
->filepos
= sofar
;
3201 #ifdef COFF_IMAGE_WITH_PE
3202 /* Set the padded size. */
3203 current
->size
= (current
->size
+ page_size
- 1) & -page_size
;
3206 sofar
+= current
->size
;
3208 #ifdef ALIGN_SECTIONS_IN_FILE
3209 /* Make sure that this section is of the right size too. */
3210 if ((abfd
->flags
& EXEC_P
) == 0)
3212 bfd_size_type old_size
;
3214 old_size
= current
->size
;
3215 current
->size
= BFD_ALIGN (current
->size
,
3216 1 << current
->alignment_power
);
3217 align_adjust
= current
->size
!= old_size
;
3218 sofar
+= current
->size
- old_size
;
3223 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3224 align_adjust
= sofar
!= old_sofar
;
3225 current
->size
+= sofar
- old_sofar
;
3229 #ifdef COFF_IMAGE_WITH_PE
3230 /* For PE we need to make sure we pad out to the aligned
3231 size, in case the caller only writes out data to the
3233 if (pei_section_data (abfd
, current
)->virt_size
< current
->size
)
3234 align_adjust
= TRUE
;
3238 /* Force .lib sections to start at zero. The vma is then
3239 incremented in coff_set_section_contents. This is right for
3241 if (strcmp (current
->name
, _LIB
) == 0)
3242 bfd_set_section_vma (current
, 0);
3245 #ifdef ALIGN_SECTIONS_IN_FILE
3250 /* It is now safe to write to the output file. If we needed an
3251 alignment adjustment for the last section, then make sure that
3252 there is a byte at offset sofar. If there are no symbols and no
3253 relocs, then nothing follows the last section. If we don't force
3254 the last byte out, then the file may appear to be truncated. */
3260 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
3261 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3265 /* Make sure the relocations are aligned. We don't need to make
3266 sure that this byte exists, because it will only matter if there
3267 really are relocs. */
3268 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
3270 obj_relocbase (abfd
) = sofar
;
3271 abfd
->output_has_begun
= TRUE
;
3276 #ifdef COFF_IMAGE_WITH_PE
3279 coff_read_word (bfd
*abfd
, unsigned int *value
, unsigned int *pelength
)
3284 status
= bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3292 *value
= (unsigned int) b
[0];
3294 *value
= (unsigned int) (b
[0] + (b
[1] << 8));
3296 *pelength
+= status
;
3302 coff_compute_checksum (bfd
*abfd
, unsigned int *pelength
)
3304 bfd_boolean more_data
;
3311 filepos
= (file_ptr
) 0;
3315 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
3318 more_data
= coff_read_word (abfd
, &value
, pelength
);
3320 total
= 0xffff & (total
+ (total
>> 0x10));
3325 return (0xffff & (total
+ (total
>> 0x10)));
3329 coff_apply_checksum (bfd
*abfd
)
3331 unsigned int computed
;
3332 unsigned int checksum
= 0;
3333 unsigned int peheader
;
3334 unsigned int pelength
;
3336 if (bfd_seek (abfd
, 0x3c, SEEK_SET
) != 0)
3339 if (!coff_read_word (abfd
, &peheader
, &pelength
))
3342 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3346 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3348 if (bfd_seek (abfd
, peheader
, SEEK_SET
) != 0)
3351 computed
= coff_compute_checksum (abfd
, &pelength
);
3353 checksum
= computed
+ pelength
;
3355 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3358 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3363 #endif /* COFF_IMAGE_WITH_PE */
3366 coff_write_object_contents (bfd
* abfd
)
3369 bfd_boolean hasrelocs
= FALSE
;
3370 bfd_boolean haslinno
= FALSE
;
3371 #ifdef COFF_IMAGE_WITH_PE
3372 bfd_boolean hasdebug
= FALSE
;
3375 file_ptr reloc_base
;
3376 file_ptr lineno_base
;
3378 unsigned long reloc_size
= 0, reloc_count
= 0;
3379 unsigned long lnno_size
= 0;
3380 bfd_boolean long_section_names
;
3381 asection
*text_sec
= NULL
;
3382 asection
*data_sec
= NULL
;
3383 asection
*bss_sec
= NULL
;
3384 struct internal_filehdr internal_f
;
3385 struct internal_aouthdr internal_a
;
3386 #ifdef COFF_LONG_SECTION_NAMES
3387 size_t string_size
= STRING_SIZE_SIZE
;
3390 bfd_set_error (bfd_error_system_call
);
3392 /* Make a pass through the symbol table to count line number entries and
3393 put them into the correct asections. */
3394 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3396 if (! abfd
->output_has_begun
)
3398 if (! coff_compute_section_file_positions (abfd
))
3402 reloc_base
= obj_relocbase (abfd
);
3404 /* Work out the size of the reloc and linno areas. */
3406 for (current
= abfd
->sections
; current
!= NULL
; current
=
3409 #ifdef COFF_WITH_EXTENDED_RELOC_COUNTER
3410 /* We store the actual reloc count in the first reloc's addr. */
3411 if ((obj_pe (abfd
) || obj_go32 (abfd
)) && current
->reloc_count
>= 0xffff)
3414 reloc_count
+= current
->reloc_count
;
3417 reloc_size
= reloc_count
* bfd_coff_relsz (abfd
);
3419 lineno_base
= reloc_base
+ reloc_size
;
3420 sym_base
= lineno_base
+ lnno_size
;
3422 /* Indicate in each section->line_filepos its actual file address. */
3423 for (current
= abfd
->sections
; current
!= NULL
; current
=
3426 if (current
->lineno_count
)
3428 current
->line_filepos
= lineno_base
;
3429 current
->moving_line_filepos
= lineno_base
;
3430 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3433 current
->line_filepos
= 0;
3435 if (current
->reloc_count
)
3437 current
->rel_filepos
= reloc_base
;
3438 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3439 #ifdef COFF_WITH_EXTENDED_RELOC_COUNTER
3440 /* Extra reloc to hold real count. */
3441 if ((obj_pe (abfd
) || obj_go32 (abfd
)) && current
->reloc_count
>= 0xffff)
3442 reloc_base
+= bfd_coff_relsz (abfd
);
3446 current
->rel_filepos
= 0;
3449 /* Write section headers to the file. */
3450 internal_f
.f_nscns
= 0;
3452 if ((abfd
->flags
& EXEC_P
) != 0)
3453 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3456 scn_base
= bfd_coff_filhsz (abfd
);
3459 if (xcoff_data (abfd
)->full_aouthdr
)
3460 scn_base
+= bfd_coff_aoutsz (abfd
);
3462 scn_base
+= SMALL_AOUTSZ
;
3467 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3470 long_section_names
= FALSE
;
3471 for (current
= abfd
->sections
;
3473 current
= current
->next
)
3475 struct internal_scnhdr section
;
3476 #ifdef COFF_IMAGE_WITH_PE
3477 bfd_boolean is_reloc_section
= FALSE
;
3479 if (strcmp (current
->name
, DOT_RELOC
) == 0)
3481 is_reloc_section
= TRUE
;
3483 pe_data (abfd
)->has_reloc_section
= 1;
3487 internal_f
.f_nscns
++;
3489 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3491 #ifdef COFF_LONG_SECTION_NAMES
3492 /* Handle long section names as in PE. This must be compatible
3493 with the code in coff_write_symbols and _bfd_coff_final_link. */
3494 if (bfd_coff_long_section_names (abfd
))
3498 len
= strlen (current
->name
);
3501 /* The s_name field is defined to be NUL-padded but need not be
3502 NUL-terminated. We use a temporary buffer so that we can still
3503 sprintf all eight chars without splatting a terminating NUL
3504 over the first byte of the following member (s_paddr). */
3505 /* PR 21096: The +20 is to stop a bogus warning from gcc7 about
3506 a possible buffer overflow. */
3507 char s_name_buf
[SCNNMLEN
+ 1 + 20];
3509 /* An inherent limitation of the /nnnnnnn notation used to indicate
3510 the offset of the long name in the string table is that we
3511 cannot address entries beyone the ten million byte boundary. */
3512 if (string_size
>= 10000000)
3514 bfd_set_error (bfd_error_file_too_big
);
3516 /* xgettext:c-format */
3517 (_("%pB: section %pA: string table overflow at offset %ld"),
3518 abfd
, current
, (unsigned long) string_size
);
3522 /* We do not need to use snprintf here as we have already verfied
3523 that string_size is not too big, plus we have an overlarge
3524 buffer, just in case. */
3525 sprintf (s_name_buf
, "/%lu", (unsigned long) string_size
);
3526 /* Then strncpy takes care of any padding for us. */
3527 strncpy (section
.s_name
, s_name_buf
, SCNNMLEN
);
3528 string_size
+= len
+ 1;
3529 long_section_names
= TRUE
;
3535 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3536 Ian Taylor <ian@cygnus.com>. */
3537 if (strcmp (current
->name
, _LIB
) == 0)
3538 section
.s_vaddr
= 0;
3541 section
.s_vaddr
= current
->vma
;
3542 section
.s_paddr
= current
->lma
;
3543 section
.s_size
= current
->size
;
3544 #ifdef coff_get_section_load_page
3545 section
.s_page
= coff_get_section_load_page (current
);
3551 section
.s_paddr
= 0;
3553 #ifdef COFF_IMAGE_WITH_PE
3554 /* Reminder: s_paddr holds the virtual size of the section. */
3555 if (coff_section_data (abfd
, current
) != NULL
3556 && pei_section_data (abfd
, current
) != NULL
)
3557 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3559 section
.s_paddr
= 0;
3562 /* If this section has no size or is unloadable then the scnptr
3564 if (current
->size
== 0
3565 || (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3566 section
.s_scnptr
= 0;
3568 section
.s_scnptr
= current
->filepos
;
3570 section
.s_relptr
= current
->rel_filepos
;
3571 section
.s_lnnoptr
= current
->line_filepos
;
3572 section
.s_nreloc
= current
->reloc_count
;
3573 section
.s_nlnno
= current
->lineno_count
;
3574 #ifndef COFF_IMAGE_WITH_PE
3575 /* In PEI, relocs come in the .reloc section. */
3576 if (current
->reloc_count
!= 0)
3579 if (current
->lineno_count
!= 0)
3581 #ifdef COFF_IMAGE_WITH_PE
3582 if ((current
->flags
& SEC_DEBUGGING
) != 0
3583 && ! is_reloc_section
)
3589 /* Indicate the use of an XCOFF overflow section header. */
3590 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3592 section
.s_nreloc
= 0xffff;
3593 section
.s_nlnno
= 0xffff;
3598 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3600 if (!strcmp (current
->name
, _TEXT
))
3602 else if (!strcmp (current
->name
, _DATA
))
3604 else if (!strcmp (current
->name
, _BSS
))
3607 #ifdef COFF_ENCODE_ALIGNMENT
3608 COFF_ENCODE_ALIGNMENT(section
, current
->alignment_power
);
3609 if ((unsigned int)COFF_DECODE_ALIGNMENT(section
.s_flags
)
3610 != current
->alignment_power
)
3612 bfd_boolean warn
= coff_data (abfd
)->link_info
3613 && !bfd_link_relocatable (coff_data (abfd
)->link_info
);
3616 /* xgettext:c-format */
3617 (_("%pB:%s section %s: alignment 2**%u not representable"),
3618 abfd
, warn
? " warning:" : "", current
->name
,
3619 current
->alignment_power
);
3622 bfd_set_error (bfd_error_nonrepresentable_section
);
3628 #ifdef COFF_IMAGE_WITH_PE
3629 /* Suppress output of the sections if they are null. ld
3630 includes the bss and data sections even if there is no size
3631 assigned to them. NT loader doesn't like it if these section
3632 headers are included if the sections themselves are not
3633 needed. See also coff_compute_section_file_positions. */
3634 if (section
.s_size
== 0)
3635 internal_f
.f_nscns
--;
3640 bfd_size_type amt
= bfd_coff_scnhsz (abfd
);
3642 if (bfd_coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3643 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3648 /* PE stores COMDAT section information in the symbol table. If
3649 this section is supposed to have some COMDAT info, track down
3650 the symbol in the symbol table and modify it. */
3651 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3653 unsigned int i
, count
;
3655 coff_symbol_type
*csym
= NULL
;
3659 count
= bfd_get_symcount (abfd
);
3660 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3662 if ((*psym
)->section
!= current
)
3665 /* Remember the location of the first symbol in this
3667 if (psymsec
== NULL
)
3670 /* See if this is the section symbol. */
3671 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3673 csym
= coff_symbol_from (*psym
);
3675 || csym
->native
== NULL
3676 || ! csym
->native
->is_sym
3677 || csym
->native
->u
.syment
.n_numaux
< 1
3678 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3679 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3682 /* Here *PSYM is the section symbol for CURRENT. */
3689 Note that we might not if we're converting the file from
3690 some other object file format. */
3693 combined_entry_type
*aux
;
3695 /* We don't touch the x_checksum field. The
3696 x_associated field is not currently supported. */
3698 aux
= csym
->native
+ 1;
3699 BFD_ASSERT (! aux
->is_sym
);
3700 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3702 case SEC_LINK_DUPLICATES_DISCARD
:
3703 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3706 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3707 aux
->u
.auxent
.x_scn
.x_comdat
=
3708 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3711 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3712 aux
->u
.auxent
.x_scn
.x_comdat
=
3713 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3716 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3717 aux
->u
.auxent
.x_scn
.x_comdat
=
3718 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3722 /* The COMDAT symbol must be the first symbol from this
3723 section in the symbol table. In order to make this
3724 work, we move the COMDAT symbol before the first
3725 symbol we found in the search above. It's OK to
3726 rearrange the symbol table at this point, because
3727 coff_renumber_symbols is going to rearrange it
3728 further and fix up all the aux entries. */
3729 if (psym
!= psymsec
)
3735 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3736 pcopy
[0] = pcopy
[-1];
3741 #endif /* COFF_WITH_PE */
3746 /* XCOFF handles overflows in the reloc and line number count fields
3747 by creating a new section header to hold the correct values. */
3748 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3750 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3752 struct internal_scnhdr scnhdr
;
3756 internal_f
.f_nscns
++;
3757 memcpy (scnhdr
.s_name
, ".ovrflo", 8);
3758 scnhdr
.s_paddr
= current
->reloc_count
;
3759 scnhdr
.s_vaddr
= current
->lineno_count
;
3761 scnhdr
.s_scnptr
= 0;
3762 scnhdr
.s_relptr
= current
->rel_filepos
;
3763 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3764 scnhdr
.s_nreloc
= current
->target_index
;
3765 scnhdr
.s_nlnno
= current
->target_index
;
3766 scnhdr
.s_flags
= STYP_OVRFLO
;
3767 amt
= bfd_coff_scnhsz (abfd
);
3768 if (bfd_coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3769 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3776 #if defined (COFF_GO32_EXE) || defined (COFF_GO32)
3777 /* Pad section headers. */
3778 if ((abfd
->flags
& EXEC_P
) && abfd
->sections
!= NULL
)
3780 file_ptr cur_ptr
= scn_base
3781 + abfd
->section_count
* bfd_coff_scnhsz (abfd
);
3782 long fill_size
= (abfd
->sections
->filepos
- cur_ptr
);
3783 bfd_byte
*b
= bfd_zmalloc (fill_size
);
3786 bfd_bwrite ((PTR
)b
, fill_size
, abfd
);
3792 /* OK, now set up the filehdr... */
3794 /* Don't include the internal abs section in the section count */
3796 /* We will NOT put a fucking timestamp in the header here. Every time you
3797 put it back, I will come in and take it out again. I'm sorry. This
3798 field does not belong here. We fill it with a 0 so it compares the
3799 same but is not a reasonable time. -- gnu@cygnus.com */
3800 internal_f
.f_timdat
= 0;
3801 internal_f
.f_flags
= 0;
3803 if (abfd
->flags
& EXEC_P
)
3804 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3807 internal_f
.f_opthdr
= 0;
3810 if (xcoff_data (abfd
)->full_aouthdr
)
3811 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3813 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
3819 internal_f
.f_flags
|= F_RELFLG
;
3821 internal_f
.f_flags
|= F_LNNO
;
3822 if (abfd
->flags
& EXEC_P
)
3823 internal_f
.f_flags
|= F_EXEC
;
3824 #ifdef COFF_IMAGE_WITH_PE
3826 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
3827 if (pe_data (abfd
)->real_flags
& IMAGE_FILE_LARGE_ADDRESS_AWARE
)
3828 internal_f
.f_flags
|= IMAGE_FILE_LARGE_ADDRESS_AWARE
;
3831 #ifndef COFF_WITH_pex64
3833 internal_f
.f_flags
|= IMAGE_FILE_32BIT_MACHINE
;
3835 if (bfd_little_endian (abfd
))
3836 internal_f
.f_flags
|= F_AR32WR
;
3838 internal_f
.f_flags
|= F_AR32W
;
3843 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
3844 but it doesn't hurt to set it internally. */
3845 internal_f
.f_target_id
= TI_TARGET_ID
;
3848 /* FIXME, should do something about the other byte orders and
3852 if ((abfd
->flags
& DYNAMIC
) != 0)
3853 internal_f
.f_flags
|= F_SHROBJ
;
3854 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
3855 internal_f
.f_flags
|= F_DYNLOAD
;
3858 memset (&internal_a
, 0, sizeof internal_a
);
3860 /* Set up architecture-dependent stuff. */
3862 unsigned int magic
= 0;
3863 unsigned short flags
= 0;
3865 coff_set_flags (abfd
, &magic
, &flags
);
3866 internal_f
.f_magic
= magic
;
3867 internal_f
.f_flags
|= flags
;
3868 /* ...and the "opt"hdr... */
3870 #ifdef TICOFF_AOUT_MAGIC
3871 internal_a
.magic
= TICOFF_AOUT_MAGIC
;
3872 #define __A_MAGIC_SET__
3876 #define __A_MAGIC_SET__
3877 internal_a
.magic
= ZMAGIC
;
3880 #if defined MCORE_PE
3881 #define __A_MAGIC_SET__
3882 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3886 #define __A_MAGIC_SET__
3888 internal_a
.magic
= LYNXCOFFMAGIC
;
3890 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR64_MAGIC
;
3892 internal_a
.magic
= ZMAGIC
;
3897 #define __A_MAGIC_SET__
3898 internal_a
.magic
= PE32PMAGIC
;
3902 #define __A_MAGIC_SET__
3904 internal_a
.magic
= LYNXCOFFMAGIC
;
3909 #define __A_MAGIC_SET__
3910 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
3911 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
3912 RS6K_AOUTHDR_OMAGIC
;
3915 #if defined(SH) && defined(COFF_WITH_PE)
3916 #define __A_MAGIC_SET__
3917 internal_a
.magic
= SH_PE_MAGIC
;
3920 #if defined(MIPS) && defined(COFF_WITH_PE)
3921 #define __A_MAGIC_SET__
3922 internal_a
.magic
= MIPS_PE_MAGIC
;
3925 #ifndef __A_MAGIC_SET__
3926 #include "Your aouthdr magic number is not being set!"
3928 #undef __A_MAGIC_SET__
3932 /* FIXME: Does anybody ever set this to another value? */
3933 internal_a
.vstamp
= 0;
3935 /* Now should write relocs, strings, syms. */
3936 obj_sym_filepos (abfd
) = sym_base
;
3938 if (bfd_get_symcount (abfd
) != 0)
3942 if (!coff_renumber_symbols (abfd
, &firstundef
))
3944 coff_mangle_symbols (abfd
);
3945 if (! coff_write_symbols (abfd
))
3947 if (! coff_write_linenumbers (abfd
))
3949 if (! coff_write_relocs (abfd
, firstundef
))
3952 #ifdef COFF_LONG_SECTION_NAMES
3953 else if (long_section_names
&& ! obj_coff_strings_written (abfd
))
3955 /* If we have long section names we have to write out the string
3956 table even if there are no symbols. */
3957 if (! coff_write_symbols (abfd
))
3961 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3962 backend linker, and obj_raw_syment_count is not valid until after
3963 coff_write_symbols is called. */
3964 if (obj_raw_syment_count (abfd
) != 0)
3966 internal_f
.f_symptr
= sym_base
;
3968 /* AIX appears to require that F_RELFLG not be set if there are
3969 local symbols but no relocations. */
3970 internal_f
.f_flags
&=~ F_RELFLG
;
3975 if (long_section_names
)
3976 internal_f
.f_symptr
= sym_base
;
3978 internal_f
.f_symptr
= 0;
3979 internal_f
.f_flags
|= F_LSYMS
;
3984 internal_a
.tsize
= text_sec
->size
;
3985 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
3989 internal_a
.dsize
= data_sec
->size
;
3990 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
3994 internal_a
.bsize
= bss_sec
->size
;
3995 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
3996 internal_a
.data_start
= bss_sec
->vma
;
3999 internal_a
.entry
= bfd_get_start_address (abfd
);
4000 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
4003 if (xcoff_data (abfd
)->full_aouthdr
)
4006 asection
*loader_sec
;
4008 internal_a
.vstamp
= 1;
4010 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
4011 if (internal_a
.o_snentry
== 0)
4012 internal_a
.entry
= (bfd_vma
) -1;
4014 if (text_sec
!= NULL
)
4016 internal_a
.o_sntext
= text_sec
->target_index
;
4017 internal_a
.o_algntext
= bfd_section_alignment (text_sec
);
4021 internal_a
.o_sntext
= 0;
4022 internal_a
.o_algntext
= 0;
4024 if (data_sec
!= NULL
)
4026 internal_a
.o_sndata
= data_sec
->target_index
;
4027 internal_a
.o_algndata
= bfd_section_alignment (data_sec
);
4031 internal_a
.o_sndata
= 0;
4032 internal_a
.o_algndata
= 0;
4034 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
4035 if (loader_sec
!= NULL
)
4036 internal_a
.o_snloader
= loader_sec
->target_index
;
4038 internal_a
.o_snloader
= 0;
4039 if (bss_sec
!= NULL
)
4040 internal_a
.o_snbss
= bss_sec
->target_index
;
4042 internal_a
.o_snbss
= 0;
4044 toc
= xcoff_data (abfd
)->toc
;
4045 internal_a
.o_toc
= toc
;
4046 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
4048 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
4049 if (xcoff_data (abfd
)->cputype
!= -1)
4050 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
4053 switch (bfd_get_arch (abfd
))
4055 case bfd_arch_rs6000
:
4056 internal_a
.o_cputype
= 4;
4058 case bfd_arch_powerpc
:
4059 if (bfd_get_mach (abfd
) == bfd_mach_ppc
)
4060 internal_a
.o_cputype
= 3;
4062 internal_a
.o_cputype
= 1;
4068 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
4069 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
4075 /* After object contents are finalized so we can compute a reasonable hash,
4076 but before header is written so we can update it to point to debug directory. */
4077 struct pe_tdata
*pe
= pe_data (abfd
);
4079 if (pe
->build_id
.after_write_object_contents
!= NULL
)
4080 (*pe
->build_id
.after_write_object_contents
) (abfd
);
4084 /* Now write header. */
4085 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
4090 bfd_size_type amount
= bfd_coff_filhsz (abfd
);
4092 buff
= (char *) bfd_malloc (amount
);
4096 bfd_coff_swap_filehdr_out (abfd
, & internal_f
, buff
);
4097 amount
= bfd_bwrite (buff
, amount
, abfd
);
4101 if (amount
!= bfd_coff_filhsz (abfd
))
4105 if (abfd
->flags
& EXEC_P
)
4107 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4108 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4110 bfd_size_type amount
= bfd_coff_aoutsz (abfd
);
4112 buff
= (char *) bfd_malloc (amount
);
4116 coff_swap_aouthdr_out (abfd
, & internal_a
, buff
);
4117 amount
= bfd_bwrite (buff
, amount
, abfd
);
4121 if (amount
!= bfd_coff_aoutsz (abfd
))
4124 #ifdef COFF_IMAGE_WITH_PE
4125 if (! coff_apply_checksum (abfd
))
4135 /* XCOFF seems to always write at least a small a.out header. */
4136 coff_swap_aouthdr_out (abfd
, & internal_a
, & buff
);
4137 if (xcoff_data (abfd
)->full_aouthdr
)
4138 size
= bfd_coff_aoutsz (abfd
);
4140 size
= SMALL_AOUTSZ
;
4141 if (bfd_bwrite (& buff
, (bfd_size_type
) size
, abfd
) != size
)
4150 coff_set_section_contents (bfd
* abfd
,
4152 const void * location
,
4154 bfd_size_type count
)
4156 if (! abfd
->output_has_begun
) /* Set by bfd.c handler. */
4158 if (! coff_compute_section_file_positions (abfd
))
4162 #if defined(_LIB) && !defined(TARG_AUX)
4163 /* The physical address field of a .lib section is used to hold the
4164 number of shared libraries in the section. This code counts the
4165 number of sections being written, and increments the lma field
4168 I have found no documentation on the contents of this section.
4169 Experimentation indicates that the section contains zero or more
4170 records, each of which has the following structure:
4172 - a (four byte) word holding the length of this record, in words,
4173 - a word that always seems to be set to "2",
4174 - the path to a shared library, null-terminated and then padded
4175 to a whole word boundary.
4177 bfd_assert calls have been added to alert if an attempt is made
4178 to write a section which doesn't follow these assumptions. The
4179 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4180 <robertl@arnet.com> (Thanks!).
4182 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4183 if (strcmp (section
->name
, _LIB
) == 0)
4185 bfd_byte
*rec
, *recend
;
4187 rec
= (bfd_byte
*) location
;
4188 recend
= rec
+ count
;
4189 while (rec
< recend
)
4192 rec
+= bfd_get_32 (abfd
, rec
) * 4;
4195 BFD_ASSERT (rec
== recend
);
4199 /* Don't write out bss sections - one way to do this is to
4200 see if the filepos has not been set. */
4201 if (section
->filepos
== 0)
4204 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0)
4210 return bfd_bwrite (location
, count
, abfd
) == count
;
4214 buy_and_read (bfd
*abfd
, file_ptr where
,
4215 bfd_size_type nmemb
, bfd_size_type size
)
4219 if (_bfd_mul_overflow (nmemb
, size
, &amt
))
4221 bfd_set_error (bfd_error_file_too_big
);
4224 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
4226 return _bfd_alloc_and_read (abfd
, amt
, amt
);
4233 Creating the linenumber table is done by reading in the entire
4234 coff linenumber table, and creating another table for internal use.
4236 A coff linenumber table is structured so that each function
4237 is marked as having a line number of 0. Each line within the
4238 function is an offset from the first line in the function. The
4239 base of the line number information for the table is stored in
4240 the symbol associated with the function.
4242 Note: The PE format uses line number 0 for a flag indicating a
4245 The information is copied from the external to the internal
4246 table, and each symbol which marks a function is marked by
4249 How does this work ?
4253 coff_sort_func_alent (const void * arg1
, const void * arg2
)
4255 const alent
*al1
= *(const alent
**) arg1
;
4256 const alent
*al2
= *(const alent
**) arg2
;
4257 const coff_symbol_type
*s1
= (const coff_symbol_type
*) (al1
->u
.sym
);
4258 const coff_symbol_type
*s2
= (const coff_symbol_type
*) (al2
->u
.sym
);
4260 if (s1
== NULL
|| s2
== NULL
)
4262 if (s1
->symbol
.value
< s2
->symbol
.value
)
4264 else if (s1
->symbol
.value
> s2
->symbol
.value
)
4271 coff_slurp_line_table (bfd
*abfd
, asection
*asect
)
4273 LINENO
*native_lineno
;
4274 alent
*lineno_cache
;
4275 unsigned int counter
;
4277 bfd_vma prev_offset
= 0;
4278 bfd_boolean ordered
= TRUE
;
4279 unsigned int nbr_func
;
4281 bfd_boolean have_func
;
4282 bfd_boolean ret
= TRUE
;
4285 if (asect
->lineno_count
== 0)
4288 BFD_ASSERT (asect
->lineno
== NULL
);
4290 if (asect
->lineno_count
> asect
->size
)
4293 (_("%pB: warning: line number count (%#lx) exceeds section size (%#lx)"),
4294 abfd
, (unsigned long) asect
->lineno_count
, (unsigned long) asect
->size
);
4298 if (_bfd_mul_overflow (asect
->lineno_count
+ 1, sizeof (alent
), &amt
))
4300 bfd_set_error (bfd_error_file_too_big
);
4303 lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
);
4304 if (lineno_cache
== NULL
)
4307 native_lineno
= (LINENO
*) buy_and_read (abfd
, asect
->line_filepos
,
4308 asect
->lineno_count
,
4309 bfd_coff_linesz (abfd
));
4310 if (native_lineno
== NULL
)
4313 (_("%pB: warning: line number table read failed"), abfd
);
4314 bfd_release (abfd
, lineno_cache
);
4318 cache_ptr
= lineno_cache
;
4319 asect
->lineno
= lineno_cache
;
4320 src
= native_lineno
;
4324 for (counter
= 0; counter
< asect
->lineno_count
; counter
++, src
++)
4326 struct internal_lineno dst
;
4328 bfd_coff_swap_lineno_in (abfd
, src
, &dst
);
4329 cache_ptr
->line_number
= dst
.l_lnno
;
4330 /* Appease memory checkers that get all excited about
4331 uninitialised memory when copying alents if u.offset is
4332 larger than u.sym. (64-bit BFD on 32-bit host.) */
4333 memset (&cache_ptr
->u
, 0, sizeof (cache_ptr
->u
));
4335 if (cache_ptr
->line_number
== 0)
4337 combined_entry_type
* ent
;
4338 unsigned long symndx
;
4339 coff_symbol_type
*sym
;
4342 symndx
= dst
.l_addr
.l_symndx
;
4343 if (symndx
>= obj_raw_syment_count (abfd
))
4346 /* xgettext:c-format */
4347 (_("%pB: warning: illegal symbol index 0x%lx in line number entry %d"),
4348 abfd
, symndx
, counter
);
4349 cache_ptr
->line_number
= -1;
4354 ent
= obj_raw_syments (abfd
) + symndx
;
4355 /* FIXME: We should not be casting between ints and
4356 pointers like this. */
4360 /* xgettext:c-format */
4361 (_("%pB: warning: illegal symbol index 0x%lx in line number entry %d"),
4362 abfd
, symndx
, counter
);
4363 cache_ptr
->line_number
= -1;
4367 sym
= (coff_symbol_type
*) (ent
->u
.syment
._n
._n_n
._n_zeroes
);
4369 /* PR 17512 file: 078-10659-0.004 */
4370 if (sym
< obj_symbols (abfd
)
4371 || sym
>= obj_symbols (abfd
) + bfd_get_symcount (abfd
))
4374 /* xgettext:c-format */
4375 (_("%pB: warning: illegal symbol in line number entry %d"),
4377 cache_ptr
->line_number
= -1;
4384 cache_ptr
->u
.sym
= (asymbol
*) sym
;
4385 if (sym
->lineno
!= NULL
)
4387 /* xgettext:c-format */
4388 (_("%pB: warning: duplicate line number information for `%s'"),
4389 abfd
, bfd_asymbol_name (&sym
->symbol
));
4391 sym
->lineno
= cache_ptr
;
4392 if (sym
->symbol
.value
< prev_offset
)
4394 prev_offset
= sym
->symbol
.value
;
4396 else if (!have_func
)
4397 /* Drop line information that has no associated function.
4398 PR 17521: file: 078-10659-0.004. */
4401 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
- bfd_section_vma (asect
);
4405 asect
->lineno_count
= cache_ptr
- lineno_cache
;
4406 memset (cache_ptr
, 0, sizeof (*cache_ptr
));
4407 bfd_release (abfd
, native_lineno
);
4409 /* On some systems (eg AIX5.3) the lineno table may not be sorted. */
4412 /* Sort the table. */
4414 alent
*n_lineno_cache
;
4416 /* Create a table of functions. */
4417 if (_bfd_mul_overflow (nbr_func
, sizeof (alent
*), &amt
))
4419 bfd_set_error (bfd_error_file_too_big
);
4422 else if ((func_table
= (alent
**) bfd_alloc (abfd
, amt
)) != NULL
)
4424 alent
**p
= func_table
;
4427 for (i
= 0; i
< asect
->lineno_count
; i
++)
4428 if (lineno_cache
[i
].line_number
== 0)
4429 *p
++ = &lineno_cache
[i
];
4431 BFD_ASSERT ((unsigned int) (p
- func_table
) == nbr_func
);
4433 /* Sort by functions. */
4434 qsort (func_table
, nbr_func
, sizeof (alent
*), coff_sort_func_alent
);
4436 /* Create the new sorted table. */
4437 if (_bfd_mul_overflow (asect
->lineno_count
, sizeof (alent
), &amt
))
4439 bfd_set_error (bfd_error_file_too_big
);
4442 else if ((n_lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
)) != NULL
)
4444 alent
*n_cache_ptr
= n_lineno_cache
;
4446 for (i
= 0; i
< nbr_func
; i
++)
4448 coff_symbol_type
*sym
;
4449 alent
*old_ptr
= func_table
[i
];
4451 /* Update the function entry. */
4452 sym
= (coff_symbol_type
*) old_ptr
->u
.sym
;
4453 /* PR binutils/17512: Point the lineno to where
4454 this entry will be after the memcpy below. */
4455 sym
->lineno
= lineno_cache
+ (n_cache_ptr
- n_lineno_cache
);
4456 /* Copy the function and line number entries. */
4458 *n_cache_ptr
++ = *old_ptr
++;
4459 while (old_ptr
->line_number
!= 0);
4462 memcpy (lineno_cache
, n_lineno_cache
,
4463 asect
->lineno_count
* sizeof (alent
));
4467 bfd_release (abfd
, func_table
);
4476 /* Slurp in the symbol table, converting it to generic form. Note
4477 that if coff_relocate_section is defined, the linker will read
4478 symbols via coff_link_add_symbols, rather than via this routine. */
4481 coff_slurp_symbol_table (bfd
* abfd
)
4483 combined_entry_type
*native_symbols
;
4484 coff_symbol_type
*cached_area
;
4485 unsigned int *table_ptr
;
4486 unsigned int number_of_symbols
= 0;
4487 bfd_boolean ret
= TRUE
;
4490 if (obj_symbols (abfd
))
4493 /* Read in the symbol table. */
4494 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4497 /* Allocate enough room for all the symbols in cached form. */
4498 if (_bfd_mul_overflow (obj_raw_syment_count (abfd
),
4499 sizeof (*cached_area
), &amt
))
4501 bfd_set_error (bfd_error_file_too_big
);
4504 cached_area
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
4505 if (cached_area
== NULL
)
4508 if (_bfd_mul_overflow (obj_raw_syment_count (abfd
),
4509 sizeof (*table_ptr
), &amt
))
4511 bfd_set_error (bfd_error_file_too_big
);
4514 table_ptr
= (unsigned int *) bfd_zalloc (abfd
, amt
);
4515 if (table_ptr
== NULL
)
4519 coff_symbol_type
*dst
= cached_area
;
4520 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4521 unsigned int this_index
= 0;
4523 while (this_index
< last_native_index
)
4525 combined_entry_type
*src
= native_symbols
+ this_index
;
4526 table_ptr
[this_index
] = number_of_symbols
;
4528 dst
->symbol
.the_bfd
= abfd
;
4529 BFD_ASSERT (src
->is_sym
);
4530 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4531 /* We use the native name field to point to the cached field. */
4532 src
->u
.syment
._n
._n_n
._n_zeroes
= (bfd_hostptr_t
) dst
;
4533 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4534 src
->u
.syment
.n_scnum
);
4535 dst
->symbol
.flags
= 0;
4536 /* PR 17512: file: 079-7098-0.001:0.1. */
4537 dst
->symbol
.value
= 0;
4538 dst
->done_lineno
= FALSE
;
4540 switch (src
->u
.syment
.n_sclass
)
4546 case C_THUMBEXTFUNC
:
4550 #if ! defined _AIX52 && ! defined AIX_WEAK_SUPPORT
4555 case C_SYSTEM
: /* System Wide variable. */
4558 /* In PE, 0x68 (104) denotes a section symbol. */
4560 /* In PE, 0x69 (105) denotes a weak external symbol. */
4563 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4565 case COFF_SYMBOL_GLOBAL
:
4566 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4567 #if defined COFF_WITH_PE
4568 /* PE sets the symbol to a value relative to the
4569 start of the section. */
4570 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4572 dst
->symbol
.value
= (src
->u
.syment
.n_value
4573 - dst
->symbol
.section
->vma
);
4575 if (ISFCN ((src
->u
.syment
.n_type
)))
4576 /* A function ext does not go at the end of a
4578 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4581 case COFF_SYMBOL_COMMON
:
4582 dst
->symbol
.section
= bfd_com_section_ptr
;
4583 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4586 case COFF_SYMBOL_UNDEFINED
:
4587 dst
->symbol
.section
= bfd_und_section_ptr
;
4588 dst
->symbol
.value
= 0;
4591 case COFF_SYMBOL_PE_SECTION
:
4592 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4593 dst
->symbol
.value
= 0;
4596 case COFF_SYMBOL_LOCAL
:
4597 dst
->symbol
.flags
= BSF_LOCAL
;
4598 #if defined COFF_WITH_PE
4599 /* PE sets the symbol to a value relative to the
4600 start of the section. */
4601 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4603 dst
->symbol
.value
= (src
->u
.syment
.n_value
4604 - dst
->symbol
.section
->vma
);
4606 if (ISFCN ((src
->u
.syment
.n_type
)))
4607 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4612 /* A symbol with a csect entry should not go at the end. */
4613 if (src
->u
.syment
.n_numaux
> 0)
4614 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4618 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4619 dst
->symbol
.flags
|= BSF_WEAK
;
4621 if (src
->u
.syment
.n_sclass
== C_SECTION
4622 && src
->u
.syment
.n_scnum
> 0)
4623 dst
->symbol
.flags
= BSF_LOCAL
;
4625 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
4627 || src
->u
.syment
.n_sclass
== C_AIX_WEAKEXT
4630 dst
->symbol
.flags
|= BSF_WEAK
;
4634 case C_STAT
: /* Static. */
4636 case C_THUMBSTAT
: /* Thumb static. */
4637 case C_THUMBLABEL
: /* Thumb label. */
4638 case C_THUMBSTATFUNC
:/* Thumb static function. */
4641 case C_DWARF
: /* A label in a dwarf section. */
4642 case C_INFO
: /* A label in a comment section. */
4644 case C_LABEL
: /* Label. */
4645 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4646 dst
->symbol
.flags
= BSF_DEBUGGING
;
4648 dst
->symbol
.flags
= BSF_LOCAL
;
4650 /* Base the value as an index from the base of the
4651 section, if there is one. */
4652 if (dst
->symbol
.section
)
4654 #if defined COFF_WITH_PE
4655 /* PE sets the symbol to a value relative to the
4656 start of the section. */
4657 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4659 dst
->symbol
.value
= (src
->u
.syment
.n_value
4660 - dst
->symbol
.section
->vma
);
4664 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4667 case C_MOS
: /* Member of structure. */
4668 case C_EOS
: /* End of structure. */
4669 case C_REGPARM
: /* Register parameter. */
4670 case C_REG
: /* register variable. */
4671 /* C_AUTOARG conflicts with TI COFF C_UEXT. */
4672 case C_TPDEF
: /* Type definition. */
4674 case C_AUTO
: /* Automatic variable. */
4675 case C_FIELD
: /* Bit field. */
4676 case C_ENTAG
: /* Enumeration tag. */
4677 case C_MOE
: /* Member of enumeration. */
4678 case C_MOU
: /* Member of union. */
4679 case C_UNTAG
: /* Union tag. */
4680 dst
->symbol
.flags
= BSF_DEBUGGING
;
4681 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4684 case C_FILE
: /* File name. */
4685 case C_STRTAG
: /* Structure tag. */
4702 dst
->symbol
.flags
= BSF_DEBUGGING
;
4703 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4707 case C_BINCL
: /* Beginning of include file. */
4708 case C_EINCL
: /* Ending of include file. */
4709 /* The value is actually a pointer into the line numbers
4710 of the file. We locate the line number entry, and
4711 set the section to the section which contains it, and
4712 the value to the index in that section. */
4716 dst
->symbol
.flags
= BSF_DEBUGGING
;
4717 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4718 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4719 && ((file_ptr
) (sec
->line_filepos
4720 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4721 > (file_ptr
) src
->u
.syment
.n_value
))
4724 dst
->symbol
.value
= 0;
4727 dst
->symbol
.section
= sec
;
4728 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4729 - sec
->line_filepos
)
4730 / bfd_coff_linesz (abfd
));
4737 dst
->symbol
.flags
= BSF_DEBUGGING
;
4739 /* The value is actually a symbol index. Save a pointer
4740 to the symbol instead of the index. FIXME: This
4741 should use a union. */
4742 src
->u
.syment
.n_value
=
4743 (long) (intptr_t) (native_symbols
+ src
->u
.syment
.n_value
);
4744 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4749 case C_BLOCK
: /* ".bb" or ".eb". */
4750 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf"). */
4751 case C_EFCN
: /* Physical end of function. */
4752 #if defined COFF_WITH_PE
4753 /* PE sets the symbol to a value relative to the start
4755 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4756 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4758 /* PE uses funny values for .ef and .lf; don't
4760 dst
->symbol
.flags
= BSF_DEBUGGING
;
4763 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4765 /* Base the value as an index from the base of the
4767 dst
->symbol
.flags
= BSF_LOCAL
;
4768 dst
->symbol
.value
= (src
->u
.syment
.n_value
4769 - dst
->symbol
.section
->vma
);
4773 case C_STATLAB
: /* Static load time label. */
4774 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4775 dst
->symbol
.flags
= BSF_GLOBAL
;
4779 /* PE DLLs sometimes have zeroed out symbols for some
4780 reason. Just ignore them without a warning. */
4781 if (src
->u
.syment
.n_type
== 0
4782 && src
->u
.syment
.n_value
== 0
4783 && src
->u
.syment
.n_scnum
== 0)
4786 /* XCOFF specific: deleted entry. */
4787 if (src
->u
.syment
.n_value
== C_NULL_VALUE
)
4791 case C_EXTDEF
: /* External definition. */
4792 case C_ULABEL
: /* Undefined label. */
4793 case C_USTATIC
: /* Undefined static. */
4794 #ifndef COFF_WITH_PE
4795 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4796 class to represent a section symbol. */
4797 case C_LINE
: /* line # reformatted as symbol table entry. */
4798 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4799 case C_ALIAS
: /* Duplicate tag. */
4801 /* New storage classes for TI COFF. */
4803 case C_UEXT
: /* Tentative external definition. */
4805 case C_EXTLAB
: /* External load time label. */
4808 /* xgettext:c-format */
4809 (_("%pB: unrecognized storage class %d for %s symbol `%s'"),
4810 abfd
, src
->u
.syment
.n_sclass
,
4811 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4814 case C_HIDDEN
: /* Ext symbol in dmert public lib. */
4815 /* PR 20722: These symbols can also be generated by
4816 building DLLs with --gc-sections enabled. */
4817 dst
->symbol
.flags
= BSF_DEBUGGING
;
4818 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4823 dst
->symbol
.udata
.i
= 0;
4826 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
4828 number_of_symbols
++;
4832 obj_symbols (abfd
) = cached_area
;
4833 obj_raw_syments (abfd
) = native_symbols
;
4835 abfd
->symcount
= number_of_symbols
;
4836 obj_convert (abfd
) = table_ptr
;
4837 /* Slurp the line tables for each section too. */
4844 if (! coff_slurp_line_table (abfd
, p
))
4853 /* Classify a COFF symbol. A couple of targets have globally visible
4854 symbols which are not class C_EXT, and this handles those. It also
4855 recognizes some special PE cases. */
4857 static enum coff_symbol_classification
4858 coff_classify_symbol (bfd
*abfd
,
4859 struct internal_syment
*syment
)
4861 /* FIXME: This partially duplicates the switch in
4862 coff_slurp_symbol_table. */
4863 switch (syment
->n_sclass
)
4869 case C_THUMBEXTFUNC
:
4873 #if ! defined _AIX52 && ! defined AIX_WEAK_SUPPORT
4883 if (syment
->n_scnum
== 0)
4885 if (syment
->n_value
== 0)
4886 return COFF_SYMBOL_UNDEFINED
;
4888 return COFF_SYMBOL_COMMON
;
4891 if (syment
->n_sclass
== C_HIDEXT
)
4892 return COFF_SYMBOL_LOCAL
;
4894 return COFF_SYMBOL_GLOBAL
;
4901 if (syment
->n_sclass
== C_STAT
)
4903 if (syment
->n_scnum
== 0)
4904 /* The Microsoft compiler sometimes generates these if a
4905 small static function is inlined every time it is used.
4906 The function is discarded, but the symbol table entry
4908 return COFF_SYMBOL_LOCAL
;
4910 #ifdef STRICT_PE_FORMAT
4911 /* This is correct for Microsoft generated objects, but it
4912 breaks gas generated objects. */
4913 if (syment
->n_value
== 0)
4917 char buf
[SYMNMLEN
+ 1];
4919 name
= _bfd_coff_internal_syment_name (abfd
, syment
, buf
)
4920 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
4921 if (sec
!= NULL
&& name
!= NULL
4922 && (strcmp (bfd_section_name (sec
), name
) == 0))
4923 return COFF_SYMBOL_PE_SECTION
;
4927 return COFF_SYMBOL_LOCAL
;
4930 if (syment
->n_sclass
== C_SECTION
)
4932 /* In some cases in a DLL generated by the Microsoft linker, the
4933 n_value field will contain garbage. FIXME: This should
4934 probably be handled by the swapping function instead. */
4935 syment
->n_value
= 0;
4936 if (syment
->n_scnum
== 0)
4937 return COFF_SYMBOL_UNDEFINED
;
4938 return COFF_SYMBOL_PE_SECTION
;
4940 #endif /* COFF_WITH_PE */
4942 /* If it is not a global symbol, we presume it is a local symbol. */
4943 if (syment
->n_scnum
== 0)
4945 char buf
[SYMNMLEN
+ 1];
4948 /* xgettext:c-format */
4949 (_("warning: %pB: local symbol `%s' has no section"),
4950 abfd
, _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
4953 return COFF_SYMBOL_LOCAL
;
4960 Coff relocations are easily transformed into the internal BFD form
4963 Reading a coff relocation table is done in the following stages:
4965 o Read the entire coff relocation table into memory.
4967 o Process each relocation in turn; first swap it from the
4968 external to the internal form.
4970 o Turn the symbol referenced in the relocation's symbol index
4971 into a pointer into the canonical symbol table.
4972 This table is the same as the one returned by a call to
4973 @code{bfd_canonicalize_symtab}. The back end will call that
4974 routine and save the result if a canonicalization hasn't been done.
4976 o The reloc index is turned into a pointer to a howto
4977 structure, in a back end specific way. For instance, the 386
4978 uses the @code{r_type} to directly produce an index
4979 into a howto table vector.
4983 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
4985 coff_symbol_type *coffsym = NULL; \
4987 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
4988 coffsym = (obj_symbols (abfd) \
4989 + (cache_ptr->sym_ptr_ptr - symbols)); \
4991 coffsym = coff_symbol_from (ptr); \
4992 if (coffsym != NULL \
4993 && coffsym->native->is_sym \
4994 && coffsym->native->u.syment.n_scnum == 0) \
4995 cache_ptr->addend = 0; \
4996 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
4997 && ptr->section != NULL) \
4998 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
5000 cache_ptr->addend = 0; \
5005 coff_slurp_reloc_table (bfd
* abfd
, sec_ptr asect
, asymbol
** symbols
)
5007 RELOC
*native_relocs
;
5008 arelent
*reloc_cache
;
5013 if (asect
->relocation
)
5015 if (asect
->reloc_count
== 0)
5017 if (asect
->flags
& SEC_CONSTRUCTOR
)
5019 if (!coff_slurp_symbol_table (abfd
))
5022 native_relocs
= (RELOC
*) buy_and_read (abfd
, asect
->rel_filepos
,
5024 bfd_coff_relsz (abfd
));
5025 if (_bfd_mul_overflow (asect
->reloc_count
, sizeof (arelent
), &amt
))
5027 bfd_set_error (bfd_error_file_too_big
);
5030 reloc_cache
= (arelent
*) bfd_alloc (abfd
, amt
);
5031 if (reloc_cache
== NULL
|| native_relocs
== NULL
)
5034 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
5036 struct internal_reloc dst
;
5037 struct external_reloc
*src
;
5038 #ifndef RELOC_PROCESSING
5042 cache_ptr
= reloc_cache
+ idx
;
5043 src
= native_relocs
+ idx
;
5046 coff_swap_reloc_in (abfd
, src
, &dst
);
5048 #ifdef RELOC_PROCESSING
5049 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
5051 cache_ptr
->address
= dst
.r_vaddr
;
5053 if (dst
.r_symndx
!= -1 && symbols
!= NULL
)
5055 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
5058 /* xgettext:c-format */
5059 (_("%pB: warning: illegal symbol index %ld in relocs"),
5060 abfd
, dst
.r_symndx
);
5061 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5066 cache_ptr
->sym_ptr_ptr
= (symbols
5067 + obj_convert (abfd
)[dst
.r_symndx
]);
5068 ptr
= *(cache_ptr
->sym_ptr_ptr
);
5073 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5077 /* The symbols definitions that we have read in have been
5078 relocated as if their sections started at 0. But the offsets
5079 refering to the symbols in the raw data have not been
5080 modified, so we have to have a negative addend to compensate.
5082 Note that symbols which used to be common must be left alone. */
5084 /* Calculate any reloc addend by looking at the symbol. */
5085 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
5088 cache_ptr
->address
-= asect
->vma
;
5089 /* !! cache_ptr->section = NULL;*/
5091 /* Fill in the cache_ptr->howto field from dst.r_type. */
5092 RTYPE2HOWTO (cache_ptr
, &dst
);
5093 #endif /* RELOC_PROCESSING */
5095 if (cache_ptr
->howto
== NULL
)
5098 /* xgettext:c-format */
5099 (_("%pB: illegal relocation type %d at address %#" PRIx64
),
5100 abfd
, dst
.r_type
, (uint64_t) dst
.r_vaddr
);
5101 bfd_set_error (bfd_error_bad_value
);
5106 asect
->relocation
= reloc_cache
;
5110 #ifndef coff_rtype_to_howto
5113 /* Get the howto structure for a reloc. This is only used if the file
5114 including this one defines coff_relocate_section to be
5115 _bfd_coff_generic_relocate_section, so it is OK if it does not
5116 always work. It is the responsibility of the including file to
5117 make sure it is reasonable if it is needed. */
5119 static reloc_howto_type
*
5120 coff_rtype_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
5121 asection
*sec ATTRIBUTE_UNUSED
,
5122 struct internal_reloc
*rel ATTRIBUTE_UNUSED
,
5123 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
,
5124 struct internal_syment
*sym ATTRIBUTE_UNUSED
,
5125 bfd_vma
*addendp ATTRIBUTE_UNUSED
)
5129 genrel
.howto
= NULL
;
5130 RTYPE2HOWTO (&genrel
, rel
);
5131 return genrel
.howto
;
5134 #else /* ! defined (RTYPE2HOWTO) */
5136 #define coff_rtype_to_howto NULL
5138 #endif /* ! defined (RTYPE2HOWTO) */
5139 #endif /* ! defined (coff_rtype_to_howto) */
5141 /* This is stupid. This function should be a boolean predicate. */
5144 coff_canonicalize_reloc (bfd
* abfd
,
5149 arelent
*tblptr
= section
->relocation
;
5150 unsigned int count
= 0;
5152 if (section
->flags
& SEC_CONSTRUCTOR
)
5154 /* This section has relocs made up by us, they are not in the
5155 file, so take them out of their chain and place them into
5156 the data area provided. */
5157 arelent_chain
*chain
= section
->constructor_chain
;
5159 for (count
= 0; count
< section
->reloc_count
; count
++)
5161 *relptr
++ = &chain
->relent
;
5162 chain
= chain
->next
;
5167 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
5170 tblptr
= section
->relocation
;
5172 for (; count
++ < section
->reloc_count
;)
5173 *relptr
++ = tblptr
++;
5176 return section
->reloc_count
;
5179 #ifndef coff_set_reloc
5180 #define coff_set_reloc _bfd_generic_set_reloc
5183 #ifndef coff_reloc16_estimate
5184 #define coff_reloc16_estimate dummy_reloc16_estimate
5187 dummy_reloc16_estimate (bfd
*abfd ATTRIBUTE_UNUSED
,
5188 asection
*input_section ATTRIBUTE_UNUSED
,
5189 arelent
*reloc ATTRIBUTE_UNUSED
,
5190 unsigned int shrink ATTRIBUTE_UNUSED
,
5191 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
)
5199 #ifndef coff_reloc16_extra_cases
5201 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5203 /* This works even if abort is not declared in any header file. */
5206 dummy_reloc16_extra_cases (bfd
*abfd ATTRIBUTE_UNUSED
,
5207 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
5208 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
,
5209 arelent
*reloc ATTRIBUTE_UNUSED
,
5210 bfd_byte
*data ATTRIBUTE_UNUSED
,
5211 unsigned int *src_ptr ATTRIBUTE_UNUSED
,
5212 unsigned int *dst_ptr ATTRIBUTE_UNUSED
)
5218 /* If coff_relocate_section is defined, we can use the optimized COFF
5219 backend linker. Otherwise we must continue to use the old linker. */
5221 #ifdef coff_relocate_section
5223 #ifndef coff_bfd_link_hash_table_create
5224 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5226 #ifndef coff_bfd_link_add_symbols
5227 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5229 #ifndef coff_bfd_final_link
5230 #define coff_bfd_final_link _bfd_coff_final_link
5233 #else /* ! defined (coff_relocate_section) */
5235 #define coff_relocate_section NULL
5236 #ifndef coff_bfd_link_hash_table_create
5237 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5239 #ifndef coff_bfd_link_add_symbols
5240 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5242 #define coff_bfd_final_link _bfd_generic_final_link
5244 #endif /* ! defined (coff_relocate_section) */
5246 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5247 #define coff_bfd_copy_link_hash_symbol_type \
5248 _bfd_generic_copy_link_hash_symbol_type
5249 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5251 #define coff_bfd_link_check_relocs _bfd_generic_link_check_relocs
5253 #ifndef coff_start_final_link
5254 #define coff_start_final_link NULL
5257 #ifndef coff_adjust_symndx
5258 #define coff_adjust_symndx NULL
5261 #ifndef coff_link_add_one_symbol
5262 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5265 #ifndef coff_link_output_has_begun
5268 coff_link_output_has_begun (bfd
* abfd
,
5269 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
)
5271 return abfd
->output_has_begun
;
5275 #ifndef coff_final_link_postscript
5278 coff_final_link_postscript (bfd
* abfd ATTRIBUTE_UNUSED
,
5279 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
)
5285 #ifndef coff_SWAP_aux_in
5286 #define coff_SWAP_aux_in coff_swap_aux_in
5288 #ifndef coff_SWAP_sym_in
5289 #define coff_SWAP_sym_in coff_swap_sym_in
5291 #ifndef coff_SWAP_lineno_in
5292 #define coff_SWAP_lineno_in coff_swap_lineno_in
5294 #ifndef coff_SWAP_aux_out
5295 #define coff_SWAP_aux_out coff_swap_aux_out
5297 #ifndef coff_SWAP_sym_out
5298 #define coff_SWAP_sym_out coff_swap_sym_out
5300 #ifndef coff_SWAP_lineno_out
5301 #define coff_SWAP_lineno_out coff_swap_lineno_out
5303 #ifndef coff_SWAP_reloc_out
5304 #define coff_SWAP_reloc_out coff_swap_reloc_out
5306 #ifndef coff_SWAP_filehdr_out
5307 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5309 #ifndef coff_SWAP_aouthdr_out
5310 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5312 #ifndef coff_SWAP_scnhdr_out
5313 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5315 #ifndef coff_SWAP_reloc_in
5316 #define coff_SWAP_reloc_in coff_swap_reloc_in
5318 #ifndef coff_SWAP_filehdr_in
5319 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5321 #ifndef coff_SWAP_aouthdr_in
5322 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5324 #ifndef coff_SWAP_scnhdr_in
5325 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5328 static bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED
=
5330 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5331 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5332 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5333 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5334 coff_SWAP_scnhdr_out
,
5335 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5336 #ifdef COFF_LONG_FILENAMES
5341 COFF_DEFAULT_LONG_SECTION_NAMES
,
5342 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5343 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5348 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5354 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5355 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5356 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5357 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5358 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5359 coff_classify_symbol
, coff_compute_section_file_positions
,
5360 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5361 coff_adjust_symndx
, coff_link_add_one_symbol
,
5362 coff_link_output_has_begun
, coff_final_link_postscript
,
5367 /* COFF0 differs in file/section header size and relocation entry size. */
5369 static bfd_coff_backend_data ticoff0_swap_table
=
5371 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5372 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5373 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5374 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5375 coff_SWAP_scnhdr_out
,
5376 FILHSZ_V0
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ_V0
, LINESZ
, FILNMLEN
,
5377 #ifdef COFF_LONG_FILENAMES
5382 COFF_DEFAULT_LONG_SECTION_NAMES
,
5383 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5384 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5389 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5395 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5396 coff_SWAP_reloc_in
, ticoff0_bad_format_hook
, coff_set_arch_mach_hook
,
5397 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5398 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5399 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5400 coff_classify_symbol
, coff_compute_section_file_positions
,
5401 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5402 coff_adjust_symndx
, coff_link_add_one_symbol
,
5403 coff_link_output_has_begun
, coff_final_link_postscript
,
5409 /* COFF1 differs in section header size. */
5411 static bfd_coff_backend_data ticoff1_swap_table
=
5413 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5414 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5415 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5416 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5417 coff_SWAP_scnhdr_out
,
5418 FILHSZ
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5419 #ifdef COFF_LONG_FILENAMES
5424 COFF_DEFAULT_LONG_SECTION_NAMES
,
5425 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5426 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5431 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5437 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5438 coff_SWAP_reloc_in
, ticoff1_bad_format_hook
, coff_set_arch_mach_hook
,
5439 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5440 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5441 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5442 coff_classify_symbol
, coff_compute_section_file_positions
,
5443 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5444 coff_adjust_symndx
, coff_link_add_one_symbol
,
5445 coff_link_output_has_begun
, coff_final_link_postscript
,
5446 bfd_pe_print_pdata
/* huh */
5450 #ifdef COFF_WITH_PE_BIGOBJ
5451 /* The UID for bigobj files. */
5453 static const char header_bigobj_classid
[16] =
5455 0xC7, 0xA1, 0xBA, 0xD1,
5459 0xFA, 0xF6, 0x6A, 0xA4, 0xDC, 0xB8
5462 /* Swap routines. */
5465 coff_bigobj_swap_filehdr_in (bfd
* abfd
, void * src
, void * dst
)
5467 struct external_ANON_OBJECT_HEADER_BIGOBJ
*filehdr_src
=
5468 (struct external_ANON_OBJECT_HEADER_BIGOBJ
*) src
;
5469 struct internal_filehdr
*filehdr_dst
= (struct internal_filehdr
*) dst
;
5471 filehdr_dst
->f_magic
= H_GET_16 (abfd
, filehdr_src
->Machine
);
5472 filehdr_dst
->f_nscns
= H_GET_32 (abfd
, filehdr_src
->NumberOfSections
);
5473 filehdr_dst
->f_timdat
= H_GET_32 (abfd
, filehdr_src
->TimeDateStamp
);
5474 filehdr_dst
->f_symptr
=
5475 GET_FILEHDR_SYMPTR (abfd
, filehdr_src
->PointerToSymbolTable
);
5476 filehdr_dst
->f_nsyms
= H_GET_32 (abfd
, filehdr_src
->NumberOfSymbols
);
5477 filehdr_dst
->f_opthdr
= 0;
5478 filehdr_dst
->f_flags
= 0;
5480 /* Check other magic numbers. */
5481 if (H_GET_16 (abfd
, filehdr_src
->Sig1
) != IMAGE_FILE_MACHINE_UNKNOWN
5482 || H_GET_16 (abfd
, filehdr_src
->Sig2
) != 0xffff
5483 || H_GET_16 (abfd
, filehdr_src
->Version
) != 2
5484 || memcmp (filehdr_src
->ClassID
, header_bigobj_classid
, 16) != 0)
5485 filehdr_dst
->f_opthdr
= 0xffff;
5487 /* Note that CLR metadata are ignored. */
5491 coff_bigobj_swap_filehdr_out (bfd
*abfd
, void * in
, void * out
)
5493 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
5494 struct external_ANON_OBJECT_HEADER_BIGOBJ
*filehdr_out
=
5495 (struct external_ANON_OBJECT_HEADER_BIGOBJ
*) out
;
5497 memset (filehdr_out
, 0, sizeof (*filehdr_out
));
5499 H_PUT_16 (abfd
, IMAGE_FILE_MACHINE_UNKNOWN
, filehdr_out
->Sig1
);
5500 H_PUT_16 (abfd
, 0xffff, filehdr_out
->Sig2
);
5501 H_PUT_16 (abfd
, 2, filehdr_out
->Version
);
5502 memcpy (filehdr_out
->ClassID
, header_bigobj_classid
, 16);
5503 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->Machine
);
5504 H_PUT_32 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->NumberOfSections
);
5505 H_PUT_32 (abfd
, filehdr_in
->f_timdat
, filehdr_out
->TimeDateStamp
);
5506 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
,
5507 filehdr_out
->PointerToSymbolTable
);
5508 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->NumberOfSymbols
);
5510 return bfd_coff_filhsz (abfd
);
5514 coff_bigobj_swap_sym_in (bfd
* abfd
, void * ext1
, void * in1
)
5516 SYMENT_BIGOBJ
*ext
= (SYMENT_BIGOBJ
*) ext1
;
5517 struct internal_syment
*in
= (struct internal_syment
*) in1
;
5519 if (ext
->e
.e_name
[0] == 0)
5521 in
->_n
._n_n
._n_zeroes
= 0;
5522 in
->_n
._n_n
._n_offset
= H_GET_32 (abfd
, ext
->e
.e
.e_offset
);
5526 #if SYMNMLEN != E_SYMNMLEN
5527 #error we need to cope with truncating or extending SYMNMLEN
5529 memcpy (in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
5533 in
->n_value
= H_GET_32 (abfd
, ext
->e_value
);
5534 BFD_ASSERT (sizeof (in
->n_scnum
) >= 4);
5535 in
->n_scnum
= H_GET_32 (abfd
, ext
->e_scnum
);
5536 in
->n_type
= H_GET_16 (abfd
, ext
->e_type
);
5537 in
->n_sclass
= H_GET_8 (abfd
, ext
->e_sclass
);
5538 in
->n_numaux
= H_GET_8 (abfd
, ext
->e_numaux
);
5542 coff_bigobj_swap_sym_out (bfd
* abfd
, void * inp
, void * extp
)
5544 struct internal_syment
*in
= (struct internal_syment
*) inp
;
5545 SYMENT_BIGOBJ
*ext
= (SYMENT_BIGOBJ
*) extp
;
5547 if (in
->_n
._n_name
[0] == 0)
5549 H_PUT_32 (abfd
, 0, ext
->e
.e
.e_zeroes
);
5550 H_PUT_32 (abfd
, in
->_n
._n_n
._n_offset
, ext
->e
.e
.e_offset
);
5554 #if SYMNMLEN != E_SYMNMLEN
5555 #error we need to cope with truncating or extending SYMNMLEN
5557 memcpy (ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
5561 H_PUT_32 (abfd
, in
->n_value
, ext
->e_value
);
5562 H_PUT_32 (abfd
, in
->n_scnum
, ext
->e_scnum
);
5564 H_PUT_16 (abfd
, in
->n_type
, ext
->e_type
);
5565 H_PUT_8 (abfd
, in
->n_sclass
, ext
->e_sclass
);
5566 H_PUT_8 (abfd
, in
->n_numaux
, ext
->e_numaux
);
5568 return SYMESZ_BIGOBJ
;
5572 coff_bigobj_swap_aux_in (bfd
*abfd
,
5580 AUXENT_BIGOBJ
*ext
= (AUXENT_BIGOBJ
*) ext1
;
5581 union internal_auxent
*in
= (union internal_auxent
*) in1
;
5583 /* Make sure that all fields in the aux structure are
5585 memset (in
, 0, sizeof * in
);
5592 memcpy (in
->x_file
.x_fname
, ext
->File
.Name
,
5593 numaux
* sizeof (AUXENT_BIGOBJ
));
5596 memcpy (in
->x_file
.x_fname
, ext
->File
.Name
, sizeof (ext
->File
.Name
));
5604 in
->x_scn
.x_scnlen
= H_GET_32 (abfd
, ext
->Section
.Length
);
5605 in
->x_scn
.x_nreloc
=
5606 H_GET_16 (abfd
, ext
->Section
.NumberOfRelocations
);
5607 in
->x_scn
.x_nlinno
=
5608 H_GET_16 (abfd
, ext
->Section
.NumberOfLinenumbers
);
5609 in
->x_scn
.x_checksum
= H_GET_32 (abfd
, ext
->Section
.Checksum
);
5610 in
->x_scn
.x_associated
= H_GET_16 (abfd
, ext
->Section
.Number
)
5611 | (H_GET_16 (abfd
, ext
->Section
.HighNumber
) << 16);
5612 in
->x_scn
.x_comdat
= H_GET_8 (abfd
, ext
->Section
.Selection
);
5618 in
->x_sym
.x_tagndx
.l
= H_GET_32 (abfd
, ext
->Sym
.WeakDefaultSymIndex
);
5619 /* Characteristics is ignored. */
5625 coff_bigobj_swap_aux_out (bfd
* abfd
,
5629 int indx ATTRIBUTE_UNUSED
,
5630 int numaux ATTRIBUTE_UNUSED
,
5633 union internal_auxent
* in
= (union internal_auxent
*) inp
;
5634 AUXENT_BIGOBJ
*ext
= (AUXENT_BIGOBJ
*) extp
;
5636 memset (ext
, 0, AUXESZ
);
5641 memcpy (ext
->File
.Name
, in
->x_file
.x_fname
, sizeof (ext
->File
.Name
));
5650 H_PUT_32 (abfd
, in
->x_scn
.x_scnlen
, ext
->Section
.Length
);
5651 H_PUT_16 (abfd
, in
->x_scn
.x_nreloc
,
5652 ext
->Section
.NumberOfRelocations
);
5653 H_PUT_16 (abfd
, in
->x_scn
.x_nlinno
,
5654 ext
->Section
.NumberOfLinenumbers
);
5655 H_PUT_32 (abfd
, in
->x_scn
.x_checksum
, ext
->Section
.Checksum
);
5656 H_PUT_16 (abfd
, in
->x_scn
.x_associated
& 0xffff,
5657 ext
->Section
.Number
);
5658 H_PUT_16 (abfd
, (in
->x_scn
.x_associated
>> 16),
5659 ext
->Section
.HighNumber
);
5660 H_PUT_8 (abfd
, in
->x_scn
.x_comdat
, ext
->Section
.Selection
);
5666 H_PUT_32 (abfd
, in
->x_sym
.x_tagndx
.l
, ext
->Sym
.WeakDefaultSymIndex
);
5667 H_PUT_32 (abfd
, 1, ext
->Sym
.WeakSearchType
);
5672 static bfd_coff_backend_data bigobj_swap_table
=
5674 coff_bigobj_swap_aux_in
, coff_bigobj_swap_sym_in
, coff_SWAP_lineno_in
,
5675 coff_bigobj_swap_aux_out
, coff_bigobj_swap_sym_out
,
5676 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5677 coff_bigobj_swap_filehdr_out
, coff_SWAP_aouthdr_out
,
5678 coff_SWAP_scnhdr_out
,
5679 FILHSZ_BIGOBJ
, AOUTSZ
, SCNHSZ
, SYMESZ_BIGOBJ
, AUXESZ_BIGOBJ
,
5680 RELSZ
, LINESZ
, FILNMLEN_BIGOBJ
,
5682 COFF_DEFAULT_LONG_SECTION_NAMES
,
5683 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5687 coff_bigobj_swap_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5688 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5689 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5690 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5691 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5692 coff_classify_symbol
, coff_compute_section_file_positions
,
5693 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5694 coff_adjust_symndx
, coff_link_add_one_symbol
,
5695 coff_link_output_has_begun
, coff_final_link_postscript
,
5696 bfd_pe_print_pdata
/* huh */
5699 #endif /* COFF_WITH_PE_BIGOBJ */
5701 #ifndef coff_close_and_cleanup
5702 #define coff_close_and_cleanup _bfd_coff_close_and_cleanup
5705 #ifndef coff_bfd_free_cached_info
5706 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5709 #ifndef coff_get_section_contents
5710 #define coff_get_section_contents _bfd_generic_get_section_contents
5713 #ifndef coff_bfd_copy_private_symbol_data
5714 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5717 #ifndef coff_bfd_copy_private_header_data
5718 #define coff_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
5721 #ifndef coff_bfd_copy_private_section_data
5722 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5725 #ifndef coff_bfd_copy_private_bfd_data
5726 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5729 #ifndef coff_bfd_merge_private_bfd_data
5730 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5733 #ifndef coff_bfd_set_private_flags
5734 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5737 #ifndef coff_bfd_print_private_bfd_data
5738 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5741 #ifndef coff_bfd_is_local_label_name
5742 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5745 #ifndef coff_bfd_is_target_special_symbol
5746 #define coff_bfd_is_target_special_symbol _bfd_bool_bfd_asymbol_false
5749 #ifndef coff_read_minisymbols
5750 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5753 #ifndef coff_minisymbol_to_symbol
5754 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5757 /* The reloc lookup routine must be supplied by each individual COFF
5759 #ifndef coff_bfd_reloc_type_lookup
5760 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5762 #ifndef coff_bfd_reloc_name_lookup
5763 #define coff_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5766 #ifndef coff_bfd_get_relocated_section_contents
5767 #define coff_bfd_get_relocated_section_contents \
5768 bfd_generic_get_relocated_section_contents
5771 #ifndef coff_bfd_relax_section
5772 #define coff_bfd_relax_section bfd_generic_relax_section
5775 #ifndef coff_bfd_gc_sections
5776 #define coff_bfd_gc_sections bfd_coff_gc_sections
5779 #ifndef coff_bfd_lookup_section_flags
5780 #define coff_bfd_lookup_section_flags bfd_generic_lookup_section_flags
5783 #ifndef coff_bfd_merge_sections
5784 #define coff_bfd_merge_sections bfd_generic_merge_sections
5787 #ifndef coff_bfd_is_group_section
5788 #define coff_bfd_is_group_section bfd_generic_is_group_section
5791 #ifndef coff_bfd_group_name
5792 #define coff_bfd_group_name bfd_coff_group_name
5795 #ifndef coff_bfd_discard_group
5796 #define coff_bfd_discard_group bfd_generic_discard_group
5799 #ifndef coff_section_already_linked
5800 #define coff_section_already_linked \
5801 _bfd_coff_section_already_linked
5804 #ifndef coff_bfd_define_common_symbol
5805 #define coff_bfd_define_common_symbol bfd_generic_define_common_symbol
5808 #ifndef coff_bfd_link_hide_symbol
5809 #define coff_bfd_link_hide_symbol _bfd_generic_link_hide_symbol
5812 #ifndef coff_bfd_define_start_stop
5813 #define coff_bfd_define_start_stop bfd_generic_define_start_stop
5816 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5817 const bfd_target VAR = \
5820 bfd_target_coff_flavour, \
5821 BFD_ENDIAN_BIG, /* Data byte order is big. */ \
5822 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5823 /* object flags */ \
5824 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5825 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5826 /* section flags */ \
5827 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5828 UNDER, /* Leading symbol underscore. */ \
5829 '/', /* AR_pad_char. */ \
5830 15, /* AR_max_namelen. */ \
5831 0, /* match priority. */ \
5832 TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols. */ \
5834 /* Data conversion functions. */ \
5835 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5836 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5837 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5839 /* Header conversion functions. */ \
5840 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5841 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5842 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5844 { /* bfd_check_format. */ \
5845 _bfd_dummy_target, \
5847 bfd_generic_archive_p, \
5850 { /* bfd_set_format. */ \
5851 _bfd_bool_bfd_false_error, \
5853 _bfd_generic_mkarchive, \
5854 _bfd_bool_bfd_false_error \
5856 { /* bfd_write_contents. */ \
5857 _bfd_bool_bfd_false_error, \
5858 coff_write_object_contents, \
5859 _bfd_write_archive_contents, \
5860 _bfd_bool_bfd_false_error \
5863 BFD_JUMP_TABLE_GENERIC (coff), \
5864 BFD_JUMP_TABLE_COPY (coff), \
5865 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5866 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5867 BFD_JUMP_TABLE_SYMBOLS (coff), \
5868 BFD_JUMP_TABLE_RELOCS (coff), \
5869 BFD_JUMP_TABLE_WRITE (coff), \
5870 BFD_JUMP_TABLE_LINK (coff), \
5871 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5878 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5879 const bfd_target VAR = \
5882 bfd_target_coff_flavour, \
5883 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5884 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5885 /* object flags */ \
5886 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5887 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5888 /* section flags */ \
5889 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5890 UNDER, /* Leading symbol underscore. */ \
5891 '/', /* AR_pad_char. */ \
5892 15, /* AR_max_namelen. */ \
5893 0, /* match priority. */ \
5894 TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols. */ \
5896 /* Data conversion functions. */ \
5897 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5898 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5899 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5901 /* Header conversion functions. */ \
5902 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5903 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5904 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5906 { /* bfd_check_format. */ \
5907 _bfd_dummy_target, \
5909 bfd_generic_archive_p, \
5912 { /* bfd_set_format. */ \
5913 _bfd_bool_bfd_false_error, \
5915 _bfd_generic_mkarchive, \
5916 _bfd_bool_bfd_false_error \
5918 { /* bfd_write_contents. */ \
5919 _bfd_bool_bfd_false_error, \
5920 coff_write_object_contents, \
5921 _bfd_write_archive_contents, \
5922 _bfd_bool_bfd_false_error \
5925 BFD_JUMP_TABLE_GENERIC (coff), \
5926 BFD_JUMP_TABLE_COPY (coff), \
5927 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5928 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5929 BFD_JUMP_TABLE_SYMBOLS (coff), \
5930 BFD_JUMP_TABLE_RELOCS (coff), \
5931 BFD_JUMP_TABLE_WRITE (coff), \
5932 BFD_JUMP_TABLE_LINK (coff), \
5933 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5940 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5941 const bfd_target VAR = \
5944 bfd_target_coff_flavour, \
5945 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5946 BFD_ENDIAN_LITTLE, /* Header byte order is little. */ \
5947 /* object flags */ \
5948 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5949 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5950 /* section flags */ \
5951 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5952 UNDER, /* Leading symbol underscore. */ \
5953 '/', /* AR_pad_char. */ \
5954 15, /* AR_max_namelen. */ \
5955 0, /* match priority. */ \
5956 TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols. */ \
5958 /* Data conversion functions. */ \
5959 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5960 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5961 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5962 /* Header conversion functions. */ \
5963 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5964 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5965 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5967 { /* bfd_check_format. */ \
5968 _bfd_dummy_target, \
5970 bfd_generic_archive_p, \
5973 { /* bfd_set_format. */ \
5974 _bfd_bool_bfd_false_error, \
5976 _bfd_generic_mkarchive, \
5977 _bfd_bool_bfd_false_error \
5979 { /* bfd_write_contents. */ \
5980 _bfd_bool_bfd_false_error, \
5981 coff_write_object_contents, \
5982 _bfd_write_archive_contents, \
5983 _bfd_bool_bfd_false_error \
5986 BFD_JUMP_TABLE_GENERIC (coff), \
5987 BFD_JUMP_TABLE_COPY (coff), \
5988 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5989 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5990 BFD_JUMP_TABLE_SYMBOLS (coff), \
5991 BFD_JUMP_TABLE_RELOCS (coff), \
5992 BFD_JUMP_TABLE_WRITE (coff), \
5993 BFD_JUMP_TABLE_LINK (coff), \
5994 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \