1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright (C) 1990-2015 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 88k bcs coff format is implemented in the file
36 @file{coff-m88k.c}. This file @code{#include}s
37 @file{coff/m88k.h} which defines the external structure of the
38 coff format for the 88k, and @file{coff/internal.h} which
39 defines the internal structure. @file{coff-m88k.c} also
40 defines the relocations used by the 88k format
43 The Intel i960 processor version of coff is implemented in
44 @file{coff-i960.c}. This file has the same structure as
45 @file{coff-m88k.c}, except that it includes @file{coff/i960.h}
46 rather than @file{coff-m88k.h}.
49 Porting to a new version of coff
51 The recommended method is to select from the existing
52 implementations the version of coff which is most like the one
53 you want to use. For example, we'll say that i386 coff is
54 the one you select, and that your coff flavour is called foo.
55 Copy @file{i386coff.c} to @file{foocoff.c}, copy
56 @file{../include/coff/i386.h} to @file{../include/coff/foo.h},
57 and add the lines to @file{targets.c} and @file{Makefile.in}
58 so that your new back end is used. Alter the shapes of the
59 structures in @file{../include/coff/foo.h} so that they match
60 what you need. You will probably also have to add
61 @code{#ifdef}s to the code in @file{coff/internal.h} and
62 @file{coffcode.h} if your version of coff is too wild.
64 You can verify that your new BFD backend works quite simply by
65 building @file{objdump} from the @file{binutils} directory,
66 and making sure that its version of what's going on and your
67 host system's idea (assuming it has the pretty standard coff
68 dump utility, usually called @code{att-dump} or just
69 @code{dump}) are the same. Then clean up your code, and send
70 what you've done to Cygnus. Then your stuff will be in the
71 next release, and you won't have to keep integrating it.
74 How the coff backend works
79 The Coff backend is split into generic routines that are
80 applicable to any Coff target and routines that are specific
81 to a particular target. The target-specific routines are
82 further split into ones which are basically the same for all
83 Coff targets except that they use the external symbol format
84 or use different values for certain constants.
86 The generic routines are in @file{coffgen.c}. These routines
87 work for any Coff target. They use some hooks into the target
88 specific code; the hooks are in a @code{bfd_coff_backend_data}
89 structure, one of which exists for each target.
91 The essentially similar target-specific routines are in
92 @file{coffcode.h}. This header file includes executable C code.
93 The various Coff targets first include the appropriate Coff
94 header file, make any special defines that are needed, and
95 then include @file{coffcode.h}.
97 Some of the Coff targets then also have additional routines in
98 the target source file itself.
100 For example, @file{coff-i960.c} includes
101 @file{coff/internal.h} and @file{coff/i960.h}. It then
102 defines a few constants, such as @code{I960}, and includes
103 @file{coffcode.h}. Since the i960 has complex relocation
104 types, @file{coff-i960.c} also includes some code to
105 manipulate the i960 relocs. This code is not in
106 @file{coffcode.h} because it would not be used by any other
110 Coff long section names
112 In the standard Coff object format, section names are limited to
113 the eight bytes available in the @code{s_name} field of the
114 @code{SCNHDR} section header structure. The format requires the
115 field to be NUL-padded, but not necessarily NUL-terminated, so
116 the longest section names permitted are a full eight characters.
118 The Microsoft PE variants of the Coff object file format add
119 an extension to support the use of long section names. This
120 extension is defined in section 4 of the Microsoft PE/COFF
121 specification (rev 8.1). If a section name is too long to fit
122 into the section header's @code{s_name} field, it is instead
123 placed into the string table, and the @code{s_name} field is
124 filled with a slash ("/") followed by the ASCII decimal
125 representation of the offset of the full name relative to the
128 Note that this implies that the extension can only be used in object
129 files, as executables do not contain a string table. The standard
130 specifies that long section names from objects emitted into executable
131 images are to be truncated.
133 However, as a GNU extension, BFD can generate executable images
134 that contain a string table and long section names. This
135 would appear to be technically valid, as the standard only says
136 that Coff debugging information is deprecated, not forbidden,
137 and in practice it works, although some tools that parse PE files
138 expecting the MS standard format may become confused; @file{PEview} is
141 The functionality is supported in BFD by code implemented under
142 the control of the macro @code{COFF_LONG_SECTION_NAMES}. If not
143 defined, the format does not support long section names in any way.
144 If defined, it is used to initialise a flag,
145 @code{_bfd_coff_long_section_names}, and a hook function pointer,
146 @code{_bfd_coff_set_long_section_names}, in the Coff backend data
147 structure. The flag controls the generation of long section names
148 in output BFDs at runtime; if it is false, as it will be by default
149 when generating an executable image, long section names are truncated;
150 if true, the long section names extension is employed. The hook
151 points to a function that allows the value of the flag to be altered
152 at runtime, on formats that support long section names at all; on
153 other formats it points to a stub that returns an error indication.
155 With input BFDs, the flag is set according to whether any long section
156 names are detected while reading the section headers. For a completely
157 new BFD, the flag is set to the default for the target format. This
158 information can be used by a client of the BFD library when deciding
159 what output format to generate, and means that a BFD that is opened
160 for read and subsequently converted to a writeable BFD and modified
161 in-place will retain whatever format it had on input.
163 If @code{COFF_LONG_SECTION_NAMES} is simply defined (blank), or is
164 defined to the value "1", then long section names are enabled by
165 default; if it is defined to the value zero, they are disabled by
166 default (but still accepted in input BFDs). The header @file{coffcode.h}
167 defines a macro, @code{COFF_DEFAULT_LONG_SECTION_NAMES}, which is
168 used in the backends to initialise the backend data structure fields
169 appropriately; see the comments for further detail.
174 Each flavour of coff supported in BFD has its own header file
175 describing the external layout of the structures. There is also
176 an internal description of the coff layout, in
177 @file{coff/internal.h}. A major function of the
178 coff backend is swapping the bytes and twiddling the bits to
179 translate the external form of the structures into the normal
180 internal form. This is all performed in the
181 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
182 elements are different sizes between different versions of
183 coff; it is the duty of the coff version specific include file
184 to override the definitions of various packing routines in
185 @file{coffcode.h}. E.g., the size of line number entry in coff is
186 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
187 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
188 correct one. No doubt, some day someone will find a version of
189 coff which has a varying field size not catered to at the
190 moment. To port BFD, that person will have to add more @code{#defines}.
191 Three of the bit twiddling routines are exported to
192 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
193 and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol
194 table on its own, but uses BFD to fix things up. More of the
195 bit twiddlers are exported for @code{gas};
196 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
197 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
198 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
199 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
200 of all the symbol table and reloc drudgery itself, thereby
201 saving the internal BFD overhead, but uses BFD to swap things
202 on the way out, making cross ports much safer. Doing so also
203 allows BFD (and thus the linker) to use the same header files
204 as @code{gas}, which makes one avenue to disaster disappear.
209 The simple canonical form for symbols used by BFD is not rich
210 enough to keep all the information available in a coff symbol
211 table. The back end gets around this problem by keeping the original
212 symbol table around, "behind the scenes".
214 When a symbol table is requested (through a call to
215 @code{bfd_canonicalize_symtab}), a request gets through to
216 @code{coff_get_normalized_symtab}. This reads the symbol table from
217 the coff file and swaps all the structures inside into the
218 internal form. It also fixes up all the pointers in the table
219 (represented in the file by offsets from the first symbol in
220 the table) into physical pointers to elements in the new
221 internal table. This involves some work since the meanings of
222 fields change depending upon context: a field that is a
223 pointer to another structure in the symbol table at one moment
224 may be the size in bytes of a structure at the next. Another
225 pass is made over the table. All symbols which mark file names
226 (<<C_FILE>> symbols) are modified so that the internal
227 string points to the value in the auxent (the real filename)
228 rather than the normal text associated with the symbol
231 At this time the symbol names are moved around. Coff stores
232 all symbols less than nine characters long physically
233 within the symbol table; longer strings are kept at the end of
234 the file in the string table. This pass moves all strings
235 into memory and replaces them with pointers to the strings.
237 The symbol table is massaged once again, this time to create
238 the canonical table used by the BFD application. Each symbol
239 is inspected in turn, and a decision made (using the
240 @code{sclass} field) about the various flags to set in the
241 @code{asymbol}. @xref{Symbols}. The generated canonical table
242 shares strings with the hidden internal symbol table.
244 Any linenumbers are read from the coff file too, and attached
245 to the symbols which own the functions the linenumbers belong to.
250 Writing a symbol to a coff file which didn't come from a coff
251 file will lose any debugging information. The @code{asymbol}
252 structure remembers the BFD from which the symbol was taken, and on
253 output the back end makes sure that the same destination target as
254 source target is present.
256 When the symbols have come from a coff file then all the
257 debugging information is preserved.
259 Symbol tables are provided for writing to the back end in a
260 vector of pointers to pointers. This allows applications like
261 the linker to accumulate and output large symbol tables
262 without having to do too much byte copying.
264 This function runs through the provided symbol table and
265 patches each symbol marked as a file place holder
266 (@code{C_FILE}) to point to the next file place holder in the
267 list. It also marks each @code{offset} field in the list with
268 the offset from the first symbol of the current symbol.
270 Another function of this procedure is to turn the canonical
271 value form of BFD into the form used by coff. Internally, BFD
272 expects symbol values to be offsets from a section base; so a
273 symbol physically at 0x120, but in a section starting at
274 0x100, would have the value 0x20. Coff expects symbols to
275 contain their final value, so symbols have their values
276 changed at this point to reflect their sum with their owning
277 section. This transformation uses the
278 <<output_section>> field of the @code{asymbol}'s
279 @code{asection} @xref{Sections}.
281 o <<coff_mangle_symbols>>
283 This routine runs though the provided symbol table and uses
284 the offsets generated by the previous pass and the pointers
285 generated when the symbol table was read in to create the
286 structured hierarchy required by coff. It changes each pointer
287 to a symbol into the index into the symbol table of the asymbol.
289 o <<coff_write_symbols>>
291 This routine runs through the symbol table and patches up the
292 symbols from their internal form into the coff way, calls the
293 bit twiddlers, and writes out the table to the file.
302 The hidden information for an <<asymbol>> is described in a
303 <<combined_entry_type>>:
307 .typedef struct coff_ptr_struct
309 . {* Remembers the offset from the first symbol in the file for
310 . this symbol. Generated by coff_renumber_symbols. *}
311 . unsigned int offset;
313 . {* Should the value of this symbol be renumbered. Used for
314 . XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
315 . unsigned int fix_value : 1;
317 . {* Should the tag field of this symbol be renumbered.
318 . Created by coff_pointerize_aux. *}
319 . unsigned int fix_tag : 1;
321 . {* Should the endidx field of this symbol be renumbered.
322 . Created by coff_pointerize_aux. *}
323 . unsigned int fix_end : 1;
325 . {* Should the x_csect.x_scnlen field be renumbered.
326 . Created by coff_pointerize_aux. *}
327 . unsigned int fix_scnlen : 1;
329 . {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
330 . index into the line number entries. Set by coff_slurp_symbol_table. *}
331 . unsigned int fix_line : 1;
333 . {* The container for the symbol structure as read and translated
337 . union internal_auxent auxent;
338 . struct internal_syment syment;
341 . {* Selector for the union above. *}
342 . bfd_boolean is_sym;
343 .} combined_entry_type;
346 .{* Each canonical asymbol really looks like this: *}
348 .typedef struct coff_symbol_struct
350 . {* The actual symbol which the rest of BFD works with *}
353 . {* A pointer to the hidden information for this symbol *}
354 . combined_entry_type *native;
356 . {* A pointer to the linenumber information for this symbol *}
357 . struct lineno_cache_entry *lineno;
359 . {* Have the line numbers been relocated yet ? *}
360 . bfd_boolean done_lineno;
365 #include "libiberty.h"
370 #include "coffswap.h"
373 #define STRING_SIZE_SIZE 4
375 #define DOT_DEBUG ".debug"
376 #define DOT_ZDEBUG ".zdebug"
377 #define GNU_LINKONCE_WI ".gnu.linkonce.wi."
378 #define GNU_LINKONCE_WT ".gnu.linkonce.wt."
379 #define DOT_RELOC ".reloc"
381 #if defined (COFF_LONG_SECTION_NAMES)
382 /* Needed to expand the inputs to BLANKOR1TOODD. */
383 #define COFFLONGSECTIONCATHELPER(x,y) x ## y
384 /* If the input macro Y is blank or '1', return an odd number; if it is
385 '0', return an even number. Result undefined in all other cases. */
386 #define BLANKOR1TOODD(y) COFFLONGSECTIONCATHELPER(1,y)
387 /* Defined to numerical 0 or 1 according to whether generation of long
388 section names is disabled or enabled by default. */
389 #define COFF_ENABLE_LONG_SECTION_NAMES (BLANKOR1TOODD(COFF_LONG_SECTION_NAMES) & 1)
390 /* Where long section names are supported, we allow them to be enabled
391 and disabled at runtime, so select an appropriate hook function for
392 _bfd_coff_set_long_section_names. */
393 #define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_allowed
394 #else /* !defined (COFF_LONG_SECTION_NAMES) */
395 /* If long section names are not supported, this stub disallows any
396 attempt to enable them at run-time. */
397 #define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_disallowed
398 #endif /* defined (COFF_LONG_SECTION_NAMES) */
400 /* Define a macro that can be used to initialise both the fields relating
401 to long section names in the backend data struct simultaneously. */
402 #if COFF_ENABLE_LONG_SECTION_NAMES
403 #define COFF_DEFAULT_LONG_SECTION_NAMES (TRUE), COFF_LONG_SECTION_NAMES_SETTER
404 #else /* !COFF_ENABLE_LONG_SECTION_NAMES */
405 #define COFF_DEFAULT_LONG_SECTION_NAMES (FALSE), COFF_LONG_SECTION_NAMES_SETTER
406 #endif /* COFF_ENABLE_LONG_SECTION_NAMES */
408 #if defined (COFF_LONG_SECTION_NAMES)
409 static bfd_boolean bfd_coff_set_long_section_names_allowed
411 #else /* !defined (COFF_LONG_SECTION_NAMES) */
412 static bfd_boolean bfd_coff_set_long_section_names_disallowed
414 #endif /* defined (COFF_LONG_SECTION_NAMES) */
415 static long sec_to_styp_flags
416 (const char *, flagword
);
417 static bfd_boolean styp_to_sec_flags
418 (bfd
*, void *, const char *, asection
*, flagword
*);
419 static bfd_boolean coff_bad_format_hook
421 static void coff_set_custom_section_alignment
422 (bfd
*, asection
*, const struct coff_section_alignment_entry
*,
424 static bfd_boolean coff_new_section_hook
426 static bfd_boolean coff_set_arch_mach_hook
428 static bfd_boolean coff_write_relocs
430 static bfd_boolean coff_set_flags
431 (bfd
*, unsigned int *, unsigned short *);
432 static bfd_boolean coff_set_arch_mach
433 (bfd
*, enum bfd_architecture
, unsigned long) ATTRIBUTE_UNUSED
;
434 static bfd_boolean coff_compute_section_file_positions
436 static bfd_boolean coff_write_object_contents
437 (bfd
*) ATTRIBUTE_UNUSED
;
438 static bfd_boolean coff_set_section_contents
439 (bfd
*, asection
*, const void *, file_ptr
, bfd_size_type
);
440 static void * buy_and_read
441 (bfd
*, file_ptr
, bfd_size_type
);
442 static bfd_boolean coff_slurp_line_table
444 static bfd_boolean coff_slurp_symbol_table
446 static enum coff_symbol_classification coff_classify_symbol
447 (bfd
*, struct internal_syment
*);
448 static bfd_boolean coff_slurp_reloc_table
449 (bfd
*, asection
*, asymbol
**);
450 static long coff_canonicalize_reloc
451 (bfd
*, asection
*, arelent
**, asymbol
**);
452 #ifndef coff_mkobject_hook
453 static void * coff_mkobject_hook
454 (bfd
*, void *, void *);
457 static flagword handle_COMDAT
458 (bfd
*, flagword
, void *, const char *, asection
*);
460 #ifdef COFF_IMAGE_WITH_PE
461 static bfd_boolean coff_read_word
462 (bfd
*, unsigned int *);
463 static unsigned int coff_compute_checksum
465 static bfd_boolean coff_apply_checksum
469 static bfd_boolean ticoff0_bad_format_hook
471 static bfd_boolean ticoff1_bad_format_hook
475 /* void warning(); */
477 #if defined (COFF_LONG_SECTION_NAMES)
479 bfd_coff_set_long_section_names_allowed (bfd
*abfd
, int enable
)
481 coff_backend_info (abfd
)->_bfd_coff_long_section_names
= enable
;
484 #else /* !defined (COFF_LONG_SECTION_NAMES) */
486 bfd_coff_set_long_section_names_disallowed (bfd
*abfd
, int enable
)
492 #endif /* defined (COFF_LONG_SECTION_NAMES) */
494 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
495 the incoming SEC_* flags. The inverse of this function is
496 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
497 should probably mirror the changes in styp_to_sec_flags(). */
501 /* Macros for setting debugging flags. */
504 #define STYP_XCOFF_DEBUG STYP_DEBUG
506 #define STYP_XCOFF_DEBUG STYP_INFO
509 #ifdef COFF_ALIGN_IN_S_FLAGS
510 #define STYP_DEBUG_INFO STYP_DSECT
512 #define STYP_DEBUG_INFO STYP_INFO
516 sec_to_styp_flags (const char *sec_name
, flagword sec_flags
)
520 if (!strcmp (sec_name
, _TEXT
))
522 styp_flags
= STYP_TEXT
;
524 else if (!strcmp (sec_name
, _DATA
))
526 styp_flags
= STYP_DATA
;
528 else if (!strcmp (sec_name
, _BSS
))
530 styp_flags
= STYP_BSS
;
533 else if (!strcmp (sec_name
, _COMMENT
))
535 styp_flags
= STYP_INFO
;
536 #endif /* _COMMENT */
539 else if (!strcmp (sec_name
, _LIB
))
541 styp_flags
= STYP_LIB
;
545 else if (!strcmp (sec_name
, _LIT
))
547 styp_flags
= STYP_LIT
;
550 else if (CONST_STRNEQ (sec_name
, DOT_DEBUG
)
551 || CONST_STRNEQ (sec_name
, DOT_ZDEBUG
))
553 /* Handle the XCOFF debug section and DWARF2 debug sections. */
555 styp_flags
= STYP_XCOFF_DEBUG
;
557 styp_flags
= STYP_DEBUG_INFO
;
559 else if (CONST_STRNEQ (sec_name
, ".stab"))
561 styp_flags
= STYP_DEBUG_INFO
;
563 #ifdef COFF_LONG_SECTION_NAMES
564 else if (CONST_STRNEQ (sec_name
, GNU_LINKONCE_WI
)
565 || CONST_STRNEQ (sec_name
, GNU_LINKONCE_WT
))
567 styp_flags
= STYP_DEBUG_INFO
;
571 else if (!strcmp (sec_name
, _PAD
))
573 styp_flags
= STYP_PAD
;
575 else if (!strcmp (sec_name
, _LOADER
))
577 styp_flags
= STYP_LOADER
;
579 else if (!strcmp (sec_name
, _EXCEPT
))
581 styp_flags
= STYP_EXCEPT
;
583 else if (!strcmp (sec_name
, _TYPCHK
))
585 styp_flags
= STYP_TYPCHK
;
587 else if (sec_flags
& SEC_DEBUGGING
)
591 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
592 if (!strcmp (sec_name
, xcoff_dwsect_names
[i
].name
))
594 styp_flags
= STYP_DWARF
| xcoff_dwsect_names
[i
].flag
;
599 /* Try and figure out what it should be */
600 else if (sec_flags
& SEC_CODE
)
602 styp_flags
= STYP_TEXT
;
604 else if (sec_flags
& SEC_DATA
)
606 styp_flags
= STYP_DATA
;
608 else if (sec_flags
& SEC_READONLY
)
610 #ifdef STYP_LIT /* 29k readonly text/data section */
611 styp_flags
= STYP_LIT
;
613 styp_flags
= STYP_TEXT
;
614 #endif /* STYP_LIT */
616 else if (sec_flags
& SEC_LOAD
)
618 styp_flags
= STYP_TEXT
;
620 else if (sec_flags
& SEC_ALLOC
)
622 styp_flags
= STYP_BSS
;
626 if (sec_flags
& SEC_TIC54X_CLINK
)
627 styp_flags
|= STYP_CLINK
;
631 if (sec_flags
& SEC_TIC54X_BLOCK
)
632 styp_flags
|= STYP_BLOCK
;
636 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
637 styp_flags
|= STYP_NOLOAD
;
643 #else /* COFF_WITH_PE */
645 /* The PE version; see above for the general comments. The non-PE
646 case seems to be more guessing, and breaks PE format; specifically,
647 .rdata is readonly, but it sure ain't text. Really, all this
648 should be set up properly in gas (or whatever assembler is in use),
649 and honor whatever objcopy/strip, etc. sent us as input. */
652 sec_to_styp_flags (const char *sec_name
, flagword sec_flags
)
655 bfd_boolean is_dbg
= FALSE
;
657 if (CONST_STRNEQ (sec_name
, DOT_DEBUG
)
658 || CONST_STRNEQ (sec_name
, DOT_ZDEBUG
)
659 #ifdef COFF_LONG_SECTION_NAMES
660 || CONST_STRNEQ (sec_name
, GNU_LINKONCE_WI
)
661 || CONST_STRNEQ (sec_name
, GNU_LINKONCE_WT
)
663 || CONST_STRNEQ (sec_name
, ".stab"))
666 /* caution: there are at least three groups of symbols that have
667 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
668 SEC_* are the BFD internal flags, used for generic BFD
669 information. STYP_* are the COFF section flags which appear in
670 COFF files. IMAGE_SCN_* are the PE section flags which appear in
671 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
672 but there are more IMAGE_SCN_* flags. */
674 /* FIXME: There is no gas syntax to specify the debug section flag. */
677 sec_flags
&= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
678 | SEC_LINK_DUPLICATES_SAME_CONTENTS
679 | SEC_LINK_DUPLICATES_SAME_SIZE
);
680 sec_flags
|= SEC_DEBUGGING
| SEC_READONLY
;
686 if ((sec_flags
& SEC_CODE
) != 0)
687 styp_flags
|= IMAGE_SCN_CNT_CODE
;
688 if ((sec_flags
& (SEC_DATA
| SEC_DEBUGGING
)) != 0)
689 styp_flags
|= IMAGE_SCN_CNT_INITIALIZED_DATA
;
690 if ((sec_flags
& SEC_ALLOC
) != 0 && (sec_flags
& SEC_LOAD
) == 0)
691 styp_flags
|= IMAGE_SCN_CNT_UNINITIALIZED_DATA
; /* ==STYP_BSS */
693 /* skip constRUCTOR */
695 if ((sec_flags
& SEC_IS_COMMON
) != 0)
696 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
697 if ((sec_flags
& SEC_DEBUGGING
) != 0)
698 styp_flags
|= IMAGE_SCN_MEM_DISCARDABLE
;
699 if ((sec_flags
& SEC_EXCLUDE
) != 0 && !is_dbg
)
700 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
701 if ((sec_flags
& SEC_NEVER_LOAD
) != 0 && !is_dbg
)
702 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
705 if (sec_flags
& SEC_LINK_ONCE
)
706 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
708 & (SEC_LINK_DUPLICATES_DISCARD
| SEC_LINK_DUPLICATES_SAME_CONTENTS
709 | SEC_LINK_DUPLICATES_SAME_SIZE
)) != 0)
710 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
712 /* skip LINKER_CREATED */
714 if ((sec_flags
& SEC_COFF_NOREAD
) == 0)
715 styp_flags
|= IMAGE_SCN_MEM_READ
; /* Invert NOREAD for read. */
716 if ((sec_flags
& SEC_READONLY
) == 0)
717 styp_flags
|= IMAGE_SCN_MEM_WRITE
; /* Invert READONLY for write. */
718 if (sec_flags
& SEC_CODE
)
719 styp_flags
|= IMAGE_SCN_MEM_EXECUTE
; /* CODE->EXECUTE. */
720 if (sec_flags
& SEC_COFF_SHARED
)
721 styp_flags
|= IMAGE_SCN_MEM_SHARED
; /* Shared remains meaningful. */
726 #endif /* COFF_WITH_PE */
728 /* Return a word with SEC_* flags set to represent the incoming STYP_*
729 flags (from scnhdr.s_flags). The inverse of this function is
730 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
731 should probably mirror the changes in sec_to_styp_flags(). */
736 styp_to_sec_flags (bfd
*abfd ATTRIBUTE_UNUSED
,
739 asection
*section ATTRIBUTE_UNUSED
,
742 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
743 long styp_flags
= internal_s
->s_flags
;
744 flagword sec_flags
= 0;
747 if (styp_flags
& STYP_BLOCK
)
748 sec_flags
|= SEC_TIC54X_BLOCK
;
752 if (styp_flags
& STYP_CLINK
)
753 sec_flags
|= SEC_TIC54X_CLINK
;
757 if (styp_flags
& STYP_NOLOAD
)
758 sec_flags
|= SEC_NEVER_LOAD
;
759 #endif /* STYP_NOLOAD */
761 /* For 386 COFF, at least, an unloadable text or data section is
762 actually a shared library section. */
763 if (styp_flags
& STYP_TEXT
)
765 if (sec_flags
& SEC_NEVER_LOAD
)
766 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
768 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
770 else if (styp_flags
& STYP_DATA
)
772 if (sec_flags
& SEC_NEVER_LOAD
)
773 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
775 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
777 else if (styp_flags
& STYP_BSS
)
779 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
780 if (sec_flags
& SEC_NEVER_LOAD
)
781 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
784 sec_flags
|= SEC_ALLOC
;
786 else if (styp_flags
& STYP_INFO
)
788 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
789 defined. coff_compute_section_file_positions uses
790 COFF_PAGE_SIZE to ensure that the low order bits of the
791 section VMA and the file offset match. If we don't know
792 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
793 and demand page loading of the file will fail. */
794 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
795 sec_flags
|= SEC_DEBUGGING
;
798 else if (styp_flags
& STYP_PAD
)
801 else if (styp_flags
& STYP_EXCEPT
)
802 sec_flags
|= SEC_LOAD
;
803 else if (styp_flags
& STYP_LOADER
)
804 sec_flags
|= SEC_LOAD
;
805 else if (styp_flags
& STYP_TYPCHK
)
806 sec_flags
|= SEC_LOAD
;
807 else if (styp_flags
& STYP_DWARF
)
808 sec_flags
|= SEC_DEBUGGING
;
810 else if (strcmp (name
, _TEXT
) == 0)
812 if (sec_flags
& SEC_NEVER_LOAD
)
813 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
815 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
817 else if (strcmp (name
, _DATA
) == 0)
819 if (sec_flags
& SEC_NEVER_LOAD
)
820 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
822 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
824 else if (strcmp (name
, _BSS
) == 0)
826 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
827 if (sec_flags
& SEC_NEVER_LOAD
)
828 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
831 sec_flags
|= SEC_ALLOC
;
833 else if (CONST_STRNEQ (name
, DOT_DEBUG
)
834 || CONST_STRNEQ (name
, DOT_ZDEBUG
)
836 || strcmp (name
, _COMMENT
) == 0
838 #ifdef COFF_LONG_SECTION_NAMES
839 || CONST_STRNEQ (name
, GNU_LINKONCE_WI
)
840 || CONST_STRNEQ (name
, GNU_LINKONCE_WT
)
842 || CONST_STRNEQ (name
, ".stab"))
844 #ifdef COFF_PAGE_SIZE
845 sec_flags
|= SEC_DEBUGGING
;
849 else if (strcmp (name
, _LIB
) == 0)
853 else if (strcmp (name
, _LIT
) == 0)
854 sec_flags
= SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
857 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
859 #ifdef STYP_LIT /* A29k readonly text/data section type. */
860 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
861 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
862 #endif /* STYP_LIT */
864 #ifdef STYP_OTHER_LOAD /* Other loaded sections. */
865 if (styp_flags
& STYP_OTHER_LOAD
)
866 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
867 #endif /* STYP_SDATA */
869 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
870 /* As a GNU extension, if the name begins with .gnu.linkonce, we
871 only link a single copy of the section. This is used to support
872 g++. g++ will emit each template expansion in its own section.
873 The symbols will be defined as weak, so that multiple definitions
874 are permitted. The GNU linker extension is to actually discard
875 all but one of the sections. */
876 if (CONST_STRNEQ (name
, ".gnu.linkonce"))
877 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
880 if (flags_ptr
== NULL
)
883 * flags_ptr
= sec_flags
;
887 #else /* COFF_WITH_PE */
890 handle_COMDAT (bfd
* abfd
,
896 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
897 bfd_byte
*esymstart
, *esym
, *esymend
;
899 char *target_name
= NULL
;
901 sec_flags
|= SEC_LINK_ONCE
;
903 /* Unfortunately, the PE format stores essential information in
904 the symbol table, of all places. We need to extract that
905 information now, so that objdump and the linker will know how
906 to handle the section without worrying about the symbols. We
907 can't call slurp_symtab, because the linker doesn't want the
910 /* COMDAT sections are special. The first symbol is the section
911 symbol, which tells what kind of COMDAT section it is. The
912 second symbol is the "comdat symbol" - the one with the
913 unique name. GNU uses the section symbol for the unique
914 name; MS uses ".text" for every comdat section. Sigh. - DJ */
916 /* This is not mirrored in sec_to_styp_flags(), but there
917 doesn't seem to be a need to, either, and it would at best be
920 if (! _bfd_coff_get_external_symbols (abfd
))
923 esymstart
= esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
924 esymend
= esym
+ obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
926 while (esym
< esymend
)
928 struct internal_syment isym
;
929 char buf
[SYMNMLEN
+ 1];
932 bfd_coff_swap_sym_in (abfd
, esym
, & isym
);
934 BFD_ASSERT (sizeof (internal_s
->s_name
) <= SYMNMLEN
);
936 if (isym
.n_scnum
== section
->target_index
)
938 /* According to the MSVC documentation, the first
939 TWO entries with the section # are both of
940 interest to us. The first one is the "section
941 symbol" (section name). The second is the comdat
942 symbol name. Here, we've found the first
943 qualifying entry; we distinguish it from the
944 second with a state flag.
946 In the case of gas-generated (at least until that
947 is fixed) .o files, it isn't necessarily the
948 second one. It may be some other later symbol.
950 Since gas also doesn't follow MS conventions and
951 emits the section similar to .text$<name>, where
952 <something> is the name we're looking for, we
953 distinguish the two as follows:
955 If the section name is simply a section name (no
956 $) we presume it's MS-generated, and look at
957 precisely the second symbol for the comdat name.
958 If the section name has a $, we assume it's
959 gas-generated, and look for <something> (whatever
960 follows the $) as the comdat symbol. */
962 /* All 3 branches use this. */
963 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
, buf
);
965 /* PR 17512 file: 078-11867-0.004 */
968 _bfd_error_handler (_("%B: unable to load COMDAT section name"), abfd
);
976 /* The first time we've seen the symbol. */
977 union internal_auxent aux
;
979 /* If it isn't the stuff we're expecting, die;
980 The MS documentation is vague, but it
981 appears that the second entry serves BOTH
982 as the comdat symbol and the defining
983 symbol record (either C_STAT or C_EXT,
984 possibly with an aux entry with debug
985 information if it's a function.) It
986 appears the only way to find the second one
987 is to count. (On Intel, they appear to be
988 adjacent, but on Alpha, they have been
991 Here, we think we've found the first one,
992 but there's some checking we can do to be
995 if (! ((isym
.n_sclass
== C_STAT
996 || isym
.n_sclass
== C_EXT
)
997 && BTYPE (isym
.n_type
) == T_NULL
998 && isym
.n_value
== 0))
1001 /* FIXME LATER: MSVC generates section names
1002 like .text for comdats. Gas generates
1003 names like .text$foo__Fv (in the case of a
1004 function). See comment above for more. */
1006 if (isym
.n_sclass
== C_STAT
&& strcmp (name
, symname
) != 0)
1007 _bfd_error_handler (_("%B: warning: COMDAT symbol '%s' does not match section name '%s'"),
1008 abfd
, symname
, name
);
1012 /* This is the section symbol. */
1013 bfd_coff_swap_aux_in (abfd
, (esym
+ bfd_coff_symesz (abfd
)),
1014 isym
.n_type
, isym
.n_sclass
,
1015 0, isym
.n_numaux
, & aux
);
1017 target_name
= strchr (name
, '$');
1018 if (target_name
!= NULL
)
1026 /* FIXME: Microsoft uses NODUPLICATES and
1027 ASSOCIATIVE, but gnu uses ANY and
1028 SAME_SIZE. Unfortunately, gnu doesn't do
1029 the comdat symbols right. So, until we can
1030 fix it to do the right thing, we are
1031 temporarily disabling comdats for the MS
1032 types (they're used in DLLs and C++, but we
1033 don't support *their* C++ libraries anyway
1036 /* Cygwin does not follow the MS style, and
1037 uses ANY and SAME_SIZE where NODUPLICATES
1038 and ASSOCIATIVE should be used. For
1039 Interix, we just do the right thing up
1042 switch (aux
.x_scn
.x_comdat
)
1044 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
1045 #ifdef STRICT_PE_FORMAT
1046 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
1048 sec_flags
&= ~SEC_LINK_ONCE
;
1052 case IMAGE_COMDAT_SELECT_ANY
:
1053 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1056 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
1057 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
1060 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
1061 /* Not yet fully implemented ??? */
1062 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
1065 /* debug$S gets this case; other
1068 /* There may be no symbol... we'll search
1069 the whole table... Is this the right
1070 place to play this game? Or should we do
1071 it when reading it in. */
1072 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
1073 #ifdef STRICT_PE_FORMAT
1074 /* FIXME: This is not currently implemented. */
1075 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1077 sec_flags
&= ~SEC_LINK_ONCE
;
1081 default: /* 0 means "no symbol" */
1082 /* debug$F gets this case; other
1084 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1091 /* Gas mode: the first matching on partial name. */
1093 #ifndef TARGET_UNDERSCORE
1094 #define TARGET_UNDERSCORE 0
1096 /* Is this the name we're looking for ? */
1097 if (strcmp (target_name
,
1098 symname
+ (TARGET_UNDERSCORE
? 1 : 0)) != 0)
1100 /* Not the name we're looking for */
1101 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1106 /* MSVC mode: the lexically second symbol (or
1107 drop through from the above). */
1112 /* This must the second symbol with the
1113 section #. It is the actual symbol name.
1114 Intel puts the two adjacent, but Alpha (at
1115 least) spreads them out. */
1117 amt
= sizeof (struct coff_comdat_info
);
1118 coff_section_data (abfd
, section
)->comdat
1119 = (struct coff_comdat_info
*) bfd_alloc (abfd
, amt
);
1120 if (coff_section_data (abfd
, section
)->comdat
== NULL
)
1123 coff_section_data (abfd
, section
)->comdat
->symbol
=
1124 (esym
- esymstart
) / bfd_coff_symesz (abfd
);
1126 amt
= strlen (symname
) + 1;
1127 newname
= (char *) bfd_alloc (abfd
, amt
);
1128 if (newname
== NULL
)
1131 strcpy (newname
, symname
);
1132 coff_section_data (abfd
, section
)->comdat
->name
1140 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1148 /* The PE version; see above for the general comments.
1150 Since to set the SEC_LINK_ONCE and associated flags, we have to
1151 look at the symbol table anyway, we return the symbol table index
1152 of the symbol being used as the COMDAT symbol. This is admittedly
1153 ugly, but there's really nowhere else that we have access to the
1154 required information. FIXME: Is the COMDAT symbol index used for
1155 any purpose other than objdump? */
1158 styp_to_sec_flags (bfd
*abfd
,
1162 flagword
*flags_ptr
)
1164 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
1165 long styp_flags
= internal_s
->s_flags
;
1167 bfd_boolean result
= TRUE
;
1168 bfd_boolean is_dbg
= FALSE
;
1170 if (CONST_STRNEQ (name
, DOT_DEBUG
)
1171 || CONST_STRNEQ (name
, DOT_ZDEBUG
)
1172 #ifdef COFF_LONG_SECTION_NAMES
1173 || CONST_STRNEQ (name
, GNU_LINKONCE_WI
)
1174 || CONST_STRNEQ (name
, GNU_LINKONCE_WT
)
1176 || CONST_STRNEQ (name
, ".stab"))
1178 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
1179 sec_flags
= SEC_READONLY
;
1181 /* If section disallows read, then set the NOREAD flag. */
1182 if ((styp_flags
& IMAGE_SCN_MEM_READ
) == 0)
1183 sec_flags
|= SEC_COFF_NOREAD
;
1185 /* Process each flag bit in styp_flags in turn. */
1188 long flag
= styp_flags
& - styp_flags
;
1189 char * unhandled
= NULL
;
1191 styp_flags
&= ~ flag
;
1193 /* We infer from the distinct read/write/execute bits the settings
1194 of some of the bfd flags; the actual values, should we need them,
1195 are also in pei_section_data (abfd, section)->pe_flags. */
1200 unhandled
= "STYP_DSECT";
1203 unhandled
= "STYP_GROUP";
1206 unhandled
= "STYP_COPY";
1209 unhandled
= "STYP_OVER";
1211 #ifdef SEC_NEVER_LOAD
1213 sec_flags
|= SEC_NEVER_LOAD
;
1216 case IMAGE_SCN_MEM_READ
:
1217 sec_flags
&= ~SEC_COFF_NOREAD
;
1219 case IMAGE_SCN_TYPE_NO_PAD
:
1222 case IMAGE_SCN_LNK_OTHER
:
1223 unhandled
= "IMAGE_SCN_LNK_OTHER";
1225 case IMAGE_SCN_MEM_NOT_CACHED
:
1226 unhandled
= "IMAGE_SCN_MEM_NOT_CACHED";
1228 case IMAGE_SCN_MEM_NOT_PAGED
:
1229 /* Generate a warning message rather using the 'unhandled'
1230 variable as this will allow some .sys files generate by
1231 other toolchains to be processed. See bugzilla issue 196. */
1232 _bfd_error_handler (_("%B: Warning: Ignoring section flag IMAGE_SCN_MEM_NOT_PAGED in section %s"),
1235 case IMAGE_SCN_MEM_EXECUTE
:
1236 sec_flags
|= SEC_CODE
;
1238 case IMAGE_SCN_MEM_WRITE
:
1239 sec_flags
&= ~ SEC_READONLY
;
1241 case IMAGE_SCN_MEM_DISCARDABLE
:
1242 /* The MS PE spec says that debug sections are DISCARDABLE,
1243 but the presence of a DISCARDABLE flag does not necessarily
1244 mean that a given section contains debug information. Thus
1245 we only set the SEC_DEBUGGING flag on sections that we
1246 recognise as containing debug information. */
1249 || strcmp (name
, _COMMENT
) == 0
1253 sec_flags
|= SEC_DEBUGGING
| SEC_READONLY
;
1256 case IMAGE_SCN_MEM_SHARED
:
1257 sec_flags
|= SEC_COFF_SHARED
;
1259 case IMAGE_SCN_LNK_REMOVE
:
1261 sec_flags
|= SEC_EXCLUDE
;
1263 case IMAGE_SCN_CNT_CODE
:
1264 sec_flags
|= SEC_CODE
| SEC_ALLOC
| SEC_LOAD
;
1266 case IMAGE_SCN_CNT_INITIALIZED_DATA
:
1268 sec_flags
|= SEC_DEBUGGING
;
1270 sec_flags
|= SEC_DATA
| SEC_ALLOC
| SEC_LOAD
;
1272 case IMAGE_SCN_CNT_UNINITIALIZED_DATA
:
1273 sec_flags
|= SEC_ALLOC
;
1275 case IMAGE_SCN_LNK_INFO
:
1276 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1277 defined. coff_compute_section_file_positions uses
1278 COFF_PAGE_SIZE to ensure that the low order bits of the
1279 section VMA and the file offset match. If we don't know
1280 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1281 and demand page loading of the file will fail. */
1282 #ifdef COFF_PAGE_SIZE
1283 sec_flags
|= SEC_DEBUGGING
;
1286 case IMAGE_SCN_LNK_COMDAT
:
1287 /* COMDAT gets very special treatment. */
1288 sec_flags
= handle_COMDAT (abfd
, sec_flags
, hdr
, name
, section
);
1291 /* Silently ignore for now. */
1295 /* If the section flag was not handled, report it here. */
1296 if (unhandled
!= NULL
)
1298 (*_bfd_error_handler
)
1299 (_("%B (%s): Section flag %s (0x%x) ignored"),
1300 abfd
, name
, unhandled
, flag
);
1305 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1306 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1307 only link a single copy of the section. This is used to support
1308 g++. g++ will emit each template expansion in its own section.
1309 The symbols will be defined as weak, so that multiple definitions
1310 are permitted. The GNU linker extension is to actually discard
1311 all but one of the sections. */
1312 if (CONST_STRNEQ (name
, ".gnu.linkonce"))
1313 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1317 * flags_ptr
= sec_flags
;
1322 #endif /* COFF_WITH_PE */
1324 #define get_index(symbol) ((symbol)->udata.i)
1328 bfd_coff_backend_data
1332 .{* COFF symbol classifications. *}
1334 .enum coff_symbol_classification
1336 . {* Global symbol. *}
1337 . COFF_SYMBOL_GLOBAL,
1338 . {* Common symbol. *}
1339 . COFF_SYMBOL_COMMON,
1340 . {* Undefined symbol. *}
1341 . COFF_SYMBOL_UNDEFINED,
1342 . {* Local symbol. *}
1343 . COFF_SYMBOL_LOCAL,
1344 . {* PE section symbol. *}
1345 . COFF_SYMBOL_PE_SECTION
1348 Special entry points for gdb to swap in coff symbol table parts:
1351 . void (*_bfd_coff_swap_aux_in)
1352 . (bfd *, void *, int, int, int, int, void *);
1354 . void (*_bfd_coff_swap_sym_in)
1355 . (bfd *, void *, void *);
1357 . void (*_bfd_coff_swap_lineno_in)
1358 . (bfd *, void *, void *);
1360 . unsigned int (*_bfd_coff_swap_aux_out)
1361 . (bfd *, void *, int, int, int, int, void *);
1363 . unsigned int (*_bfd_coff_swap_sym_out)
1364 . (bfd *, void *, void *);
1366 . unsigned int (*_bfd_coff_swap_lineno_out)
1367 . (bfd *, void *, void *);
1369 . unsigned int (*_bfd_coff_swap_reloc_out)
1370 . (bfd *, void *, void *);
1372 . unsigned int (*_bfd_coff_swap_filehdr_out)
1373 . (bfd *, void *, void *);
1375 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1376 . (bfd *, void *, void *);
1378 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1379 . (bfd *, void *, void *);
1381 . unsigned int _bfd_filhsz;
1382 . unsigned int _bfd_aoutsz;
1383 . unsigned int _bfd_scnhsz;
1384 . unsigned int _bfd_symesz;
1385 . unsigned int _bfd_auxesz;
1386 . unsigned int _bfd_relsz;
1387 . unsigned int _bfd_linesz;
1388 . unsigned int _bfd_filnmlen;
1389 . bfd_boolean _bfd_coff_long_filenames;
1391 . bfd_boolean _bfd_coff_long_section_names;
1392 . bfd_boolean (*_bfd_coff_set_long_section_names)
1395 . unsigned int _bfd_coff_default_section_alignment_power;
1396 . bfd_boolean _bfd_coff_force_symnames_in_strings;
1397 . unsigned int _bfd_coff_debug_string_prefix_length;
1398 . unsigned int _bfd_coff_max_nscns;
1400 . void (*_bfd_coff_swap_filehdr_in)
1401 . (bfd *, void *, void *);
1403 . void (*_bfd_coff_swap_aouthdr_in)
1404 . (bfd *, void *, void *);
1406 . void (*_bfd_coff_swap_scnhdr_in)
1407 . (bfd *, void *, void *);
1409 . void (*_bfd_coff_swap_reloc_in)
1410 . (bfd *abfd, void *, void *);
1412 . bfd_boolean (*_bfd_coff_bad_format_hook)
1415 . bfd_boolean (*_bfd_coff_set_arch_mach_hook)
1418 . void * (*_bfd_coff_mkobject_hook)
1419 . (bfd *, void *, void *);
1421 . bfd_boolean (*_bfd_styp_to_sec_flags_hook)
1422 . (bfd *, void *, const char *, asection *, flagword *);
1424 . void (*_bfd_set_alignment_hook)
1425 . (bfd *, asection *, void *);
1427 . bfd_boolean (*_bfd_coff_slurp_symbol_table)
1430 . bfd_boolean (*_bfd_coff_symname_in_debug)
1431 . (bfd *, struct internal_syment *);
1433 . bfd_boolean (*_bfd_coff_pointerize_aux_hook)
1434 . (bfd *, combined_entry_type *, combined_entry_type *,
1435 . unsigned int, combined_entry_type *);
1437 . bfd_boolean (*_bfd_coff_print_aux)
1438 . (bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1439 . combined_entry_type *, unsigned int);
1441 . void (*_bfd_coff_reloc16_extra_cases)
1442 . (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1443 . bfd_byte *, unsigned int *, unsigned int *);
1445 . int (*_bfd_coff_reloc16_estimate)
1446 . (bfd *, asection *, arelent *, unsigned int,
1447 . struct bfd_link_info *);
1449 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1450 . (bfd *, struct internal_syment *);
1452 . bfd_boolean (*_bfd_coff_compute_section_file_positions)
1455 . bfd_boolean (*_bfd_coff_start_final_link)
1456 . (bfd *, struct bfd_link_info *);
1458 . bfd_boolean (*_bfd_coff_relocate_section)
1459 . (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1460 . struct internal_reloc *, struct internal_syment *, asection **);
1462 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1463 . (bfd *, asection *, struct internal_reloc *,
1464 . struct coff_link_hash_entry *, struct internal_syment *,
1467 . bfd_boolean (*_bfd_coff_adjust_symndx)
1468 . (bfd *, struct bfd_link_info *, bfd *, asection *,
1469 . struct internal_reloc *, bfd_boolean *);
1471 . bfd_boolean (*_bfd_coff_link_add_one_symbol)
1472 . (struct bfd_link_info *, bfd *, const char *, flagword,
1473 . asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
1474 . struct bfd_link_hash_entry **);
1476 . bfd_boolean (*_bfd_coff_link_output_has_begun)
1477 . (bfd *, struct coff_final_link_info *);
1479 . bfd_boolean (*_bfd_coff_final_link_postscript)
1480 . (bfd *, struct coff_final_link_info *);
1482 . bfd_boolean (*_bfd_coff_print_pdata)
1485 .} bfd_coff_backend_data;
1487 .#define coff_backend_info(abfd) \
1488 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1490 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1491 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1493 .#define bfd_coff_swap_sym_in(a,e,i) \
1494 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1496 .#define bfd_coff_swap_lineno_in(a,e,i) \
1497 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1499 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1500 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1502 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1503 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1505 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1506 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1508 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1509 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1511 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1512 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1514 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1515 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1517 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1518 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1520 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1521 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1522 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1523 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1524 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1525 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1526 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1527 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1528 .#define bfd_coff_long_filenames(abfd) \
1529 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1530 .#define bfd_coff_long_section_names(abfd) \
1531 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1532 .#define bfd_coff_set_long_section_names(abfd, enable) \
1533 . ((coff_backend_info (abfd)->_bfd_coff_set_long_section_names) (abfd, enable))
1534 .#define bfd_coff_default_section_alignment_power(abfd) \
1535 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1536 .#define bfd_coff_max_nscns(abfd) \
1537 . (coff_backend_info (abfd)->_bfd_coff_max_nscns)
1539 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1540 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1542 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1543 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1545 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1546 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1548 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1549 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1551 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1552 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1554 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1555 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1556 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1557 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1558 . (abfd, filehdr, aouthdr))
1560 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1561 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1562 . (abfd, scnhdr, name, section, flags_ptr))
1564 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1565 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1567 .#define bfd_coff_slurp_symbol_table(abfd)\
1568 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1570 .#define bfd_coff_symname_in_debug(abfd, sym)\
1571 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1573 .#define bfd_coff_force_symnames_in_strings(abfd)\
1574 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1576 .#define bfd_coff_debug_string_prefix_length(abfd)\
1577 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1579 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1580 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1581 . (abfd, file, base, symbol, aux, indaux))
1583 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1584 . reloc, data, src_ptr, dst_ptr)\
1585 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1586 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1588 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1589 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1590 . (abfd, section, reloc, shrink, link_info))
1592 .#define bfd_coff_classify_symbol(abfd, sym)\
1593 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1596 .#define bfd_coff_compute_section_file_positions(abfd)\
1597 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1600 .#define bfd_coff_start_final_link(obfd, info)\
1601 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1603 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1604 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1605 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1606 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1607 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1608 . (abfd, sec, rel, h, sym, addendp))
1609 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1610 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1611 . (obfd, info, ibfd, sec, rel, adjustedp))
1612 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1613 . value, string, cp, coll, hashp)\
1614 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1615 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1617 .#define bfd_coff_link_output_has_begun(a,p) \
1618 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p))
1619 .#define bfd_coff_final_link_postscript(a,p) \
1620 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p))
1622 .#define bfd_coff_have_print_pdata(a) \
1623 . (coff_backend_info (a)->_bfd_coff_print_pdata)
1624 .#define bfd_coff_print_pdata(a,p) \
1625 . ((coff_backend_info (a)->_bfd_coff_print_pdata) (a, p))
1627 .{* Macro: Returns true if the bfd is a PE executable as opposed to a
1628 . PE object file. *}
1629 .#define bfd_pei_p(abfd) \
1630 . (CONST_STRNEQ ((abfd)->xvec->name, "pei-"))
1633 /* See whether the magic number matches. */
1636 coff_bad_format_hook (bfd
* abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1638 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1640 if (BADMAG (*internal_f
))
1643 /* If the optional header is NULL or not the correct size then
1644 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1645 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1646 optional header is of a different size.
1648 But the mips keeps extra stuff in it's opthdr, so dont check
1651 #if defined(M88) || defined(I960)
1652 if (internal_f
->f_opthdr
!= 0 && bfd_coff_aoutsz (abfd
) != internal_f
->f_opthdr
)
1661 ticoff0_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1663 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1665 if (COFF0_BADMAG (*internal_f
))
1674 ticoff1_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1676 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1678 if (COFF1_BADMAG (*internal_f
))
1685 /* Check whether this section uses an alignment other than the
1689 coff_set_custom_section_alignment (bfd
*abfd ATTRIBUTE_UNUSED
,
1691 const struct coff_section_alignment_entry
*alignment_table
,
1692 const unsigned int table_size
)
1694 const unsigned int default_alignment
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1697 for (i
= 0; i
< table_size
; ++i
)
1699 const char *secname
= bfd_get_section_name (abfd
, section
);
1701 if (alignment_table
[i
].comparison_length
== (unsigned int) -1
1702 ? strcmp (alignment_table
[i
].name
, secname
) == 0
1703 : strncmp (alignment_table
[i
].name
, secname
,
1704 alignment_table
[i
].comparison_length
) == 0)
1707 if (i
>= table_size
)
1710 if (alignment_table
[i
].default_alignment_min
!= COFF_ALIGNMENT_FIELD_EMPTY
1711 && default_alignment
< alignment_table
[i
].default_alignment_min
)
1714 if (alignment_table
[i
].default_alignment_max
!= COFF_ALIGNMENT_FIELD_EMPTY
1715 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1716 && default_alignment
> alignment_table
[i
].default_alignment_max
1721 section
->alignment_power
= alignment_table
[i
].alignment_power
;
1724 /* Custom section alignment records. */
1726 static const struct coff_section_alignment_entry
1727 coff_section_alignment_table
[] =
1729 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1730 COFF_SECTION_ALIGNMENT_ENTRIES
,
1732 /* There must not be any gaps between .stabstr sections. */
1733 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1734 1, COFF_ALIGNMENT_FIELD_EMPTY
, 0 },
1735 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1736 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1737 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1738 /* Similarly for the .ctors and .dtors sections. */
1739 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1740 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1741 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1742 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 }
1745 static const unsigned int coff_section_alignment_table_size
=
1746 sizeof coff_section_alignment_table
/ sizeof coff_section_alignment_table
[0];
1748 /* Initialize a section structure with information peculiar to this
1749 particular implementation of COFF. */
1752 coff_new_section_hook (bfd
* abfd
, asection
* section
)
1754 combined_entry_type
*native
;
1756 unsigned char sclass
= C_STAT
;
1758 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1761 if (bfd_xcoff_text_align_power (abfd
) != 0
1762 && strcmp (bfd_get_section_name (abfd
, section
), ".text") == 0)
1763 section
->alignment_power
= bfd_xcoff_text_align_power (abfd
);
1764 else if (bfd_xcoff_data_align_power (abfd
) != 0
1765 && strcmp (bfd_get_section_name (abfd
, section
), ".data") == 0)
1766 section
->alignment_power
= bfd_xcoff_data_align_power (abfd
);
1771 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
1772 if (strcmp (bfd_get_section_name (abfd
, section
),
1773 xcoff_dwsect_names
[i
].name
) == 0)
1775 section
->alignment_power
= 0;
1782 /* Set up the section symbol. */
1783 if (!_bfd_generic_new_section_hook (abfd
, section
))
1786 /* Allocate aux records for section symbols, to store size and
1789 @@ The 10 is a guess at a plausible maximum number of aux entries
1790 (but shouldn't be a constant). */
1791 amt
= sizeof (combined_entry_type
) * 10;
1792 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
1796 /* We don't need to set up n_name, n_value, or n_scnum in the native
1797 symbol information, since they'll be overridden by the BFD symbol
1798 anyhow. However, we do need to set the type and storage class,
1799 in case this symbol winds up getting written out. The value 0
1800 for n_numaux is already correct. */
1802 native
->is_sym
= TRUE
;
1803 native
->u
.syment
.n_type
= T_NULL
;
1804 native
->u
.syment
.n_sclass
= sclass
;
1806 coffsymbol (section
->symbol
)->native
= native
;
1808 coff_set_custom_section_alignment (abfd
, section
,
1809 coff_section_alignment_table
,
1810 coff_section_alignment_table_size
);
1815 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1817 /* Set the alignment of a BFD section. */
1820 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1824 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1828 /* Extract ALIGN from 2**ALIGN stored in section header. */
1829 for (i
= 0; i
< 32; i
++)
1830 if ((1 << i
) >= hdr
->s_align
)
1834 /* TI tools puts the alignment power in bits 8-11. */
1835 i
= (hdr
->s_flags
>> 8) & 0xF ;
1837 #ifdef COFF_DECODE_ALIGNMENT
1838 i
= COFF_DECODE_ALIGNMENT(hdr
->s_flags
);
1840 section
->alignment_power
= i
;
1842 #ifdef coff_set_section_load_page
1843 coff_set_section_load_page (section
, hdr
->s_page
);
1847 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1851 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1855 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1857 unsigned int alignment_power_const
1858 = hdr
->s_flags
& IMAGE_SCN_ALIGN_POWER_BIT_MASK
;
1860 switch (alignment_power_const
)
1862 case IMAGE_SCN_ALIGN_8192BYTES
:
1863 case IMAGE_SCN_ALIGN_4096BYTES
:
1864 case IMAGE_SCN_ALIGN_2048BYTES
:
1865 case IMAGE_SCN_ALIGN_1024BYTES
:
1866 case IMAGE_SCN_ALIGN_512BYTES
:
1867 case IMAGE_SCN_ALIGN_256BYTES
:
1868 case IMAGE_SCN_ALIGN_128BYTES
:
1869 case IMAGE_SCN_ALIGN_64BYTES
:
1870 case IMAGE_SCN_ALIGN_32BYTES
:
1871 case IMAGE_SCN_ALIGN_16BYTES
:
1872 case IMAGE_SCN_ALIGN_8BYTES
:
1873 case IMAGE_SCN_ALIGN_4BYTES
:
1874 case IMAGE_SCN_ALIGN_2BYTES
:
1875 case IMAGE_SCN_ALIGN_1BYTES
:
1876 section
->alignment_power
1877 = IMAGE_SCN_ALIGN_POWER_NUM (alignment_power_const
);
1883 /* In a PE image file, the s_paddr field holds the virtual size of a
1884 section, while the s_size field holds the raw size. We also keep
1885 the original section flag value, since not every bit can be
1886 mapped onto a generic BFD section bit. */
1887 if (coff_section_data (abfd
, section
) == NULL
)
1889 amt
= sizeof (struct coff_section_tdata
);
1890 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
1891 if (section
->used_by_bfd
== NULL
)
1892 /* FIXME: Return error. */
1896 if (pei_section_data (abfd
, section
) == NULL
)
1898 amt
= sizeof (struct pei_section_tdata
);
1899 coff_section_data (abfd
, section
)->tdata
= bfd_zalloc (abfd
, amt
);
1900 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1901 /* FIXME: Return error. */
1904 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1905 pei_section_data (abfd
, section
)->pe_flags
= hdr
->s_flags
;
1907 section
->lma
= hdr
->s_vaddr
;
1909 /* Check for extended relocs. */
1910 if (hdr
->s_flags
& IMAGE_SCN_LNK_NRELOC_OVFL
)
1912 struct external_reloc dst
;
1913 struct internal_reloc n
;
1914 file_ptr oldpos
= bfd_tell (abfd
);
1915 bfd_size_type relsz
= bfd_coff_relsz (abfd
);
1917 if (bfd_seek (abfd
, (file_ptr
) hdr
->s_relptr
, 0) != 0)
1919 if (bfd_bread (& dst
, relsz
, abfd
) != relsz
)
1922 coff_swap_reloc_in (abfd
, &dst
, &n
);
1923 if (bfd_seek (abfd
, oldpos
, 0) != 0)
1925 section
->reloc_count
= hdr
->s_nreloc
= n
.r_vaddr
- 1;
1926 section
->rel_filepos
+= relsz
;
1928 else if (hdr
->s_nreloc
== 0xffff)
1929 (*_bfd_error_handler
)
1930 ("%s: warning: claims to have 0xffff relocs, without overflow",
1931 bfd_get_filename (abfd
));
1934 #undef ELIFALIGN_SET
1936 #else /* ! COFF_WITH_PE */
1939 /* We grossly abuse this function to handle XCOFF overflow headers.
1940 When we see one, we correct the reloc and line number counts in the
1941 real header, and remove the section we just created. */
1944 coff_set_alignment_hook (bfd
*abfd
, asection
*section
, void * scnhdr
)
1946 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1949 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1952 real_sec
= coff_section_from_bfd_index (abfd
, (int) hdr
->s_nreloc
);
1953 if (real_sec
== NULL
)
1956 real_sec
->reloc_count
= hdr
->s_paddr
;
1957 real_sec
->lineno_count
= hdr
->s_vaddr
;
1959 if (!bfd_section_removed_from_list (abfd
, section
))
1961 bfd_section_list_remove (abfd
, section
);
1962 --abfd
->section_count
;
1966 #else /* ! RS6000COFF_C */
1968 #define coff_set_alignment_hook \
1969 ((void (*) (bfd *, asection *, void *)) bfd_void)
1971 #endif /* ! RS6000COFF_C */
1972 #endif /* ! COFF_WITH_PE */
1973 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1975 #ifndef coff_mkobject
1978 coff_mkobject (bfd
* abfd
)
1980 coff_data_type
*coff
;
1981 bfd_size_type amt
= sizeof (coff_data_type
);
1983 abfd
->tdata
.coff_obj_data
= bfd_zalloc (abfd
, amt
);
1984 if (abfd
->tdata
.coff_obj_data
== NULL
)
1986 coff
= coff_data (abfd
);
1987 coff
->symbols
= NULL
;
1988 coff
->conversion_table
= NULL
;
1989 coff
->raw_syments
= NULL
;
1990 coff
->relocbase
= 0;
1991 coff
->local_toc_sym_map
= 0;
1993 /* make_abs_section(abfd);*/
1999 /* Create the COFF backend specific information. */
2001 #ifndef coff_mkobject_hook
2003 coff_mkobject_hook (bfd
* abfd
,
2005 void * aouthdr ATTRIBUTE_UNUSED
)
2007 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
2008 coff_data_type
*coff
;
2010 if (! coff_mkobject (abfd
))
2013 coff
= coff_data (abfd
);
2015 coff
->sym_filepos
= internal_f
->f_symptr
;
2017 /* These members communicate important constants about the symbol
2018 table to GDB's symbol-reading code. These `constants'
2019 unfortunately vary among coff implementations... */
2020 coff
->local_n_btmask
= N_BTMASK
;
2021 coff
->local_n_btshft
= N_BTSHFT
;
2022 coff
->local_n_tmask
= N_TMASK
;
2023 coff
->local_n_tshift
= N_TSHIFT
;
2024 coff
->local_symesz
= bfd_coff_symesz (abfd
);
2025 coff
->local_auxesz
= bfd_coff_auxesz (abfd
);
2026 coff
->local_linesz
= bfd_coff_linesz (abfd
);
2028 coff
->timestamp
= internal_f
->f_timdat
;
2030 obj_raw_syment_count (abfd
) =
2031 obj_conv_table_size (abfd
) =
2032 internal_f
->f_nsyms
;
2035 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
2036 abfd
->flags
|= DYNAMIC
;
2037 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= bfd_coff_aoutsz (abfd
))
2039 struct internal_aouthdr
*internal_a
=
2040 (struct internal_aouthdr
*) aouthdr
;
2041 struct xcoff_tdata
*xcoff
;
2043 xcoff
= xcoff_data (abfd
);
2044 # ifdef U803XTOCMAGIC
2045 xcoff
->xcoff64
= internal_f
->f_magic
== U803XTOCMAGIC
;
2049 xcoff
->full_aouthdr
= TRUE
;
2050 xcoff
->toc
= internal_a
->o_toc
;
2051 xcoff
->sntoc
= internal_a
->o_sntoc
;
2052 xcoff
->snentry
= internal_a
->o_snentry
;
2053 bfd_xcoff_text_align_power (abfd
) = internal_a
->o_algntext
;
2054 bfd_xcoff_data_align_power (abfd
) = internal_a
->o_algndata
;
2055 xcoff
->modtype
= internal_a
->o_modtype
;
2056 xcoff
->cputype
= internal_a
->o_cputype
;
2057 xcoff
->maxdata
= internal_a
->o_maxdata
;
2058 xcoff
->maxstack
= internal_a
->o_maxstack
;
2063 /* Set the flags field from the COFF header read in. */
2064 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
2069 /* FIXME: I'm not sure this is ever executed, since peicode.h
2070 defines coff_mkobject_hook. */
2071 if ((internal_f
->f_flags
& IMAGE_FILE_DEBUG_STRIPPED
) == 0)
2072 abfd
->flags
|= HAS_DEBUG
;
2075 if ((internal_f
->f_flags
& F_GO32STUB
) != 0)
2077 coff
->go32stub
= (char *) bfd_alloc (abfd
, (bfd_size_type
) GO32_STUBSIZE
);
2078 if (coff
->go32stub
== NULL
)
2081 if (coff
->go32stub
!= NULL
)
2082 memcpy (coff
->go32stub
, internal_f
->go32stub
, GO32_STUBSIZE
);
2088 /* Determine the machine architecture and type. FIXME: This is target
2089 dependent because the magic numbers are defined in the target
2090 dependent header files. But there is no particular need for this.
2091 If the magic numbers were moved to a separate file, this function
2092 would be target independent and would also be much more successful
2093 at linking together COFF files for different architectures. */
2096 coff_set_arch_mach_hook (bfd
*abfd
, void * filehdr
)
2098 unsigned long machine
;
2099 enum bfd_architecture arch
;
2100 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
2102 /* Zero selects the default machine for an arch. */
2104 switch (internal_f
->f_magic
)
2108 arch
= bfd_arch_powerpc
;
2114 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler. */
2115 case LYNXCOFFMAGIC
: /* Shadows the m68k Lynx number below, sigh. */
2116 arch
= bfd_arch_i386
;
2121 arch
= bfd_arch_i386
;
2122 machine
= bfd_mach_x86_64
;
2127 arch
= bfd_arch_ia64
;
2134 arch
= bfd_arch_arm
;
2135 machine
= bfd_arm_get_mach_from_notes (abfd
, ARM_NOTE_SECTION
);
2136 if (machine
== bfd_mach_arm_unknown
)
2138 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
2140 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
2141 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
2142 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
2144 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
2145 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
2146 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
2147 /* The COFF header does not have enough bits available
2148 to cover all the different ARM architectures. So
2149 we interpret F_ARM_5, the highest flag value to mean
2150 "the highest ARM architecture known to BFD" which is
2151 currently the XScale. */
2152 case F_ARM_5
: machine
= bfd_mach_arm_XScale
; break;
2160 #ifdef MC68KBCSMAGIC
2163 #ifdef APOLLOM68KMAGIC
2164 case APOLLOM68KMAGIC
:
2166 #ifdef LYNXCOFFMAGIC
2169 arch
= bfd_arch_m68k
;
2170 machine
= bfd_mach_m68020
;
2177 arch
= bfd_arch_m88k
;
2183 arch
= bfd_arch_z80
;
2184 switch (internal_f
->f_flags
& F_MACHMASK
)
2187 case bfd_mach_z80strict
<< 12:
2188 case bfd_mach_z80
<< 12:
2189 case bfd_mach_z80full
<< 12:
2190 case bfd_mach_r800
<< 12:
2191 machine
= ((unsigned)internal_f
->f_flags
& F_MACHMASK
) >> 12;
2200 arch
= bfd_arch_z8k
;
2201 switch (internal_f
->f_flags
& F_MACHMASK
)
2204 machine
= bfd_mach_z8001
;
2207 machine
= bfd_mach_z8002
;
2216 arch
= bfd_arch_i860
;
2223 arch
= bfd_arch_i960
;
2224 switch (F_I960TYPE
& internal_f
->f_flags
)
2228 machine
= bfd_mach_i960_core
;
2231 machine
= bfd_mach_i960_kb_sb
;
2234 machine
= bfd_mach_i960_mc
;
2237 machine
= bfd_mach_i960_xa
;
2240 machine
= bfd_mach_i960_ca
;
2243 machine
= bfd_mach_i960_ka_sa
;
2246 machine
= bfd_mach_i960_jx
;
2249 machine
= bfd_mach_i960_hx
;
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 buf
= bfd_malloc (amt
);
2287 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
2288 || bfd_bread (buf
, amt
, abfd
) != amt
)
2293 bfd_coff_swap_sym_in (abfd
, buf
, & sym
);
2294 if (sym
.n_sclass
== C_FILE
)
2295 cputype
= sym
.n_type
& 0xff;
2302 /* FIXME: We don't handle all cases here. */
2307 arch
= bfd_xcoff_architecture (abfd
);
2308 machine
= bfd_xcoff_machine (abfd
);
2312 arch
= bfd_arch_powerpc
;
2313 machine
= bfd_mach_ppc_601
;
2315 case 2: /* 64 bit PowerPC */
2316 arch
= bfd_arch_powerpc
;
2317 machine
= bfd_mach_ppc_620
;
2320 arch
= bfd_arch_powerpc
;
2321 machine
= bfd_mach_ppc
;
2324 arch
= bfd_arch_rs6000
;
2325 machine
= bfd_mach_rs6k
;
2334 arch
= bfd_arch_we32k
;
2340 arch
= bfd_arch_h8300
;
2341 machine
= bfd_mach_h8300
;
2342 /* !! FIXME this probably isn't the right place for this. */
2343 abfd
->flags
|= BFD_IS_RELAXABLE
;
2349 arch
= bfd_arch_h8300
;
2350 machine
= bfd_mach_h8300h
;
2351 /* !! FIXME this probably isn't the right place for this. */
2352 abfd
->flags
|= BFD_IS_RELAXABLE
;
2358 arch
= bfd_arch_h8300
;
2359 machine
= bfd_mach_h8300s
;
2360 /* !! FIXME this probably isn't the right place for this. */
2361 abfd
->flags
|= BFD_IS_RELAXABLE
;
2367 arch
= bfd_arch_h8300
;
2368 machine
= bfd_mach_h8300hn
;
2369 /* !! FIXME this probably isn't the right place for this. */
2370 abfd
->flags
|= BFD_IS_RELAXABLE
;
2376 arch
= bfd_arch_h8300
;
2377 machine
= bfd_mach_h8300sn
;
2378 /* !! FIXME this probably isn't the right place for this. */
2379 abfd
->flags
|= BFD_IS_RELAXABLE
;
2383 #ifdef SH_ARCH_MAGIC_BIG
2384 case SH_ARCH_MAGIC_BIG
:
2385 case SH_ARCH_MAGIC_LITTLE
:
2387 case SH_ARCH_MAGIC_WINCE
:
2393 #ifdef MIPS_ARCH_MAGIC_WINCE
2394 case MIPS_ARCH_MAGIC_WINCE
:
2395 arch
= bfd_arch_mips
;
2401 arch
= bfd_arch_h8500
;
2407 #ifdef LYNXCOFFMAGIC
2410 arch
= bfd_arch_sparc
;
2416 arch
= bfd_arch_tic30
;
2421 #ifdef TICOFF_TARGET_ARCH
2422 /* This TI COFF section should be used by all new TI COFF v0 targets. */
2424 arch
= TICOFF_TARGET_ARCH
;
2425 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2431 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */
2432 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */
2435 switch (internal_f
->f_target_id
)
2439 arch
= TICOFF_TARGET_ARCH
;
2440 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2444 arch
= bfd_arch_obscure
;
2445 (*_bfd_error_handler
)
2446 (_("Unrecognized TI COFF target id '0x%x'"),
2447 internal_f
->f_target_id
);
2453 #ifdef TIC80_ARCH_MAGIC
2454 case TIC80_ARCH_MAGIC
:
2455 arch
= bfd_arch_tic80
;
2461 arch
= bfd_arch_mcore
;
2467 arch
= bfd_arch_w65
;
2471 default: /* Unreadable input file type. */
2472 arch
= bfd_arch_obscure
;
2476 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2480 #ifdef SYMNAME_IN_DEBUG
2483 symname_in_debug_hook (bfd
* abfd ATTRIBUTE_UNUSED
, struct internal_syment
*sym
)
2485 return SYMNAME_IN_DEBUG (sym
) != 0;
2490 #define symname_in_debug_hook \
2491 (bfd_boolean (*) (bfd *, struct internal_syment *)) bfd_false
2498 #define FORCE_SYMNAMES_IN_STRINGS
2501 /* Handle the csect auxent of a C_EXT, C_AIX_WEAKEXT or C_HIDEXT symbol. */
2504 coff_pointerize_aux_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2505 combined_entry_type
*table_base
,
2506 combined_entry_type
*symbol
,
2507 unsigned int indaux
,
2508 combined_entry_type
*aux
)
2510 BFD_ASSERT (symbol
->is_sym
);
2511 int n_sclass
= symbol
->u
.syment
.n_sclass
;
2513 if (CSECT_SYM_P (n_sclass
)
2514 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2516 BFD_ASSERT (! aux
->is_sym
);
2517 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2519 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2520 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2521 aux
->fix_scnlen
= 1;
2524 /* Return TRUE to indicate that the caller should not do any
2525 further work on this auxent. */
2529 /* Return FALSE to indicate that this auxent should be handled by
2537 /* We don't want to pointerize bal entries. */
2540 coff_pointerize_aux_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2541 combined_entry_type
*table_base ATTRIBUTE_UNUSED
,
2542 combined_entry_type
*symbol
,
2543 unsigned int indaux
,
2544 combined_entry_type
*aux ATTRIBUTE_UNUSED
)
2546 /* Return TRUE if we don't want to pointerize this aux entry, which
2547 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2550 && (symbol
->u
.syment
.n_sclass
== C_LEAFPROC
2551 || symbol
->u
.syment
.n_sclass
== C_LEAFSTAT
2552 || symbol
->u
.syment
.n_sclass
== C_LEAFEXT
));
2557 #define coff_pointerize_aux_hook 0
2560 #endif /* ! RS6000COFF_C */
2562 /* Print an aux entry. This returns TRUE if it has printed it. */
2565 coff_print_aux (bfd
*abfd ATTRIBUTE_UNUSED
,
2566 FILE *file ATTRIBUTE_UNUSED
,
2567 combined_entry_type
*table_base ATTRIBUTE_UNUSED
,
2568 combined_entry_type
*symbol ATTRIBUTE_UNUSED
,
2569 combined_entry_type
*aux ATTRIBUTE_UNUSED
,
2570 unsigned int indaux ATTRIBUTE_UNUSED
)
2572 BFD_ASSERT (symbol
->is_sym
);
2573 BFD_ASSERT (! aux
->is_sym
);
2575 if (CSECT_SYM_P (symbol
->u
.syment
.n_sclass
)
2576 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2578 /* This is a csect entry. */
2579 fprintf (file
, "AUX ");
2580 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2582 BFD_ASSERT (! aux
->fix_scnlen
);
2584 fprintf (file
, "val %5lld",
2585 (long long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2587 fprintf (file
, "val %5ld", (long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2592 fprintf (file
, "indx ");
2593 if (! aux
->fix_scnlen
)
2595 fprintf (file
, "%4lld",
2596 (long long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2598 fprintf (file
, "%4ld", (long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2601 fprintf (file
, "%4ld",
2602 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2605 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2606 aux
->u
.auxent
.x_csect
.x_parmhash
,
2607 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2608 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2609 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2610 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2611 aux
->u
.auxent
.x_csect
.x_stab
,
2612 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2617 /* Return FALSE to indicate that no special action was taken. */
2625 To write relocations, the back end steps though the
2626 canonical relocation table and create an
2627 @code{internal_reloc}. The symbol index to use is removed from
2628 the @code{offset} field in the symbol table supplied. The
2629 address comes directly from the sum of the section base
2630 address and the relocation offset; the type is dug directly
2631 from the howto field. Then the @code{internal_reloc} is
2632 swapped into the shape of an @code{external_reloc} and written
2640 /* AUX's ld wants relocations to be sorted. */
2642 compare_arelent_ptr (const void * x
, const void * y
)
2644 const arelent
**a
= (const arelent
**) x
;
2645 const arelent
**b
= (const arelent
**) y
;
2646 bfd_size_type aadr
= (*a
)->address
;
2647 bfd_size_type badr
= (*b
)->address
;
2649 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2652 #endif /* TARG_AUX */
2655 coff_write_relocs (bfd
* abfd
, int first_undef
)
2659 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2662 struct external_reloc dst
;
2669 /* Sort relocations before we write them out. */
2672 amt
= s
->reloc_count
;
2673 amt
*= sizeof (arelent
*);
2674 p
= bfd_malloc (amt
);
2677 if (s
->reloc_count
> 0)
2682 memcpy (p
, s
->orelocation
, (size_t) amt
);
2683 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2688 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2692 if (obj_pe (abfd
) && s
->reloc_count
>= 0xffff)
2694 /* Encode real count here as first reloc. */
2695 struct internal_reloc n
;
2697 memset (& n
, 0, sizeof (n
));
2698 /* Add one to count *this* reloc (grr). */
2699 n
.r_vaddr
= s
->reloc_count
+ 1;
2700 coff_swap_reloc_out (abfd
, &n
, &dst
);
2701 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2702 abfd
) != bfd_coff_relsz (abfd
))
2707 for (i
= 0; i
< s
->reloc_count
; i
++)
2709 struct internal_reloc n
;
2712 memset (& n
, 0, sizeof (n
));
2714 /* Now we've renumbered the symbols we know where the
2715 undefined symbols live in the table. Check the reloc
2716 entries for symbols who's output bfd isn't the right one.
2717 This is because the symbol was undefined (which means
2718 that all the pointers are never made to point to the same
2719 place). This is a bad thing,'cause the symbols attached
2720 to the output bfd are indexed, so that the relocation
2721 entries know which symbol index they point to. So we
2722 have to look up the output symbol here. */
2724 if (q
->sym_ptr_ptr
[0] != NULL
&& q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2727 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2728 asymbol
**outsyms
= abfd
->outsymbols
;
2730 for (j
= first_undef
; outsyms
[j
]; j
++)
2732 const char *intable
= outsyms
[j
]->name
;
2734 if (strcmp (intable
, sname
) == 0)
2736 /* Got a hit, so repoint the reloc. */
2737 q
->sym_ptr_ptr
= outsyms
+ j
;
2743 n
.r_vaddr
= q
->address
+ s
->vma
;
2746 /* The 29k const/consth reloc pair is a real kludge. The consth
2747 part doesn't have a symbol; it has an offset. So rebuilt
2749 if (q
->howto
->type
== R_IHCONST
)
2750 n
.r_symndx
= q
->addend
;
2753 if (q
->sym_ptr_ptr
&& q
->sym_ptr_ptr
[0] != NULL
)
2755 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2756 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
, s
))
2758 if ((*q
->sym_ptr_ptr
)->section
== bfd_abs_section_ptr
2759 && ((*q
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) != 0)
2761 /* This is a relocation relative to the absolute symbol. */
2765 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2766 /* Check to see if the symbol reloc points to a symbol
2767 we don't have in our symbol table. */
2768 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2770 bfd_set_error (bfd_error_bad_value
);
2771 _bfd_error_handler (_("%B: reloc against a non-existant symbol index: %ld"),
2778 #ifdef SWAP_OUT_RELOC_OFFSET
2779 n
.r_offset
= q
->addend
;
2783 /* Work out reloc type from what is required. */
2784 SELECT_RELOC (n
, q
->howto
);
2786 n
.r_type
= q
->howto
->type
;
2788 coff_swap_reloc_out (abfd
, &n
, &dst
);
2790 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2791 abfd
) != bfd_coff_relsz (abfd
))
2804 /* Set flags and magic number of a coff file from architecture and machine
2805 type. Result is TRUE if we can represent the arch&type, FALSE if not. */
2808 coff_set_flags (bfd
* abfd
,
2809 unsigned int *magicp ATTRIBUTE_UNUSED
,
2810 unsigned short *flagsp ATTRIBUTE_UNUSED
)
2812 switch (bfd_get_arch (abfd
))
2817 switch (bfd_get_mach (abfd
))
2820 case bfd_mach_z80strict
:
2822 case bfd_mach_z80full
:
2824 *flagsp
= bfd_get_mach (abfd
) << 12;
2836 switch (bfd_get_mach (abfd
))
2838 case bfd_mach_z8001
: *flagsp
= F_Z8001
; break;
2839 case bfd_mach_z8002
: *flagsp
= F_Z8002
; break;
2840 default: return FALSE
;
2851 *magicp
= I960ROMAGIC
;
2853 switch (bfd_get_mach (abfd
))
2855 case bfd_mach_i960_core
: flags
= F_I960CORE
; break;
2856 case bfd_mach_i960_kb_sb
: flags
= F_I960KB
; break;
2857 case bfd_mach_i960_mc
: flags
= F_I960MC
; break;
2858 case bfd_mach_i960_xa
: flags
= F_I960XA
; break;
2859 case bfd_mach_i960_ca
: flags
= F_I960CA
; break;
2860 case bfd_mach_i960_ka_sa
: flags
= F_I960KA
; break;
2861 case bfd_mach_i960_jx
: flags
= F_I960JX
; break;
2862 case bfd_mach_i960_hx
: flags
= F_I960HX
; break;
2863 default: return FALSE
;
2872 case bfd_arch_tic30
:
2873 *magicp
= TIC30MAGIC
;
2877 #ifdef TICOFF_DEFAULT_MAGIC
2878 case TICOFF_TARGET_ARCH
:
2879 /* If there's no indication of which version we want, use the default. */
2881 *magicp
= TICOFF_DEFAULT_MAGIC
;
2884 /* We may want to output in a different COFF version. */
2885 switch (abfd
->xvec
->name
[4])
2888 *magicp
= TICOFF0MAGIC
;
2891 *magicp
= TICOFF1MAGIC
;
2894 *magicp
= TICOFF2MAGIC
;
2900 TICOFF_TARGET_MACHINE_SET (flagsp
, bfd_get_mach (abfd
));
2904 #ifdef TIC80_ARCH_MAGIC
2905 case bfd_arch_tic80
:
2906 *magicp
= TIC80_ARCH_MAGIC
;
2913 * magicp
= ARMPEMAGIC
;
2915 * magicp
= ARMMAGIC
;
2918 if (APCS_SET (abfd
))
2920 if (APCS_26_FLAG (abfd
))
2921 * flagsp
|= F_APCS26
;
2923 if (APCS_FLOAT_FLAG (abfd
))
2924 * flagsp
|= F_APCS_FLOAT
;
2926 if (PIC_FLAG (abfd
))
2929 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2930 * flagsp
|= F_INTERWORK
;
2931 switch (bfd_get_mach (abfd
))
2933 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2934 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2935 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2936 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2937 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2938 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2939 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2940 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2941 See also the comment in coff_set_arch_mach_hook(). */
2942 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break;
2943 case bfd_mach_arm_5TE
: * flagsp
|= F_ARM_5
; break;
2944 case bfd_mach_arm_XScale
: * flagsp
|= F_ARM_5
; break;
2950 case bfd_arch_powerpc
:
2955 #if defined(I386MAGIC) || defined(AMD64MAGIC)
2957 #if defined(I386MAGIC)
2958 *magicp
= I386MAGIC
;
2961 /* Just overwrite the usual value if we're doing Lynx. */
2962 *magicp
= LYNXCOFFMAGIC
;
2964 #if defined AMD64MAGIC
2965 *magicp
= AMD64MAGIC
;
2972 *magicp
= I860MAGIC
;
2978 *magicp
= IA64MAGIC
;
2984 #ifdef APOLLOM68KMAGIC
2985 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
2987 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2988 #ifdef NAMES_HAVE_UNDERSCORE
2989 *magicp
= MC68KBCSMAGIC
;
2991 *magicp
= MC68MAGIC
;
2995 /* Just overwrite the usual value if we're doing Lynx. */
2996 *magicp
= LYNXCOFFMAGIC
;
3003 *magicp
= MC88OMAGIC
;
3008 case bfd_arch_h8300
:
3009 switch (bfd_get_mach (abfd
))
3011 case bfd_mach_h8300
: *magicp
= H8300MAGIC
; return TRUE
;
3012 case bfd_mach_h8300h
: *magicp
= H8300HMAGIC
; return TRUE
;
3013 case bfd_mach_h8300s
: *magicp
= H8300SMAGIC
; return TRUE
;
3014 case bfd_mach_h8300hn
: *magicp
= H8300HNMAGIC
; return TRUE
;
3015 case bfd_mach_h8300sn
: *magicp
= H8300SNMAGIC
; return TRUE
;
3021 #ifdef SH_ARCH_MAGIC_BIG
3023 #ifdef COFF_IMAGE_WITH_PE
3024 *magicp
= SH_ARCH_MAGIC_WINCE
;
3026 if (bfd_big_endian (abfd
))
3027 *magicp
= SH_ARCH_MAGIC_BIG
;
3029 *magicp
= SH_ARCH_MAGIC_LITTLE
;
3034 #ifdef MIPS_ARCH_MAGIC_WINCE
3036 *magicp
= MIPS_ARCH_MAGIC_WINCE
;
3041 case bfd_arch_sparc
:
3042 *magicp
= SPARCMAGIC
;
3044 /* Just overwrite the usual value if we're doing Lynx. */
3045 *magicp
= LYNXCOFFMAGIC
;
3051 case bfd_arch_h8500
:
3052 *magicp
= H8500MAGIC
;
3058 case bfd_arch_we32k
:
3059 *magicp
= WE32KMAGIC
;
3064 case bfd_arch_rs6000
:
3066 case bfd_arch_powerpc
:
3068 BFD_ASSERT (bfd_get_flavour (abfd
) == bfd_target_xcoff_flavour
);
3069 *magicp
= bfd_xcoff_magic_number (abfd
);
3074 case bfd_arch_mcore
:
3075 * magicp
= MCOREMAGIC
;
3085 default: /* Unknown architecture. */
3086 /* Fall through to "return FALSE" below, to avoid
3087 "statement never reached" errors on the one below. */
3095 coff_set_arch_mach (bfd
* abfd
,
3096 enum bfd_architecture arch
,
3097 unsigned long machine
)
3100 unsigned short dummy2
;
3102 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
3105 if (arch
!= bfd_arch_unknown
3106 && ! coff_set_flags (abfd
, &dummy1
, &dummy2
))
3107 return FALSE
; /* We can't represent this type. */
3109 return TRUE
; /* We're easy... */
3112 #ifdef COFF_IMAGE_WITH_PE
3114 /* This is used to sort sections by VMA, as required by PE image
3118 sort_by_secaddr (const void * arg1
, const void * arg2
)
3120 const asection
*a
= *(const asection
**) arg1
;
3121 const asection
*b
= *(const asection
**) arg2
;
3123 if (a
->vma
< b
->vma
)
3125 else if (a
->vma
> b
->vma
)
3131 #endif /* COFF_IMAGE_WITH_PE */
3133 /* Calculate the file position for each section. */
3136 #define ALIGN_SECTIONS_IN_FILE
3138 #if defined(TIC80COFF) || defined(TICOFF)
3139 #undef ALIGN_SECTIONS_IN_FILE
3143 coff_compute_section_file_positions (bfd
* abfd
)
3146 file_ptr sofar
= bfd_coff_filhsz (abfd
);
3147 bfd_boolean align_adjust
;
3148 unsigned int target_index
;
3149 #ifdef ALIGN_SECTIONS_IN_FILE
3150 asection
*previous
= NULL
;
3154 #ifdef COFF_IMAGE_WITH_PE
3157 if (coff_data (abfd
)->link_info
3158 || (pe_data (abfd
) && pe_data (abfd
)->pe_opthdr
.FileAlignment
))
3160 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
3162 /* If no file alignment has been set, default to one.
3163 This repairs 'ld -r' for arm-wince-pe target. */
3168 page_size
= PE_DEF_FILE_ALIGNMENT
;
3170 #ifdef COFF_PAGE_SIZE
3171 int page_size
= COFF_PAGE_SIZE
;
3176 /* On XCOFF, if we have symbols, set up the .debug section. */
3177 if (bfd_get_symcount (abfd
) > 0)
3180 bfd_size_type i
, symcount
;
3184 symcount
= bfd_get_symcount (abfd
);
3185 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
3187 coff_symbol_type
*cf
;
3189 cf
= coff_symbol_from (*symp
);
3191 && cf
->native
!= NULL
3192 && cf
->native
->is_sym
3193 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
3197 len
= strlen (bfd_asymbol_name (*symp
));
3198 if (len
> SYMNMLEN
|| bfd_coff_force_symnames_in_strings (abfd
))
3199 sz
+= len
+ 1 + bfd_coff_debug_string_prefix_length (abfd
);
3206 dsec
= bfd_make_section_old_way (abfd
, DOT_DEBUG
);
3210 dsec
->flags
|= SEC_HAS_CONTENTS
;
3215 if (bfd_get_start_address (abfd
))
3216 /* A start address may have been added to the original file. In this
3217 case it will need an optional header to record it. */
3218 abfd
->flags
|= EXEC_P
;
3220 if (abfd
->flags
& EXEC_P
)
3221 sofar
+= bfd_coff_aoutsz (abfd
);
3223 else if (xcoff_data (abfd
)->full_aouthdr
)
3224 sofar
+= bfd_coff_aoutsz (abfd
);
3226 sofar
+= SMALL_AOUTSZ
;
3229 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
3232 /* XCOFF handles overflows in the reloc and line number count fields
3233 by allocating a new section header to hold the correct counts. */
3234 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3235 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3236 sofar
+= bfd_coff_scnhsz (abfd
);
3239 #ifdef COFF_IMAGE_WITH_PE
3241 /* PE requires the sections to be in memory order when listed in
3242 the section headers. It also does not like empty loadable
3243 sections. The sections apparently do not have to be in the
3244 right order in the image file itself, but we do need to get the
3245 target_index values right. */
3248 asection
**section_list
;
3252 #ifdef COFF_PAGE_SIZE
3253 /* Clear D_PAGED if section alignment is smaller than
3255 if (pe_data (abfd
)->pe_opthdr
.SectionAlignment
< COFF_PAGE_SIZE
)
3256 abfd
->flags
&= ~D_PAGED
;
3260 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3263 /* We allocate an extra cell to simplify the final loop. */
3264 amt
= sizeof (struct asection
*) * (count
+ 1);
3265 section_list
= (asection
**) bfd_malloc (amt
);
3266 if (section_list
== NULL
)
3270 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3272 section_list
[i
] = current
;
3275 section_list
[i
] = NULL
;
3277 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
3279 /* Rethread the linked list into sorted order; at the same time,
3280 assign target_index values. */
3282 abfd
->sections
= NULL
;
3283 abfd
->section_last
= NULL
;
3284 for (i
= 0; i
< count
; i
++)
3286 current
= section_list
[i
];
3287 bfd_section_list_append (abfd
, current
);
3289 /* Later, if the section has zero size, we'll be throwing it
3290 away, so we don't want to number it now. Note that having
3291 a zero size and having real contents are different
3292 concepts: .bss has no contents, but (usually) non-zero
3294 if (current
->size
== 0)
3296 /* Discard. However, it still might have (valid) symbols
3297 in it, so arbitrarily set it to section 1 (indexing is
3298 1-based here; usually .text). __end__ and other
3299 contents of .endsection really have this happen.
3300 FIXME: This seems somewhat dubious. */
3301 current
->target_index
= 1;
3304 current
->target_index
= target_index
++;
3307 free (section_list
);
3309 #else /* ! COFF_IMAGE_WITH_PE */
3311 /* Set the target_index field. */
3313 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3314 current
->target_index
= target_index
++;
3316 #endif /* ! COFF_IMAGE_WITH_PE */
3318 if (target_index
>= bfd_coff_max_nscns (abfd
))
3320 bfd_set_error (bfd_error_file_too_big
);
3321 (*_bfd_error_handler
)
3322 (_("%B: too many sections (%d)"), abfd
, target_index
);
3326 align_adjust
= FALSE
;
3327 for (current
= abfd
->sections
;
3329 current
= current
->next
)
3331 #ifdef COFF_IMAGE_WITH_PE
3332 /* With PE we have to pad each section to be a multiple of its
3333 page size too, and remember both sizes. */
3334 if (coff_section_data (abfd
, current
) == NULL
)
3336 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
3338 current
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
3339 if (current
->used_by_bfd
== NULL
)
3342 if (pei_section_data (abfd
, current
) == NULL
)
3344 bfd_size_type amt
= sizeof (struct pei_section_tdata
);
3346 coff_section_data (abfd
, current
)->tdata
= bfd_zalloc (abfd
, amt
);
3347 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
3350 if (pei_section_data (abfd
, current
)->virt_size
== 0)
3351 pei_section_data (abfd
, current
)->virt_size
= current
->size
;
3354 /* Only deal with sections which have contents. */
3355 if (!(current
->flags
& SEC_HAS_CONTENTS
))
3358 current
->rawsize
= current
->size
;
3360 #ifdef COFF_IMAGE_WITH_PE
3361 /* Make sure we skip empty sections in a PE image. */
3362 if (current
->size
== 0)
3366 /* Align the sections in the file to the same boundary on
3367 which they are aligned in virtual memory. I960 doesn't
3368 do this (FIXME) so we can stay in sync with Intel. 960
3369 doesn't yet page from files... */
3370 #ifdef ALIGN_SECTIONS_IN_FILE
3371 if ((abfd
->flags
& EXEC_P
) != 0)
3373 /* Make sure this section is aligned on the right boundary - by
3374 padding the previous section up if necessary. */
3377 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3380 /* Make sure the file offset and the vma of .text/.data are at the
3381 same page offset, so that the file can be mmap'ed without being
3382 relocated. Failing that, AIX is able to load and execute the
3383 program, but it will be silently relocated (possible as
3384 executables are PIE). But the relocation is slightly costly and
3385 complexify the use of addr2line or gdb. So better to avoid it,
3386 like does the native linker. Usually gnu ld makes sure that
3387 the vma of .text is the file offset so this issue shouldn't
3388 appear unless you are stripping such an executable.
3390 AIX loader checks the text section alignment of (vma - filepos),
3391 and the native linker doesn't try to align the text sections.
3394 0 .text 000054cc 10000128 10000128 00000128 2**5
3395 CONTENTS, ALLOC, LOAD, CODE
3398 if (!strcmp (current
->name
, _TEXT
)
3399 || !strcmp (current
->name
, _DATA
))
3401 bfd_vma align
= 4096;
3402 bfd_vma sofar_off
= sofar
% align
;
3403 bfd_vma vma_off
= current
->vma
% align
;
3405 if (vma_off
> sofar_off
)
3406 sofar
+= vma_off
- sofar_off
;
3407 else if (vma_off
< sofar_off
)
3408 sofar
+= align
+ vma_off
- sofar_off
;
3411 if (previous
!= NULL
)
3412 previous
->size
+= sofar
- old_sofar
;
3417 /* In demand paged files the low order bits of the file offset
3418 must match the low order bits of the virtual address. */
3419 #ifdef COFF_PAGE_SIZE
3420 if ((abfd
->flags
& D_PAGED
) != 0
3421 && (current
->flags
& SEC_ALLOC
) != 0)
3422 sofar
+= (current
->vma
- (bfd_vma
) sofar
) % page_size
;
3424 current
->filepos
= sofar
;
3426 #ifdef COFF_IMAGE_WITH_PE
3427 /* Set the padded size. */
3428 current
->size
= (current
->size
+ page_size
- 1) & -page_size
;
3431 sofar
+= current
->size
;
3433 #ifdef ALIGN_SECTIONS_IN_FILE
3434 /* Make sure that this section is of the right size too. */
3435 if ((abfd
->flags
& EXEC_P
) == 0)
3437 bfd_size_type old_size
;
3439 old_size
= current
->size
;
3440 current
->size
= BFD_ALIGN (current
->size
,
3441 1 << current
->alignment_power
);
3442 align_adjust
= current
->size
!= old_size
;
3443 sofar
+= current
->size
- old_size
;
3448 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3449 align_adjust
= sofar
!= old_sofar
;
3450 current
->size
+= sofar
- old_sofar
;
3454 #ifdef COFF_IMAGE_WITH_PE
3455 /* For PE we need to make sure we pad out to the aligned
3456 size, in case the caller only writes out data to the
3458 if (pei_section_data (abfd
, current
)->virt_size
< current
->size
)
3459 align_adjust
= TRUE
;
3463 /* Force .lib sections to start at zero. The vma is then
3464 incremented in coff_set_section_contents. This is right for
3466 if (strcmp (current
->name
, _LIB
) == 0)
3467 (void) bfd_set_section_vma (abfd
, current
, 0);
3470 #ifdef ALIGN_SECTIONS_IN_FILE
3475 /* It is now safe to write to the output file. If we needed an
3476 alignment adjustment for the last section, then make sure that
3477 there is a byte at offset sofar. If there are no symbols and no
3478 relocs, then nothing follows the last section. If we don't force
3479 the last byte out, then the file may appear to be truncated. */
3485 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
3486 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3490 /* Make sure the relocations are aligned. We don't need to make
3491 sure that this byte exists, because it will only matter if there
3492 really are relocs. */
3493 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
3495 obj_relocbase (abfd
) = sofar
;
3496 abfd
->output_has_begun
= TRUE
;
3501 #ifdef COFF_IMAGE_WITH_PE
3503 static unsigned int pelength
;
3504 static unsigned int peheader
;
3507 coff_read_word (bfd
*abfd
, unsigned int *value
)
3512 status
= bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3520 *value
= (unsigned int) b
[0];
3522 *value
= (unsigned int) (b
[0] + (b
[1] << 8));
3524 pelength
+= (unsigned int) status
;
3530 coff_compute_checksum (bfd
*abfd
)
3532 bfd_boolean more_data
;
3539 filepos
= (file_ptr
) 0;
3543 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
3546 more_data
= coff_read_word (abfd
, &value
);
3548 total
= 0xffff & (total
+ (total
>> 0x10));
3553 return (0xffff & (total
+ (total
>> 0x10)));
3557 coff_apply_checksum (bfd
*abfd
)
3559 unsigned int computed
;
3560 unsigned int checksum
= 0;
3562 if (bfd_seek (abfd
, 0x3c, SEEK_SET
) != 0)
3565 if (!coff_read_word (abfd
, &peheader
))
3568 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3572 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3574 if (bfd_seek (abfd
, peheader
, SEEK_SET
) != 0)
3577 computed
= coff_compute_checksum (abfd
);
3579 checksum
= computed
+ pelength
;
3581 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3584 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3589 #endif /* COFF_IMAGE_WITH_PE */
3592 coff_write_object_contents (bfd
* abfd
)
3595 bfd_boolean hasrelocs
= FALSE
;
3596 bfd_boolean haslinno
= FALSE
;
3597 #ifdef COFF_IMAGE_WITH_PE
3598 bfd_boolean hasdebug
= FALSE
;
3601 file_ptr reloc_base
;
3602 file_ptr lineno_base
;
3604 unsigned long reloc_size
= 0, reloc_count
= 0;
3605 unsigned long lnno_size
= 0;
3606 bfd_boolean long_section_names
;
3607 asection
*text_sec
= NULL
;
3608 asection
*data_sec
= NULL
;
3609 asection
*bss_sec
= NULL
;
3610 struct internal_filehdr internal_f
;
3611 struct internal_aouthdr internal_a
;
3612 #ifdef COFF_LONG_SECTION_NAMES
3613 size_t string_size
= STRING_SIZE_SIZE
;
3616 bfd_set_error (bfd_error_system_call
);
3618 /* Make a pass through the symbol table to count line number entries and
3619 put them into the correct asections. */
3620 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3622 if (! abfd
->output_has_begun
)
3624 if (! coff_compute_section_file_positions (abfd
))
3628 reloc_base
= obj_relocbase (abfd
);
3630 /* Work out the size of the reloc and linno areas. */
3632 for (current
= abfd
->sections
; current
!= NULL
; current
=
3636 /* We store the actual reloc count in the first reloc's addr. */
3637 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3640 reloc_count
+= current
->reloc_count
;
3643 reloc_size
= reloc_count
* bfd_coff_relsz (abfd
);
3645 lineno_base
= reloc_base
+ reloc_size
;
3646 sym_base
= lineno_base
+ lnno_size
;
3648 /* Indicate in each section->line_filepos its actual file address. */
3649 for (current
= abfd
->sections
; current
!= NULL
; current
=
3652 if (current
->lineno_count
)
3654 current
->line_filepos
= lineno_base
;
3655 current
->moving_line_filepos
= lineno_base
;
3656 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3659 current
->line_filepos
= 0;
3661 if (current
->reloc_count
)
3663 current
->rel_filepos
= reloc_base
;
3664 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3666 /* Extra reloc to hold real count. */
3667 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3668 reloc_base
+= bfd_coff_relsz (abfd
);
3672 current
->rel_filepos
= 0;
3675 /* Write section headers to the file. */
3676 internal_f
.f_nscns
= 0;
3678 if ((abfd
->flags
& EXEC_P
) != 0)
3679 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3682 scn_base
= bfd_coff_filhsz (abfd
);
3685 if (xcoff_data (abfd
)->full_aouthdr
)
3686 scn_base
+= bfd_coff_aoutsz (abfd
);
3688 scn_base
+= SMALL_AOUTSZ
;
3693 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3696 long_section_names
= FALSE
;
3697 for (current
= abfd
->sections
;
3699 current
= current
->next
)
3701 struct internal_scnhdr section
;
3702 #ifdef COFF_IMAGE_WITH_PE
3703 bfd_boolean is_reloc_section
= FALSE
;
3705 if (strcmp (current
->name
, DOT_RELOC
) == 0)
3707 is_reloc_section
= TRUE
;
3709 pe_data (abfd
)->has_reloc_section
= 1;
3713 internal_f
.f_nscns
++;
3715 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3717 #ifdef COFF_LONG_SECTION_NAMES
3718 /* Handle long section names as in PE. This must be compatible
3719 with the code in coff_write_symbols and _bfd_coff_final_link. */
3720 if (bfd_coff_long_section_names (abfd
))
3724 len
= strlen (current
->name
);
3727 /* The s_name field is defined to be NUL-padded but need not be
3728 NUL-terminated. We use a temporary buffer so that we can still
3729 sprintf all eight chars without splatting a terminating NUL
3730 over the first byte of the following member (s_paddr). */
3731 char s_name_buf
[SCNNMLEN
+ 1];
3733 /* An inherent limitation of the /nnnnnnn notation used to indicate
3734 the offset of the long name in the string table is that we
3735 cannot address entries beyone the ten million byte boundary. */
3736 if (string_size
>= 10000000)
3738 bfd_set_error (bfd_error_file_too_big
);
3739 (*_bfd_error_handler
)
3740 (_("%B: section %s: string table overflow at offset %ld"),
3741 abfd
, current
->name
, string_size
);
3745 /* snprintf not strictly necessary now we've verified the value
3746 has less than eight ASCII digits, but never mind. */
3747 snprintf (s_name_buf
, SCNNMLEN
+ 1, "/%lu", (unsigned long) string_size
);
3748 /* Then strncpy takes care of any padding for us. */
3749 strncpy (section
.s_name
, s_name_buf
, SCNNMLEN
);
3750 string_size
+= len
+ 1;
3751 long_section_names
= TRUE
;
3757 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3758 Ian Taylor <ian@cygnus.com>. */
3759 if (strcmp (current
->name
, _LIB
) == 0)
3760 section
.s_vaddr
= 0;
3763 section
.s_vaddr
= current
->vma
;
3764 section
.s_paddr
= current
->lma
;
3765 section
.s_size
= current
->size
;
3766 #ifdef coff_get_section_load_page
3767 section
.s_page
= coff_get_section_load_page (current
);
3773 section
.s_paddr
= 0;
3775 #ifdef COFF_IMAGE_WITH_PE
3776 /* Reminder: s_paddr holds the virtual size of the section. */
3777 if (coff_section_data (abfd
, current
) != NULL
3778 && pei_section_data (abfd
, current
) != NULL
)
3779 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3781 section
.s_paddr
= 0;
3784 /* If this section has no size or is unloadable then the scnptr
3786 if (current
->size
== 0
3787 || (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3788 section
.s_scnptr
= 0;
3790 section
.s_scnptr
= current
->filepos
;
3792 section
.s_relptr
= current
->rel_filepos
;
3793 section
.s_lnnoptr
= current
->line_filepos
;
3794 section
.s_nreloc
= current
->reloc_count
;
3795 section
.s_nlnno
= current
->lineno_count
;
3796 #ifndef COFF_IMAGE_WITH_PE
3797 /* In PEI, relocs come in the .reloc section. */
3798 if (current
->reloc_count
!= 0)
3801 if (current
->lineno_count
!= 0)
3803 #ifdef COFF_IMAGE_WITH_PE
3804 if ((current
->flags
& SEC_DEBUGGING
) != 0
3805 && ! is_reloc_section
)
3811 /* Indicate the use of an XCOFF overflow section header. */
3812 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3814 section
.s_nreloc
= 0xffff;
3815 section
.s_nlnno
= 0xffff;
3820 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3822 if (!strcmp (current
->name
, _TEXT
))
3824 else if (!strcmp (current
->name
, _DATA
))
3826 else if (!strcmp (current
->name
, _BSS
))
3830 section
.s_align
= (current
->alignment_power
3831 ? 1 << current
->alignment_power
3835 /* TI COFF puts the alignment power in bits 8-11 of the flags. */
3836 section
.s_flags
|= (current
->alignment_power
& 0xF) << 8;
3838 #ifdef COFF_ENCODE_ALIGNMENT
3839 COFF_ENCODE_ALIGNMENT(section
, current
->alignment_power
);
3842 #ifdef COFF_IMAGE_WITH_PE
3843 /* Suppress output of the sections if they are null. ld
3844 includes the bss and data sections even if there is no size
3845 assigned to them. NT loader doesn't like it if these section
3846 headers are included if the sections themselves are not
3847 needed. See also coff_compute_section_file_positions. */
3848 if (section
.s_size
== 0)
3849 internal_f
.f_nscns
--;
3854 bfd_size_type amt
= bfd_coff_scnhsz (abfd
);
3856 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3857 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3862 /* PE stores COMDAT section information in the symbol table. If
3863 this section is supposed to have some COMDAT info, track down
3864 the symbol in the symbol table and modify it. */
3865 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3867 unsigned int i
, count
;
3869 coff_symbol_type
*csym
= NULL
;
3873 count
= bfd_get_symcount (abfd
);
3874 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3876 if ((*psym
)->section
!= current
)
3879 /* Remember the location of the first symbol in this
3881 if (psymsec
== NULL
)
3884 /* See if this is the section symbol. */
3885 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3887 csym
= coff_symbol_from (*psym
);
3889 || csym
->native
== NULL
3890 || ! csym
->native
->is_sym
3891 || csym
->native
->u
.syment
.n_numaux
< 1
3892 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3893 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3896 /* Here *PSYM is the section symbol for CURRENT. */
3903 Note that we might not if we're converting the file from
3904 some other object file format. */
3907 combined_entry_type
*aux
;
3909 /* We don't touch the x_checksum field. The
3910 x_associated field is not currently supported. */
3912 aux
= csym
->native
+ 1;
3913 BFD_ASSERT (! aux
->is_sym
);
3914 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3916 case SEC_LINK_DUPLICATES_DISCARD
:
3917 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3920 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3921 aux
->u
.auxent
.x_scn
.x_comdat
=
3922 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3925 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3926 aux
->u
.auxent
.x_scn
.x_comdat
=
3927 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3930 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3931 aux
->u
.auxent
.x_scn
.x_comdat
=
3932 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3936 /* The COMDAT symbol must be the first symbol from this
3937 section in the symbol table. In order to make this
3938 work, we move the COMDAT symbol before the first
3939 symbol we found in the search above. It's OK to
3940 rearrange the symbol table at this point, because
3941 coff_renumber_symbols is going to rearrange it
3942 further and fix up all the aux entries. */
3943 if (psym
!= psymsec
)
3949 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3950 pcopy
[0] = pcopy
[-1];
3955 #endif /* COFF_WITH_PE */
3960 /* XCOFF handles overflows in the reloc and line number count fields
3961 by creating a new section header to hold the correct values. */
3962 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3964 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3966 struct internal_scnhdr scnhdr
;
3970 internal_f
.f_nscns
++;
3971 memcpy (scnhdr
.s_name
, ".ovrflo", 8);
3972 scnhdr
.s_paddr
= current
->reloc_count
;
3973 scnhdr
.s_vaddr
= current
->lineno_count
;
3975 scnhdr
.s_scnptr
= 0;
3976 scnhdr
.s_relptr
= current
->rel_filepos
;
3977 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3978 scnhdr
.s_nreloc
= current
->target_index
;
3979 scnhdr
.s_nlnno
= current
->target_index
;
3980 scnhdr
.s_flags
= STYP_OVRFLO
;
3981 amt
= bfd_coff_scnhsz (abfd
);
3982 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3983 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3990 /* OK, now set up the filehdr... */
3992 /* Don't include the internal abs section in the section count */
3994 /* We will NOT put a fucking timestamp in the header here. Every time you
3995 put it back, I will come in and take it out again. I'm sorry. This
3996 field does not belong here. We fill it with a 0 so it compares the
3997 same but is not a reasonable time. -- gnu@cygnus.com */
3998 internal_f
.f_timdat
= 0;
3999 internal_f
.f_flags
= 0;
4001 if (abfd
->flags
& EXEC_P
)
4002 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
4005 internal_f
.f_opthdr
= 0;
4008 if (xcoff_data (abfd
)->full_aouthdr
)
4009 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
4011 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
4017 internal_f
.f_flags
|= F_RELFLG
;
4019 internal_f
.f_flags
|= F_LNNO
;
4020 if (abfd
->flags
& EXEC_P
)
4021 internal_f
.f_flags
|= F_EXEC
;
4022 #ifdef COFF_IMAGE_WITH_PE
4024 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
4025 if (pe_data (abfd
)->real_flags
& IMAGE_FILE_LARGE_ADDRESS_AWARE
)
4026 internal_f
.f_flags
|= IMAGE_FILE_LARGE_ADDRESS_AWARE
;
4029 #ifndef COFF_WITH_pex64
4031 internal_f
.f_flags
|= IMAGE_FILE_32BIT_MACHINE
;
4033 if (bfd_little_endian (abfd
))
4034 internal_f
.f_flags
|= F_AR32WR
;
4036 internal_f
.f_flags
|= F_AR32W
;
4041 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
4042 but it doesn't hurt to set it internally. */
4043 internal_f
.f_target_id
= TI_TARGET_ID
;
4045 #ifdef TIC80_TARGET_ID
4046 internal_f
.f_target_id
= TIC80_TARGET_ID
;
4049 /* FIXME, should do something about the other byte orders and
4053 if ((abfd
->flags
& DYNAMIC
) != 0)
4054 internal_f
.f_flags
|= F_SHROBJ
;
4055 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
4056 internal_f
.f_flags
|= F_DYNLOAD
;
4059 /* Set up architecture-dependent stuff. */
4061 unsigned int magic
= 0;
4062 unsigned short flags
= 0;
4064 coff_set_flags (abfd
, &magic
, &flags
);
4065 internal_f
.f_magic
= magic
;
4066 internal_f
.f_flags
|= flags
;
4067 /* ...and the "opt"hdr... */
4069 #ifdef TICOFF_AOUT_MAGIC
4070 internal_a
.magic
= TICOFF_AOUT_MAGIC
;
4071 #define __A_MAGIC_SET__
4074 internal_a
.magic
= TIC80_ARCH_MAGIC
;
4075 #define __A_MAGIC_SET__
4078 /* FIXME: What are the a.out magic numbers for the i860? */
4079 internal_a
.magic
= 0;
4080 #define __A_MAGIC_SET__
4083 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
4084 #define __A_MAGIC_SET__
4087 #define __A_MAGIC_SET__
4088 internal_a
.magic
= PAGEMAGICBCS
;
4092 #define __A_MAGIC_SET__
4093 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
4096 #if defined(M68) || defined(WE32K) || defined(M68K)
4097 #define __A_MAGIC_SET__
4099 internal_a
.magic
= LYNXCOFFMAGIC
;
4101 #if defined(TARG_AUX)
4102 internal_a
.magic
= (abfd
->flags
& D_PAGED
? PAGEMAGICPEXECPAGED
:
4103 abfd
->flags
& WP_TEXT
? PAGEMAGICPEXECSWAPPED
:
4104 PAGEMAGICEXECSWAPPED
);
4106 #if defined (PAGEMAGICPEXECPAGED)
4107 internal_a
.magic
= PAGEMAGICPEXECPAGED
;
4109 #endif /* TARG_AUX */
4111 #endif /* M68 || WE32K || M68K */
4114 #define __A_MAGIC_SET__
4115 internal_a
.magic
= ZMAGIC
;
4119 #define __A_MAGIC_SET__
4120 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
4123 #if defined MCORE_PE
4124 #define __A_MAGIC_SET__
4125 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
4129 #define __A_MAGIC_SET__
4131 internal_a
.magic
= LYNXCOFFMAGIC
;
4133 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR64_MAGIC
;
4135 internal_a
.magic
= ZMAGIC
;
4140 #define __A_MAGIC_SET__
4141 internal_a
.magic
= PE32PMAGIC
;
4145 #define __A_MAGIC_SET__
4147 internal_a
.magic
= LYNXCOFFMAGIC
;
4152 #define __A_MAGIC_SET__
4153 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
4154 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
4155 RS6K_AOUTHDR_OMAGIC
;
4158 #if defined(SH) && defined(COFF_WITH_PE)
4159 #define __A_MAGIC_SET__
4160 internal_a
.magic
= SH_PE_MAGIC
;
4163 #if defined(MIPS) && defined(COFF_WITH_PE)
4164 #define __A_MAGIC_SET__
4165 internal_a
.magic
= MIPS_PE_MAGIC
;
4168 #ifndef __A_MAGIC_SET__
4169 #include "Your aouthdr magic number is not being set!"
4171 #undef __A_MAGIC_SET__
4175 /* FIXME: Does anybody ever set this to another value? */
4176 internal_a
.vstamp
= 0;
4178 /* Now should write relocs, strings, syms. */
4179 obj_sym_filepos (abfd
) = sym_base
;
4181 if (bfd_get_symcount (abfd
) != 0)
4185 if (!coff_renumber_symbols (abfd
, &firstundef
))
4187 coff_mangle_symbols (abfd
);
4188 if (! coff_write_symbols (abfd
))
4190 if (! coff_write_linenumbers (abfd
))
4192 if (! coff_write_relocs (abfd
, firstundef
))
4195 #ifdef COFF_LONG_SECTION_NAMES
4196 else if (long_section_names
&& ! obj_coff_strings_written (abfd
))
4198 /* If we have long section names we have to write out the string
4199 table even if there are no symbols. */
4200 if (! coff_write_symbols (abfd
))
4204 #ifdef COFF_IMAGE_WITH_PE
4206 else if ((abfd
->flags
& EXEC_P
) != 0)
4210 /* PowerPC PE appears to require that all executable files be
4211 rounded up to the page size. */
4214 (file_ptr
) BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
4216 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
4222 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
4223 backend linker, and obj_raw_syment_count is not valid until after
4224 coff_write_symbols is called. */
4225 if (obj_raw_syment_count (abfd
) != 0)
4227 internal_f
.f_symptr
= sym_base
;
4229 /* AIX appears to require that F_RELFLG not be set if there are
4230 local symbols but no relocations. */
4231 internal_f
.f_flags
&=~ F_RELFLG
;
4236 if (long_section_names
)
4237 internal_f
.f_symptr
= sym_base
;
4239 internal_f
.f_symptr
= 0;
4240 internal_f
.f_flags
|= F_LSYMS
;
4245 internal_a
.tsize
= text_sec
->size
;
4246 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
4250 internal_a
.dsize
= data_sec
->size
;
4251 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
4255 internal_a
.bsize
= bss_sec
->size
;
4256 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
4257 internal_a
.data_start
= bss_sec
->vma
;
4260 internal_a
.entry
= bfd_get_start_address (abfd
);
4261 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
4264 if (xcoff_data (abfd
)->full_aouthdr
)
4267 asection
*loader_sec
;
4269 internal_a
.vstamp
= 1;
4271 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
4272 if (internal_a
.o_snentry
== 0)
4273 internal_a
.entry
= (bfd_vma
) -1;
4275 if (text_sec
!= NULL
)
4277 internal_a
.o_sntext
= text_sec
->target_index
;
4278 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
4282 internal_a
.o_sntext
= 0;
4283 internal_a
.o_algntext
= 0;
4285 if (data_sec
!= NULL
)
4287 internal_a
.o_sndata
= data_sec
->target_index
;
4288 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
4292 internal_a
.o_sndata
= 0;
4293 internal_a
.o_algndata
= 0;
4295 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
4296 if (loader_sec
!= NULL
)
4297 internal_a
.o_snloader
= loader_sec
->target_index
;
4299 internal_a
.o_snloader
= 0;
4300 if (bss_sec
!= NULL
)
4301 internal_a
.o_snbss
= bss_sec
->target_index
;
4303 internal_a
.o_snbss
= 0;
4305 toc
= xcoff_data (abfd
)->toc
;
4306 internal_a
.o_toc
= toc
;
4307 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
4309 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
4310 if (xcoff_data (abfd
)->cputype
!= -1)
4311 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
4314 switch (bfd_get_arch (abfd
))
4316 case bfd_arch_rs6000
:
4317 internal_a
.o_cputype
= 4;
4319 case bfd_arch_powerpc
:
4320 if (bfd_get_mach (abfd
) == bfd_mach_ppc
)
4321 internal_a
.o_cputype
= 3;
4323 internal_a
.o_cputype
= 1;
4329 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
4330 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
4336 /* After object contents are finalized so we can compute a reasonable hash,
4337 but before header is written so we can update it to point to debug directory. */
4338 struct pe_tdata
*pe
= pe_data (abfd
);
4340 if (pe
->build_id
.after_write_object_contents
!= NULL
)
4341 (*pe
->build_id
.after_write_object_contents
) (abfd
);
4345 /* Now write header. */
4346 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
4351 bfd_size_type amount
= bfd_coff_filhsz (abfd
);
4353 buff
= (char *) bfd_malloc (amount
);
4357 bfd_coff_swap_filehdr_out (abfd
, & internal_f
, buff
);
4358 amount
= bfd_bwrite (buff
, amount
, abfd
);
4362 if (amount
!= bfd_coff_filhsz (abfd
))
4366 if (abfd
->flags
& EXEC_P
)
4368 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4369 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4371 bfd_size_type amount
= bfd_coff_aoutsz (abfd
);
4373 buff
= (char *) bfd_malloc (amount
);
4377 coff_swap_aouthdr_out (abfd
, & internal_a
, buff
);
4378 amount
= bfd_bwrite (buff
, amount
, abfd
);
4382 if (amount
!= bfd_coff_aoutsz (abfd
))
4385 #ifdef COFF_IMAGE_WITH_PE
4386 if (! coff_apply_checksum (abfd
))
4396 /* XCOFF seems to always write at least a small a.out header. */
4397 coff_swap_aouthdr_out (abfd
, & internal_a
, & buff
);
4398 if (xcoff_data (abfd
)->full_aouthdr
)
4399 size
= bfd_coff_aoutsz (abfd
);
4401 size
= SMALL_AOUTSZ
;
4402 if (bfd_bwrite (& buff
, (bfd_size_type
) size
, abfd
) != size
)
4411 coff_set_section_contents (bfd
* abfd
,
4413 const void * location
,
4415 bfd_size_type count
)
4417 if (! abfd
->output_has_begun
) /* Set by bfd.c handler. */
4419 if (! coff_compute_section_file_positions (abfd
))
4423 #if defined(_LIB) && !defined(TARG_AUX)
4424 /* The physical address field of a .lib section is used to hold the
4425 number of shared libraries in the section. This code counts the
4426 number of sections being written, and increments the lma field
4429 I have found no documentation on the contents of this section.
4430 Experimentation indicates that the section contains zero or more
4431 records, each of which has the following structure:
4433 - a (four byte) word holding the length of this record, in words,
4434 - a word that always seems to be set to "2",
4435 - the path to a shared library, null-terminated and then padded
4436 to a whole word boundary.
4438 bfd_assert calls have been added to alert if an attempt is made
4439 to write a section which doesn't follow these assumptions. The
4440 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4441 <robertl@arnet.com> (Thanks!).
4443 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4444 if (strcmp (section
->name
, _LIB
) == 0)
4446 bfd_byte
*rec
, *recend
;
4448 rec
= (bfd_byte
*) location
;
4449 recend
= rec
+ count
;
4450 while (rec
< recend
)
4453 rec
+= bfd_get_32 (abfd
, rec
) * 4;
4456 BFD_ASSERT (rec
== recend
);
4460 /* Don't write out bss sections - one way to do this is to
4461 see if the filepos has not been set. */
4462 if (section
->filepos
== 0)
4465 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0)
4471 return bfd_bwrite (location
, count
, abfd
) == count
;
4475 buy_and_read (bfd
*abfd
, file_ptr where
, bfd_size_type size
)
4477 void * area
= bfd_alloc (abfd
, size
);
4481 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0
4482 || bfd_bread (area
, size
, abfd
) != size
)
4491 Creating the linenumber table is done by reading in the entire
4492 coff linenumber table, and creating another table for internal use.
4494 A coff linenumber table is structured so that each function
4495 is marked as having a line number of 0. Each line within the
4496 function is an offset from the first line in the function. The
4497 base of the line number information for the table is stored in
4498 the symbol associated with the function.
4500 Note: The PE format uses line number 0 for a flag indicating a
4503 The information is copied from the external to the internal
4504 table, and each symbol which marks a function is marked by
4507 How does this work ?
4511 coff_sort_func_alent (const void * arg1
, const void * arg2
)
4513 const alent
*al1
= *(const alent
**) arg1
;
4514 const alent
*al2
= *(const alent
**) arg2
;
4515 const coff_symbol_type
*s1
= (const coff_symbol_type
*) (al1
->u
.sym
);
4516 const coff_symbol_type
*s2
= (const coff_symbol_type
*) (al2
->u
.sym
);
4518 if (s1
== NULL
|| s2
== NULL
)
4520 if (s1
->symbol
.value
< s2
->symbol
.value
)
4522 else if (s1
->symbol
.value
> s2
->symbol
.value
)
4529 coff_slurp_line_table (bfd
*abfd
, asection
*asect
)
4531 LINENO
*native_lineno
;
4532 alent
*lineno_cache
;
4534 unsigned int counter
;
4536 bfd_vma prev_offset
= 0;
4537 bfd_boolean ordered
= TRUE
;
4538 unsigned int nbr_func
;
4540 bfd_boolean have_func
;
4541 bfd_boolean ret
= TRUE
;
4543 BFD_ASSERT (asect
->lineno
== NULL
);
4545 amt
= ((bfd_size_type
) asect
->lineno_count
+ 1) * sizeof (alent
);
4546 lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
);
4547 if (lineno_cache
== NULL
)
4550 amt
= (bfd_size_type
) bfd_coff_linesz (abfd
) * asect
->lineno_count
;
4551 native_lineno
= (LINENO
*) buy_and_read (abfd
, asect
->line_filepos
, amt
);
4552 if (native_lineno
== NULL
)
4554 (*_bfd_error_handler
)
4555 (_("%B: warning: line number table read failed"), abfd
);
4556 bfd_release (abfd
, lineno_cache
);
4560 cache_ptr
= lineno_cache
;
4561 asect
->lineno
= lineno_cache
;
4562 src
= native_lineno
;
4566 for (counter
= 0; counter
< asect
->lineno_count
; counter
++, src
++)
4568 struct internal_lineno dst
;
4570 bfd_coff_swap_lineno_in (abfd
, src
, &dst
);
4571 cache_ptr
->line_number
= dst
.l_lnno
;
4572 /* Appease memory checkers that get all excited about
4573 uninitialised memory when copying alents if u.offset is
4574 larger than u.sym. (64-bit BFD on 32-bit host.) */
4575 memset (&cache_ptr
->u
, 0, sizeof (cache_ptr
->u
));
4577 if (cache_ptr
->line_number
== 0)
4579 combined_entry_type
* ent
;
4581 coff_symbol_type
*sym
;
4584 symndx
= dst
.l_addr
.l_symndx
;
4585 if (symndx
>= obj_raw_syment_count (abfd
))
4587 (*_bfd_error_handler
)
4588 (_("%B: warning: illegal symbol index 0x%lx in line number entry %d"),
4589 abfd
, (long) symndx
, counter
);
4590 cache_ptr
->line_number
= -1;
4595 ent
= obj_raw_syments (abfd
) + symndx
;
4596 /* FIXME: We should not be casting between ints and
4597 pointers like this. */
4600 (*_bfd_error_handler
)
4601 (_("%B: warning: illegal symbol index 0x%lx in line number entry %d"),
4602 abfd
, (long) symndx
, counter
);
4603 cache_ptr
->line_number
= -1;
4607 sym
= (coff_symbol_type
*) (ent
->u
.syment
._n
._n_n
._n_zeroes
);
4609 /* PR 17512 file: 078-10659-0.004 */
4610 if (sym
< obj_symbols (abfd
)
4611 || sym
>= obj_symbols (abfd
) + bfd_get_symcount (abfd
))
4613 (*_bfd_error_handler
)
4614 (_("%B: warning: illegal symbol in line number entry %d"),
4616 cache_ptr
->line_number
= -1;
4623 cache_ptr
->u
.sym
= (asymbol
*) sym
;
4624 if (sym
->lineno
!= NULL
)
4625 (*_bfd_error_handler
)
4626 (_("%B: warning: duplicate line number information for `%s'"),
4627 abfd
, bfd_asymbol_name (&sym
->symbol
));
4629 sym
->lineno
= cache_ptr
;
4630 if (sym
->symbol
.value
< prev_offset
)
4632 prev_offset
= sym
->symbol
.value
;
4634 else if (!have_func
)
4635 /* Drop line information that has no associated function.
4636 PR 17521: file: 078-10659-0.004. */
4639 cache_ptr
->u
.offset
= (dst
.l_addr
.l_paddr
4640 - bfd_section_vma (abfd
, asect
));
4644 asect
->lineno_count
= cache_ptr
- lineno_cache
;
4645 memset (cache_ptr
, 0, sizeof (*cache_ptr
));
4646 bfd_release (abfd
, native_lineno
);
4648 /* On some systems (eg AIX5.3) the lineno table may not be sorted. */
4651 /* Sort the table. */
4653 alent
*n_lineno_cache
;
4655 /* Create a table of functions. */
4656 func_table
= (alent
**) bfd_alloc (abfd
, nbr_func
* sizeof (alent
*));
4657 if (func_table
!= NULL
)
4659 alent
**p
= func_table
;
4662 for (i
= 0; i
< asect
->lineno_count
; i
++)
4663 if (lineno_cache
[i
].line_number
== 0)
4664 *p
++ = &lineno_cache
[i
];
4666 BFD_ASSERT ((unsigned int) (p
- func_table
) == nbr_func
);
4668 /* Sort by functions. */
4669 qsort (func_table
, nbr_func
, sizeof (alent
*), coff_sort_func_alent
);
4671 /* Create the new sorted table. */
4672 amt
= (bfd_size_type
) asect
->lineno_count
* sizeof (alent
);
4673 n_lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
);
4674 if (n_lineno_cache
!= NULL
)
4676 alent
*n_cache_ptr
= n_lineno_cache
;
4678 for (i
= 0; i
< nbr_func
; i
++)
4680 coff_symbol_type
*sym
;
4681 alent
*old_ptr
= func_table
[i
];
4683 /* Update the function entry. */
4684 sym
= (coff_symbol_type
*) old_ptr
->u
.sym
;
4685 /* PR binutils/17512: Point the lineno to where
4686 this entry will be after the memcpy below. */
4687 sym
->lineno
= lineno_cache
+ (n_cache_ptr
- n_lineno_cache
);
4688 /* Copy the function and line number entries. */
4690 *n_cache_ptr
++ = *old_ptr
++;
4691 while (old_ptr
->line_number
!= 0);
4693 BFD_ASSERT ((bfd_size_type
) (n_cache_ptr
- n_lineno_cache
) == (amt
/ sizeof (alent
)));
4695 memcpy (lineno_cache
, n_lineno_cache
, amt
);
4699 bfd_release (abfd
, func_table
);
4708 /* Slurp in the symbol table, converting it to generic form. Note
4709 that if coff_relocate_section is defined, the linker will read
4710 symbols via coff_link_add_symbols, rather than via this routine. */
4713 coff_slurp_symbol_table (bfd
* abfd
)
4715 combined_entry_type
*native_symbols
;
4716 coff_symbol_type
*cached_area
;
4717 unsigned int *table_ptr
;
4719 unsigned int number_of_symbols
= 0;
4720 bfd_boolean ret
= TRUE
;
4722 if (obj_symbols (abfd
))
4725 /* Read in the symbol table. */
4726 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4729 /* Allocate enough room for all the symbols in cached form. */
4730 amt
= obj_raw_syment_count (abfd
);
4731 amt
*= sizeof (coff_symbol_type
);
4732 cached_area
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
4733 if (cached_area
== NULL
)
4736 amt
= obj_raw_syment_count (abfd
);
4737 amt
*= sizeof (unsigned int);
4738 table_ptr
= (unsigned int *) bfd_zalloc (abfd
, amt
);
4740 if (table_ptr
== NULL
)
4744 coff_symbol_type
*dst
= cached_area
;
4745 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4746 unsigned int this_index
= 0;
4748 while (this_index
< last_native_index
)
4750 combined_entry_type
*src
= native_symbols
+ this_index
;
4751 table_ptr
[this_index
] = number_of_symbols
;
4753 dst
->symbol
.the_bfd
= abfd
;
4754 BFD_ASSERT (src
->is_sym
);
4755 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4756 /* We use the native name field to point to the cached field. */
4757 src
->u
.syment
._n
._n_n
._n_zeroes
= (bfd_hostptr_t
) dst
;
4758 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4759 src
->u
.syment
.n_scnum
);
4760 dst
->symbol
.flags
= 0;
4761 /* PR 17512: file: 079-7098-0.001:0.1. */
4762 dst
->symbol
.value
= 0;
4763 dst
->done_lineno
= FALSE
;
4765 switch (src
->u
.syment
.n_sclass
)
4769 /* Fall through to next case. */
4776 case C_THUMBEXTFUNC
:
4782 case C_SYSTEM
: /* System Wide variable. */
4785 /* In PE, 0x68 (104) denotes a section symbol. */
4787 /* In PE, 0x69 (105) denotes a weak external symbol. */
4790 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4792 case COFF_SYMBOL_GLOBAL
:
4793 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4794 #if defined COFF_WITH_PE
4795 /* PE sets the symbol to a value relative to the
4796 start of the section. */
4797 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4799 dst
->symbol
.value
= (src
->u
.syment
.n_value
4800 - dst
->symbol
.section
->vma
);
4802 if (ISFCN ((src
->u
.syment
.n_type
)))
4803 /* A function ext does not go at the end of a
4805 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4808 case COFF_SYMBOL_COMMON
:
4809 dst
->symbol
.section
= bfd_com_section_ptr
;
4810 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4813 case COFF_SYMBOL_UNDEFINED
:
4814 dst
->symbol
.section
= bfd_und_section_ptr
;
4815 dst
->symbol
.value
= 0;
4818 case COFF_SYMBOL_PE_SECTION
:
4819 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4820 dst
->symbol
.value
= 0;
4823 case COFF_SYMBOL_LOCAL
:
4824 dst
->symbol
.flags
= BSF_LOCAL
;
4825 #if defined COFF_WITH_PE
4826 /* PE sets the symbol to a value relative to the
4827 start of the section. */
4828 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4830 dst
->symbol
.value
= (src
->u
.syment
.n_value
4831 - dst
->symbol
.section
->vma
);
4833 if (ISFCN ((src
->u
.syment
.n_type
)))
4834 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4839 /* A symbol with a csect entry should not go at the end. */
4840 if (src
->u
.syment
.n_numaux
> 0)
4841 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4845 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4846 dst
->symbol
.flags
|= BSF_WEAK
;
4848 if (src
->u
.syment
.n_sclass
== C_SECTION
4849 && src
->u
.syment
.n_scnum
> 0)
4850 dst
->symbol
.flags
= BSF_LOCAL
;
4852 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
)
4853 dst
->symbol
.flags
|= BSF_WEAK
;
4857 case C_STAT
: /* Static. */
4859 case C_LEAFSTAT
: /* Static leaf procedure. */
4862 case C_THUMBSTAT
: /* Thumb static. */
4863 case C_THUMBLABEL
: /* Thumb label. */
4864 case C_THUMBSTATFUNC
:/* Thumb static function. */
4867 case C_DWARF
: /* A label in a dwarf section. */
4868 case C_INFO
: /* A label in a comment section. */
4870 case C_LABEL
: /* Label. */
4871 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4872 dst
->symbol
.flags
= BSF_DEBUGGING
;
4874 dst
->symbol
.flags
= BSF_LOCAL
;
4876 /* Base the value as an index from the base of the
4877 section, if there is one. */
4878 if (dst
->symbol
.section
)
4880 #if defined COFF_WITH_PE
4881 /* PE sets the symbol to a value relative to the
4882 start of the section. */
4883 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4885 dst
->symbol
.value
= (src
->u
.syment
.n_value
4886 - dst
->symbol
.section
->vma
);
4890 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4893 case C_MOS
: /* Member of structure. */
4894 case C_EOS
: /* End of structure. */
4895 case C_REGPARM
: /* Register parameter. */
4896 case C_REG
: /* register variable. */
4897 /* C_AUTOARG conflicts with TI COFF C_UEXT. */
4898 #if !defined (TIC80COFF) && !defined (TICOFF)
4900 case C_AUTOARG
: /* 960-specific storage class. */
4903 case C_TPDEF
: /* Type definition. */
4905 case C_AUTO
: /* Automatic variable. */
4906 case C_FIELD
: /* Bit field. */
4907 case C_ENTAG
: /* Enumeration tag. */
4908 case C_MOE
: /* Member of enumeration. */
4909 case C_MOU
: /* Member of union. */
4910 case C_UNTAG
: /* Union tag. */
4911 dst
->symbol
.flags
= BSF_DEBUGGING
;
4912 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4915 case C_FILE
: /* File name. */
4916 case C_STRTAG
: /* Structure tag. */
4933 dst
->symbol
.flags
= BSF_DEBUGGING
;
4934 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4938 case C_BINCL
: /* Beginning of include file. */
4939 case C_EINCL
: /* Ending of include file. */
4940 /* The value is actually a pointer into the line numbers
4941 of the file. We locate the line number entry, and
4942 set the section to the section which contains it, and
4943 the value to the index in that section. */
4947 dst
->symbol
.flags
= BSF_DEBUGGING
;
4948 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4949 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4950 && ((file_ptr
) (sec
->line_filepos
4951 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4952 > (file_ptr
) src
->u
.syment
.n_value
))
4955 dst
->symbol
.value
= 0;
4958 dst
->symbol
.section
= sec
;
4959 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4960 - sec
->line_filepos
)
4961 / bfd_coff_linesz (abfd
));
4968 dst
->symbol
.flags
= BSF_DEBUGGING
;
4970 /* The value is actually a symbol index. Save a pointer
4971 to the symbol instead of the index. FIXME: This
4972 should use a union. */
4973 src
->u
.syment
.n_value
=
4974 (long) (intptr_t) (native_symbols
+ src
->u
.syment
.n_value
);
4975 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4980 case C_BLOCK
: /* ".bb" or ".eb". */
4981 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf"). */
4982 case C_EFCN
: /* Physical end of function. */
4983 #if defined COFF_WITH_PE
4984 /* PE sets the symbol to a value relative to the start
4986 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4987 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4989 /* PE uses funny values for .ef and .lf; don't
4991 dst
->symbol
.flags
= BSF_DEBUGGING
;
4994 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4996 /* Base the value as an index from the base of the
4998 dst
->symbol
.flags
= BSF_LOCAL
;
4999 dst
->symbol
.value
= (src
->u
.syment
.n_value
5000 - dst
->symbol
.section
->vma
);
5004 case C_STATLAB
: /* Static load time label. */
5005 dst
->symbol
.value
= src
->u
.syment
.n_value
;
5006 dst
->symbol
.flags
= BSF_GLOBAL
;
5010 /* PE DLLs sometimes have zeroed out symbols for some
5011 reason. Just ignore them without a warning. */
5012 if (src
->u
.syment
.n_type
== 0
5013 && src
->u
.syment
.n_value
== 0
5014 && src
->u
.syment
.n_scnum
== 0)
5017 /* XCOFF specific: deleted entry. */
5018 if (src
->u
.syment
.n_value
== C_NULL_VALUE
)
5022 case C_EXTDEF
: /* External definition. */
5023 case C_ULABEL
: /* Undefined label. */
5024 case C_USTATIC
: /* Undefined static. */
5025 #ifndef COFF_WITH_PE
5026 /* C_LINE in regular coff is 0x68. NT has taken over this storage
5027 class to represent a section symbol. */
5028 case C_LINE
: /* line # reformatted as symbol table entry. */
5029 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
5030 case C_ALIAS
: /* Duplicate tag. */
5032 /* New storage classes for TI COFF. */
5033 #if defined(TIC80COFF) || defined(TICOFF)
5034 case C_UEXT
: /* Tentative external definition. */
5037 (*_bfd_error_handler
)
5038 (_("%B: Unrecognized storage class %d for %s symbol `%s'"),
5039 abfd
, src
->u
.syment
.n_sclass
,
5040 dst
->symbol
.section
->name
, dst
->symbol
.name
);
5042 case C_EXTLAB
: /* External load time label. */
5043 case C_HIDDEN
: /* Ext symbol in dmert public lib. */
5044 dst
->symbol
.flags
= BSF_DEBUGGING
;
5045 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
5050 dst
->symbol
.udata
.i
= 0;
5053 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
5055 number_of_symbols
++;
5059 obj_symbols (abfd
) = cached_area
;
5060 obj_raw_syments (abfd
) = native_symbols
;
5062 bfd_get_symcount (abfd
) = number_of_symbols
;
5063 obj_convert (abfd
) = table_ptr
;
5064 /* Slurp the line tables for each section too. */
5071 if (! coff_slurp_line_table (abfd
, p
))
5080 /* Classify a COFF symbol. A couple of targets have globally visible
5081 symbols which are not class C_EXT, and this handles those. It also
5082 recognizes some special PE cases. */
5084 static enum coff_symbol_classification
5085 coff_classify_symbol (bfd
*abfd
,
5086 struct internal_syment
*syment
)
5088 /* FIXME: This partially duplicates the switch in
5089 coff_slurp_symbol_table. */
5090 switch (syment
->n_sclass
)
5099 case C_THUMBEXTFUNC
:
5107 if (syment
->n_scnum
== 0)
5109 if (syment
->n_value
== 0)
5110 return COFF_SYMBOL_UNDEFINED
;
5112 return COFF_SYMBOL_COMMON
;
5114 return COFF_SYMBOL_GLOBAL
;
5121 if (syment
->n_sclass
== C_STAT
)
5123 if (syment
->n_scnum
== 0)
5124 /* The Microsoft compiler sometimes generates these if a
5125 small static function is inlined every time it is used.
5126 The function is discarded, but the symbol table entry
5128 return COFF_SYMBOL_LOCAL
;
5130 #ifdef STRICT_PE_FORMAT
5131 /* This is correct for Microsoft generated objects, but it
5132 breaks gas generated objects. */
5133 if (syment
->n_value
== 0)
5137 char buf
[SYMNMLEN
+ 1];
5139 name
= _bfd_coff_internal_syment_name (abfd
, syment
, buf
)
5140 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
5141 if (sec
!= NULL
&& name
!= NULL
5142 && (strcmp (bfd_get_section_name (abfd
, sec
), name
) == 0))
5143 return COFF_SYMBOL_PE_SECTION
;
5147 return COFF_SYMBOL_LOCAL
;
5150 if (syment
->n_sclass
== C_SECTION
)
5152 /* In some cases in a DLL generated by the Microsoft linker, the
5153 n_value field will contain garbage. FIXME: This should
5154 probably be handled by the swapping function instead. */
5155 syment
->n_value
= 0;
5156 if (syment
->n_scnum
== 0)
5157 return COFF_SYMBOL_UNDEFINED
;
5158 return COFF_SYMBOL_PE_SECTION
;
5160 #endif /* COFF_WITH_PE */
5162 /* If it is not a global symbol, we presume it is a local symbol. */
5163 if (syment
->n_scnum
== 0)
5165 char buf
[SYMNMLEN
+ 1];
5167 (*_bfd_error_handler
)
5168 (_("warning: %B: local symbol `%s' has no section"),
5169 abfd
, _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
5172 return COFF_SYMBOL_LOCAL
;
5179 Coff relocations are easily transformed into the internal BFD form
5182 Reading a coff relocation table is done in the following stages:
5184 o Read the entire coff relocation table into memory.
5186 o Process each relocation in turn; first swap it from the
5187 external to the internal form.
5189 o Turn the symbol referenced in the relocation's symbol index
5190 into a pointer into the canonical symbol table.
5191 This table is the same as the one returned by a call to
5192 @code{bfd_canonicalize_symtab}. The back end will call that
5193 routine and save the result if a canonicalization hasn't been done.
5195 o The reloc index is turned into a pointer to a howto
5196 structure, in a back end specific way. For instance, the 386
5197 and 960 use the @code{r_type} to directly produce an index
5198 into a howto table vector; the 88k subtracts a number from the
5199 @code{r_type} field and creates an addend field.
5203 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
5205 coff_symbol_type *coffsym = NULL; \
5207 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
5208 coffsym = (obj_symbols (abfd) \
5209 + (cache_ptr->sym_ptr_ptr - symbols)); \
5211 coffsym = coff_symbol_from (ptr); \
5212 if (coffsym != NULL \
5213 && coffsym->native->is_sym \
5214 && coffsym->native->u.syment.n_scnum == 0) \
5215 cache_ptr->addend = 0; \
5216 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
5217 && ptr->section != NULL) \
5218 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
5220 cache_ptr->addend = 0; \
5225 coff_slurp_reloc_table (bfd
* abfd
, sec_ptr asect
, asymbol
** symbols
)
5227 RELOC
*native_relocs
;
5228 arelent
*reloc_cache
;
5233 if (asect
->relocation
)
5235 if (asect
->reloc_count
== 0)
5237 if (asect
->flags
& SEC_CONSTRUCTOR
)
5239 if (!coff_slurp_symbol_table (abfd
))
5242 amt
= (bfd_size_type
) bfd_coff_relsz (abfd
) * asect
->reloc_count
;
5243 native_relocs
= (RELOC
*) buy_and_read (abfd
, asect
->rel_filepos
, amt
);
5244 amt
= (bfd_size_type
) asect
->reloc_count
* sizeof (arelent
);
5245 reloc_cache
= (arelent
*) bfd_alloc (abfd
, amt
);
5247 if (reloc_cache
== NULL
|| native_relocs
== NULL
)
5250 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
5252 struct internal_reloc dst
;
5253 struct external_reloc
*src
;
5254 #ifndef RELOC_PROCESSING
5258 cache_ptr
= reloc_cache
+ idx
;
5259 src
= native_relocs
+ idx
;
5262 coff_swap_reloc_in (abfd
, src
, &dst
);
5264 #ifdef RELOC_PROCESSING
5265 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
5267 cache_ptr
->address
= dst
.r_vaddr
;
5269 if (dst
.r_symndx
!= -1)
5271 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
5273 (*_bfd_error_handler
)
5274 (_("%B: warning: illegal symbol index %ld in relocs"),
5275 abfd
, (long) dst
.r_symndx
);
5276 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5281 cache_ptr
->sym_ptr_ptr
= (symbols
5282 + obj_convert (abfd
)[dst
.r_symndx
]);
5283 ptr
= *(cache_ptr
->sym_ptr_ptr
);
5288 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5292 /* The symbols definitions that we have read in have been
5293 relocated as if their sections started at 0. But the offsets
5294 refering to the symbols in the raw data have not been
5295 modified, so we have to have a negative addend to compensate.
5297 Note that symbols which used to be common must be left alone. */
5299 /* Calculate any reloc addend by looking at the symbol. */
5300 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
5303 cache_ptr
->address
-= asect
->vma
;
5304 /* !! cache_ptr->section = NULL;*/
5306 /* Fill in the cache_ptr->howto field from dst.r_type. */
5307 RTYPE2HOWTO (cache_ptr
, &dst
);
5308 #endif /* RELOC_PROCESSING */
5310 if (cache_ptr
->howto
== NULL
)
5312 (*_bfd_error_handler
)
5313 (_("%B: illegal relocation type %d at address 0x%lx"),
5314 abfd
, dst
.r_type
, (long) dst
.r_vaddr
);
5315 bfd_set_error (bfd_error_bad_value
);
5320 asect
->relocation
= reloc_cache
;
5324 #ifndef coff_rtype_to_howto
5327 /* Get the howto structure for a reloc. This is only used if the file
5328 including this one defines coff_relocate_section to be
5329 _bfd_coff_generic_relocate_section, so it is OK if it does not
5330 always work. It is the responsibility of the including file to
5331 make sure it is reasonable if it is needed. */
5333 static reloc_howto_type
*
5334 coff_rtype_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
5335 asection
*sec ATTRIBUTE_UNUSED
,
5336 struct internal_reloc
*rel ATTRIBUTE_UNUSED
,
5337 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
,
5338 struct internal_syment
*sym ATTRIBUTE_UNUSED
,
5339 bfd_vma
*addendp ATTRIBUTE_UNUSED
)
5343 genrel
.howto
= NULL
;
5344 RTYPE2HOWTO (&genrel
, rel
);
5345 return genrel
.howto
;
5348 #else /* ! defined (RTYPE2HOWTO) */
5350 #define coff_rtype_to_howto NULL
5352 #endif /* ! defined (RTYPE2HOWTO) */
5353 #endif /* ! defined (coff_rtype_to_howto) */
5355 /* This is stupid. This function should be a boolean predicate. */
5358 coff_canonicalize_reloc (bfd
* abfd
,
5363 arelent
*tblptr
= section
->relocation
;
5364 unsigned int count
= 0;
5366 if (section
->flags
& SEC_CONSTRUCTOR
)
5368 /* This section has relocs made up by us, they are not in the
5369 file, so take them out of their chain and place them into
5370 the data area provided. */
5371 arelent_chain
*chain
= section
->constructor_chain
;
5373 for (count
= 0; count
< section
->reloc_count
; count
++)
5375 *relptr
++ = &chain
->relent
;
5376 chain
= chain
->next
;
5381 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
5384 tblptr
= section
->relocation
;
5386 for (; count
++ < section
->reloc_count
;)
5387 *relptr
++ = tblptr
++;
5390 return section
->reloc_count
;
5393 #ifndef coff_reloc16_estimate
5394 #define coff_reloc16_estimate dummy_reloc16_estimate
5397 dummy_reloc16_estimate (bfd
*abfd ATTRIBUTE_UNUSED
,
5398 asection
*input_section ATTRIBUTE_UNUSED
,
5399 arelent
*reloc ATTRIBUTE_UNUSED
,
5400 unsigned int shrink ATTRIBUTE_UNUSED
,
5401 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
)
5409 #ifndef coff_reloc16_extra_cases
5411 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5413 /* This works even if abort is not declared in any header file. */
5416 dummy_reloc16_extra_cases (bfd
*abfd ATTRIBUTE_UNUSED
,
5417 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
5418 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
,
5419 arelent
*reloc ATTRIBUTE_UNUSED
,
5420 bfd_byte
*data ATTRIBUTE_UNUSED
,
5421 unsigned int *src_ptr ATTRIBUTE_UNUSED
,
5422 unsigned int *dst_ptr ATTRIBUTE_UNUSED
)
5428 /* If coff_relocate_section is defined, we can use the optimized COFF
5429 backend linker. Otherwise we must continue to use the old linker. */
5431 #ifdef coff_relocate_section
5433 #ifndef coff_bfd_link_hash_table_create
5434 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5436 #ifndef coff_bfd_link_add_symbols
5437 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5439 #ifndef coff_bfd_final_link
5440 #define coff_bfd_final_link _bfd_coff_final_link
5443 #else /* ! defined (coff_relocate_section) */
5445 #define coff_relocate_section NULL
5446 #ifndef coff_bfd_link_hash_table_create
5447 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5449 #ifndef coff_bfd_link_add_symbols
5450 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5452 #define coff_bfd_final_link _bfd_generic_final_link
5454 #endif /* ! defined (coff_relocate_section) */
5456 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5457 #define coff_bfd_copy_link_hash_symbol_type \
5458 _bfd_generic_copy_link_hash_symbol_type
5459 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5461 #ifndef coff_start_final_link
5462 #define coff_start_final_link NULL
5465 #ifndef coff_adjust_symndx
5466 #define coff_adjust_symndx NULL
5469 #ifndef coff_link_add_one_symbol
5470 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5473 #ifndef coff_link_output_has_begun
5476 coff_link_output_has_begun (bfd
* abfd
,
5477 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
)
5479 return abfd
->output_has_begun
;
5483 #ifndef coff_final_link_postscript
5486 coff_final_link_postscript (bfd
* abfd ATTRIBUTE_UNUSED
,
5487 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
)
5493 #ifndef coff_SWAP_aux_in
5494 #define coff_SWAP_aux_in coff_swap_aux_in
5496 #ifndef coff_SWAP_sym_in
5497 #define coff_SWAP_sym_in coff_swap_sym_in
5499 #ifndef coff_SWAP_lineno_in
5500 #define coff_SWAP_lineno_in coff_swap_lineno_in
5502 #ifndef coff_SWAP_aux_out
5503 #define coff_SWAP_aux_out coff_swap_aux_out
5505 #ifndef coff_SWAP_sym_out
5506 #define coff_SWAP_sym_out coff_swap_sym_out
5508 #ifndef coff_SWAP_lineno_out
5509 #define coff_SWAP_lineno_out coff_swap_lineno_out
5511 #ifndef coff_SWAP_reloc_out
5512 #define coff_SWAP_reloc_out coff_swap_reloc_out
5514 #ifndef coff_SWAP_filehdr_out
5515 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5517 #ifndef coff_SWAP_aouthdr_out
5518 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5520 #ifndef coff_SWAP_scnhdr_out
5521 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5523 #ifndef coff_SWAP_reloc_in
5524 #define coff_SWAP_reloc_in coff_swap_reloc_in
5526 #ifndef coff_SWAP_filehdr_in
5527 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5529 #ifndef coff_SWAP_aouthdr_in
5530 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5532 #ifndef coff_SWAP_scnhdr_in
5533 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5536 static bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED
=
5538 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5539 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5540 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5541 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5542 coff_SWAP_scnhdr_out
,
5543 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5544 #ifdef COFF_LONG_FILENAMES
5549 COFF_DEFAULT_LONG_SECTION_NAMES
,
5550 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5551 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5556 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5562 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5563 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5564 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5565 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5566 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5567 coff_classify_symbol
, coff_compute_section_file_positions
,
5568 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5569 coff_adjust_symndx
, coff_link_add_one_symbol
,
5570 coff_link_output_has_begun
, coff_final_link_postscript
,
5575 /* COFF0 differs in file/section header size and relocation entry size. */
5577 static bfd_coff_backend_data ticoff0_swap_table
=
5579 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5580 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5581 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5582 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5583 coff_SWAP_scnhdr_out
,
5584 FILHSZ_V0
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ_V0
, LINESZ
, FILNMLEN
,
5585 #ifdef COFF_LONG_FILENAMES
5590 COFF_DEFAULT_LONG_SECTION_NAMES
,
5591 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5592 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5597 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5603 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5604 coff_SWAP_reloc_in
, ticoff0_bad_format_hook
, coff_set_arch_mach_hook
,
5605 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5606 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5607 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5608 coff_classify_symbol
, coff_compute_section_file_positions
,
5609 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5610 coff_adjust_symndx
, coff_link_add_one_symbol
,
5611 coff_link_output_has_begun
, coff_final_link_postscript
,
5617 /* COFF1 differs in section header size. */
5619 static bfd_coff_backend_data ticoff1_swap_table
=
5621 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5622 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5623 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5624 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5625 coff_SWAP_scnhdr_out
,
5626 FILHSZ
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5627 #ifdef COFF_LONG_FILENAMES
5632 COFF_DEFAULT_LONG_SECTION_NAMES
,
5633 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5634 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5639 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5645 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5646 coff_SWAP_reloc_in
, ticoff1_bad_format_hook
, coff_set_arch_mach_hook
,
5647 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5648 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5649 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5650 coff_classify_symbol
, coff_compute_section_file_positions
,
5651 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5652 coff_adjust_symndx
, coff_link_add_one_symbol
,
5653 coff_link_output_has_begun
, coff_final_link_postscript
,
5654 bfd_pe_print_pdata
/* huh */
5658 #ifdef COFF_WITH_PE_BIGOBJ
5659 /* The UID for bigobj files. */
5661 static const char header_bigobj_classid
[16] =
5663 0xC7, 0xA1, 0xBA, 0xD1,
5667 0xFA, 0xF6, 0x6A, 0xA4, 0xDC, 0xB8
5670 /* Swap routines. */
5673 coff_bigobj_swap_filehdr_in (bfd
* abfd
, void * src
, void * dst
)
5675 struct external_ANON_OBJECT_HEADER_BIGOBJ
*filehdr_src
=
5676 (struct external_ANON_OBJECT_HEADER_BIGOBJ
*) src
;
5677 struct internal_filehdr
*filehdr_dst
= (struct internal_filehdr
*) dst
;
5679 filehdr_dst
->f_magic
= H_GET_16 (abfd
, filehdr_src
->Machine
);
5680 filehdr_dst
->f_nscns
= H_GET_32 (abfd
, filehdr_src
->NumberOfSections
);
5681 filehdr_dst
->f_timdat
= H_GET_32 (abfd
, filehdr_src
->TimeDateStamp
);
5682 filehdr_dst
->f_symptr
=
5683 GET_FILEHDR_SYMPTR (abfd
, filehdr_src
->PointerToSymbolTable
);
5684 filehdr_dst
->f_nsyms
= H_GET_32 (abfd
, filehdr_src
->NumberOfSymbols
);
5685 filehdr_dst
->f_opthdr
= 0;
5686 filehdr_dst
->f_flags
= 0;
5688 /* Check other magic numbers. */
5689 if (H_GET_16 (abfd
, filehdr_src
->Sig1
) != IMAGE_FILE_MACHINE_UNKNOWN
5690 || H_GET_16 (abfd
, filehdr_src
->Sig2
) != 0xffff
5691 || H_GET_16 (abfd
, filehdr_src
->Version
) != 2
5692 || memcmp (filehdr_src
->ClassID
, header_bigobj_classid
, 16) != 0)
5693 filehdr_dst
->f_opthdr
= 0xffff;
5695 /* Note that CLR metadata are ignored. */
5699 coff_bigobj_swap_filehdr_out (bfd
*abfd
, void * in
, void * out
)
5701 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
5702 struct external_ANON_OBJECT_HEADER_BIGOBJ
*filehdr_out
=
5703 (struct external_ANON_OBJECT_HEADER_BIGOBJ
*) out
;
5705 memset (filehdr_out
, 0, sizeof (*filehdr_out
));
5707 H_PUT_16 (abfd
, IMAGE_FILE_MACHINE_UNKNOWN
, filehdr_out
->Sig1
);
5708 H_PUT_16 (abfd
, 0xffff, filehdr_out
->Sig2
);
5709 H_PUT_16 (abfd
, 2, filehdr_out
->Version
);
5710 memcpy (filehdr_out
->ClassID
, header_bigobj_classid
, 16);
5711 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->Machine
);
5712 H_PUT_32 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->NumberOfSections
);
5713 H_PUT_32 (abfd
, filehdr_in
->f_timdat
, filehdr_out
->TimeDateStamp
);
5714 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
,
5715 filehdr_out
->PointerToSymbolTable
);
5716 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->NumberOfSymbols
);
5718 return bfd_coff_filhsz (abfd
);
5722 coff_bigobj_swap_sym_in (bfd
* abfd
, void * ext1
, void * in1
)
5724 SYMENT_BIGOBJ
*ext
= (SYMENT_BIGOBJ
*) ext1
;
5725 struct internal_syment
*in
= (struct internal_syment
*) in1
;
5727 if (ext
->e
.e_name
[0] == 0)
5729 in
->_n
._n_n
._n_zeroes
= 0;
5730 in
->_n
._n_n
._n_offset
= H_GET_32 (abfd
, ext
->e
.e
.e_offset
);
5734 #if SYMNMLEN != E_SYMNMLEN
5735 #error we need to cope with truncating or extending SYMNMLEN
5737 memcpy (in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
5741 in
->n_value
= H_GET_32 (abfd
, ext
->e_value
);
5742 in
->n_scnum
= H_GET_32 (abfd
, ext
->e_scnum
);
5743 in
->n_type
= H_GET_16 (abfd
, ext
->e_type
);
5744 in
->n_sclass
= H_GET_8 (abfd
, ext
->e_sclass
);
5745 in
->n_numaux
= H_GET_8 (abfd
, ext
->e_numaux
);
5749 coff_bigobj_swap_sym_out (bfd
* abfd
, void * inp
, void * extp
)
5751 struct internal_syment
*in
= (struct internal_syment
*) inp
;
5752 SYMENT_BIGOBJ
*ext
= (SYMENT_BIGOBJ
*) extp
;
5754 if (in
->_n
._n_name
[0] == 0)
5756 H_PUT_32 (abfd
, 0, ext
->e
.e
.e_zeroes
);
5757 H_PUT_32 (abfd
, in
->_n
._n_n
._n_offset
, ext
->e
.e
.e_offset
);
5761 #if SYMNMLEN != E_SYMNMLEN
5762 #error we need to cope with truncating or extending SYMNMLEN
5764 memcpy (ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
5768 H_PUT_32 (abfd
, in
->n_value
, ext
->e_value
);
5769 H_PUT_32 (abfd
, in
->n_scnum
, ext
->e_scnum
);
5771 H_PUT_16 (abfd
, in
->n_type
, ext
->e_type
);
5772 H_PUT_8 (abfd
, in
->n_sclass
, ext
->e_sclass
);
5773 H_PUT_8 (abfd
, in
->n_numaux
, ext
->e_numaux
);
5775 return SYMESZ_BIGOBJ
;
5779 coff_bigobj_swap_aux_in (bfd
*abfd
,
5787 AUXENT_BIGOBJ
*ext
= (AUXENT_BIGOBJ
*) ext1
;
5788 union internal_auxent
*in
= (union internal_auxent
*) in1
;
5796 memcpy (in
->x_file
.x_fname
, ext
->File
.Name
,
5797 numaux
* sizeof (AUXENT_BIGOBJ
));
5800 memcpy (in
->x_file
.x_fname
, ext
->File
.Name
, sizeof (ext
->File
.Name
));
5808 in
->x_scn
.x_scnlen
= H_GET_32 (abfd
, ext
->Section
.Length
);
5809 in
->x_scn
.x_nreloc
=
5810 H_GET_16 (abfd
, ext
->Section
.NumberOfRelocations
);
5811 in
->x_scn
.x_nlinno
=
5812 H_GET_16 (abfd
, ext
->Section
.NumberOfLinenumbers
);
5813 in
->x_scn
.x_checksum
= H_GET_32 (abfd
, ext
->Section
.Checksum
);
5814 in
->x_scn
.x_associated
= H_GET_16 (abfd
, ext
->Section
.Number
)
5815 | (H_GET_16 (abfd
, ext
->Section
.HighNumber
) << 16);
5816 in
->x_scn
.x_comdat
= H_GET_8 (abfd
, ext
->Section
.Selection
);
5822 in
->x_sym
.x_tagndx
.l
= H_GET_32 (abfd
, ext
->Sym
.WeakDefaultSymIndex
);
5823 /* Characteristics is ignored. */
5829 coff_bigobj_swap_aux_out (bfd
* abfd
,
5833 int indx ATTRIBUTE_UNUSED
,
5834 int numaux ATTRIBUTE_UNUSED
,
5837 union internal_auxent
* in
= (union internal_auxent
*) inp
;
5838 AUXENT_BIGOBJ
*ext
= (AUXENT_BIGOBJ
*) extp
;
5840 memset (ext
, 0, AUXESZ
);
5845 memcpy (ext
->File
.Name
, in
->x_file
.x_fname
, sizeof (ext
->File
.Name
));
5854 H_PUT_32 (abfd
, in
->x_scn
.x_scnlen
, ext
->Section
.Length
);
5855 H_PUT_16 (abfd
, in
->x_scn
.x_nreloc
,
5856 ext
->Section
.NumberOfRelocations
);
5857 H_PUT_16 (abfd
, in
->x_scn
.x_nlinno
,
5858 ext
->Section
.NumberOfLinenumbers
);
5859 H_PUT_32 (abfd
, in
->x_scn
.x_checksum
, ext
->Section
.Checksum
);
5860 H_PUT_16 (abfd
, in
->x_scn
.x_associated
& 0xffff,
5861 ext
->Section
.Number
);
5862 H_PUT_16 (abfd
, (in
->x_scn
.x_associated
>> 16),
5863 ext
->Section
.HighNumber
);
5864 H_PUT_8 (abfd
, in
->x_scn
.x_comdat
, ext
->Section
.Selection
);
5870 H_PUT_32 (abfd
, in
->x_sym
.x_tagndx
.l
, ext
->Sym
.WeakDefaultSymIndex
);
5871 H_PUT_32 (abfd
, 1, ext
->Sym
.WeakSearchType
);
5876 static bfd_coff_backend_data bigobj_swap_table
=
5878 coff_bigobj_swap_aux_in
, coff_bigobj_swap_sym_in
, coff_SWAP_lineno_in
,
5879 coff_bigobj_swap_aux_out
, coff_bigobj_swap_sym_out
,
5880 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5881 coff_bigobj_swap_filehdr_out
, coff_SWAP_aouthdr_out
,
5882 coff_SWAP_scnhdr_out
,
5883 FILHSZ_BIGOBJ
, AOUTSZ
, SCNHSZ
, SYMESZ_BIGOBJ
, AUXESZ_BIGOBJ
,
5884 RELSZ
, LINESZ
, FILNMLEN_BIGOBJ
,
5886 COFF_DEFAULT_LONG_SECTION_NAMES
,
5887 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5891 coff_bigobj_swap_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5892 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5893 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5894 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5895 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5896 coff_classify_symbol
, coff_compute_section_file_positions
,
5897 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5898 coff_adjust_symndx
, coff_link_add_one_symbol
,
5899 coff_link_output_has_begun
, coff_final_link_postscript
,
5900 bfd_pe_print_pdata
/* huh */
5903 #endif /* COFF_WITH_PE_BIGOBJ */
5905 #ifndef coff_close_and_cleanup
5906 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5909 #ifndef coff_bfd_free_cached_info
5910 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5913 #ifndef coff_get_section_contents
5914 #define coff_get_section_contents _bfd_generic_get_section_contents
5917 #ifndef coff_bfd_copy_private_symbol_data
5918 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5921 #ifndef coff_bfd_copy_private_header_data
5922 #define coff_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
5925 #ifndef coff_bfd_copy_private_section_data
5926 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5929 #ifndef coff_bfd_copy_private_bfd_data
5930 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5933 #ifndef coff_bfd_merge_private_bfd_data
5934 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5937 #ifndef coff_bfd_set_private_flags
5938 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5941 #ifndef coff_bfd_print_private_bfd_data
5942 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5945 #ifndef coff_bfd_is_local_label_name
5946 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5949 #ifndef coff_bfd_is_target_special_symbol
5950 #define coff_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
5953 #ifndef coff_read_minisymbols
5954 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5957 #ifndef coff_minisymbol_to_symbol
5958 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5961 /* The reloc lookup routine must be supplied by each individual COFF
5963 #ifndef coff_bfd_reloc_type_lookup
5964 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5966 #ifndef coff_bfd_reloc_name_lookup
5967 #define coff_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5970 #ifndef coff_bfd_get_relocated_section_contents
5971 #define coff_bfd_get_relocated_section_contents \
5972 bfd_generic_get_relocated_section_contents
5975 #ifndef coff_bfd_relax_section
5976 #define coff_bfd_relax_section bfd_generic_relax_section
5979 #ifndef coff_bfd_gc_sections
5980 #define coff_bfd_gc_sections bfd_generic_gc_sections
5983 #ifndef coff_bfd_lookup_section_flags
5984 #define coff_bfd_lookup_section_flags bfd_generic_lookup_section_flags
5987 #ifndef coff_bfd_merge_sections
5988 #define coff_bfd_merge_sections bfd_generic_merge_sections
5991 #ifndef coff_bfd_is_group_section
5992 #define coff_bfd_is_group_section bfd_generic_is_group_section
5995 #ifndef coff_bfd_discard_group
5996 #define coff_bfd_discard_group bfd_generic_discard_group
5999 #ifndef coff_section_already_linked
6000 #define coff_section_already_linked \
6001 _bfd_coff_section_already_linked
6004 #ifndef coff_bfd_define_common_symbol
6005 #define coff_bfd_define_common_symbol bfd_generic_define_common_symbol
6008 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
6009 const bfd_target VAR = \
6012 bfd_target_coff_flavour, \
6013 BFD_ENDIAN_BIG, /* Data byte order is big. */ \
6014 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
6015 /* object flags */ \
6016 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
6017 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
6018 /* section flags */ \
6019 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
6020 UNDER, /* Leading symbol underscore. */ \
6021 '/', /* AR_pad_char. */ \
6022 15, /* AR_max_namelen. */ \
6023 0, /* match priority. */ \
6025 /* Data conversion functions. */ \
6026 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
6027 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
6028 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
6030 /* Header conversion functions. */ \
6031 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
6032 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
6033 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
6035 /* bfd_check_format. */ \
6036 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
6037 _bfd_dummy_target }, \
6038 /* bfd_set_format. */ \
6039 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
6040 /* bfd_write_contents. */ \
6041 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
6044 BFD_JUMP_TABLE_GENERIC (coff), \
6045 BFD_JUMP_TABLE_COPY (coff), \
6046 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
6047 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
6048 BFD_JUMP_TABLE_SYMBOLS (coff), \
6049 BFD_JUMP_TABLE_RELOCS (coff), \
6050 BFD_JUMP_TABLE_WRITE (coff), \
6051 BFD_JUMP_TABLE_LINK (coff), \
6052 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
6059 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
6060 const bfd_target VAR = \
6063 bfd_target_coff_flavour, \
6064 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
6065 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
6066 /* object flags */ \
6067 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
6068 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
6069 /* section flags */ \
6070 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
6071 UNDER, /* Leading symbol underscore. */ \
6072 '/', /* AR_pad_char. */ \
6073 15, /* AR_max_namelen. */ \
6074 0, /* match priority. */ \
6076 /* Data conversion functions. */ \
6077 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
6078 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
6079 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
6081 /* Header conversion functions. */ \
6082 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
6083 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
6084 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
6086 /* bfd_check_format. */ \
6087 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
6088 _bfd_dummy_target }, \
6089 /* bfd_set_format. */ \
6090 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
6091 /* bfd_write_contents. */ \
6092 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
6095 BFD_JUMP_TABLE_GENERIC (coff), \
6096 BFD_JUMP_TABLE_COPY (coff), \
6097 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
6098 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
6099 BFD_JUMP_TABLE_SYMBOLS (coff), \
6100 BFD_JUMP_TABLE_RELOCS (coff), \
6101 BFD_JUMP_TABLE_WRITE (coff), \
6102 BFD_JUMP_TABLE_LINK (coff), \
6103 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
6110 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
6111 const bfd_target VAR = \
6114 bfd_target_coff_flavour, \
6115 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
6116 BFD_ENDIAN_LITTLE, /* Header byte order is little. */ \
6117 /* object flags */ \
6118 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
6119 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
6120 /* section flags */ \
6121 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
6122 UNDER, /* Leading symbol underscore. */ \
6123 '/', /* AR_pad_char. */ \
6124 15, /* AR_max_namelen. */ \
6125 0, /* match priority. */ \
6127 /* Data conversion functions. */ \
6128 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
6129 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
6130 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
6131 /* Header conversion functions. */ \
6132 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
6133 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
6134 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
6135 /* bfd_check_format. */ \
6136 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
6137 _bfd_dummy_target }, \
6138 /* bfd_set_format. */ \
6139 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
6140 /* bfd_write_contents. */ \
6141 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
6144 BFD_JUMP_TABLE_GENERIC (coff), \
6145 BFD_JUMP_TABLE_COPY (coff), \
6146 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
6147 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
6148 BFD_JUMP_TABLE_SYMBOLS (coff), \
6149 BFD_JUMP_TABLE_RELOCS (coff), \
6150 BFD_JUMP_TABLE_WRITE (coff), \
6151 BFD_JUMP_TABLE_LINK (coff), \
6152 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \