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 (startswith (sec_name
, DOT_DEBUG
)
531 || startswith (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 (startswith (sec_name
, ".stab"))
541 styp_flags
= STYP_DEBUG_INFO
;
543 #ifdef COFF_LONG_SECTION_NAMES
544 else if (startswith (sec_name
, GNU_LINKONCE_WI
)
545 || startswith (sec_name
, GNU_LINKONCE_WT
))
547 styp_flags
= STYP_DEBUG_INFO
;
551 else if (!strcmp (sec_name
, _TDATA
))
553 styp_flags
= STYP_TDATA
;
555 else if (!strcmp (sec_name
, _TBSS
))
557 styp_flags
= STYP_TBSS
;
559 else if (!strcmp (sec_name
, _PAD
))
561 styp_flags
= STYP_PAD
;
563 else if (!strcmp (sec_name
, _LOADER
))
565 styp_flags
= STYP_LOADER
;
567 else if (!strcmp (sec_name
, _EXCEPT
))
569 styp_flags
= STYP_EXCEPT
;
571 else if (!strcmp (sec_name
, _TYPCHK
))
573 styp_flags
= STYP_TYPCHK
;
575 else if (sec_flags
& SEC_DEBUGGING
)
579 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
580 if (!strcmp (sec_name
, xcoff_dwsect_names
[i
].name
))
582 styp_flags
= STYP_DWARF
| xcoff_dwsect_names
[i
].flag
;
587 /* Try and figure out what it should be */
588 else if (sec_flags
& SEC_CODE
)
590 styp_flags
= STYP_TEXT
;
592 else if (sec_flags
& SEC_DATA
)
594 styp_flags
= STYP_DATA
;
596 else if (sec_flags
& SEC_READONLY
)
598 #ifdef STYP_LIT /* 29k readonly text/data section */
599 styp_flags
= STYP_LIT
;
601 styp_flags
= STYP_TEXT
;
602 #endif /* STYP_LIT */
604 else if (sec_flags
& SEC_LOAD
)
606 styp_flags
= STYP_TEXT
;
608 else if (sec_flags
& SEC_ALLOC
)
610 styp_flags
= STYP_BSS
;
614 if (sec_flags
& SEC_TIC54X_CLINK
)
615 styp_flags
|= STYP_CLINK
;
619 if (sec_flags
& SEC_TIC54X_BLOCK
)
620 styp_flags
|= STYP_BLOCK
;
624 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
625 styp_flags
|= STYP_NOLOAD
;
631 #else /* COFF_WITH_PE */
633 /* The PE version; see above for the general comments. The non-PE
634 case seems to be more guessing, and breaks PE format; specifically,
635 .rdata is readonly, but it sure ain't text. Really, all this
636 should be set up properly in gas (or whatever assembler is in use),
637 and honor whatever objcopy/strip, etc. sent us as input. */
640 sec_to_styp_flags (const char *sec_name
, flagword sec_flags
)
643 bfd_boolean is_dbg
= FALSE
;
645 if (startswith (sec_name
, DOT_DEBUG
)
646 || startswith (sec_name
, DOT_ZDEBUG
)
647 #ifdef COFF_LONG_SECTION_NAMES
648 || startswith (sec_name
, GNU_LINKONCE_WI
)
649 || startswith (sec_name
, GNU_LINKONCE_WT
)
651 || startswith (sec_name
, ".stab"))
654 /* caution: there are at least three groups of symbols that have
655 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
656 SEC_* are the BFD internal flags, used for generic BFD
657 information. STYP_* are the COFF section flags which appear in
658 COFF files. IMAGE_SCN_* are the PE section flags which appear in
659 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
660 but there are more IMAGE_SCN_* flags. */
662 /* FIXME: There is no gas syntax to specify the debug section flag. */
665 sec_flags
&= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
666 | SEC_LINK_DUPLICATES_SAME_CONTENTS
667 | SEC_LINK_DUPLICATES_SAME_SIZE
);
668 sec_flags
|= SEC_DEBUGGING
| SEC_READONLY
;
674 if ((sec_flags
& SEC_CODE
) != 0)
675 styp_flags
|= IMAGE_SCN_CNT_CODE
;
676 if ((sec_flags
& (SEC_DATA
| SEC_DEBUGGING
)) != 0)
677 styp_flags
|= IMAGE_SCN_CNT_INITIALIZED_DATA
;
678 if ((sec_flags
& SEC_ALLOC
) != 0 && (sec_flags
& SEC_LOAD
) == 0)
679 styp_flags
|= IMAGE_SCN_CNT_UNINITIALIZED_DATA
; /* ==STYP_BSS */
681 /* skip constRUCTOR */
683 #ifndef COFF_IMAGE_WITH_PE
684 /* I don't think any of the IMAGE_SCN_LNK_* flags set below should be set
685 when the output is PE. Only object files should have them, for the linker
687 if ((sec_flags
& SEC_IS_COMMON
) != 0)
688 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
690 if ((sec_flags
& SEC_DEBUGGING
) != 0)
691 styp_flags
|= IMAGE_SCN_MEM_DISCARDABLE
;
692 if ((sec_flags
& (SEC_EXCLUDE
| SEC_NEVER_LOAD
)) != 0 && !is_dbg
)
693 #ifdef COFF_IMAGE_WITH_PE
694 styp_flags
|= IMAGE_SCN_MEM_DISCARDABLE
;
696 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
700 #ifndef COFF_IMAGE_WITH_PE
701 if (sec_flags
& SEC_LINK_ONCE
)
702 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
704 & (SEC_LINK_DUPLICATES_DISCARD
| SEC_LINK_DUPLICATES_SAME_CONTENTS
705 | SEC_LINK_DUPLICATES_SAME_SIZE
)) != 0)
706 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
709 /* skip LINKER_CREATED */
711 if ((sec_flags
& SEC_COFF_NOREAD
) == 0)
712 styp_flags
|= IMAGE_SCN_MEM_READ
; /* Invert NOREAD for read. */
713 if ((sec_flags
& SEC_READONLY
) == 0)
714 styp_flags
|= IMAGE_SCN_MEM_WRITE
; /* Invert READONLY for write. */
715 if (sec_flags
& SEC_CODE
)
716 styp_flags
|= IMAGE_SCN_MEM_EXECUTE
; /* CODE->EXECUTE. */
717 if (sec_flags
& SEC_COFF_SHARED
)
718 styp_flags
|= IMAGE_SCN_MEM_SHARED
; /* Shared remains meaningful. */
723 #endif /* COFF_WITH_PE */
725 /* Return a word with SEC_* flags set to represent the incoming STYP_*
726 flags (from scnhdr.s_flags). The inverse of this function is
727 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
728 should probably mirror the changes in sec_to_styp_flags(). */
733 styp_to_sec_flags (bfd
*abfd
,
736 asection
*section ATTRIBUTE_UNUSED
,
739 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
740 long styp_flags
= internal_s
->s_flags
;
741 flagword sec_flags
= 0;
744 if (styp_flags
& STYP_BLOCK
)
745 sec_flags
|= SEC_TIC54X_BLOCK
;
749 if (styp_flags
& STYP_CLINK
)
750 sec_flags
|= SEC_TIC54X_CLINK
;
754 if (styp_flags
& STYP_NOLOAD
)
755 sec_flags
|= SEC_NEVER_LOAD
;
756 #endif /* STYP_NOLOAD */
758 /* For 386 COFF, at least, an unloadable text or data section is
759 actually a shared library section. */
760 if (styp_flags
& STYP_TEXT
)
762 if (sec_flags
& SEC_NEVER_LOAD
)
763 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
765 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
767 else if (styp_flags
& STYP_DATA
)
769 if (sec_flags
& SEC_NEVER_LOAD
)
770 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
772 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
774 else if (styp_flags
& STYP_BSS
)
776 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
777 if (sec_flags
& SEC_NEVER_LOAD
)
778 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
781 sec_flags
|= SEC_ALLOC
;
783 else if (styp_flags
& STYP_INFO
)
785 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
786 defined. coff_compute_section_file_positions uses
787 COFF_PAGE_SIZE to ensure that the low order bits of the
788 section VMA and the file offset match. If we don't know
789 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
790 and demand page loading of the file will fail. */
791 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
792 sec_flags
|= SEC_DEBUGGING
;
795 else if (styp_flags
& STYP_PAD
)
798 else if (styp_flags
& STYP_TDATA
)
800 if (sec_flags
& SEC_NEVER_LOAD
)
801 sec_flags
|= SEC_DATA
| SEC_THREAD_LOCAL
| SEC_COFF_SHARED_LIBRARY
;
803 sec_flags
|= SEC_DATA
| SEC_THREAD_LOCAL
| SEC_LOAD
| SEC_ALLOC
;
805 else if (styp_flags
& STYP_TBSS
)
807 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
808 if (sec_flags
& SEC_NEVER_LOAD
)
809 sec_flags
|= SEC_ALLOC
| SEC_THREAD_LOCAL
| SEC_COFF_SHARED_LIBRARY
;
812 sec_flags
|= SEC_ALLOC
| SEC_THREAD_LOCAL
;
814 else if (styp_flags
& STYP_EXCEPT
)
815 sec_flags
|= SEC_LOAD
;
816 else if (styp_flags
& STYP_LOADER
)
817 sec_flags
|= SEC_LOAD
;
818 else if (styp_flags
& STYP_TYPCHK
)
819 sec_flags
|= SEC_LOAD
;
820 else if (styp_flags
& STYP_DWARF
)
821 sec_flags
|= SEC_DEBUGGING
;
823 else if (strcmp (name
, _TEXT
) == 0)
825 if (sec_flags
& SEC_NEVER_LOAD
)
826 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
828 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
830 else if (strcmp (name
, _DATA
) == 0)
832 if (sec_flags
& SEC_NEVER_LOAD
)
833 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
835 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
837 else if (strcmp (name
, _BSS
) == 0)
839 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
840 if (sec_flags
& SEC_NEVER_LOAD
)
841 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
844 sec_flags
|= SEC_ALLOC
;
846 else if (startswith (name
, DOT_DEBUG
)
847 || startswith (name
, DOT_ZDEBUG
)
849 || strcmp (name
, _COMMENT
) == 0
851 #ifdef COFF_LONG_SECTION_NAMES
852 || startswith (name
, GNU_LINKONCE_WI
)
853 || startswith (name
, GNU_LINKONCE_WT
)
855 || startswith (name
, ".stab"))
857 #ifdef COFF_PAGE_SIZE
858 sec_flags
|= SEC_DEBUGGING
;
862 else if (strcmp (name
, _LIB
) == 0)
866 else if (strcmp (name
, _LIT
) == 0)
867 sec_flags
= SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
870 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
872 #ifdef STYP_LIT /* A29k readonly text/data section type. */
873 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
874 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
875 #endif /* STYP_LIT */
877 #ifdef STYP_OTHER_LOAD /* Other loaded sections. */
878 if (styp_flags
& STYP_OTHER_LOAD
)
879 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
880 #endif /* STYP_SDATA */
882 if ((bfd_applicable_section_flags (abfd
) & SEC_SMALL_DATA
) != 0
883 && (startswith (name
, ".sbss")
884 || startswith (name
, ".sdata")))
885 sec_flags
|= SEC_SMALL_DATA
;
887 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
888 /* As a GNU extension, if the name begins with .gnu.linkonce, we
889 only link a single copy of the section. This is used to support
890 g++. g++ will emit each template expansion in its own section.
891 The symbols will be defined as weak, so that multiple definitions
892 are permitted. The GNU linker extension is to actually discard
893 all but one of the sections. */
894 if (startswith (name
, ".gnu.linkonce"))
895 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
898 if (flags_ptr
== NULL
)
901 * flags_ptr
= sec_flags
;
905 #else /* COFF_WITH_PE */
908 handle_COMDAT (bfd
* abfd
,
914 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
915 bfd_byte
*esymstart
, *esym
, *esymend
;
917 char *target_name
= NULL
;
919 sec_flags
|= SEC_LINK_ONCE
;
921 /* Unfortunately, the PE format stores essential information in
922 the symbol table, of all places. We need to extract that
923 information now, so that objdump and the linker will know how
924 to handle the section without worrying about the symbols. We
925 can't call slurp_symtab, because the linker doesn't want the
928 /* COMDAT sections are special. The first symbol is the section
929 symbol, which tells what kind of COMDAT section it is. The
930 second symbol is the "comdat symbol" - the one with the
931 unique name. GNU uses the section symbol for the unique
932 name; MS uses ".text" for every comdat section. Sigh. - DJ */
934 /* This is not mirrored in sec_to_styp_flags(), but there
935 doesn't seem to be a need to, either, and it would at best be
938 if (! _bfd_coff_get_external_symbols (abfd
))
941 esymstart
= esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
942 esymend
= esym
+ obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
944 while (esym
< esymend
)
946 struct internal_syment isym
;
947 char buf
[SYMNMLEN
+ 1];
950 bfd_coff_swap_sym_in (abfd
, esym
, & isym
);
952 BFD_ASSERT (sizeof (internal_s
->s_name
) <= SYMNMLEN
);
954 if (isym
.n_scnum
== section
->target_index
)
956 /* According to the MSVC documentation, the first
957 TWO entries with the section # are both of
958 interest to us. The first one is the "section
959 symbol" (section name). The second is the comdat
960 symbol name. Here, we've found the first
961 qualifying entry; we distinguish it from the
962 second with a state flag.
964 In the case of gas-generated (at least until that
965 is fixed) .o files, it isn't necessarily the
966 second one. It may be some other later symbol.
968 Since gas also doesn't follow MS conventions and
969 emits the section similar to .text$<name>, where
970 <something> is the name we're looking for, we
971 distinguish the two as follows:
973 If the section name is simply a section name (no
974 $) we presume it's MS-generated, and look at
975 precisely the second symbol for the comdat name.
976 If the section name has a $, we assume it's
977 gas-generated, and look for <something> (whatever
978 follows the $) as the comdat symbol. */
980 /* All 3 branches use this. */
981 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
, buf
);
983 /* PR 17512 file: 078-11867-0.004 */
986 _bfd_error_handler (_("%pB: unable to load COMDAT section name"),
995 /* The first time we've seen the symbol. */
996 union internal_auxent aux
;
998 /* If it isn't the stuff we're expecting, die;
999 The MS documentation is vague, but it
1000 appears that the second entry serves BOTH
1001 as the comdat symbol and the defining
1002 symbol record (either C_STAT or C_EXT,
1003 possibly with an aux entry with debug
1004 information if it's a function.) It
1005 appears the only way to find the second one
1006 is to count. (On Intel, they appear to be
1007 adjacent, but on Alpha, they have been
1010 Here, we think we've found the first one,
1011 but there's some checking we can do to be
1014 if (! ((isym
.n_sclass
== C_STAT
1015 || isym
.n_sclass
== C_EXT
)
1016 && BTYPE (isym
.n_type
) == T_NULL
1017 && isym
.n_value
== 0))
1019 /* Malformed input files can trigger this test.
1021 _bfd_error_handler (_("%pB: error: unexpected symbol '%s' in COMDAT section"),
1026 /* FIXME LATER: MSVC generates section names
1027 like .text for comdats. Gas generates
1028 names like .text$foo__Fv (in the case of a
1029 function). See comment above for more. */
1031 if (isym
.n_sclass
== C_STAT
&& strcmp (name
, symname
) != 0)
1032 /* xgettext:c-format */
1033 _bfd_error_handler (_("%pB: warning: COMDAT symbol '%s'"
1034 " does not match section name '%s'"),
1035 abfd
, symname
, name
);
1039 /* PR 17512: file: e2cfe54f. */
1040 if (esym
+ bfd_coff_symesz (abfd
) >= esymend
)
1042 /* xgettext:c-format */
1043 _bfd_error_handler (_("%pB: warning: no symbol for"
1044 " section '%s' found"),
1048 /* This is the section symbol. */
1049 bfd_coff_swap_aux_in (abfd
, (esym
+ bfd_coff_symesz (abfd
)),
1050 isym
.n_type
, isym
.n_sclass
,
1051 0, isym
.n_numaux
, & aux
);
1053 target_name
= strchr (name
, '$');
1054 if (target_name
!= NULL
)
1062 /* FIXME: Microsoft uses NODUPLICATES and
1063 ASSOCIATIVE, but gnu uses ANY and
1064 SAME_SIZE. Unfortunately, gnu doesn't do
1065 the comdat symbols right. So, until we can
1066 fix it to do the right thing, we are
1067 temporarily disabling comdats for the MS
1068 types (they're used in DLLs and C++, but we
1069 don't support *their* C++ libraries anyway
1072 /* Cygwin does not follow the MS style, and
1073 uses ANY and SAME_SIZE where NODUPLICATES
1074 and ASSOCIATIVE should be used. For
1075 Interix, we just do the right thing up
1078 switch (aux
.x_scn
.x_comdat
)
1080 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
1081 #ifdef STRICT_PE_FORMAT
1082 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
1084 sec_flags
&= ~SEC_LINK_ONCE
;
1088 case IMAGE_COMDAT_SELECT_ANY
:
1089 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1092 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
1093 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
1096 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
1097 /* Not yet fully implemented ??? */
1098 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
1101 /* debug$S gets this case; other
1104 /* There may be no symbol... we'll search
1105 the whole table... Is this the right
1106 place to play this game? Or should we do
1107 it when reading it in. */
1108 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
1109 #ifdef STRICT_PE_FORMAT
1110 /* FIXME: This is not currently implemented. */
1111 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1113 sec_flags
&= ~SEC_LINK_ONCE
;
1117 default: /* 0 means "no symbol" */
1118 /* debug$F gets this case; other
1120 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1127 /* Gas mode: the first matching on partial name. */
1129 #ifndef TARGET_UNDERSCORE
1130 #define TARGET_UNDERSCORE 0
1132 /* Is this the name we're looking for ? */
1133 if (strcmp (target_name
,
1134 symname
+ (TARGET_UNDERSCORE
? 1 : 0)) != 0)
1136 /* Not the name we're looking for */
1137 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1142 /* MSVC mode: the lexically second symbol (or
1143 drop through from the above). */
1148 /* This must the second symbol with the
1149 section #. It is the actual symbol name.
1150 Intel puts the two adjacent, but Alpha (at
1151 least) spreads them out. */
1153 amt
= sizeof (struct coff_comdat_info
);
1154 coff_section_data (abfd
, section
)->comdat
1155 = (struct coff_comdat_info
*) bfd_alloc (abfd
, amt
);
1156 if (coff_section_data (abfd
, section
)->comdat
== NULL
)
1159 coff_section_data (abfd
, section
)->comdat
->symbol
=
1160 (esym
- esymstart
) / bfd_coff_symesz (abfd
);
1162 amt
= strlen (symname
) + 1;
1163 newname
= (char *) bfd_alloc (abfd
, amt
);
1164 if (newname
== NULL
)
1167 strcpy (newname
, symname
);
1168 coff_section_data (abfd
, section
)->comdat
->name
1176 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1184 /* The PE version; see above for the general comments.
1186 Since to set the SEC_LINK_ONCE and associated flags, we have to
1187 look at the symbol table anyway, we return the symbol table index
1188 of the symbol being used as the COMDAT symbol. This is admittedly
1189 ugly, but there's really nowhere else that we have access to the
1190 required information. FIXME: Is the COMDAT symbol index used for
1191 any purpose other than objdump? */
1194 styp_to_sec_flags (bfd
*abfd
,
1198 flagword
*flags_ptr
)
1200 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
1201 unsigned long styp_flags
= internal_s
->s_flags
;
1203 bfd_boolean result
= TRUE
;
1204 bfd_boolean is_dbg
= FALSE
;
1206 if (startswith (name
, DOT_DEBUG
)
1207 || startswith (name
, DOT_ZDEBUG
)
1208 #ifdef COFF_LONG_SECTION_NAMES
1209 || startswith (name
, GNU_LINKONCE_WI
)
1210 || startswith (name
, GNU_LINKONCE_WT
)
1211 /* FIXME: These definitions ought to be in a header file. */
1212 #define GNU_DEBUGLINK ".gnu_debuglink"
1213 #define GNU_DEBUGALTLINK ".gnu_debugaltlink"
1214 || startswith (name
, GNU_DEBUGLINK
)
1215 || startswith (name
, GNU_DEBUGALTLINK
)
1217 || startswith (name
, ".stab"))
1219 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
1220 sec_flags
= SEC_READONLY
;
1222 /* If section disallows read, then set the NOREAD flag. */
1223 if ((styp_flags
& IMAGE_SCN_MEM_READ
) == 0)
1224 sec_flags
|= SEC_COFF_NOREAD
;
1226 /* Process each flag bit in styp_flags in turn. */
1229 unsigned long flag
= styp_flags
& - styp_flags
;
1230 char * unhandled
= NULL
;
1232 styp_flags
&= ~ flag
;
1234 /* We infer from the distinct read/write/execute bits the settings
1235 of some of the bfd flags; the actual values, should we need them,
1236 are also in pei_section_data (abfd, section)->pe_flags. */
1241 unhandled
= "STYP_DSECT";
1244 unhandled
= "STYP_GROUP";
1247 unhandled
= "STYP_COPY";
1250 unhandled
= "STYP_OVER";
1252 #ifdef SEC_NEVER_LOAD
1254 sec_flags
|= SEC_NEVER_LOAD
;
1257 case IMAGE_SCN_MEM_READ
:
1258 sec_flags
&= ~SEC_COFF_NOREAD
;
1260 case IMAGE_SCN_TYPE_NO_PAD
:
1263 case IMAGE_SCN_LNK_OTHER
:
1264 unhandled
= "IMAGE_SCN_LNK_OTHER";
1266 case IMAGE_SCN_MEM_NOT_CACHED
:
1267 unhandled
= "IMAGE_SCN_MEM_NOT_CACHED";
1269 case IMAGE_SCN_MEM_NOT_PAGED
:
1270 /* Generate a warning message rather using the 'unhandled'
1271 variable as this will allow some .sys files generate by
1272 other toolchains to be processed. See bugzilla issue 196. */
1273 /* xgettext:c-format */
1274 _bfd_error_handler (_("%pB: warning: ignoring section flag"
1275 " %s in section %s"),
1276 abfd
, "IMAGE_SCN_MEM_NOT_PAGED", name
);
1278 case IMAGE_SCN_MEM_EXECUTE
:
1279 sec_flags
|= SEC_CODE
;
1281 case IMAGE_SCN_MEM_WRITE
:
1282 sec_flags
&= ~ SEC_READONLY
;
1284 case IMAGE_SCN_MEM_DISCARDABLE
:
1285 /* The MS PE spec says that debug sections are DISCARDABLE,
1286 but the presence of a DISCARDABLE flag does not necessarily
1287 mean that a given section contains debug information. Thus
1288 we only set the SEC_DEBUGGING flag on sections that we
1289 recognise as containing debug information. */
1292 || strcmp (name
, _COMMENT
) == 0
1296 sec_flags
|= SEC_DEBUGGING
| SEC_READONLY
;
1299 case IMAGE_SCN_MEM_SHARED
:
1300 sec_flags
|= SEC_COFF_SHARED
;
1302 case IMAGE_SCN_LNK_REMOVE
:
1304 sec_flags
|= SEC_EXCLUDE
;
1306 case IMAGE_SCN_CNT_CODE
:
1307 sec_flags
|= SEC_CODE
| SEC_ALLOC
| SEC_LOAD
;
1309 case IMAGE_SCN_CNT_INITIALIZED_DATA
:
1311 sec_flags
|= SEC_DEBUGGING
;
1313 sec_flags
|= SEC_DATA
| SEC_ALLOC
| SEC_LOAD
;
1315 case IMAGE_SCN_CNT_UNINITIALIZED_DATA
:
1316 sec_flags
|= SEC_ALLOC
;
1318 case IMAGE_SCN_LNK_INFO
:
1319 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1320 defined. coff_compute_section_file_positions uses
1321 COFF_PAGE_SIZE to ensure that the low order bits of the
1322 section VMA and the file offset match. If we don't know
1323 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1324 and demand page loading of the file will fail. */
1325 #ifdef COFF_PAGE_SIZE
1326 sec_flags
|= SEC_DEBUGGING
;
1329 case IMAGE_SCN_LNK_COMDAT
:
1330 /* COMDAT gets very special treatment. */
1331 sec_flags
= handle_COMDAT (abfd
, sec_flags
, hdr
, name
, section
);
1334 /* Silently ignore for now. */
1338 /* If the section flag was not handled, report it here. */
1339 if (unhandled
!= NULL
)
1342 /* xgettext:c-format */
1343 (_("%pB (%s): section flag %s (%#lx) ignored"),
1344 abfd
, name
, unhandled
, flag
);
1349 if ((bfd_applicable_section_flags (abfd
) & SEC_SMALL_DATA
) != 0
1350 && (startswith (name
, ".sbss")
1351 || startswith (name
, ".sdata")))
1352 sec_flags
|= SEC_SMALL_DATA
;
1354 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1355 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1356 only link a single copy of the section. This is used to support
1357 g++. g++ will emit each template expansion in its own section.
1358 The symbols will be defined as weak, so that multiple definitions
1359 are permitted. The GNU linker extension is to actually discard
1360 all but one of the sections. */
1361 if (startswith (name
, ".gnu.linkonce"))
1362 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1366 * flags_ptr
= sec_flags
;
1371 #endif /* COFF_WITH_PE */
1373 #define get_index(symbol) ((symbol)->udata.i)
1377 bfd_coff_backend_data
1381 .{* COFF symbol classifications. *}
1383 .enum coff_symbol_classification
1385 . {* Global symbol. *}
1386 . COFF_SYMBOL_GLOBAL,
1387 . {* Common symbol. *}
1388 . COFF_SYMBOL_COMMON,
1389 . {* Undefined symbol. *}
1390 . COFF_SYMBOL_UNDEFINED,
1391 . {* Local symbol. *}
1392 . COFF_SYMBOL_LOCAL,
1393 . {* PE section symbol. *}
1394 . COFF_SYMBOL_PE_SECTION
1397 .typedef asection * (*coff_gc_mark_hook_fn)
1398 . (asection *, struct bfd_link_info *, struct internal_reloc *,
1399 . struct coff_link_hash_entry *, struct internal_syment *);
1401 Special entry points for gdb to swap in coff symbol table parts:
1404 . void (*_bfd_coff_swap_aux_in)
1405 . (bfd *, void *, int, int, int, int, void *);
1407 . void (*_bfd_coff_swap_sym_in)
1408 . (bfd *, void *, void *);
1410 . void (*_bfd_coff_swap_lineno_in)
1411 . (bfd *, void *, void *);
1413 . unsigned int (*_bfd_coff_swap_aux_out)
1414 . (bfd *, void *, int, int, int, int, void *);
1416 . unsigned int (*_bfd_coff_swap_sym_out)
1417 . (bfd *, void *, void *);
1419 . unsigned int (*_bfd_coff_swap_lineno_out)
1420 . (bfd *, void *, void *);
1422 . unsigned int (*_bfd_coff_swap_reloc_out)
1423 . (bfd *, void *, void *);
1425 . unsigned int (*_bfd_coff_swap_filehdr_out)
1426 . (bfd *, void *, void *);
1428 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1429 . (bfd *, void *, void *);
1431 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1432 . (bfd *, void *, void *);
1434 . unsigned int _bfd_filhsz;
1435 . unsigned int _bfd_aoutsz;
1436 . unsigned int _bfd_scnhsz;
1437 . unsigned int _bfd_symesz;
1438 . unsigned int _bfd_auxesz;
1439 . unsigned int _bfd_relsz;
1440 . unsigned int _bfd_linesz;
1441 . unsigned int _bfd_filnmlen;
1442 . bfd_boolean _bfd_coff_long_filenames;
1444 . bfd_boolean _bfd_coff_long_section_names;
1445 . bfd_boolean (*_bfd_coff_set_long_section_names)
1448 . unsigned int _bfd_coff_default_section_alignment_power;
1449 . bfd_boolean _bfd_coff_force_symnames_in_strings;
1450 . unsigned int _bfd_coff_debug_string_prefix_length;
1451 . unsigned int _bfd_coff_max_nscns;
1453 . void (*_bfd_coff_swap_filehdr_in)
1454 . (bfd *, void *, void *);
1456 . void (*_bfd_coff_swap_aouthdr_in)
1457 . (bfd *, void *, void *);
1459 . void (*_bfd_coff_swap_scnhdr_in)
1460 . (bfd *, void *, void *);
1462 . void (*_bfd_coff_swap_reloc_in)
1463 . (bfd *abfd, void *, void *);
1465 . bfd_boolean (*_bfd_coff_bad_format_hook)
1468 . bfd_boolean (*_bfd_coff_set_arch_mach_hook)
1471 . void * (*_bfd_coff_mkobject_hook)
1472 . (bfd *, void *, void *);
1474 . bfd_boolean (*_bfd_styp_to_sec_flags_hook)
1475 . (bfd *, void *, const char *, asection *, flagword *);
1477 . void (*_bfd_set_alignment_hook)
1478 . (bfd *, asection *, void *);
1480 . bfd_boolean (*_bfd_coff_slurp_symbol_table)
1483 . bfd_boolean (*_bfd_coff_symname_in_debug)
1484 . (bfd *, struct internal_syment *);
1486 . bfd_boolean (*_bfd_coff_pointerize_aux_hook)
1487 . (bfd *, combined_entry_type *, combined_entry_type *,
1488 . unsigned int, combined_entry_type *);
1490 . bfd_boolean (*_bfd_coff_print_aux)
1491 . (bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1492 . combined_entry_type *, unsigned int);
1494 . void (*_bfd_coff_reloc16_extra_cases)
1495 . (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1496 . bfd_byte *, unsigned int *, unsigned int *);
1498 . int (*_bfd_coff_reloc16_estimate)
1499 . (bfd *, asection *, arelent *, unsigned int,
1500 . struct bfd_link_info *);
1502 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1503 . (bfd *, struct internal_syment *);
1505 . bfd_boolean (*_bfd_coff_compute_section_file_positions)
1508 . bfd_boolean (*_bfd_coff_start_final_link)
1509 . (bfd *, struct bfd_link_info *);
1511 . bfd_boolean (*_bfd_coff_relocate_section)
1512 . (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1513 . struct internal_reloc *, struct internal_syment *, asection **);
1515 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1516 . (bfd *, asection *, struct internal_reloc *,
1517 . struct coff_link_hash_entry *, struct internal_syment *, bfd_vma *);
1519 . bfd_boolean (*_bfd_coff_adjust_symndx)
1520 . (bfd *, struct bfd_link_info *, bfd *, asection *,
1521 . struct internal_reloc *, bfd_boolean *);
1523 . bfd_boolean (*_bfd_coff_link_add_one_symbol)
1524 . (struct bfd_link_info *, bfd *, const char *, flagword,
1525 . asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
1526 . struct bfd_link_hash_entry **);
1528 . bfd_boolean (*_bfd_coff_link_output_has_begun)
1529 . (bfd *, struct coff_final_link_info *);
1531 . bfd_boolean (*_bfd_coff_final_link_postscript)
1532 . (bfd *, struct coff_final_link_info *);
1534 . bfd_boolean (*_bfd_coff_print_pdata)
1537 .} bfd_coff_backend_data;
1539 .#define coff_backend_info(abfd) \
1540 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1542 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1543 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1545 .#define bfd_coff_swap_sym_in(a,e,i) \
1546 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1548 .#define bfd_coff_swap_lineno_in(a,e,i) \
1549 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1551 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1552 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1554 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1555 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1557 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1558 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1560 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1561 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1563 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1564 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1566 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1567 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1569 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1570 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1572 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1573 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1574 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1575 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1576 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1577 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1578 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1579 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1580 .#define bfd_coff_long_filenames(abfd) \
1581 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1582 .#define bfd_coff_long_section_names(abfd) \
1583 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1584 .#define bfd_coff_set_long_section_names(abfd, enable) \
1585 . ((coff_backend_info (abfd)->_bfd_coff_set_long_section_names) (abfd, enable))
1586 .#define bfd_coff_default_section_alignment_power(abfd) \
1587 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1588 .#define bfd_coff_max_nscns(abfd) \
1589 . (coff_backend_info (abfd)->_bfd_coff_max_nscns)
1591 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1592 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1594 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1595 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1597 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1598 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1600 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1601 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1603 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1604 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1606 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1607 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1608 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1609 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1610 . (abfd, filehdr, aouthdr))
1612 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1613 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1614 . (abfd, scnhdr, name, section, flags_ptr))
1616 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1617 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1619 .#define bfd_coff_slurp_symbol_table(abfd)\
1620 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1622 .#define bfd_coff_symname_in_debug(abfd, sym)\
1623 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1625 .#define bfd_coff_force_symnames_in_strings(abfd)\
1626 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1628 .#define bfd_coff_debug_string_prefix_length(abfd)\
1629 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1631 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1632 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1633 . (abfd, file, base, symbol, aux, indaux))
1635 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1636 . reloc, data, src_ptr, dst_ptr)\
1637 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1638 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1640 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1641 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1642 . (abfd, section, reloc, shrink, link_info))
1644 .#define bfd_coff_classify_symbol(abfd, sym)\
1645 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1648 .#define bfd_coff_compute_section_file_positions(abfd)\
1649 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1652 .#define bfd_coff_start_final_link(obfd, info)\
1653 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1655 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1656 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1657 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1658 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1659 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1660 . (abfd, sec, rel, h, sym, addendp))
1661 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1662 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1663 . (obfd, info, ibfd, sec, rel, adjustedp))
1664 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1665 . value, string, cp, coll, hashp)\
1666 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1667 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1669 .#define bfd_coff_link_output_has_begun(a,p) \
1670 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p))
1671 .#define bfd_coff_final_link_postscript(a,p) \
1672 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p))
1674 .#define bfd_coff_have_print_pdata(a) \
1675 . (coff_backend_info (a)->_bfd_coff_print_pdata)
1676 .#define bfd_coff_print_pdata(a,p) \
1677 . ((coff_backend_info (a)->_bfd_coff_print_pdata) (a, p))
1679 .{* Macro: Returns true if the bfd is a PE executable as opposed to a
1680 . PE object file. *}
1681 .#define bfd_pei_p(abfd) \
1682 . (startswith ((abfd)->xvec->name, "pei-"))
1685 /* See whether the magic number matches. */
1688 coff_bad_format_hook (bfd
* abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1690 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1692 if (BADMAG (*internal_f
))
1700 ticoff0_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1702 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1704 if (COFF0_BADMAG (*internal_f
))
1713 ticoff1_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1715 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1717 if (COFF1_BADMAG (*internal_f
))
1724 /* Check whether this section uses an alignment other than the
1728 coff_set_custom_section_alignment (bfd
*abfd ATTRIBUTE_UNUSED
,
1730 const struct coff_section_alignment_entry
*alignment_table
,
1731 const unsigned int table_size
)
1733 const unsigned int default_alignment
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1736 for (i
= 0; i
< table_size
; ++i
)
1738 const char *secname
= bfd_section_name (section
);
1740 if (alignment_table
[i
].comparison_length
== (unsigned int) -1
1741 ? strcmp (alignment_table
[i
].name
, secname
) == 0
1742 : strncmp (alignment_table
[i
].name
, secname
,
1743 alignment_table
[i
].comparison_length
) == 0)
1746 if (i
>= table_size
)
1749 if (alignment_table
[i
].default_alignment_min
!= COFF_ALIGNMENT_FIELD_EMPTY
1750 && default_alignment
< alignment_table
[i
].default_alignment_min
)
1753 if (alignment_table
[i
].default_alignment_max
!= COFF_ALIGNMENT_FIELD_EMPTY
1754 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1755 && default_alignment
> alignment_table
[i
].default_alignment_max
1760 section
->alignment_power
= alignment_table
[i
].alignment_power
;
1763 /* Custom section alignment records. */
1765 static const struct coff_section_alignment_entry
1766 coff_section_alignment_table
[] =
1768 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1769 COFF_SECTION_ALIGNMENT_ENTRIES
,
1771 /* There must not be any gaps between .stabstr sections. */
1772 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1773 1, COFF_ALIGNMENT_FIELD_EMPTY
, 0 },
1774 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1775 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1776 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1777 /* Similarly for the .ctors and .dtors sections. */
1778 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1779 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1780 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1781 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 }
1784 static const unsigned int coff_section_alignment_table_size
=
1785 sizeof coff_section_alignment_table
/ sizeof coff_section_alignment_table
[0];
1787 /* Initialize a section structure with information peculiar to this
1788 particular implementation of COFF. */
1791 coff_new_section_hook (bfd
* abfd
, asection
* section
)
1793 combined_entry_type
*native
;
1795 unsigned char sclass
= C_STAT
;
1797 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1800 if (bfd_xcoff_text_align_power (abfd
) != 0
1801 && strcmp (bfd_section_name (section
), ".text") == 0)
1802 section
->alignment_power
= bfd_xcoff_text_align_power (abfd
);
1803 else if (bfd_xcoff_data_align_power (abfd
) != 0
1804 && strcmp (bfd_section_name (section
), ".data") == 0)
1805 section
->alignment_power
= bfd_xcoff_data_align_power (abfd
);
1810 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
1811 if (strcmp (bfd_section_name (section
),
1812 xcoff_dwsect_names
[i
].name
) == 0)
1814 section
->alignment_power
= 0;
1821 /* Set up the section symbol. */
1822 if (!_bfd_generic_new_section_hook (abfd
, section
))
1825 /* Allocate aux records for section symbols, to store size and
1828 @@ The 10 is a guess at a plausible maximum number of aux entries
1829 (but shouldn't be a constant). */
1830 amt
= sizeof (combined_entry_type
) * 10;
1831 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
1835 /* We don't need to set up n_name, n_value, or n_scnum in the native
1836 symbol information, since they'll be overridden by the BFD symbol
1837 anyhow. However, we do need to set the type and storage class,
1838 in case this symbol winds up getting written out. The value 0
1839 for n_numaux is already correct. */
1841 native
->is_sym
= TRUE
;
1842 native
->u
.syment
.n_type
= T_NULL
;
1843 native
->u
.syment
.n_sclass
= sclass
;
1845 coffsymbol (section
->symbol
)->native
= native
;
1847 coff_set_custom_section_alignment (abfd
, section
,
1848 coff_section_alignment_table
,
1849 coff_section_alignment_table_size
);
1854 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1856 /* Set the alignment of a BFD section. */
1859 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1863 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1866 #ifdef COFF_DECODE_ALIGNMENT
1867 i
= COFF_DECODE_ALIGNMENT(hdr
->s_flags
);
1869 section
->alignment_power
= i
;
1871 #ifdef coff_set_section_load_page
1872 coff_set_section_load_page (section
, hdr
->s_page
);
1876 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1880 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1884 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1886 unsigned int alignment_power_const
1887 = hdr
->s_flags
& IMAGE_SCN_ALIGN_POWER_BIT_MASK
;
1889 switch (alignment_power_const
)
1891 case IMAGE_SCN_ALIGN_8192BYTES
:
1892 case IMAGE_SCN_ALIGN_4096BYTES
:
1893 case IMAGE_SCN_ALIGN_2048BYTES
:
1894 case IMAGE_SCN_ALIGN_1024BYTES
:
1895 case IMAGE_SCN_ALIGN_512BYTES
:
1896 case IMAGE_SCN_ALIGN_256BYTES
:
1897 case IMAGE_SCN_ALIGN_128BYTES
:
1898 case IMAGE_SCN_ALIGN_64BYTES
:
1899 case IMAGE_SCN_ALIGN_32BYTES
:
1900 case IMAGE_SCN_ALIGN_16BYTES
:
1901 case IMAGE_SCN_ALIGN_8BYTES
:
1902 case IMAGE_SCN_ALIGN_4BYTES
:
1903 case IMAGE_SCN_ALIGN_2BYTES
:
1904 case IMAGE_SCN_ALIGN_1BYTES
:
1905 section
->alignment_power
1906 = IMAGE_SCN_ALIGN_POWER_NUM (alignment_power_const
);
1912 /* In a PE image file, the s_paddr field holds the virtual size of a
1913 section, while the s_size field holds the raw size. We also keep
1914 the original section flag value, since not every bit can be
1915 mapped onto a generic BFD section bit. */
1916 if (coff_section_data (abfd
, section
) == NULL
)
1918 amt
= sizeof (struct coff_section_tdata
);
1919 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
1920 if (section
->used_by_bfd
== NULL
)
1921 /* FIXME: Return error. */
1925 if (pei_section_data (abfd
, section
) == NULL
)
1927 amt
= sizeof (struct pei_section_tdata
);
1928 coff_section_data (abfd
, section
)->tdata
= bfd_zalloc (abfd
, amt
);
1929 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1930 /* FIXME: Return error. */
1933 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1934 pei_section_data (abfd
, section
)->pe_flags
= hdr
->s_flags
;
1936 section
->lma
= hdr
->s_vaddr
;
1938 /* Check for extended relocs. */
1939 if (hdr
->s_flags
& IMAGE_SCN_LNK_NRELOC_OVFL
)
1941 struct external_reloc dst
;
1942 struct internal_reloc n
;
1943 file_ptr oldpos
= bfd_tell (abfd
);
1944 bfd_size_type relsz
= bfd_coff_relsz (abfd
);
1946 if (bfd_seek (abfd
, (file_ptr
) hdr
->s_relptr
, 0) != 0)
1948 if (bfd_bread (& dst
, relsz
, abfd
) != relsz
)
1951 coff_swap_reloc_in (abfd
, &dst
, &n
);
1952 if (bfd_seek (abfd
, oldpos
, 0) != 0)
1954 section
->reloc_count
= hdr
->s_nreloc
= n
.r_vaddr
- 1;
1955 section
->rel_filepos
+= relsz
;
1957 else if (hdr
->s_nreloc
== 0xffff)
1959 (_("%pB: warning: claims to have 0xffff relocs, without overflow"),
1963 #undef ELIFALIGN_SET
1965 #else /* ! COFF_WITH_PE */
1968 /* We grossly abuse this function to handle XCOFF overflow headers.
1969 When we see one, we correct the reloc and line number counts in the
1970 real header, and remove the section we just created. */
1973 coff_set_alignment_hook (bfd
*abfd
, asection
*section
, void * scnhdr
)
1975 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1978 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1981 real_sec
= coff_section_from_bfd_index (abfd
, (int) hdr
->s_nreloc
);
1982 if (real_sec
== NULL
)
1985 real_sec
->reloc_count
= hdr
->s_paddr
;
1986 real_sec
->lineno_count
= hdr
->s_vaddr
;
1988 if (!bfd_section_removed_from_list (abfd
, section
))
1990 bfd_section_list_remove (abfd
, section
);
1991 --abfd
->section_count
;
1995 #else /* ! RS6000COFF_C */
1996 #if defined (COFF_GO32_EXE) || defined (COFF_GO32)
1999 coff_set_alignment_hook (bfd
* abfd
, asection
* section
, void * scnhdr
)
2001 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
2003 /* Check for extended relocs. */
2004 if (hdr
->s_flags
& IMAGE_SCN_LNK_NRELOC_OVFL
)
2006 struct external_reloc dst
;
2007 struct internal_reloc n
;
2008 const file_ptr oldpos
= bfd_tell (abfd
);
2009 const bfd_size_type relsz
= bfd_coff_relsz (abfd
);
2011 if (bfd_seek (abfd
, (file_ptr
) hdr
->s_relptr
, 0) != 0)
2013 if (bfd_bread (& dst
, relsz
, abfd
) != relsz
)
2016 coff_swap_reloc_in (abfd
, &dst
, &n
);
2017 if (bfd_seek (abfd
, oldpos
, 0) != 0)
2019 section
->reloc_count
= hdr
->s_nreloc
= n
.r_vaddr
- 1;
2020 section
->rel_filepos
+= relsz
;
2022 else if (hdr
->s_nreloc
== 0xffff)
2024 (_("%pB: warning: claims to have 0xffff relocs, without overflow"),
2028 #else /* ! COFF_GO32_EXE && ! COFF_GO32 */
2031 coff_set_alignment_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2032 asection
*section ATTRIBUTE_UNUSED
,
2033 void *scnhdr ATTRIBUTE_UNUSED
)
2037 #endif /* ! COFF_GO32_EXE && ! COFF_GO32 */
2038 #endif /* ! RS6000COFF_C */
2039 #endif /* ! COFF_WITH_PE */
2040 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
2042 #ifndef coff_mkobject
2045 coff_mkobject (bfd
* abfd
)
2047 coff_data_type
*coff
;
2048 size_t amt
= sizeof (coff_data_type
);
2050 abfd
->tdata
.coff_obj_data
= bfd_zalloc (abfd
, amt
);
2051 if (abfd
->tdata
.coff_obj_data
== NULL
)
2053 coff
= coff_data (abfd
);
2054 coff
->symbols
= NULL
;
2055 coff
->conversion_table
= NULL
;
2056 coff
->raw_syments
= NULL
;
2057 coff
->relocbase
= 0;
2058 coff
->local_toc_sym_map
= 0;
2060 /* make_abs_section(abfd);*/
2066 /* Create the COFF backend specific information. */
2068 #ifndef coff_mkobject_hook
2070 coff_mkobject_hook (bfd
* abfd
,
2072 void * aouthdr ATTRIBUTE_UNUSED
)
2074 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
2075 coff_data_type
*coff
;
2077 if (! coff_mkobject (abfd
))
2080 coff
= coff_data (abfd
);
2082 coff
->sym_filepos
= internal_f
->f_symptr
;
2084 /* These members communicate important constants about the symbol
2085 table to GDB's symbol-reading code. These `constants'
2086 unfortunately vary among coff implementations... */
2087 coff
->local_n_btmask
= N_BTMASK
;
2088 coff
->local_n_btshft
= N_BTSHFT
;
2089 coff
->local_n_tmask
= N_TMASK
;
2090 coff
->local_n_tshift
= N_TSHIFT
;
2091 coff
->local_symesz
= bfd_coff_symesz (abfd
);
2092 coff
->local_auxesz
= bfd_coff_auxesz (abfd
);
2093 coff
->local_linesz
= bfd_coff_linesz (abfd
);
2095 coff
->timestamp
= internal_f
->f_timdat
;
2097 obj_raw_syment_count (abfd
) =
2098 obj_conv_table_size (abfd
) =
2099 internal_f
->f_nsyms
;
2102 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
2103 abfd
->flags
|= DYNAMIC
;
2104 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= bfd_coff_aoutsz (abfd
))
2106 struct internal_aouthdr
*internal_a
=
2107 (struct internal_aouthdr
*) aouthdr
;
2108 struct xcoff_tdata
*xcoff
;
2110 xcoff
= xcoff_data (abfd
);
2111 # ifdef U803XTOCMAGIC
2112 xcoff
->xcoff64
= internal_f
->f_magic
== U803XTOCMAGIC
;
2116 xcoff
->full_aouthdr
= TRUE
;
2117 xcoff
->toc
= internal_a
->o_toc
;
2118 xcoff
->sntoc
= internal_a
->o_sntoc
;
2119 xcoff
->snentry
= internal_a
->o_snentry
;
2120 bfd_xcoff_text_align_power (abfd
) = internal_a
->o_algntext
;
2121 bfd_xcoff_data_align_power (abfd
) = internal_a
->o_algndata
;
2122 xcoff
->modtype
= internal_a
->o_modtype
;
2123 xcoff
->cputype
= internal_a
->o_cputype
;
2124 xcoff
->maxdata
= internal_a
->o_maxdata
;
2125 xcoff
->maxstack
= internal_a
->o_maxstack
;
2130 /* Set the flags field from the COFF header read in. */
2131 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
2136 /* FIXME: I'm not sure this is ever executed, since peicode.h
2137 defines coff_mkobject_hook. */
2138 if ((internal_f
->f_flags
& IMAGE_FILE_DEBUG_STRIPPED
) == 0)
2139 abfd
->flags
|= HAS_DEBUG
;
2146 /* Determine the machine architecture and type. FIXME: This is target
2147 dependent because the magic numbers are defined in the target
2148 dependent header files. But there is no particular need for this.
2149 If the magic numbers were moved to a separate file, this function
2150 would be target independent and would also be much more successful
2151 at linking together COFF files for different architectures. */
2154 coff_set_arch_mach_hook (bfd
*abfd
, void * filehdr
)
2156 unsigned long machine
;
2157 enum bfd_architecture arch
;
2158 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
2160 /* Zero selects the default machine for an arch. */
2162 switch (internal_f
->f_magic
)
2167 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler. */
2169 case I386_APPLE_MAGIC
:
2170 case I386_FREEBSD_MAGIC
:
2171 case I386_LINUX_MAGIC
:
2172 case I386_NETBSD_MAGIC
:
2173 arch
= bfd_arch_i386
;
2178 case AMD64_APPLE_MAGIC
:
2179 case AMD64_FREEBSD_MAGIC
:
2180 case AMD64_LINUX_MAGIC
:
2181 case AMD64_NETBSD_MAGIC
:
2182 arch
= bfd_arch_i386
;
2183 machine
= bfd_mach_x86_64
;
2188 arch
= bfd_arch_ia64
;
2195 arch
= bfd_arch_arm
;
2196 machine
= bfd_arm_get_mach_from_notes (abfd
, ARM_NOTE_SECTION
);
2197 if (machine
== bfd_mach_arm_unknown
)
2199 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
2201 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
2202 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
2203 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
2205 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
2206 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
2207 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
2208 /* The COFF header does not have enough bits available
2209 to cover all the different ARM architectures. So
2210 we interpret F_ARM_5, the highest flag value to mean
2211 "the highest ARM architecture known to BFD" which is
2212 currently the XScale. */
2213 case F_ARM_5
: machine
= bfd_mach_arm_XScale
; break;
2220 arch
= bfd_arch_z80
;
2221 switch (internal_f
->f_flags
& F_MACHMASK
)
2223 case bfd_mach_z80strict
<< 12:
2224 case bfd_mach_z80
<< 12:
2225 case bfd_mach_z80n
<< 12:
2226 case bfd_mach_z80full
<< 12:
2227 case bfd_mach_r800
<< 12:
2228 case bfd_mach_gbz80
<< 12:
2229 case bfd_mach_z180
<< 12:
2230 case bfd_mach_ez80_z80
<< 12:
2231 case bfd_mach_ez80_adl
<< 12:
2232 machine
= ((unsigned)internal_f
->f_flags
& F_MACHMASK
) >> 12;
2241 arch
= bfd_arch_z8k
;
2242 switch (internal_f
->f_flags
& F_MACHMASK
)
2245 machine
= bfd_mach_z8001
;
2248 machine
= bfd_mach_z8002
;
2268 if (xcoff_data (abfd
)->cputype
!= -1)
2269 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
2272 /* We did not get a value from the a.out header. If the
2273 file has not been stripped, we may be able to get the
2274 architecture information from the first symbol, if it
2275 is a .file symbol. */
2276 if (obj_raw_syment_count (abfd
) == 0)
2281 struct internal_syment sym
;
2282 bfd_size_type amt
= bfd_coff_symesz (abfd
);
2284 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
2286 buf
= _bfd_malloc_and_read (abfd
, amt
, amt
);
2289 bfd_coff_swap_sym_in (abfd
, buf
, & sym
);
2290 if (sym
.n_sclass
== C_FILE
)
2291 cputype
= sym
.n_type
& 0xff;
2298 /* FIXME: We don't handle all cases here. */
2303 arch
= bfd_xcoff_architecture (abfd
);
2304 machine
= bfd_xcoff_machine (abfd
);
2308 arch
= bfd_arch_powerpc
;
2309 machine
= bfd_mach_ppc_601
;
2311 case 2: /* 64 bit PowerPC */
2312 arch
= bfd_arch_powerpc
;
2313 machine
= bfd_mach_ppc_620
;
2316 arch
= bfd_arch_powerpc
;
2317 machine
= bfd_mach_ppc
;
2320 arch
= bfd_arch_rs6000
;
2321 machine
= bfd_mach_rs6k
;
2328 #ifdef SH_ARCH_MAGIC_BIG
2329 case SH_ARCH_MAGIC_BIG
:
2330 case SH_ARCH_MAGIC_LITTLE
:
2332 case SH_ARCH_MAGIC_WINCE
:
2338 #ifdef MIPS_ARCH_MAGIC_WINCE
2339 case MIPS_ARCH_MAGIC_WINCE
:
2340 arch
= bfd_arch_mips
;
2346 #ifdef LYNXCOFFMAGIC
2349 arch
= bfd_arch_sparc
;
2355 arch
= bfd_arch_tic30
;
2360 #ifdef TICOFF_TARGET_ARCH
2361 /* This TI COFF section should be used by all new TI COFF v0 targets. */
2363 arch
= TICOFF_TARGET_ARCH
;
2364 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2370 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */
2371 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */
2374 switch (internal_f
->f_target_id
)
2378 arch
= TICOFF_TARGET_ARCH
;
2379 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2383 arch
= bfd_arch_obscure
;
2385 (_("unrecognized TI COFF target id '0x%x'"),
2386 internal_f
->f_target_id
);
2394 arch
= bfd_arch_mcore
;
2398 default: /* Unreadable input file type. */
2399 arch
= bfd_arch_obscure
;
2403 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2408 symname_in_debug_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2409 struct internal_syment
*sym ATTRIBUTE_UNUSED
)
2411 #ifdef SYMNAME_IN_DEBUG
2412 return SYMNAME_IN_DEBUG (sym
) != 0;
2421 #define FORCE_SYMNAMES_IN_STRINGS
2424 /* Handle the csect auxent of a C_EXT, C_AIX_WEAKEXT or C_HIDEXT symbol. */
2427 coff_pointerize_aux_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2428 combined_entry_type
*table_base
,
2429 combined_entry_type
*symbol
,
2430 unsigned int indaux
,
2431 combined_entry_type
*aux
)
2433 BFD_ASSERT (symbol
->is_sym
);
2434 int n_sclass
= symbol
->u
.syment
.n_sclass
;
2436 if (CSECT_SYM_P (n_sclass
)
2437 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2439 BFD_ASSERT (! aux
->is_sym
);
2440 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2442 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2443 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2444 aux
->fix_scnlen
= 1;
2447 /* Return TRUE to indicate that the caller should not do any
2448 further work on this auxent. */
2452 /* Return FALSE to indicate that this auxent should be handled by
2458 #define coff_pointerize_aux_hook 0
2459 #endif /* ! RS6000COFF_C */
2461 /* Print an aux entry. This returns TRUE if it has printed it. */
2464 coff_print_aux (bfd
*abfd ATTRIBUTE_UNUSED
,
2465 FILE *file ATTRIBUTE_UNUSED
,
2466 combined_entry_type
*table_base ATTRIBUTE_UNUSED
,
2467 combined_entry_type
*symbol ATTRIBUTE_UNUSED
,
2468 combined_entry_type
*aux ATTRIBUTE_UNUSED
,
2469 unsigned int indaux ATTRIBUTE_UNUSED
)
2471 BFD_ASSERT (symbol
->is_sym
);
2472 BFD_ASSERT (! aux
->is_sym
);
2474 if (CSECT_SYM_P (symbol
->u
.syment
.n_sclass
)
2475 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2477 /* This is a csect entry. */
2478 fprintf (file
, "AUX ");
2479 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2481 BFD_ASSERT (! aux
->fix_scnlen
);
2482 fprintf (file
, "val %5" BFD_VMA_FMT
"d",
2483 aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2487 fprintf (file
, "indx ");
2488 if (! aux
->fix_scnlen
)
2489 fprintf (file
, "%4" BFD_VMA_FMT
"d",
2490 aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2492 fprintf (file
, "%4ld",
2493 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2496 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2497 aux
->u
.auxent
.x_csect
.x_parmhash
,
2498 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2499 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2500 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2501 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2502 aux
->u
.auxent
.x_csect
.x_stab
,
2503 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2508 /* Return FALSE to indicate that no special action was taken. */
2516 To write relocations, the back end steps though the
2517 canonical relocation table and create an
2518 @code{internal_reloc}. The symbol index to use is removed from
2519 the @code{offset} field in the symbol table supplied. The
2520 address comes directly from the sum of the section base
2521 address and the relocation offset; the type is dug directly
2522 from the howto field. Then the @code{internal_reloc} is
2523 swapped into the shape of an @code{external_reloc} and written
2531 /* AUX's ld wants relocations to be sorted. */
2533 compare_arelent_ptr (const void * x
, const void * y
)
2535 const arelent
**a
= (const arelent
**) x
;
2536 const arelent
**b
= (const arelent
**) y
;
2537 bfd_size_type aadr
= (*a
)->address
;
2538 bfd_size_type badr
= (*b
)->address
;
2540 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2543 #endif /* TARG_AUX */
2546 coff_write_relocs (bfd
* abfd
, int first_undef
)
2550 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2553 struct external_reloc dst
;
2560 /* Sort relocations before we write them out. */
2563 amt
= s
->reloc_count
;
2564 amt
*= sizeof (arelent
*);
2565 p
= bfd_malloc (amt
);
2568 if (s
->reloc_count
> 0)
2573 memcpy (p
, s
->orelocation
, (size_t) amt
);
2574 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2579 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2582 #ifdef COFF_WITH_EXTENDED_RELOC_COUNTER
2583 if ((obj_pe (abfd
) || obj_go32 (abfd
)) && s
->reloc_count
>= 0xffff)
2585 /* Encode real count here as first reloc. */
2586 struct internal_reloc n
;
2588 memset (& n
, 0, sizeof (n
));
2589 /* Add one to count *this* reloc (grr). */
2590 n
.r_vaddr
= s
->reloc_count
+ 1;
2591 coff_swap_reloc_out (abfd
, &n
, &dst
);
2592 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2593 abfd
) != bfd_coff_relsz (abfd
))
2598 for (i
= 0; i
< s
->reloc_count
; i
++)
2600 struct internal_reloc n
;
2603 memset (& n
, 0, sizeof (n
));
2605 /* Now we've renumbered the symbols we know where the
2606 undefined symbols live in the table. Check the reloc
2607 entries for symbols who's output bfd isn't the right one.
2608 This is because the symbol was undefined (which means
2609 that all the pointers are never made to point to the same
2610 place). This is a bad thing,'cause the symbols attached
2611 to the output bfd are indexed, so that the relocation
2612 entries know which symbol index they point to. So we
2613 have to look up the output symbol here. */
2615 if (q
->sym_ptr_ptr
[0] != NULL
&& q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2618 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2619 asymbol
**outsyms
= abfd
->outsymbols
;
2621 for (j
= first_undef
; outsyms
[j
]; j
++)
2623 const char *intable
= outsyms
[j
]->name
;
2625 if (strcmp (intable
, sname
) == 0)
2627 /* Got a hit, so repoint the reloc. */
2628 q
->sym_ptr_ptr
= outsyms
+ j
;
2634 n
.r_vaddr
= q
->address
+ s
->vma
;
2637 /* The 29k const/consth reloc pair is a real kludge. The consth
2638 part doesn't have a symbol; it has an offset. So rebuilt
2640 if (q
->howto
->type
== R_IHCONST
)
2641 n
.r_symndx
= q
->addend
;
2644 if (q
->sym_ptr_ptr
&& q
->sym_ptr_ptr
[0] != NULL
)
2646 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2647 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
, s
))
2649 if ((*q
->sym_ptr_ptr
)->section
== bfd_abs_section_ptr
2650 && ((*q
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) != 0)
2652 /* This is a relocation relative to the absolute symbol. */
2656 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2657 /* Check to see if the symbol reloc points to a symbol
2658 we don't have in our symbol table. */
2659 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2661 bfd_set_error (bfd_error_bad_value
);
2662 /* xgettext:c-format */
2663 _bfd_error_handler (_("%pB: reloc against a non-existent"
2664 " symbol index: %ld"),
2671 #ifdef SWAP_OUT_RELOC_OFFSET
2672 n
.r_offset
= q
->addend
;
2676 /* Work out reloc type from what is required. */
2677 SELECT_RELOC (n
, q
->howto
);
2679 n
.r_type
= q
->howto
->type
;
2681 coff_swap_reloc_out (abfd
, &n
, &dst
);
2683 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2684 abfd
) != bfd_coff_relsz (abfd
))
2696 /* Set flags and magic number of a coff file from architecture and machine
2697 type. Result is TRUE if we can represent the arch&type, FALSE if not. */
2700 coff_set_flags (bfd
* abfd
,
2701 unsigned int *magicp ATTRIBUTE_UNUSED
,
2702 unsigned short *flagsp ATTRIBUTE_UNUSED
)
2704 switch (bfd_get_arch (abfd
))
2709 switch (bfd_get_mach (abfd
))
2711 case bfd_mach_z80strict
:
2714 case bfd_mach_z80full
:
2716 case bfd_mach_gbz80
:
2718 case bfd_mach_ez80_z80
:
2719 case bfd_mach_ez80_adl
:
2720 *flagsp
= bfd_get_mach (abfd
) << 12;
2732 switch (bfd_get_mach (abfd
))
2734 case bfd_mach_z8001
: *flagsp
= F_Z8001
; break;
2735 case bfd_mach_z8002
: *flagsp
= F_Z8002
; break;
2736 default: return FALSE
;
2742 case bfd_arch_tic30
:
2743 *magicp
= TIC30MAGIC
;
2747 #ifdef TICOFF_DEFAULT_MAGIC
2748 case TICOFF_TARGET_ARCH
:
2749 /* If there's no indication of which version we want, use the default. */
2751 *magicp
= TICOFF_DEFAULT_MAGIC
;
2754 /* We may want to output in a different COFF version. */
2755 switch (abfd
->xvec
->name
[4])
2758 *magicp
= TICOFF0MAGIC
;
2761 *magicp
= TICOFF1MAGIC
;
2764 *magicp
= TICOFF2MAGIC
;
2770 TICOFF_TARGET_MACHINE_SET (flagsp
, bfd_get_mach (abfd
));
2777 * magicp
= ARMPEMAGIC
;
2779 * magicp
= ARMMAGIC
;
2782 if (APCS_SET (abfd
))
2784 if (APCS_26_FLAG (abfd
))
2785 * flagsp
|= F_APCS26
;
2787 if (APCS_FLOAT_FLAG (abfd
))
2788 * flagsp
|= F_APCS_FLOAT
;
2790 if (PIC_FLAG (abfd
))
2793 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2794 * flagsp
|= F_INTERWORK
;
2795 switch (bfd_get_mach (abfd
))
2797 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2798 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2799 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2800 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2801 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2802 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2803 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2804 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2805 See also the comment in coff_set_arch_mach_hook(). */
2806 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break;
2807 case bfd_mach_arm_5TE
: * flagsp
|= F_ARM_5
; break;
2808 case bfd_mach_arm_XScale
: * flagsp
|= F_ARM_5
; break;
2813 #if defined(I386MAGIC) || defined(AMD64MAGIC)
2815 #if defined(I386MAGIC)
2816 *magicp
= I386MAGIC
;
2819 /* Just overwrite the usual value if we're doing Lynx. */
2820 *magicp
= LYNXCOFFMAGIC
;
2822 #if defined AMD64MAGIC
2823 *magicp
= AMD64MAGIC
;
2830 *magicp
= IA64MAGIC
;
2834 #ifdef SH_ARCH_MAGIC_BIG
2836 #ifdef COFF_IMAGE_WITH_PE
2837 *magicp
= SH_ARCH_MAGIC_WINCE
;
2839 if (bfd_big_endian (abfd
))
2840 *magicp
= SH_ARCH_MAGIC_BIG
;
2842 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2847 #ifdef MIPS_ARCH_MAGIC_WINCE
2849 *magicp
= MIPS_ARCH_MAGIC_WINCE
;
2854 case bfd_arch_sparc
:
2855 *magicp
= SPARCMAGIC
;
2857 /* Just overwrite the usual value if we're doing Lynx. */
2858 *magicp
= LYNXCOFFMAGIC
;
2864 case bfd_arch_rs6000
:
2865 case bfd_arch_powerpc
:
2866 BFD_ASSERT (bfd_get_flavour (abfd
) == bfd_target_xcoff_flavour
);
2867 *magicp
= bfd_xcoff_magic_number (abfd
);
2872 case bfd_arch_mcore
:
2873 * magicp
= MCOREMAGIC
;
2877 default: /* Unknown architecture. */
2878 /* Fall through to "return FALSE" below, to avoid
2879 "statement never reached" errors on the one below. */
2887 coff_set_arch_mach (bfd
* abfd
,
2888 enum bfd_architecture arch
,
2889 unsigned long machine
)
2892 unsigned short dummy2
;
2894 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
2897 if (arch
!= bfd_arch_unknown
2898 && ! coff_set_flags (abfd
, &dummy1
, &dummy2
))
2899 return FALSE
; /* We can't represent this type. */
2901 return TRUE
; /* We're easy... */
2904 #ifdef COFF_IMAGE_WITH_PE
2906 /* This is used to sort sections by VMA, as required by PE image
2910 sort_by_secaddr (const void * arg1
, const void * arg2
)
2912 const asection
*a
= *(const asection
**) arg1
;
2913 const asection
*b
= *(const asection
**) arg2
;
2915 if (a
->vma
< b
->vma
)
2917 else if (a
->vma
> b
->vma
)
2923 #endif /* COFF_IMAGE_WITH_PE */
2925 /* Calculate the file position for each section. */
2927 #define ALIGN_SECTIONS_IN_FILE
2929 #undef ALIGN_SECTIONS_IN_FILE
2933 coff_compute_section_file_positions (bfd
* abfd
)
2936 file_ptr sofar
= bfd_coff_filhsz (abfd
);
2937 bfd_boolean align_adjust
;
2938 unsigned int target_index
;
2939 #ifdef ALIGN_SECTIONS_IN_FILE
2940 asection
*previous
= NULL
;
2944 #ifdef COFF_IMAGE_WITH_PE
2947 if (coff_data (abfd
)->link_info
2948 || (pe_data (abfd
) && pe_data (abfd
)->pe_opthdr
.FileAlignment
))
2950 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
2952 /* If no file alignment has been set, default to one.
2953 This repairs 'ld -r' for arm-wince-pe target. */
2957 /* PR 17512: file: 0ac816d3. */
2960 bfd_set_error (bfd_error_file_too_big
);
2962 /* xgettext:c-format */
2963 (_("%pB: page size is too large (0x%x)"), abfd
, page_size
);
2968 page_size
= PE_DEF_FILE_ALIGNMENT
;
2970 #ifdef COFF_PAGE_SIZE
2971 int page_size
= COFF_PAGE_SIZE
;
2976 /* On XCOFF, if we have symbols, set up the .debug section. */
2977 if (bfd_get_symcount (abfd
) > 0)
2980 bfd_size_type i
, symcount
;
2984 symcount
= bfd_get_symcount (abfd
);
2985 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
2987 coff_symbol_type
*cf
;
2989 cf
= coff_symbol_from (*symp
);
2991 && cf
->native
!= NULL
2992 && cf
->native
->is_sym
2993 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
2997 len
= strlen (bfd_asymbol_name (*symp
));
2998 if (len
> SYMNMLEN
|| bfd_coff_force_symnames_in_strings (abfd
))
2999 sz
+= len
+ 1 + bfd_coff_debug_string_prefix_length (abfd
);
3006 dsec
= bfd_make_section_old_way (abfd
, DOT_DEBUG
);
3010 dsec
->flags
|= SEC_HAS_CONTENTS
;
3015 if (bfd_get_start_address (abfd
))
3016 /* A start address may have been added to the original file. In this
3017 case it will need an optional header to record it. */
3018 abfd
->flags
|= EXEC_P
;
3020 if (abfd
->flags
& EXEC_P
)
3021 sofar
+= bfd_coff_aoutsz (abfd
);
3023 else if (xcoff_data (abfd
)->full_aouthdr
)
3024 sofar
+= bfd_coff_aoutsz (abfd
);
3026 sofar
+= SMALL_AOUTSZ
;
3029 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
3032 /* XCOFF handles overflows in the reloc and line number count fields
3033 by allocating a new section header to hold the correct counts. */
3034 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3035 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3036 sofar
+= bfd_coff_scnhsz (abfd
);
3039 #ifdef COFF_IMAGE_WITH_PE
3041 /* PE requires the sections to be in memory order when listed in
3042 the section headers. It also does not like empty loadable
3043 sections. The sections apparently do not have to be in the
3044 right order in the image file itself, but we do need to get the
3045 target_index values right. */
3048 asection
**section_list
;
3052 #ifdef COFF_PAGE_SIZE
3053 /* Clear D_PAGED if section alignment is smaller than
3055 if (pe_data (abfd
)->pe_opthdr
.SectionAlignment
< COFF_PAGE_SIZE
)
3056 abfd
->flags
&= ~D_PAGED
;
3060 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3063 /* We allocate an extra cell to simplify the final loop. */
3064 amt
= sizeof (struct asection
*) * (count
+ 1);
3065 section_list
= (asection
**) bfd_malloc (amt
);
3066 if (section_list
== NULL
)
3070 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3072 section_list
[i
] = current
;
3075 section_list
[i
] = NULL
;
3077 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
3079 /* Rethread the linked list into sorted order; at the same time,
3080 assign target_index values. */
3082 abfd
->sections
= NULL
;
3083 abfd
->section_last
= NULL
;
3084 for (i
= 0; i
< count
; i
++)
3086 current
= section_list
[i
];
3087 bfd_section_list_append (abfd
, current
);
3089 /* Later, if the section has zero size, we'll be throwing it
3090 away, so we don't want to number it now. Note that having
3091 a zero size and having real contents are different
3092 concepts: .bss has no contents, but (usually) non-zero
3094 if (current
->size
== 0)
3096 /* Discard. However, it still might have (valid) symbols
3097 in it, so arbitrarily set it to section 1 (indexing is
3098 1-based here; usually .text). __end__ and other
3099 contents of .endsection really have this happen.
3100 FIXME: This seems somewhat dubious. */
3101 current
->target_index
= 1;
3104 current
->target_index
= target_index
++;
3107 free (section_list
);
3109 #else /* ! COFF_IMAGE_WITH_PE */
3111 /* Set the target_index field. */
3113 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3114 current
->target_index
= target_index
++;
3116 #endif /* ! COFF_IMAGE_WITH_PE */
3118 if (target_index
>= bfd_coff_max_nscns (abfd
))
3120 bfd_set_error (bfd_error_file_too_big
);
3122 /* xgettext:c-format */
3123 (_("%pB: too many sections (%d)"), abfd
, target_index
);
3127 align_adjust
= FALSE
;
3128 for (current
= abfd
->sections
;
3130 current
= current
->next
)
3132 #ifdef COFF_IMAGE_WITH_PE
3133 /* With PE we have to pad each section to be a multiple of its
3134 page size too, and remember both sizes. */
3135 if (coff_section_data (abfd
, current
) == NULL
)
3137 size_t amt
= sizeof (struct coff_section_tdata
);
3139 current
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
3140 if (current
->used_by_bfd
== NULL
)
3143 if (pei_section_data (abfd
, current
) == NULL
)
3145 size_t amt
= sizeof (struct pei_section_tdata
);
3147 coff_section_data (abfd
, current
)->tdata
= bfd_zalloc (abfd
, amt
);
3148 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
3151 if (pei_section_data (abfd
, current
)->virt_size
== 0)
3152 pei_section_data (abfd
, current
)->virt_size
= current
->size
;
3155 /* Only deal with sections which have contents. */
3156 if (!(current
->flags
& SEC_HAS_CONTENTS
))
3159 current
->rawsize
= current
->size
;
3161 #ifdef COFF_IMAGE_WITH_PE
3162 /* Make sure we skip empty sections in a PE image. */
3163 if (current
->size
== 0)
3167 /* Align the sections in the file to the same boundary on
3168 which they are aligned in virtual memory. */
3169 #ifdef ALIGN_SECTIONS_IN_FILE
3170 if ((abfd
->flags
& EXEC_P
) != 0)
3172 /* Make sure this section is aligned on the right boundary - by
3173 padding the previous section up if necessary. */
3176 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3179 /* Make sure the file offset and the vma of .text/.data are at the
3180 same page offset, so that the file can be mmap'ed without being
3181 relocated. Failing that, AIX is able to load and execute the
3182 program, but it will be silently relocated (possible as
3183 executables are PIE). But the relocation is slightly costly and
3184 complexify the use of addr2line or gdb. So better to avoid it,
3185 like does the native linker. Usually gnu ld makes sure that
3186 the vma of .text is the file offset so this issue shouldn't
3187 appear unless you are stripping such an executable.
3189 AIX loader checks the text section alignment of (vma - filepos),
3190 and the native linker doesn't try to align the text sections.
3193 0 .text 000054cc 10000128 10000128 00000128 2**5
3194 CONTENTS, ALLOC, LOAD, CODE
3196 Don't perform the above tweak if the previous one is .tdata,
3197 as it will increase the memory allocated for every threads
3198 created and not just improve performances with gdb.
3201 if ((!strcmp (current
->name
, _TEXT
)
3202 || !strcmp (current
->name
, _DATA
))
3203 && (previous
== NULL
|| strcmp(previous
->name
, _TDATA
)))
3205 bfd_vma align
= 4096;
3206 bfd_vma sofar_off
= sofar
% align
;
3207 bfd_vma vma_off
= current
->vma
% align
;
3209 if (vma_off
> sofar_off
)
3210 sofar
+= vma_off
- sofar_off
;
3211 else if (vma_off
< sofar_off
)
3212 sofar
+= align
+ vma_off
- sofar_off
;
3215 if (previous
!= NULL
)
3216 previous
->size
+= sofar
- old_sofar
;
3221 /* In demand paged files the low order bits of the file offset
3222 must match the low order bits of the virtual address. */
3223 #ifdef COFF_PAGE_SIZE
3224 if ((abfd
->flags
& D_PAGED
) != 0
3225 && (current
->flags
& SEC_ALLOC
) != 0)
3226 sofar
+= (current
->vma
- (bfd_vma
) sofar
) % page_size
;
3228 current
->filepos
= sofar
;
3230 #ifdef COFF_IMAGE_WITH_PE
3231 /* Set the padded size. */
3232 current
->size
= (current
->size
+ page_size
- 1) & -page_size
;
3235 sofar
+= current
->size
;
3237 #ifdef ALIGN_SECTIONS_IN_FILE
3238 /* Make sure that this section is of the right size too. */
3239 if ((abfd
->flags
& EXEC_P
) == 0)
3241 bfd_size_type old_size
;
3243 old_size
= current
->size
;
3244 current
->size
= BFD_ALIGN (current
->size
,
3245 1 << current
->alignment_power
);
3246 align_adjust
= current
->size
!= old_size
;
3247 sofar
+= current
->size
- old_size
;
3252 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3253 align_adjust
= sofar
!= old_sofar
;
3254 current
->size
+= sofar
- old_sofar
;
3258 #ifdef COFF_IMAGE_WITH_PE
3259 /* For PE we need to make sure we pad out to the aligned
3260 size, in case the caller only writes out data to the
3262 if (pei_section_data (abfd
, current
)->virt_size
< current
->size
)
3263 align_adjust
= TRUE
;
3267 /* Force .lib sections to start at zero. The vma is then
3268 incremented in coff_set_section_contents. This is right for
3270 if (strcmp (current
->name
, _LIB
) == 0)
3271 bfd_set_section_vma (current
, 0);
3274 #ifdef ALIGN_SECTIONS_IN_FILE
3279 /* It is now safe to write to the output file. If we needed an
3280 alignment adjustment for the last section, then make sure that
3281 there is a byte at offset sofar. If there are no symbols and no
3282 relocs, then nothing follows the last section. If we don't force
3283 the last byte out, then the file may appear to be truncated. */
3289 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
3290 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3294 /* Make sure the relocations are aligned. We don't need to make
3295 sure that this byte exists, because it will only matter if there
3296 really are relocs. */
3297 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
3299 obj_relocbase (abfd
) = sofar
;
3300 abfd
->output_has_begun
= TRUE
;
3305 #ifdef COFF_IMAGE_WITH_PE
3308 coff_read_word (bfd
*abfd
, unsigned int *value
, unsigned int *pelength
)
3313 status
= bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3321 *value
= (unsigned int) b
[0];
3323 *value
= (unsigned int) (b
[0] + (b
[1] << 8));
3325 *pelength
+= status
;
3331 coff_compute_checksum (bfd
*abfd
, unsigned int *pelength
)
3333 bfd_boolean more_data
;
3340 filepos
= (file_ptr
) 0;
3344 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
3347 more_data
= coff_read_word (abfd
, &value
, pelength
);
3349 total
= 0xffff & (total
+ (total
>> 0x10));
3354 return (0xffff & (total
+ (total
>> 0x10)));
3358 coff_apply_checksum (bfd
*abfd
)
3360 unsigned int computed
;
3361 unsigned int checksum
= 0;
3362 unsigned int peheader
;
3363 unsigned int pelength
;
3365 if (bfd_seek (abfd
, 0x3c, SEEK_SET
) != 0)
3368 if (!coff_read_word (abfd
, &peheader
, &pelength
))
3371 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3375 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3377 if (bfd_seek (abfd
, peheader
, SEEK_SET
) != 0)
3380 computed
= coff_compute_checksum (abfd
, &pelength
);
3382 checksum
= computed
+ pelength
;
3384 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3387 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3392 #endif /* COFF_IMAGE_WITH_PE */
3395 coff_write_object_contents (bfd
* abfd
)
3398 bfd_boolean hasrelocs
= FALSE
;
3399 bfd_boolean haslinno
= FALSE
;
3400 #ifdef COFF_IMAGE_WITH_PE
3401 bfd_boolean hasdebug
= FALSE
;
3404 file_ptr reloc_base
;
3405 file_ptr lineno_base
;
3407 unsigned long reloc_size
= 0, reloc_count
= 0;
3408 unsigned long lnno_size
= 0;
3409 bfd_boolean long_section_names
;
3410 asection
*text_sec
= NULL
;
3411 asection
*data_sec
= NULL
;
3412 asection
*bss_sec
= NULL
;
3414 asection
*tdata_sec
= NULL
;
3415 asection
*tbss_sec
= NULL
;
3417 struct internal_filehdr internal_f
;
3418 struct internal_aouthdr internal_a
;
3419 #ifdef COFF_LONG_SECTION_NAMES
3420 size_t string_size
= STRING_SIZE_SIZE
;
3423 bfd_set_error (bfd_error_system_call
);
3425 /* Make a pass through the symbol table to count line number entries and
3426 put them into the correct asections. */
3427 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3429 if (! abfd
->output_has_begun
)
3431 if (! coff_compute_section_file_positions (abfd
))
3435 reloc_base
= obj_relocbase (abfd
);
3437 /* Work out the size of the reloc and linno areas. */
3439 for (current
= abfd
->sections
; current
!= NULL
; current
=
3442 #ifdef COFF_WITH_EXTENDED_RELOC_COUNTER
3443 /* We store the actual reloc count in the first reloc's addr. */
3444 if ((obj_pe (abfd
) || obj_go32 (abfd
)) && current
->reloc_count
>= 0xffff)
3447 reloc_count
+= current
->reloc_count
;
3450 reloc_size
= reloc_count
* bfd_coff_relsz (abfd
);
3452 lineno_base
= reloc_base
+ reloc_size
;
3453 sym_base
= lineno_base
+ lnno_size
;
3455 /* Indicate in each section->line_filepos its actual file address. */
3456 for (current
= abfd
->sections
; current
!= NULL
; current
=
3459 if (current
->lineno_count
)
3461 current
->line_filepos
= lineno_base
;
3462 current
->moving_line_filepos
= lineno_base
;
3463 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3466 current
->line_filepos
= 0;
3468 if (current
->reloc_count
)
3470 current
->rel_filepos
= reloc_base
;
3471 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3472 #ifdef COFF_WITH_EXTENDED_RELOC_COUNTER
3473 /* Extra reloc to hold real count. */
3474 if ((obj_pe (abfd
) || obj_go32 (abfd
)) && current
->reloc_count
>= 0xffff)
3475 reloc_base
+= bfd_coff_relsz (abfd
);
3479 current
->rel_filepos
= 0;
3482 /* Write section headers to the file. */
3483 internal_f
.f_nscns
= 0;
3485 if ((abfd
->flags
& EXEC_P
) != 0)
3486 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3489 scn_base
= bfd_coff_filhsz (abfd
);
3492 if (xcoff_data (abfd
)->full_aouthdr
)
3493 scn_base
+= bfd_coff_aoutsz (abfd
);
3495 scn_base
+= SMALL_AOUTSZ
;
3500 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3503 long_section_names
= FALSE
;
3504 for (current
= abfd
->sections
;
3506 current
= current
->next
)
3508 struct internal_scnhdr section
;
3509 #ifdef COFF_IMAGE_WITH_PE
3510 bfd_boolean is_reloc_section
= FALSE
;
3512 if (strcmp (current
->name
, DOT_RELOC
) == 0)
3514 is_reloc_section
= TRUE
;
3516 pe_data (abfd
)->has_reloc_section
= 1;
3520 internal_f
.f_nscns
++;
3522 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3524 #ifdef COFF_LONG_SECTION_NAMES
3525 /* Handle long section names as in PE. This must be compatible
3526 with the code in coff_write_symbols and _bfd_coff_final_link. */
3527 if (bfd_coff_long_section_names (abfd
))
3531 len
= strlen (current
->name
);
3534 /* The s_name field is defined to be NUL-padded but need not be
3535 NUL-terminated. We use a temporary buffer so that we can still
3536 sprintf all eight chars without splatting a terminating NUL
3537 over the first byte of the following member (s_paddr). */
3538 /* PR 21096: The +20 is to stop a bogus warning from gcc7 about
3539 a possible buffer overflow. */
3540 char s_name_buf
[SCNNMLEN
+ 1 + 20];
3542 /* An inherent limitation of the /nnnnnnn notation used to indicate
3543 the offset of the long name in the string table is that we
3544 cannot address entries beyone the ten million byte boundary. */
3545 if (string_size
>= 10000000)
3547 bfd_set_error (bfd_error_file_too_big
);
3549 /* xgettext:c-format */
3550 (_("%pB: section %pA: string table overflow at offset %ld"),
3551 abfd
, current
, (unsigned long) string_size
);
3555 /* We do not need to use snprintf here as we have already verfied
3556 that string_size is not too big, plus we have an overlarge
3557 buffer, just in case. */
3558 sprintf (s_name_buf
, "/%lu", (unsigned long) string_size
);
3559 /* Then strncpy takes care of any padding for us. */
3560 strncpy (section
.s_name
, s_name_buf
, SCNNMLEN
);
3561 string_size
+= len
+ 1;
3562 long_section_names
= TRUE
;
3568 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3569 Ian Taylor <ian@cygnus.com>. */
3570 if (strcmp (current
->name
, _LIB
) == 0)
3571 section
.s_vaddr
= 0;
3574 section
.s_vaddr
= current
->vma
;
3575 section
.s_paddr
= current
->lma
;
3576 section
.s_size
= current
->size
;
3577 #ifdef coff_get_section_load_page
3578 section
.s_page
= coff_get_section_load_page (current
);
3584 section
.s_paddr
= 0;
3586 #ifdef COFF_IMAGE_WITH_PE
3587 /* Reminder: s_paddr holds the virtual size of the section. */
3588 if (coff_section_data (abfd
, current
) != NULL
3589 && pei_section_data (abfd
, current
) != NULL
)
3590 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3592 section
.s_paddr
= 0;
3595 /* If this section has no size or is unloadable then the scnptr
3597 if (current
->size
== 0
3598 || (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3599 section
.s_scnptr
= 0;
3601 section
.s_scnptr
= current
->filepos
;
3603 section
.s_relptr
= current
->rel_filepos
;
3604 section
.s_lnnoptr
= current
->line_filepos
;
3605 section
.s_nreloc
= current
->reloc_count
;
3606 section
.s_nlnno
= current
->lineno_count
;
3607 #ifndef COFF_IMAGE_WITH_PE
3608 /* In PEI, relocs come in the .reloc section. */
3609 if (current
->reloc_count
!= 0)
3612 if (current
->lineno_count
!= 0)
3614 #ifdef COFF_IMAGE_WITH_PE
3615 if ((current
->flags
& SEC_DEBUGGING
) != 0
3616 && ! is_reloc_section
)
3622 /* Indicate the use of an XCOFF overflow section header. */
3623 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3625 section
.s_nreloc
= 0xffff;
3626 section
.s_nlnno
= 0xffff;
3631 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3633 if (!strcmp (current
->name
, _TEXT
))
3635 else if (!strcmp (current
->name
, _DATA
))
3637 else if (!strcmp (current
->name
, _BSS
))
3640 else if (!strcmp (current
->name
, _TDATA
))
3641 tdata_sec
= current
;
3642 else if (!strcmp (current
->name
, _TBSS
))
3647 #ifdef COFF_ENCODE_ALIGNMENT
3648 COFF_ENCODE_ALIGNMENT(section
, current
->alignment_power
);
3649 if ((unsigned int)COFF_DECODE_ALIGNMENT(section
.s_flags
)
3650 != current
->alignment_power
)
3652 bfd_boolean warn
= coff_data (abfd
)->link_info
3653 && !bfd_link_relocatable (coff_data (abfd
)->link_info
);
3656 /* xgettext:c-format */
3657 (_("%pB:%s section %s: alignment 2**%u not representable"),
3658 abfd
, warn
? " warning:" : "", current
->name
,
3659 current
->alignment_power
);
3662 bfd_set_error (bfd_error_nonrepresentable_section
);
3668 #ifdef COFF_IMAGE_WITH_PE
3669 /* Suppress output of the sections if they are null. ld
3670 includes the bss and data sections even if there is no size
3671 assigned to them. NT loader doesn't like it if these section
3672 headers are included if the sections themselves are not
3673 needed. See also coff_compute_section_file_positions. */
3674 if (section
.s_size
== 0)
3675 internal_f
.f_nscns
--;
3680 bfd_size_type amt
= bfd_coff_scnhsz (abfd
);
3682 if (bfd_coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3683 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3688 /* PE stores COMDAT section information in the symbol table. If
3689 this section is supposed to have some COMDAT info, track down
3690 the symbol in the symbol table and modify it. */
3691 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3693 unsigned int i
, count
;
3695 coff_symbol_type
*csym
= NULL
;
3699 count
= bfd_get_symcount (abfd
);
3700 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3702 if ((*psym
)->section
!= current
)
3705 /* Remember the location of the first symbol in this
3707 if (psymsec
== NULL
)
3710 /* See if this is the section symbol. */
3711 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3713 csym
= coff_symbol_from (*psym
);
3715 || csym
->native
== NULL
3716 || ! csym
->native
->is_sym
3717 || csym
->native
->u
.syment
.n_numaux
< 1
3718 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3719 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3722 /* Here *PSYM is the section symbol for CURRENT. */
3729 Note that we might not if we're converting the file from
3730 some other object file format. */
3733 combined_entry_type
*aux
;
3735 /* We don't touch the x_checksum field. The
3736 x_associated field is not currently supported. */
3738 aux
= csym
->native
+ 1;
3739 BFD_ASSERT (! aux
->is_sym
);
3740 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3742 case SEC_LINK_DUPLICATES_DISCARD
:
3743 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3746 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3747 aux
->u
.auxent
.x_scn
.x_comdat
=
3748 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3751 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3752 aux
->u
.auxent
.x_scn
.x_comdat
=
3753 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3756 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3757 aux
->u
.auxent
.x_scn
.x_comdat
=
3758 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3762 /* The COMDAT symbol must be the first symbol from this
3763 section in the symbol table. In order to make this
3764 work, we move the COMDAT symbol before the first
3765 symbol we found in the search above. It's OK to
3766 rearrange the symbol table at this point, because
3767 coff_renumber_symbols is going to rearrange it
3768 further and fix up all the aux entries. */
3769 if (psym
!= psymsec
)
3775 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3776 pcopy
[0] = pcopy
[-1];
3781 #endif /* COFF_WITH_PE */
3786 /* XCOFF handles overflows in the reloc and line number count fields
3787 by creating a new section header to hold the correct values. */
3788 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3790 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3792 struct internal_scnhdr scnhdr
;
3796 internal_f
.f_nscns
++;
3797 memcpy (scnhdr
.s_name
, ".ovrflo", 8);
3798 scnhdr
.s_paddr
= current
->reloc_count
;
3799 scnhdr
.s_vaddr
= current
->lineno_count
;
3801 scnhdr
.s_scnptr
= 0;
3802 scnhdr
.s_relptr
= current
->rel_filepos
;
3803 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3804 scnhdr
.s_nreloc
= current
->target_index
;
3805 scnhdr
.s_nlnno
= current
->target_index
;
3806 scnhdr
.s_flags
= STYP_OVRFLO
;
3807 amt
= bfd_coff_scnhsz (abfd
);
3808 if (bfd_coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3809 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3816 #if defined (COFF_GO32_EXE) || defined (COFF_GO32)
3817 /* Pad section headers. */
3818 if ((abfd
->flags
& EXEC_P
) && abfd
->sections
!= NULL
)
3820 file_ptr cur_ptr
= scn_base
3821 + abfd
->section_count
* bfd_coff_scnhsz (abfd
);
3822 long fill_size
= (abfd
->sections
->filepos
- cur_ptr
);
3823 bfd_byte
*b
= bfd_zmalloc (fill_size
);
3826 bfd_bwrite ((PTR
)b
, fill_size
, abfd
);
3832 /* OK, now set up the filehdr... */
3834 /* Don't include the internal abs section in the section count */
3836 /* We will NOT put a fucking timestamp in the header here. Every time you
3837 put it back, I will come in and take it out again. I'm sorry. This
3838 field does not belong here. We fill it with a 0 so it compares the
3839 same but is not a reasonable time. -- gnu@cygnus.com */
3840 internal_f
.f_timdat
= 0;
3841 internal_f
.f_flags
= 0;
3843 if (abfd
->flags
& EXEC_P
)
3844 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3847 internal_f
.f_opthdr
= 0;
3850 if (xcoff_data (abfd
)->full_aouthdr
)
3851 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3853 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
3859 internal_f
.f_flags
|= F_RELFLG
;
3861 internal_f
.f_flags
|= F_LNNO
;
3862 if (abfd
->flags
& EXEC_P
)
3863 internal_f
.f_flags
|= F_EXEC
;
3864 #ifdef COFF_IMAGE_WITH_PE
3866 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
3867 if (pe_data (abfd
)->real_flags
& IMAGE_FILE_LARGE_ADDRESS_AWARE
)
3868 internal_f
.f_flags
|= IMAGE_FILE_LARGE_ADDRESS_AWARE
;
3871 #ifndef COFF_WITH_pex64
3873 internal_f
.f_flags
|= IMAGE_FILE_32BIT_MACHINE
;
3875 if (bfd_little_endian (abfd
))
3876 internal_f
.f_flags
|= F_AR32WR
;
3878 internal_f
.f_flags
|= F_AR32W
;
3883 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
3884 but it doesn't hurt to set it internally. */
3885 internal_f
.f_target_id
= TI_TARGET_ID
;
3888 /* FIXME, should do something about the other byte orders and
3892 if ((abfd
->flags
& DYNAMIC
) != 0)
3893 internal_f
.f_flags
|= F_SHROBJ
;
3894 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
3895 internal_f
.f_flags
|= F_DYNLOAD
;
3898 memset (&internal_a
, 0, sizeof internal_a
);
3900 /* Set up architecture-dependent stuff. */
3902 unsigned int magic
= 0;
3903 unsigned short flags
= 0;
3905 coff_set_flags (abfd
, &magic
, &flags
);
3906 internal_f
.f_magic
= magic
;
3907 internal_f
.f_flags
|= flags
;
3908 /* ...and the "opt"hdr... */
3910 #ifdef TICOFF_AOUT_MAGIC
3911 internal_a
.magic
= TICOFF_AOUT_MAGIC
;
3912 #define __A_MAGIC_SET__
3916 #define __A_MAGIC_SET__
3917 internal_a
.magic
= ZMAGIC
;
3920 #if defined MCORE_PE
3921 #define __A_MAGIC_SET__
3922 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3926 #define __A_MAGIC_SET__
3928 internal_a
.magic
= LYNXCOFFMAGIC
;
3930 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR64_MAGIC
;
3932 internal_a
.magic
= ZMAGIC
;
3937 #define __A_MAGIC_SET__
3938 internal_a
.magic
= PE32PMAGIC
;
3942 #define __A_MAGIC_SET__
3944 internal_a
.magic
= LYNXCOFFMAGIC
;
3949 #define __A_MAGIC_SET__
3950 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
3951 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
3952 RS6K_AOUTHDR_OMAGIC
;
3955 #if defined(SH) && defined(COFF_WITH_PE)
3956 #define __A_MAGIC_SET__
3957 internal_a
.magic
= SH_PE_MAGIC
;
3960 #if defined(MIPS) && defined(COFF_WITH_PE)
3961 #define __A_MAGIC_SET__
3962 internal_a
.magic
= MIPS_PE_MAGIC
;
3965 #ifndef __A_MAGIC_SET__
3966 #include "Your aouthdr magic number is not being set!"
3968 #undef __A_MAGIC_SET__
3972 /* FIXME: Does anybody ever set this to another value? */
3973 internal_a
.vstamp
= 0;
3975 /* Now should write relocs, strings, syms. */
3976 obj_sym_filepos (abfd
) = sym_base
;
3978 if (bfd_get_symcount (abfd
) != 0)
3982 if (!coff_renumber_symbols (abfd
, &firstundef
))
3984 coff_mangle_symbols (abfd
);
3985 if (! coff_write_symbols (abfd
))
3987 if (! coff_write_linenumbers (abfd
))
3989 if (! coff_write_relocs (abfd
, firstundef
))
3992 #ifdef COFF_LONG_SECTION_NAMES
3993 else if (long_section_names
&& ! obj_coff_strings_written (abfd
))
3995 /* If we have long section names we have to write out the string
3996 table even if there are no symbols. */
3997 if (! coff_write_symbols (abfd
))
4001 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
4002 backend linker, and obj_raw_syment_count is not valid until after
4003 coff_write_symbols is called. */
4004 if (obj_raw_syment_count (abfd
) != 0)
4006 internal_f
.f_symptr
= sym_base
;
4008 /* AIX appears to require that F_RELFLG not be set if there are
4009 local symbols but no relocations. */
4010 internal_f
.f_flags
&=~ F_RELFLG
;
4015 if (long_section_names
)
4016 internal_f
.f_symptr
= sym_base
;
4018 internal_f
.f_symptr
= 0;
4019 internal_f
.f_flags
|= F_LSYMS
;
4024 internal_a
.tsize
= text_sec
->size
;
4025 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
4029 internal_a
.dsize
= data_sec
->size
;
4030 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
4034 internal_a
.bsize
= bss_sec
->size
;
4035 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
4036 internal_a
.data_start
= bss_sec
->vma
;
4039 internal_a
.entry
= bfd_get_start_address (abfd
);
4040 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
4043 if (xcoff_data (abfd
)->full_aouthdr
)
4046 asection
*loader_sec
;
4048 internal_a
.vstamp
= 1;
4050 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
4051 if (internal_a
.o_snentry
== 0)
4052 internal_a
.entry
= (bfd_vma
) -1;
4054 if (text_sec
!= NULL
)
4056 internal_a
.o_sntext
= text_sec
->target_index
;
4057 internal_a
.o_algntext
= bfd_section_alignment (text_sec
);
4061 internal_a
.o_sntext
= 0;
4062 internal_a
.o_algntext
= 0;
4064 if (data_sec
!= NULL
)
4066 internal_a
.o_sndata
= data_sec
->target_index
;
4067 internal_a
.o_algndata
= bfd_section_alignment (data_sec
);
4071 internal_a
.o_sndata
= 0;
4072 internal_a
.o_algndata
= 0;
4074 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
4075 if (loader_sec
!= NULL
)
4076 internal_a
.o_snloader
= loader_sec
->target_index
;
4078 internal_a
.o_snloader
= 0;
4079 if (bss_sec
!= NULL
)
4080 internal_a
.o_snbss
= bss_sec
->target_index
;
4082 internal_a
.o_snbss
= 0;
4084 if (tdata_sec
!= NULL
)
4086 internal_a
.o_sntdata
= tdata_sec
->target_index
;
4087 /* TODO: o_flags should be set to RS6K_AOUTHDR_TLS_LE
4088 if there is at least one R_TLS_LE relocations. */
4089 internal_a
.o_flags
= 0;
4091 internal_a
.o_x64flags
= 0;
4096 internal_a
.o_sntdata
= 0;
4097 internal_a
.o_flags
= 0;
4099 internal_a
.o_x64flags
= 0;
4102 if (tbss_sec
!= NULL
)
4103 internal_a
.o_sntbss
= tbss_sec
->target_index
;
4105 internal_a
.o_sntbss
= 0;
4107 toc
= xcoff_data (abfd
)->toc
;
4108 internal_a
.o_toc
= toc
;
4109 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
4111 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
4112 if (xcoff_data (abfd
)->cputype
!= -1)
4113 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
4116 switch (bfd_get_arch (abfd
))
4118 case bfd_arch_rs6000
:
4119 internal_a
.o_cputype
= 4;
4121 case bfd_arch_powerpc
:
4122 if (bfd_get_mach (abfd
) == bfd_mach_ppc
)
4123 internal_a
.o_cputype
= 3;
4124 else if (bfd_get_mach (abfd
) == bfd_mach_ppc_620
)
4125 internal_a
.o_cputype
= 2;
4127 internal_a
.o_cputype
= 1;
4133 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
4134 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
4140 /* After object contents are finalized so we can compute a reasonable hash,
4141 but before header is written so we can update it to point to debug directory. */
4142 struct pe_tdata
*pe
= pe_data (abfd
);
4144 if (pe
->build_id
.after_write_object_contents
!= NULL
)
4145 (*pe
->build_id
.after_write_object_contents
) (abfd
);
4149 /* Now write header. */
4150 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
4155 bfd_size_type amount
= bfd_coff_filhsz (abfd
);
4157 buff
= (char *) bfd_malloc (amount
);
4161 bfd_coff_swap_filehdr_out (abfd
, & internal_f
, buff
);
4162 amount
= bfd_bwrite (buff
, amount
, abfd
);
4166 if (amount
!= bfd_coff_filhsz (abfd
))
4170 if (abfd
->flags
& EXEC_P
)
4172 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4173 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4175 bfd_size_type amount
= bfd_coff_aoutsz (abfd
);
4177 buff
= (char *) bfd_malloc (amount
);
4181 coff_swap_aouthdr_out (abfd
, & internal_a
, buff
);
4182 amount
= bfd_bwrite (buff
, amount
, abfd
);
4186 if (amount
!= bfd_coff_aoutsz (abfd
))
4189 #ifdef COFF_IMAGE_WITH_PE
4190 if (! coff_apply_checksum (abfd
))
4201 /* XCOFF32 seems to always write at least a small a.out header. */
4202 coff_swap_aouthdr_out (abfd
, & internal_a
, & buff
);
4203 if (xcoff_data (abfd
)->full_aouthdr
)
4204 size
= bfd_coff_aoutsz (abfd
);
4206 size
= SMALL_AOUTSZ
;
4207 if (bfd_bwrite (& buff
, (bfd_size_type
) size
, abfd
) != size
)
4217 coff_set_section_contents (bfd
* abfd
,
4219 const void * location
,
4221 bfd_size_type count
)
4223 if (! abfd
->output_has_begun
) /* Set by bfd.c handler. */
4225 if (! coff_compute_section_file_positions (abfd
))
4229 #if defined(_LIB) && !defined(TARG_AUX)
4230 /* The physical address field of a .lib section is used to hold the
4231 number of shared libraries in the section. This code counts the
4232 number of sections being written, and increments the lma field
4235 I have found no documentation on the contents of this section.
4236 Experimentation indicates that the section contains zero or more
4237 records, each of which has the following structure:
4239 - a (four byte) word holding the length of this record, in words,
4240 - a word that always seems to be set to "2",
4241 - the path to a shared library, null-terminated and then padded
4242 to a whole word boundary.
4244 bfd_assert calls have been added to alert if an attempt is made
4245 to write a section which doesn't follow these assumptions. The
4246 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4247 <robertl@arnet.com> (Thanks!).
4249 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4250 if (strcmp (section
->name
, _LIB
) == 0)
4252 bfd_byte
*rec
, *recend
;
4254 rec
= (bfd_byte
*) location
;
4255 recend
= rec
+ count
;
4256 while (rec
< recend
)
4259 rec
+= bfd_get_32 (abfd
, rec
) * 4;
4262 BFD_ASSERT (rec
== recend
);
4266 /* Don't write out bss sections - one way to do this is to
4267 see if the filepos has not been set. */
4268 if (section
->filepos
== 0)
4271 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0)
4277 return bfd_bwrite (location
, count
, abfd
) == count
;
4281 buy_and_read (bfd
*abfd
, file_ptr where
,
4282 bfd_size_type nmemb
, bfd_size_type size
)
4286 if (_bfd_mul_overflow (nmemb
, size
, &amt
))
4288 bfd_set_error (bfd_error_file_too_big
);
4291 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
4293 return _bfd_alloc_and_read (abfd
, amt
, amt
);
4300 Creating the linenumber table is done by reading in the entire
4301 coff linenumber table, and creating another table for internal use.
4303 A coff linenumber table is structured so that each function
4304 is marked as having a line number of 0. Each line within the
4305 function is an offset from the first line in the function. The
4306 base of the line number information for the table is stored in
4307 the symbol associated with the function.
4309 Note: The PE format uses line number 0 for a flag indicating a
4312 The information is copied from the external to the internal
4313 table, and each symbol which marks a function is marked by
4316 How does this work ?
4320 coff_sort_func_alent (const void * arg1
, const void * arg2
)
4322 const alent
*al1
= *(const alent
**) arg1
;
4323 const alent
*al2
= *(const alent
**) arg2
;
4324 const coff_symbol_type
*s1
= (const coff_symbol_type
*) (al1
->u
.sym
);
4325 const coff_symbol_type
*s2
= (const coff_symbol_type
*) (al2
->u
.sym
);
4327 if (s1
== NULL
|| s2
== NULL
)
4329 if (s1
->symbol
.value
< s2
->symbol
.value
)
4331 else if (s1
->symbol
.value
> s2
->symbol
.value
)
4338 coff_slurp_line_table (bfd
*abfd
, asection
*asect
)
4340 LINENO
*native_lineno
;
4341 alent
*lineno_cache
;
4342 unsigned int counter
;
4344 bfd_vma prev_offset
= 0;
4345 bfd_boolean ordered
= TRUE
;
4346 unsigned int nbr_func
;
4348 bfd_boolean have_func
;
4349 bfd_boolean ret
= TRUE
;
4352 if (asect
->lineno_count
== 0)
4355 BFD_ASSERT (asect
->lineno
== NULL
);
4357 if (asect
->lineno_count
> asect
->size
)
4360 (_("%pB: warning: line number count (%#lx) exceeds section size (%#lx)"),
4361 abfd
, (unsigned long) asect
->lineno_count
, (unsigned long) asect
->size
);
4365 if (_bfd_mul_overflow (asect
->lineno_count
+ 1, sizeof (alent
), &amt
))
4367 bfd_set_error (bfd_error_file_too_big
);
4370 lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
);
4371 if (lineno_cache
== NULL
)
4374 native_lineno
= (LINENO
*) buy_and_read (abfd
, asect
->line_filepos
,
4375 asect
->lineno_count
,
4376 bfd_coff_linesz (abfd
));
4377 if (native_lineno
== NULL
)
4380 (_("%pB: warning: line number table read failed"), abfd
);
4381 bfd_release (abfd
, lineno_cache
);
4385 cache_ptr
= lineno_cache
;
4386 asect
->lineno
= lineno_cache
;
4387 src
= native_lineno
;
4391 for (counter
= 0; counter
< asect
->lineno_count
; counter
++, src
++)
4393 struct internal_lineno dst
;
4395 bfd_coff_swap_lineno_in (abfd
, src
, &dst
);
4396 cache_ptr
->line_number
= dst
.l_lnno
;
4397 /* Appease memory checkers that get all excited about
4398 uninitialised memory when copying alents if u.offset is
4399 larger than u.sym. (64-bit BFD on 32-bit host.) */
4400 memset (&cache_ptr
->u
, 0, sizeof (cache_ptr
->u
));
4402 if (cache_ptr
->line_number
== 0)
4404 combined_entry_type
* ent
;
4405 unsigned long symndx
;
4406 coff_symbol_type
*sym
;
4409 symndx
= dst
.l_addr
.l_symndx
;
4410 if (symndx
>= obj_raw_syment_count (abfd
))
4413 /* xgettext:c-format */
4414 (_("%pB: warning: illegal symbol index 0x%lx in line number entry %d"),
4415 abfd
, symndx
, counter
);
4416 cache_ptr
->line_number
= -1;
4421 ent
= obj_raw_syments (abfd
) + symndx
;
4422 /* FIXME: We should not be casting between ints and
4423 pointers like this. */
4427 /* xgettext:c-format */
4428 (_("%pB: warning: illegal symbol index 0x%lx in line number entry %d"),
4429 abfd
, symndx
, counter
);
4430 cache_ptr
->line_number
= -1;
4434 sym
= (coff_symbol_type
*) (ent
->u
.syment
._n
._n_n
._n_zeroes
);
4436 /* PR 17512 file: 078-10659-0.004 */
4437 if (sym
< obj_symbols (abfd
)
4438 || sym
>= obj_symbols (abfd
) + bfd_get_symcount (abfd
))
4441 /* xgettext:c-format */
4442 (_("%pB: warning: illegal symbol in line number entry %d"),
4444 cache_ptr
->line_number
= -1;
4451 cache_ptr
->u
.sym
= (asymbol
*) sym
;
4452 if (sym
->lineno
!= NULL
)
4454 /* xgettext:c-format */
4455 (_("%pB: warning: duplicate line number information for `%s'"),
4456 abfd
, bfd_asymbol_name (&sym
->symbol
));
4458 sym
->lineno
= cache_ptr
;
4459 if (sym
->symbol
.value
< prev_offset
)
4461 prev_offset
= sym
->symbol
.value
;
4463 else if (!have_func
)
4464 /* Drop line information that has no associated function.
4465 PR 17521: file: 078-10659-0.004. */
4468 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
- bfd_section_vma (asect
);
4472 asect
->lineno_count
= cache_ptr
- lineno_cache
;
4473 memset (cache_ptr
, 0, sizeof (*cache_ptr
));
4474 bfd_release (abfd
, native_lineno
);
4476 /* On some systems (eg AIX5.3) the lineno table may not be sorted. */
4479 /* Sort the table. */
4481 alent
*n_lineno_cache
;
4483 /* Create a table of functions. */
4484 if (_bfd_mul_overflow (nbr_func
, sizeof (alent
*), &amt
))
4486 bfd_set_error (bfd_error_file_too_big
);
4489 else if ((func_table
= (alent
**) bfd_alloc (abfd
, amt
)) != NULL
)
4491 alent
**p
= func_table
;
4494 for (i
= 0; i
< asect
->lineno_count
; i
++)
4495 if (lineno_cache
[i
].line_number
== 0)
4496 *p
++ = &lineno_cache
[i
];
4498 BFD_ASSERT ((unsigned int) (p
- func_table
) == nbr_func
);
4500 /* Sort by functions. */
4501 qsort (func_table
, nbr_func
, sizeof (alent
*), coff_sort_func_alent
);
4503 /* Create the new sorted table. */
4504 if (_bfd_mul_overflow (asect
->lineno_count
, sizeof (alent
), &amt
))
4506 bfd_set_error (bfd_error_file_too_big
);
4509 else if ((n_lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
)) != NULL
)
4511 alent
*n_cache_ptr
= n_lineno_cache
;
4513 for (i
= 0; i
< nbr_func
; i
++)
4515 coff_symbol_type
*sym
;
4516 alent
*old_ptr
= func_table
[i
];
4518 /* Update the function entry. */
4519 sym
= (coff_symbol_type
*) old_ptr
->u
.sym
;
4520 /* PR binutils/17512: Point the lineno to where
4521 this entry will be after the memcpy below. */
4522 sym
->lineno
= lineno_cache
+ (n_cache_ptr
- n_lineno_cache
);
4523 /* Copy the function and line number entries. */
4525 *n_cache_ptr
++ = *old_ptr
++;
4526 while (old_ptr
->line_number
!= 0);
4529 memcpy (lineno_cache
, n_lineno_cache
,
4530 asect
->lineno_count
* sizeof (alent
));
4534 bfd_release (abfd
, func_table
);
4543 /* Slurp in the symbol table, converting it to generic form. Note
4544 that if coff_relocate_section is defined, the linker will read
4545 symbols via coff_link_add_symbols, rather than via this routine. */
4548 coff_slurp_symbol_table (bfd
* abfd
)
4550 combined_entry_type
*native_symbols
;
4551 coff_symbol_type
*cached_area
;
4552 unsigned int *table_ptr
;
4553 unsigned int number_of_symbols
= 0;
4554 bfd_boolean ret
= TRUE
;
4557 if (obj_symbols (abfd
))
4560 /* Read in the symbol table. */
4561 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4564 /* Allocate enough room for all the symbols in cached form. */
4565 if (_bfd_mul_overflow (obj_raw_syment_count (abfd
),
4566 sizeof (*cached_area
), &amt
))
4568 bfd_set_error (bfd_error_file_too_big
);
4571 cached_area
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
4572 if (cached_area
== NULL
)
4575 if (_bfd_mul_overflow (obj_raw_syment_count (abfd
),
4576 sizeof (*table_ptr
), &amt
))
4578 bfd_set_error (bfd_error_file_too_big
);
4581 table_ptr
= (unsigned int *) bfd_zalloc (abfd
, amt
);
4582 if (table_ptr
== NULL
)
4586 coff_symbol_type
*dst
= cached_area
;
4587 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4588 unsigned int this_index
= 0;
4590 while (this_index
< last_native_index
)
4592 combined_entry_type
*src
= native_symbols
+ this_index
;
4593 table_ptr
[this_index
] = number_of_symbols
;
4595 dst
->symbol
.the_bfd
= abfd
;
4596 BFD_ASSERT (src
->is_sym
);
4597 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4598 /* We use the native name field to point to the cached field. */
4599 src
->u
.syment
._n
._n_n
._n_zeroes
= (bfd_hostptr_t
) dst
;
4600 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4601 src
->u
.syment
.n_scnum
);
4602 dst
->symbol
.flags
= 0;
4603 /* PR 17512: file: 079-7098-0.001:0.1. */
4604 dst
->symbol
.value
= 0;
4605 dst
->done_lineno
= FALSE
;
4607 switch (src
->u
.syment
.n_sclass
)
4613 case C_THUMBEXTFUNC
:
4617 #if ! defined _AIX52 && ! defined AIX_WEAK_SUPPORT
4622 case C_SYSTEM
: /* System Wide variable. */
4625 /* In PE, 0x68 (104) denotes a section symbol. */
4627 /* In PE, 0x69 (105) denotes a weak external symbol. */
4630 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4632 case COFF_SYMBOL_GLOBAL
:
4633 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4634 #if defined COFF_WITH_PE
4635 /* PE sets the symbol to a value relative to the
4636 start of the section. */
4637 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4639 dst
->symbol
.value
= (src
->u
.syment
.n_value
4640 - dst
->symbol
.section
->vma
);
4642 if (ISFCN ((src
->u
.syment
.n_type
)))
4643 /* A function ext does not go at the end of a
4645 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4648 case COFF_SYMBOL_COMMON
:
4649 dst
->symbol
.section
= bfd_com_section_ptr
;
4650 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4653 case COFF_SYMBOL_UNDEFINED
:
4654 dst
->symbol
.section
= bfd_und_section_ptr
;
4655 dst
->symbol
.value
= 0;
4658 case COFF_SYMBOL_PE_SECTION
:
4659 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4660 dst
->symbol
.value
= 0;
4663 case COFF_SYMBOL_LOCAL
:
4664 dst
->symbol
.flags
= BSF_LOCAL
;
4665 #if defined COFF_WITH_PE
4666 /* PE sets the symbol to a value relative to the
4667 start of the section. */
4668 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4670 dst
->symbol
.value
= (src
->u
.syment
.n_value
4671 - dst
->symbol
.section
->vma
);
4673 if (ISFCN ((src
->u
.syment
.n_type
)))
4674 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4679 /* A symbol with a csect entry should not go at the end. */
4680 if (src
->u
.syment
.n_numaux
> 0)
4681 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4685 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4686 dst
->symbol
.flags
|= BSF_WEAK
;
4688 if (src
->u
.syment
.n_sclass
== C_SECTION
4689 && src
->u
.syment
.n_scnum
> 0)
4690 dst
->symbol
.flags
= BSF_LOCAL
;
4692 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
4694 || src
->u
.syment
.n_sclass
== C_AIX_WEAKEXT
4697 dst
->symbol
.flags
|= BSF_WEAK
;
4701 case C_STAT
: /* Static. */
4703 case C_THUMBSTAT
: /* Thumb static. */
4704 case C_THUMBLABEL
: /* Thumb label. */
4705 case C_THUMBSTATFUNC
:/* Thumb static function. */
4708 case C_DWARF
: /* A label in a dwarf section. */
4709 case C_INFO
: /* A label in a comment section. */
4711 case C_LABEL
: /* Label. */
4712 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4713 dst
->symbol
.flags
= BSF_DEBUGGING
;
4715 dst
->symbol
.flags
= BSF_LOCAL
;
4717 /* Base the value as an index from the base of the
4718 section, if there is one. */
4719 if (dst
->symbol
.section
)
4721 #if defined COFF_WITH_PE
4722 /* PE sets the symbol to a value relative to the
4723 start of the section. */
4724 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4726 dst
->symbol
.value
= (src
->u
.syment
.n_value
4727 - dst
->symbol
.section
->vma
);
4731 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4734 case C_MOS
: /* Member of structure. */
4735 case C_EOS
: /* End of structure. */
4736 case C_REGPARM
: /* Register parameter. */
4737 case C_REG
: /* register variable. */
4738 /* C_AUTOARG conflicts with TI COFF C_UEXT. */
4739 case C_TPDEF
: /* Type definition. */
4741 case C_AUTO
: /* Automatic variable. */
4742 case C_FIELD
: /* Bit field. */
4743 case C_ENTAG
: /* Enumeration tag. */
4744 case C_MOE
: /* Member of enumeration. */
4745 case C_MOU
: /* Member of union. */
4746 case C_UNTAG
: /* Union tag. */
4747 dst
->symbol
.flags
= BSF_DEBUGGING
;
4748 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4751 case C_FILE
: /* File name. */
4752 case C_STRTAG
: /* Structure tag. */
4769 dst
->symbol
.flags
= BSF_DEBUGGING
;
4770 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4774 case C_BINCL
: /* Beginning of include file. */
4775 case C_EINCL
: /* Ending of include file. */
4776 /* The value is actually a pointer into the line numbers
4777 of the file. We locate the line number entry, and
4778 set the section to the section which contains it, and
4779 the value to the index in that section. */
4783 dst
->symbol
.flags
= BSF_DEBUGGING
;
4784 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4785 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4786 && ((file_ptr
) (sec
->line_filepos
4787 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4788 > (file_ptr
) src
->u
.syment
.n_value
))
4791 dst
->symbol
.value
= 0;
4794 dst
->symbol
.section
= sec
;
4795 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4796 - sec
->line_filepos
)
4797 / bfd_coff_linesz (abfd
));
4804 dst
->symbol
.flags
= BSF_DEBUGGING
;
4806 /* The value is actually a symbol index. Save a pointer
4807 to the symbol instead of the index. FIXME: This
4808 should use a union. */
4809 src
->u
.syment
.n_value
=
4810 (long) (intptr_t) (native_symbols
+ src
->u
.syment
.n_value
);
4811 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4816 case C_BLOCK
: /* ".bb" or ".eb". */
4817 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf"). */
4818 case C_EFCN
: /* Physical end of function. */
4819 #if defined COFF_WITH_PE
4820 /* PE sets the symbol to a value relative to the start
4822 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4823 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4825 /* PE uses funny values for .ef and .lf; don't
4827 dst
->symbol
.flags
= BSF_DEBUGGING
;
4830 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4832 /* Base the value as an index from the base of the
4834 dst
->symbol
.flags
= BSF_LOCAL
;
4835 dst
->symbol
.value
= (src
->u
.syment
.n_value
4836 - dst
->symbol
.section
->vma
);
4840 case C_STATLAB
: /* Static load time label. */
4841 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4842 dst
->symbol
.flags
= BSF_GLOBAL
;
4846 /* PE DLLs sometimes have zeroed out symbols for some
4847 reason. Just ignore them without a warning. */
4848 if (src
->u
.syment
.n_type
== 0
4849 && src
->u
.syment
.n_value
== 0
4850 && src
->u
.syment
.n_scnum
== 0)
4853 /* XCOFF specific: deleted entry. */
4854 if (src
->u
.syment
.n_value
== C_NULL_VALUE
)
4858 case C_EXTDEF
: /* External definition. */
4859 case C_ULABEL
: /* Undefined label. */
4860 case C_USTATIC
: /* Undefined static. */
4861 #ifndef COFF_WITH_PE
4862 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4863 class to represent a section symbol. */
4864 case C_LINE
: /* line # reformatted as symbol table entry. */
4865 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4866 case C_ALIAS
: /* Duplicate tag. */
4868 /* New storage classes for TI COFF. */
4870 case C_UEXT
: /* Tentative external definition. */
4872 case C_EXTLAB
: /* External load time label. */
4875 /* xgettext:c-format */
4876 (_("%pB: unrecognized storage class %d for %s symbol `%s'"),
4877 abfd
, src
->u
.syment
.n_sclass
,
4878 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4881 case C_HIDDEN
: /* Ext symbol in dmert public lib. */
4882 /* PR 20722: These symbols can also be generated by
4883 building DLLs with --gc-sections enabled. */
4884 dst
->symbol
.flags
= BSF_DEBUGGING
;
4885 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4890 dst
->symbol
.udata
.i
= 0;
4893 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
4895 number_of_symbols
++;
4899 obj_symbols (abfd
) = cached_area
;
4900 obj_raw_syments (abfd
) = native_symbols
;
4902 abfd
->symcount
= number_of_symbols
;
4903 obj_convert (abfd
) = table_ptr
;
4904 /* Slurp the line tables for each section too. */
4911 if (! coff_slurp_line_table (abfd
, p
))
4920 /* Classify a COFF symbol. A couple of targets have globally visible
4921 symbols which are not class C_EXT, and this handles those. It also
4922 recognizes some special PE cases. */
4924 static enum coff_symbol_classification
4925 coff_classify_symbol (bfd
*abfd
,
4926 struct internal_syment
*syment
)
4928 /* FIXME: This partially duplicates the switch in
4929 coff_slurp_symbol_table. */
4930 switch (syment
->n_sclass
)
4936 case C_THUMBEXTFUNC
:
4940 #if ! defined _AIX52 && ! defined AIX_WEAK_SUPPORT
4950 if (syment
->n_scnum
== 0)
4952 if (syment
->n_value
== 0)
4953 return COFF_SYMBOL_UNDEFINED
;
4955 return COFF_SYMBOL_COMMON
;
4958 if (syment
->n_sclass
== C_HIDEXT
)
4959 return COFF_SYMBOL_LOCAL
;
4961 return COFF_SYMBOL_GLOBAL
;
4968 if (syment
->n_sclass
== C_STAT
)
4970 if (syment
->n_scnum
== 0)
4971 /* The Microsoft compiler sometimes generates these if a
4972 small static function is inlined every time it is used.
4973 The function is discarded, but the symbol table entry
4975 return COFF_SYMBOL_LOCAL
;
4977 #ifdef STRICT_PE_FORMAT
4978 /* This is correct for Microsoft generated objects, but it
4979 breaks gas generated objects. */
4980 if (syment
->n_value
== 0)
4984 char buf
[SYMNMLEN
+ 1];
4986 name
= _bfd_coff_internal_syment_name (abfd
, syment
, buf
)
4987 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
4988 if (sec
!= NULL
&& name
!= NULL
4989 && (strcmp (bfd_section_name (sec
), name
) == 0))
4990 return COFF_SYMBOL_PE_SECTION
;
4994 return COFF_SYMBOL_LOCAL
;
4997 if (syment
->n_sclass
== C_SECTION
)
4999 /* In some cases in a DLL generated by the Microsoft linker, the
5000 n_value field will contain garbage. FIXME: This should
5001 probably be handled by the swapping function instead. */
5002 syment
->n_value
= 0;
5003 if (syment
->n_scnum
== 0)
5004 return COFF_SYMBOL_UNDEFINED
;
5005 return COFF_SYMBOL_PE_SECTION
;
5007 #endif /* COFF_WITH_PE */
5009 /* If it is not a global symbol, we presume it is a local symbol. */
5010 if (syment
->n_scnum
== 0)
5012 char buf
[SYMNMLEN
+ 1];
5015 /* xgettext:c-format */
5016 (_("warning: %pB: local symbol `%s' has no section"),
5017 abfd
, _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
5020 return COFF_SYMBOL_LOCAL
;
5027 Coff relocations are easily transformed into the internal BFD form
5030 Reading a coff relocation table is done in the following stages:
5032 o Read the entire coff relocation table into memory.
5034 o Process each relocation in turn; first swap it from the
5035 external to the internal form.
5037 o Turn the symbol referenced in the relocation's symbol index
5038 into a pointer into the canonical symbol table.
5039 This table is the same as the one returned by a call to
5040 @code{bfd_canonicalize_symtab}. The back end will call that
5041 routine and save the result if a canonicalization hasn't been done.
5043 o The reloc index is turned into a pointer to a howto
5044 structure, in a back end specific way. For instance, the 386
5045 uses the @code{r_type} to directly produce an index
5046 into a howto table vector.
5050 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
5052 coff_symbol_type *coffsym = NULL; \
5054 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
5055 coffsym = (obj_symbols (abfd) \
5056 + (cache_ptr->sym_ptr_ptr - symbols)); \
5058 coffsym = coff_symbol_from (ptr); \
5059 if (coffsym != NULL \
5060 && coffsym->native->is_sym \
5061 && coffsym->native->u.syment.n_scnum == 0) \
5062 cache_ptr->addend = 0; \
5063 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
5064 && ptr->section != NULL) \
5065 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
5067 cache_ptr->addend = 0; \
5072 coff_slurp_reloc_table (bfd
* abfd
, sec_ptr asect
, asymbol
** symbols
)
5074 RELOC
*native_relocs
;
5075 arelent
*reloc_cache
;
5080 if (asect
->relocation
)
5082 if (asect
->reloc_count
== 0)
5084 if (asect
->flags
& SEC_CONSTRUCTOR
)
5086 if (!coff_slurp_symbol_table (abfd
))
5089 native_relocs
= (RELOC
*) buy_and_read (abfd
, asect
->rel_filepos
,
5091 bfd_coff_relsz (abfd
));
5092 if (_bfd_mul_overflow (asect
->reloc_count
, sizeof (arelent
), &amt
))
5094 bfd_set_error (bfd_error_file_too_big
);
5097 reloc_cache
= (arelent
*) bfd_alloc (abfd
, amt
);
5098 if (reloc_cache
== NULL
|| native_relocs
== NULL
)
5101 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
5103 struct internal_reloc dst
;
5104 struct external_reloc
*src
;
5105 #ifndef RELOC_PROCESSING
5109 cache_ptr
= reloc_cache
+ idx
;
5110 src
= native_relocs
+ idx
;
5113 coff_swap_reloc_in (abfd
, src
, &dst
);
5115 #ifdef RELOC_PROCESSING
5116 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
5118 cache_ptr
->address
= dst
.r_vaddr
;
5120 if (dst
.r_symndx
!= -1 && symbols
!= NULL
)
5122 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
5125 /* xgettext:c-format */
5126 (_("%pB: warning: illegal symbol index %ld in relocs"),
5127 abfd
, dst
.r_symndx
);
5128 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5133 cache_ptr
->sym_ptr_ptr
= (symbols
5134 + obj_convert (abfd
)[dst
.r_symndx
]);
5135 ptr
= *(cache_ptr
->sym_ptr_ptr
);
5140 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5144 /* The symbols definitions that we have read in have been
5145 relocated as if their sections started at 0. But the offsets
5146 refering to the symbols in the raw data have not been
5147 modified, so we have to have a negative addend to compensate.
5149 Note that symbols which used to be common must be left alone. */
5151 /* Calculate any reloc addend by looking at the symbol. */
5152 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
5155 cache_ptr
->address
-= asect
->vma
;
5156 /* !! cache_ptr->section = NULL;*/
5158 /* Fill in the cache_ptr->howto field from dst.r_type. */
5159 RTYPE2HOWTO (cache_ptr
, &dst
);
5160 #endif /* RELOC_PROCESSING */
5162 if (cache_ptr
->howto
== NULL
)
5165 /* xgettext:c-format */
5166 (_("%pB: illegal relocation type %d at address %#" PRIx64
),
5167 abfd
, dst
.r_type
, (uint64_t) dst
.r_vaddr
);
5168 bfd_set_error (bfd_error_bad_value
);
5173 asect
->relocation
= reloc_cache
;
5177 #ifndef coff_rtype_to_howto
5180 /* Get the howto structure for a reloc. This is only used if the file
5181 including this one defines coff_relocate_section to be
5182 _bfd_coff_generic_relocate_section, so it is OK if it does not
5183 always work. It is the responsibility of the including file to
5184 make sure it is reasonable if it is needed. */
5186 static reloc_howto_type
*
5187 coff_rtype_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
5188 asection
*sec ATTRIBUTE_UNUSED
,
5189 struct internal_reloc
*rel ATTRIBUTE_UNUSED
,
5190 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
,
5191 struct internal_syment
*sym ATTRIBUTE_UNUSED
,
5192 bfd_vma
*addendp ATTRIBUTE_UNUSED
)
5196 genrel
.howto
= NULL
;
5197 RTYPE2HOWTO (&genrel
, rel
);
5198 return genrel
.howto
;
5201 #else /* ! defined (RTYPE2HOWTO) */
5203 #define coff_rtype_to_howto NULL
5205 #endif /* ! defined (RTYPE2HOWTO) */
5206 #endif /* ! defined (coff_rtype_to_howto) */
5208 /* This is stupid. This function should be a boolean predicate. */
5211 coff_canonicalize_reloc (bfd
* abfd
,
5216 arelent
*tblptr
= section
->relocation
;
5217 unsigned int count
= 0;
5219 if (section
->flags
& SEC_CONSTRUCTOR
)
5221 /* This section has relocs made up by us, they are not in the
5222 file, so take them out of their chain and place them into
5223 the data area provided. */
5224 arelent_chain
*chain
= section
->constructor_chain
;
5226 for (count
= 0; count
< section
->reloc_count
; count
++)
5228 *relptr
++ = &chain
->relent
;
5229 chain
= chain
->next
;
5234 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
5237 tblptr
= section
->relocation
;
5239 for (; count
++ < section
->reloc_count
;)
5240 *relptr
++ = tblptr
++;
5243 return section
->reloc_count
;
5246 #ifndef coff_set_reloc
5247 #define coff_set_reloc _bfd_generic_set_reloc
5250 #ifndef coff_reloc16_estimate
5251 #define coff_reloc16_estimate dummy_reloc16_estimate
5254 dummy_reloc16_estimate (bfd
*abfd ATTRIBUTE_UNUSED
,
5255 asection
*input_section ATTRIBUTE_UNUSED
,
5256 arelent
*reloc ATTRIBUTE_UNUSED
,
5257 unsigned int shrink ATTRIBUTE_UNUSED
,
5258 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
)
5266 #ifndef coff_reloc16_extra_cases
5268 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5270 /* This works even if abort is not declared in any header file. */
5273 dummy_reloc16_extra_cases (bfd
*abfd ATTRIBUTE_UNUSED
,
5274 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
5275 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
,
5276 arelent
*reloc ATTRIBUTE_UNUSED
,
5277 bfd_byte
*data ATTRIBUTE_UNUSED
,
5278 unsigned int *src_ptr ATTRIBUTE_UNUSED
,
5279 unsigned int *dst_ptr ATTRIBUTE_UNUSED
)
5285 /* If coff_relocate_section is defined, we can use the optimized COFF
5286 backend linker. Otherwise we must continue to use the old linker. */
5288 #ifdef coff_relocate_section
5290 #ifndef coff_bfd_link_hash_table_create
5291 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5293 #ifndef coff_bfd_link_add_symbols
5294 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5296 #ifndef coff_bfd_final_link
5297 #define coff_bfd_final_link _bfd_coff_final_link
5300 #else /* ! defined (coff_relocate_section) */
5302 #define coff_relocate_section NULL
5303 #ifndef coff_bfd_link_hash_table_create
5304 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5306 #ifndef coff_bfd_link_add_symbols
5307 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5309 #define coff_bfd_final_link _bfd_generic_final_link
5311 #endif /* ! defined (coff_relocate_section) */
5313 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5314 #define coff_bfd_copy_link_hash_symbol_type \
5315 _bfd_generic_copy_link_hash_symbol_type
5316 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5318 #define coff_bfd_link_check_relocs _bfd_generic_link_check_relocs
5320 #ifndef coff_start_final_link
5321 #define coff_start_final_link NULL
5324 #ifndef coff_adjust_symndx
5325 #define coff_adjust_symndx NULL
5328 #ifndef coff_link_add_one_symbol
5329 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5332 #ifndef coff_link_output_has_begun
5335 coff_link_output_has_begun (bfd
* abfd
,
5336 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
)
5338 return abfd
->output_has_begun
;
5342 #ifndef coff_final_link_postscript
5345 coff_final_link_postscript (bfd
* abfd ATTRIBUTE_UNUSED
,
5346 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
)
5352 #ifndef coff_SWAP_aux_in
5353 #define coff_SWAP_aux_in coff_swap_aux_in
5355 #ifndef coff_SWAP_sym_in
5356 #define coff_SWAP_sym_in coff_swap_sym_in
5358 #ifndef coff_SWAP_lineno_in
5359 #define coff_SWAP_lineno_in coff_swap_lineno_in
5361 #ifndef coff_SWAP_aux_out
5362 #define coff_SWAP_aux_out coff_swap_aux_out
5364 #ifndef coff_SWAP_sym_out
5365 #define coff_SWAP_sym_out coff_swap_sym_out
5367 #ifndef coff_SWAP_lineno_out
5368 #define coff_SWAP_lineno_out coff_swap_lineno_out
5370 #ifndef coff_SWAP_reloc_out
5371 #define coff_SWAP_reloc_out coff_swap_reloc_out
5373 #ifndef coff_SWAP_filehdr_out
5374 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5376 #ifndef coff_SWAP_aouthdr_out
5377 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5379 #ifndef coff_SWAP_scnhdr_out
5380 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5382 #ifndef coff_SWAP_reloc_in
5383 #define coff_SWAP_reloc_in coff_swap_reloc_in
5385 #ifndef coff_SWAP_filehdr_in
5386 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5388 #ifndef coff_SWAP_aouthdr_in
5389 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5391 #ifndef coff_SWAP_scnhdr_in
5392 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5395 static bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED
=
5397 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5398 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5399 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5400 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5401 coff_SWAP_scnhdr_out
,
5402 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5403 #ifdef COFF_LONG_FILENAMES
5408 COFF_DEFAULT_LONG_SECTION_NAMES
,
5409 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5410 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5415 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5421 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5422 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5423 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5424 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5425 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5426 coff_classify_symbol
, coff_compute_section_file_positions
,
5427 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5428 coff_adjust_symndx
, coff_link_add_one_symbol
,
5429 coff_link_output_has_begun
, coff_final_link_postscript
,
5434 /* COFF0 differs in file/section header size and relocation entry size. */
5436 static bfd_coff_backend_data ticoff0_swap_table
=
5438 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5439 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5440 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5441 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5442 coff_SWAP_scnhdr_out
,
5443 FILHSZ_V0
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ_V0
, LINESZ
, FILNMLEN
,
5444 #ifdef COFF_LONG_FILENAMES
5449 COFF_DEFAULT_LONG_SECTION_NAMES
,
5450 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5451 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5456 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5462 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5463 coff_SWAP_reloc_in
, ticoff0_bad_format_hook
, coff_set_arch_mach_hook
,
5464 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5465 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5466 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5467 coff_classify_symbol
, coff_compute_section_file_positions
,
5468 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5469 coff_adjust_symndx
, coff_link_add_one_symbol
,
5470 coff_link_output_has_begun
, coff_final_link_postscript
,
5476 /* COFF1 differs in section header size. */
5478 static bfd_coff_backend_data ticoff1_swap_table
=
5480 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5481 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5482 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5483 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5484 coff_SWAP_scnhdr_out
,
5485 FILHSZ
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5486 #ifdef COFF_LONG_FILENAMES
5491 COFF_DEFAULT_LONG_SECTION_NAMES
,
5492 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5493 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5498 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5504 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5505 coff_SWAP_reloc_in
, ticoff1_bad_format_hook
, coff_set_arch_mach_hook
,
5506 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5507 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5508 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5509 coff_classify_symbol
, coff_compute_section_file_positions
,
5510 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5511 coff_adjust_symndx
, coff_link_add_one_symbol
,
5512 coff_link_output_has_begun
, coff_final_link_postscript
,
5513 bfd_pe_print_pdata
/* huh */
5517 #ifdef COFF_WITH_PE_BIGOBJ
5518 /* The UID for bigobj files. */
5520 static const char header_bigobj_classid
[16] =
5522 0xC7, 0xA1, 0xBA, 0xD1,
5526 0xFA, 0xF6, 0x6A, 0xA4, 0xDC, 0xB8
5529 /* Swap routines. */
5532 coff_bigobj_swap_filehdr_in (bfd
* abfd
, void * src
, void * dst
)
5534 struct external_ANON_OBJECT_HEADER_BIGOBJ
*filehdr_src
=
5535 (struct external_ANON_OBJECT_HEADER_BIGOBJ
*) src
;
5536 struct internal_filehdr
*filehdr_dst
= (struct internal_filehdr
*) dst
;
5538 filehdr_dst
->f_magic
= H_GET_16 (abfd
, filehdr_src
->Machine
);
5539 filehdr_dst
->f_nscns
= H_GET_32 (abfd
, filehdr_src
->NumberOfSections
);
5540 filehdr_dst
->f_timdat
= H_GET_32 (abfd
, filehdr_src
->TimeDateStamp
);
5541 filehdr_dst
->f_symptr
=
5542 GET_FILEHDR_SYMPTR (abfd
, filehdr_src
->PointerToSymbolTable
);
5543 filehdr_dst
->f_nsyms
= H_GET_32 (abfd
, filehdr_src
->NumberOfSymbols
);
5544 filehdr_dst
->f_opthdr
= 0;
5545 filehdr_dst
->f_flags
= 0;
5547 /* Check other magic numbers. */
5548 if (H_GET_16 (abfd
, filehdr_src
->Sig1
) != IMAGE_FILE_MACHINE_UNKNOWN
5549 || H_GET_16 (abfd
, filehdr_src
->Sig2
) != 0xffff
5550 || H_GET_16 (abfd
, filehdr_src
->Version
) != 2
5551 || memcmp (filehdr_src
->ClassID
, header_bigobj_classid
, 16) != 0)
5552 filehdr_dst
->f_opthdr
= 0xffff;
5554 /* Note that CLR metadata are ignored. */
5558 coff_bigobj_swap_filehdr_out (bfd
*abfd
, void * in
, void * out
)
5560 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
5561 struct external_ANON_OBJECT_HEADER_BIGOBJ
*filehdr_out
=
5562 (struct external_ANON_OBJECT_HEADER_BIGOBJ
*) out
;
5564 memset (filehdr_out
, 0, sizeof (*filehdr_out
));
5566 H_PUT_16 (abfd
, IMAGE_FILE_MACHINE_UNKNOWN
, filehdr_out
->Sig1
);
5567 H_PUT_16 (abfd
, 0xffff, filehdr_out
->Sig2
);
5568 H_PUT_16 (abfd
, 2, filehdr_out
->Version
);
5569 memcpy (filehdr_out
->ClassID
, header_bigobj_classid
, 16);
5570 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->Machine
);
5571 H_PUT_32 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->NumberOfSections
);
5572 H_PUT_32 (abfd
, filehdr_in
->f_timdat
, filehdr_out
->TimeDateStamp
);
5573 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
,
5574 filehdr_out
->PointerToSymbolTable
);
5575 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->NumberOfSymbols
);
5577 return bfd_coff_filhsz (abfd
);
5581 coff_bigobj_swap_sym_in (bfd
* abfd
, void * ext1
, void * in1
)
5583 SYMENT_BIGOBJ
*ext
= (SYMENT_BIGOBJ
*) ext1
;
5584 struct internal_syment
*in
= (struct internal_syment
*) in1
;
5586 if (ext
->e
.e_name
[0] == 0)
5588 in
->_n
._n_n
._n_zeroes
= 0;
5589 in
->_n
._n_n
._n_offset
= H_GET_32 (abfd
, ext
->e
.e
.e_offset
);
5593 #if SYMNMLEN != E_SYMNMLEN
5594 #error we need to cope with truncating or extending SYMNMLEN
5596 memcpy (in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
5600 in
->n_value
= H_GET_32 (abfd
, ext
->e_value
);
5601 BFD_ASSERT (sizeof (in
->n_scnum
) >= 4);
5602 in
->n_scnum
= H_GET_32 (abfd
, ext
->e_scnum
);
5603 in
->n_type
= H_GET_16 (abfd
, ext
->e_type
);
5604 in
->n_sclass
= H_GET_8 (abfd
, ext
->e_sclass
);
5605 in
->n_numaux
= H_GET_8 (abfd
, ext
->e_numaux
);
5609 coff_bigobj_swap_sym_out (bfd
* abfd
, void * inp
, void * extp
)
5611 struct internal_syment
*in
= (struct internal_syment
*) inp
;
5612 SYMENT_BIGOBJ
*ext
= (SYMENT_BIGOBJ
*) extp
;
5614 if (in
->_n
._n_name
[0] == 0)
5616 H_PUT_32 (abfd
, 0, ext
->e
.e
.e_zeroes
);
5617 H_PUT_32 (abfd
, in
->_n
._n_n
._n_offset
, ext
->e
.e
.e_offset
);
5621 #if SYMNMLEN != E_SYMNMLEN
5622 #error we need to cope with truncating or extending SYMNMLEN
5624 memcpy (ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
5628 H_PUT_32 (abfd
, in
->n_value
, ext
->e_value
);
5629 H_PUT_32 (abfd
, in
->n_scnum
, ext
->e_scnum
);
5631 H_PUT_16 (abfd
, in
->n_type
, ext
->e_type
);
5632 H_PUT_8 (abfd
, in
->n_sclass
, ext
->e_sclass
);
5633 H_PUT_8 (abfd
, in
->n_numaux
, ext
->e_numaux
);
5635 return SYMESZ_BIGOBJ
;
5639 coff_bigobj_swap_aux_in (bfd
*abfd
,
5647 AUXENT_BIGOBJ
*ext
= (AUXENT_BIGOBJ
*) ext1
;
5648 union internal_auxent
*in
= (union internal_auxent
*) in1
;
5650 /* Make sure that all fields in the aux structure are
5652 memset (in
, 0, sizeof * in
);
5659 memcpy (in
->x_file
.x_fname
, ext
->File
.Name
,
5660 numaux
* sizeof (AUXENT_BIGOBJ
));
5663 memcpy (in
->x_file
.x_fname
, ext
->File
.Name
, sizeof (ext
->File
.Name
));
5671 in
->x_scn
.x_scnlen
= H_GET_32 (abfd
, ext
->Section
.Length
);
5672 in
->x_scn
.x_nreloc
=
5673 H_GET_16 (abfd
, ext
->Section
.NumberOfRelocations
);
5674 in
->x_scn
.x_nlinno
=
5675 H_GET_16 (abfd
, ext
->Section
.NumberOfLinenumbers
);
5676 in
->x_scn
.x_checksum
= H_GET_32 (abfd
, ext
->Section
.Checksum
);
5677 in
->x_scn
.x_associated
= H_GET_16 (abfd
, ext
->Section
.Number
)
5678 | (H_GET_16 (abfd
, ext
->Section
.HighNumber
) << 16);
5679 in
->x_scn
.x_comdat
= H_GET_8 (abfd
, ext
->Section
.Selection
);
5685 in
->x_sym
.x_tagndx
.l
= H_GET_32 (abfd
, ext
->Sym
.WeakDefaultSymIndex
);
5686 /* Characteristics is ignored. */
5692 coff_bigobj_swap_aux_out (bfd
* abfd
,
5696 int indx ATTRIBUTE_UNUSED
,
5697 int numaux ATTRIBUTE_UNUSED
,
5700 union internal_auxent
* in
= (union internal_auxent
*) inp
;
5701 AUXENT_BIGOBJ
*ext
= (AUXENT_BIGOBJ
*) extp
;
5703 memset (ext
, 0, AUXESZ
);
5708 memcpy (ext
->File
.Name
, in
->x_file
.x_fname
, sizeof (ext
->File
.Name
));
5717 H_PUT_32 (abfd
, in
->x_scn
.x_scnlen
, ext
->Section
.Length
);
5718 H_PUT_16 (abfd
, in
->x_scn
.x_nreloc
,
5719 ext
->Section
.NumberOfRelocations
);
5720 H_PUT_16 (abfd
, in
->x_scn
.x_nlinno
,
5721 ext
->Section
.NumberOfLinenumbers
);
5722 H_PUT_32 (abfd
, in
->x_scn
.x_checksum
, ext
->Section
.Checksum
);
5723 H_PUT_16 (abfd
, in
->x_scn
.x_associated
& 0xffff,
5724 ext
->Section
.Number
);
5725 H_PUT_16 (abfd
, (in
->x_scn
.x_associated
>> 16),
5726 ext
->Section
.HighNumber
);
5727 H_PUT_8 (abfd
, in
->x_scn
.x_comdat
, ext
->Section
.Selection
);
5733 H_PUT_32 (abfd
, in
->x_sym
.x_tagndx
.l
, ext
->Sym
.WeakDefaultSymIndex
);
5734 H_PUT_32 (abfd
, 1, ext
->Sym
.WeakSearchType
);
5739 static bfd_coff_backend_data bigobj_swap_table
=
5741 coff_bigobj_swap_aux_in
, coff_bigobj_swap_sym_in
, coff_SWAP_lineno_in
,
5742 coff_bigobj_swap_aux_out
, coff_bigobj_swap_sym_out
,
5743 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5744 coff_bigobj_swap_filehdr_out
, coff_SWAP_aouthdr_out
,
5745 coff_SWAP_scnhdr_out
,
5746 FILHSZ_BIGOBJ
, AOUTSZ
, SCNHSZ
, SYMESZ_BIGOBJ
, AUXESZ_BIGOBJ
,
5747 RELSZ
, LINESZ
, FILNMLEN_BIGOBJ
,
5749 COFF_DEFAULT_LONG_SECTION_NAMES
,
5750 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5754 coff_bigobj_swap_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5755 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5756 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5757 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5758 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5759 coff_classify_symbol
, coff_compute_section_file_positions
,
5760 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5761 coff_adjust_symndx
, coff_link_add_one_symbol
,
5762 coff_link_output_has_begun
, coff_final_link_postscript
,
5763 bfd_pe_print_pdata
/* huh */
5766 #endif /* COFF_WITH_PE_BIGOBJ */
5768 #ifndef coff_close_and_cleanup
5769 #define coff_close_and_cleanup _bfd_coff_close_and_cleanup
5772 #ifndef coff_bfd_free_cached_info
5773 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5776 #ifndef coff_get_section_contents
5777 #define coff_get_section_contents _bfd_generic_get_section_contents
5780 #ifndef coff_bfd_copy_private_symbol_data
5781 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5784 #ifndef coff_bfd_copy_private_header_data
5785 #define coff_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
5788 #ifndef coff_bfd_copy_private_section_data
5789 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5792 #ifndef coff_bfd_copy_private_bfd_data
5793 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5796 #ifndef coff_bfd_merge_private_bfd_data
5797 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5800 #ifndef coff_bfd_set_private_flags
5801 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5804 #ifndef coff_bfd_print_private_bfd_data
5805 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5808 #ifndef coff_bfd_is_local_label_name
5809 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5812 #ifndef coff_bfd_is_target_special_symbol
5813 #define coff_bfd_is_target_special_symbol _bfd_bool_bfd_asymbol_false
5816 #ifndef coff_read_minisymbols
5817 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5820 #ifndef coff_minisymbol_to_symbol
5821 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5824 /* The reloc lookup routine must be supplied by each individual COFF
5826 #ifndef coff_bfd_reloc_type_lookup
5827 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5829 #ifndef coff_bfd_reloc_name_lookup
5830 #define coff_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5833 #ifndef coff_bfd_get_relocated_section_contents
5834 #define coff_bfd_get_relocated_section_contents \
5835 bfd_generic_get_relocated_section_contents
5838 #ifndef coff_bfd_relax_section
5839 #define coff_bfd_relax_section bfd_generic_relax_section
5842 #ifndef coff_bfd_gc_sections
5843 #define coff_bfd_gc_sections bfd_coff_gc_sections
5846 #ifndef coff_bfd_lookup_section_flags
5847 #define coff_bfd_lookup_section_flags bfd_generic_lookup_section_flags
5850 #ifndef coff_bfd_merge_sections
5851 #define coff_bfd_merge_sections bfd_generic_merge_sections
5854 #ifndef coff_bfd_is_group_section
5855 #define coff_bfd_is_group_section bfd_generic_is_group_section
5858 #ifndef coff_bfd_group_name
5859 #define coff_bfd_group_name bfd_coff_group_name
5862 #ifndef coff_bfd_discard_group
5863 #define coff_bfd_discard_group bfd_generic_discard_group
5866 #ifndef coff_section_already_linked
5867 #define coff_section_already_linked \
5868 _bfd_coff_section_already_linked
5871 #ifndef coff_bfd_define_common_symbol
5872 #define coff_bfd_define_common_symbol bfd_generic_define_common_symbol
5875 #ifndef coff_bfd_link_hide_symbol
5876 #define coff_bfd_link_hide_symbol _bfd_generic_link_hide_symbol
5879 #ifndef coff_bfd_define_start_stop
5880 #define coff_bfd_define_start_stop bfd_generic_define_start_stop
5883 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5884 const bfd_target VAR = \
5887 bfd_target_coff_flavour, \
5888 BFD_ENDIAN_BIG, /* Data byte order is big. */ \
5889 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5890 /* object flags */ \
5891 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5892 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5893 /* section flags */ \
5894 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5895 UNDER, /* Leading symbol underscore. */ \
5896 '/', /* AR_pad_char. */ \
5897 15, /* AR_max_namelen. */ \
5898 0, /* match priority. */ \
5899 TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols. */ \
5901 /* Data 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 /* Header conversion functions. */ \
5907 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5908 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5909 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5911 { /* bfd_check_format. */ \
5912 _bfd_dummy_target, \
5914 bfd_generic_archive_p, \
5917 { /* bfd_set_format. */ \
5918 _bfd_bool_bfd_false_error, \
5920 _bfd_generic_mkarchive, \
5921 _bfd_bool_bfd_false_error \
5923 { /* bfd_write_contents. */ \
5924 _bfd_bool_bfd_false_error, \
5925 coff_write_object_contents, \
5926 _bfd_write_archive_contents, \
5927 _bfd_bool_bfd_false_error \
5930 BFD_JUMP_TABLE_GENERIC (coff), \
5931 BFD_JUMP_TABLE_COPY (coff), \
5932 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5933 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5934 BFD_JUMP_TABLE_SYMBOLS (coff), \
5935 BFD_JUMP_TABLE_RELOCS (coff), \
5936 BFD_JUMP_TABLE_WRITE (coff), \
5937 BFD_JUMP_TABLE_LINK (coff), \
5938 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5945 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5946 const bfd_target VAR = \
5949 bfd_target_coff_flavour, \
5950 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5951 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5952 /* object flags */ \
5953 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5954 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5955 /* section flags */ \
5956 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5957 UNDER, /* Leading symbol underscore. */ \
5958 '/', /* AR_pad_char. */ \
5959 15, /* AR_max_namelen. */ \
5960 0, /* match priority. */ \
5961 TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols. */ \
5963 /* Data conversion functions. */ \
5964 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5965 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5966 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5968 /* Header conversion functions. */ \
5969 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5970 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5971 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5973 { /* bfd_check_format. */ \
5974 _bfd_dummy_target, \
5976 bfd_generic_archive_p, \
5979 { /* bfd_set_format. */ \
5980 _bfd_bool_bfd_false_error, \
5982 _bfd_generic_mkarchive, \
5983 _bfd_bool_bfd_false_error \
5985 { /* bfd_write_contents. */ \
5986 _bfd_bool_bfd_false_error, \
5987 coff_write_object_contents, \
5988 _bfd_write_archive_contents, \
5989 _bfd_bool_bfd_false_error \
5992 BFD_JUMP_TABLE_GENERIC (coff), \
5993 BFD_JUMP_TABLE_COPY (coff), \
5994 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5995 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5996 BFD_JUMP_TABLE_SYMBOLS (coff), \
5997 BFD_JUMP_TABLE_RELOCS (coff), \
5998 BFD_JUMP_TABLE_WRITE (coff), \
5999 BFD_JUMP_TABLE_LINK (coff), \
6000 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
6007 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
6008 const bfd_target VAR = \
6011 bfd_target_coff_flavour, \
6012 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
6013 BFD_ENDIAN_LITTLE, /* Header byte order is little. */ \
6014 /* object flags */ \
6015 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
6016 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
6017 /* section flags */ \
6018 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
6019 UNDER, /* Leading symbol underscore. */ \
6020 '/', /* AR_pad_char. */ \
6021 15, /* AR_max_namelen. */ \
6022 0, /* match priority. */ \
6023 TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols. */ \
6025 /* Data conversion functions. */ \
6026 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
6027 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
6028 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
6029 /* Header conversion functions. */ \
6030 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
6031 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
6032 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
6034 { /* bfd_check_format. */ \
6035 _bfd_dummy_target, \
6037 bfd_generic_archive_p, \
6040 { /* bfd_set_format. */ \
6041 _bfd_bool_bfd_false_error, \
6043 _bfd_generic_mkarchive, \
6044 _bfd_bool_bfd_false_error \
6046 { /* bfd_write_contents. */ \
6047 _bfd_bool_bfd_false_error, \
6048 coff_write_object_contents, \
6049 _bfd_write_archive_contents, \
6050 _bfd_bool_bfd_false_error \
6053 BFD_JUMP_TABLE_GENERIC (coff), \
6054 BFD_JUMP_TABLE_COPY (coff), \
6055 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
6056 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
6057 BFD_JUMP_TABLE_SYMBOLS (coff), \
6058 BFD_JUMP_TABLE_RELOCS (coff), \
6059 BFD_JUMP_TABLE_WRITE (coff), \
6060 BFD_JUMP_TABLE_LINK (coff), \
6061 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \