1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright (C) 1990-2017 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"),
977 /* The first time we've seen the symbol. */
978 union internal_auxent aux
;
980 /* If it isn't the stuff we're expecting, die;
981 The MS documentation is vague, but it
982 appears that the second entry serves BOTH
983 as the comdat symbol and the defining
984 symbol record (either C_STAT or C_EXT,
985 possibly with an aux entry with debug
986 information if it's a function.) It
987 appears the only way to find the second one
988 is to count. (On Intel, they appear to be
989 adjacent, but on Alpha, they have been
992 Here, we think we've found the first one,
993 but there's some checking we can do to be
996 if (! ((isym
.n_sclass
== C_STAT
997 || isym
.n_sclass
== C_EXT
)
998 && BTYPE (isym
.n_type
) == T_NULL
999 && isym
.n_value
== 0))
1001 /* Malformed input files can trigger this test.
1003 _bfd_error_handler (_("%B: error: unexpected symbol '%s' in COMDAT section"),
1008 /* FIXME LATER: MSVC generates section names
1009 like .text for comdats. Gas generates
1010 names like .text$foo__Fv (in the case of a
1011 function). See comment above for more. */
1013 if (isym
.n_sclass
== C_STAT
&& strcmp (name
, symname
) != 0)
1014 /* xgettext:c-format */
1015 _bfd_error_handler (_("%B: warning: COMDAT symbol '%s'"
1016 " does not match section name '%s'"),
1017 abfd
, symname
, name
);
1021 /* PR 17512: file: e2cfe54f. */
1022 if (esym
+ bfd_coff_symesz (abfd
) >= esymend
)
1024 /* xgettext:c-format */
1025 _bfd_error_handler (_("%B: warning: No symbol for"
1026 " section '%s' found"),
1030 /* This is the section symbol. */
1031 bfd_coff_swap_aux_in (abfd
, (esym
+ bfd_coff_symesz (abfd
)),
1032 isym
.n_type
, isym
.n_sclass
,
1033 0, isym
.n_numaux
, & aux
);
1035 target_name
= strchr (name
, '$');
1036 if (target_name
!= NULL
)
1044 /* FIXME: Microsoft uses NODUPLICATES and
1045 ASSOCIATIVE, but gnu uses ANY and
1046 SAME_SIZE. Unfortunately, gnu doesn't do
1047 the comdat symbols right. So, until we can
1048 fix it to do the right thing, we are
1049 temporarily disabling comdats for the MS
1050 types (they're used in DLLs and C++, but we
1051 don't support *their* C++ libraries anyway
1054 /* Cygwin does not follow the MS style, and
1055 uses ANY and SAME_SIZE where NODUPLICATES
1056 and ASSOCIATIVE should be used. For
1057 Interix, we just do the right thing up
1060 switch (aux
.x_scn
.x_comdat
)
1062 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
1063 #ifdef STRICT_PE_FORMAT
1064 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
1066 sec_flags
&= ~SEC_LINK_ONCE
;
1070 case IMAGE_COMDAT_SELECT_ANY
:
1071 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1074 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
1075 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
1078 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
1079 /* Not yet fully implemented ??? */
1080 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
1083 /* debug$S gets this case; other
1086 /* There may be no symbol... we'll search
1087 the whole table... Is this the right
1088 place to play this game? Or should we do
1089 it when reading it in. */
1090 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
1091 #ifdef STRICT_PE_FORMAT
1092 /* FIXME: This is not currently implemented. */
1093 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1095 sec_flags
&= ~SEC_LINK_ONCE
;
1099 default: /* 0 means "no symbol" */
1100 /* debug$F gets this case; other
1102 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1109 /* Gas mode: the first matching on partial name. */
1111 #ifndef TARGET_UNDERSCORE
1112 #define TARGET_UNDERSCORE 0
1114 /* Is this the name we're looking for ? */
1115 if (strcmp (target_name
,
1116 symname
+ (TARGET_UNDERSCORE
? 1 : 0)) != 0)
1118 /* Not the name we're looking for */
1119 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1124 /* MSVC mode: the lexically second symbol (or
1125 drop through from the above). */
1130 /* This must the second symbol with the
1131 section #. It is the actual symbol name.
1132 Intel puts the two adjacent, but Alpha (at
1133 least) spreads them out. */
1135 amt
= sizeof (struct coff_comdat_info
);
1136 coff_section_data (abfd
, section
)->comdat
1137 = (struct coff_comdat_info
*) bfd_alloc (abfd
, amt
);
1138 if (coff_section_data (abfd
, section
)->comdat
== NULL
)
1141 coff_section_data (abfd
, section
)->comdat
->symbol
=
1142 (esym
- esymstart
) / bfd_coff_symesz (abfd
);
1144 amt
= strlen (symname
) + 1;
1145 newname
= (char *) bfd_alloc (abfd
, amt
);
1146 if (newname
== NULL
)
1149 strcpy (newname
, symname
);
1150 coff_section_data (abfd
, section
)->comdat
->name
1158 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1166 /* The PE version; see above for the general comments.
1168 Since to set the SEC_LINK_ONCE and associated flags, we have to
1169 look at the symbol table anyway, we return the symbol table index
1170 of the symbol being used as the COMDAT symbol. This is admittedly
1171 ugly, but there's really nowhere else that we have access to the
1172 required information. FIXME: Is the COMDAT symbol index used for
1173 any purpose other than objdump? */
1176 styp_to_sec_flags (bfd
*abfd
,
1180 flagword
*flags_ptr
)
1182 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
1183 unsigned long styp_flags
= internal_s
->s_flags
;
1185 bfd_boolean result
= TRUE
;
1186 bfd_boolean is_dbg
= FALSE
;
1188 if (CONST_STRNEQ (name
, DOT_DEBUG
)
1189 || CONST_STRNEQ (name
, DOT_ZDEBUG
)
1190 #ifdef COFF_LONG_SECTION_NAMES
1191 || CONST_STRNEQ (name
, GNU_LINKONCE_WI
)
1192 || CONST_STRNEQ (name
, GNU_LINKONCE_WT
)
1194 || CONST_STRNEQ (name
, ".stab"))
1196 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
1197 sec_flags
= SEC_READONLY
;
1199 /* If section disallows read, then set the NOREAD flag. */
1200 if ((styp_flags
& IMAGE_SCN_MEM_READ
) == 0)
1201 sec_flags
|= SEC_COFF_NOREAD
;
1203 /* Process each flag bit in styp_flags in turn. */
1206 unsigned long flag
= styp_flags
& - styp_flags
;
1207 char * unhandled
= NULL
;
1209 styp_flags
&= ~ flag
;
1211 /* We infer from the distinct read/write/execute bits the settings
1212 of some of the bfd flags; the actual values, should we need them,
1213 are also in pei_section_data (abfd, section)->pe_flags. */
1218 unhandled
= "STYP_DSECT";
1221 unhandled
= "STYP_GROUP";
1224 unhandled
= "STYP_COPY";
1227 unhandled
= "STYP_OVER";
1229 #ifdef SEC_NEVER_LOAD
1231 sec_flags
|= SEC_NEVER_LOAD
;
1234 case IMAGE_SCN_MEM_READ
:
1235 sec_flags
&= ~SEC_COFF_NOREAD
;
1237 case IMAGE_SCN_TYPE_NO_PAD
:
1240 case IMAGE_SCN_LNK_OTHER
:
1241 unhandled
= "IMAGE_SCN_LNK_OTHER";
1243 case IMAGE_SCN_MEM_NOT_CACHED
:
1244 unhandled
= "IMAGE_SCN_MEM_NOT_CACHED";
1246 case IMAGE_SCN_MEM_NOT_PAGED
:
1247 /* Generate a warning message rather using the 'unhandled'
1248 variable as this will allow some .sys files generate by
1249 other toolchains to be processed. See bugzilla issue 196. */
1250 /* xgettext:c-format */
1251 _bfd_error_handler (_("%B: Warning: Ignoring section flag"
1252 " IMAGE_SCN_MEM_NOT_PAGED in section %s"),
1255 case IMAGE_SCN_MEM_EXECUTE
:
1256 sec_flags
|= SEC_CODE
;
1258 case IMAGE_SCN_MEM_WRITE
:
1259 sec_flags
&= ~ SEC_READONLY
;
1261 case IMAGE_SCN_MEM_DISCARDABLE
:
1262 /* The MS PE spec says that debug sections are DISCARDABLE,
1263 but the presence of a DISCARDABLE flag does not necessarily
1264 mean that a given section contains debug information. Thus
1265 we only set the SEC_DEBUGGING flag on sections that we
1266 recognise as containing debug information. */
1269 || strcmp (name
, _COMMENT
) == 0
1273 sec_flags
|= SEC_DEBUGGING
| SEC_READONLY
;
1276 case IMAGE_SCN_MEM_SHARED
:
1277 sec_flags
|= SEC_COFF_SHARED
;
1279 case IMAGE_SCN_LNK_REMOVE
:
1281 sec_flags
|= SEC_EXCLUDE
;
1283 case IMAGE_SCN_CNT_CODE
:
1284 sec_flags
|= SEC_CODE
| SEC_ALLOC
| SEC_LOAD
;
1286 case IMAGE_SCN_CNT_INITIALIZED_DATA
:
1288 sec_flags
|= SEC_DEBUGGING
;
1290 sec_flags
|= SEC_DATA
| SEC_ALLOC
| SEC_LOAD
;
1292 case IMAGE_SCN_CNT_UNINITIALIZED_DATA
:
1293 sec_flags
|= SEC_ALLOC
;
1295 case IMAGE_SCN_LNK_INFO
:
1296 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1297 defined. coff_compute_section_file_positions uses
1298 COFF_PAGE_SIZE to ensure that the low order bits of the
1299 section VMA and the file offset match. If we don't know
1300 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1301 and demand page loading of the file will fail. */
1302 #ifdef COFF_PAGE_SIZE
1303 sec_flags
|= SEC_DEBUGGING
;
1306 case IMAGE_SCN_LNK_COMDAT
:
1307 /* COMDAT gets very special treatment. */
1308 sec_flags
= handle_COMDAT (abfd
, sec_flags
, hdr
, name
, section
);
1311 /* Silently ignore for now. */
1315 /* If the section flag was not handled, report it here. */
1316 if (unhandled
!= NULL
)
1319 /* xgettext:c-format */
1320 (_("%B (%s): Section flag %s (%#lx) ignored"),
1321 abfd
, name
, unhandled
, flag
);
1326 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1327 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1328 only link a single copy of the section. This is used to support
1329 g++. g++ will emit each template expansion in its own section.
1330 The symbols will be defined as weak, so that multiple definitions
1331 are permitted. The GNU linker extension is to actually discard
1332 all but one of the sections. */
1333 if (CONST_STRNEQ (name
, ".gnu.linkonce"))
1334 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1338 * flags_ptr
= sec_flags
;
1343 #endif /* COFF_WITH_PE */
1345 #define get_index(symbol) ((symbol)->udata.i)
1349 bfd_coff_backend_data
1353 .{* COFF symbol classifications. *}
1355 .enum coff_symbol_classification
1357 . {* Global symbol. *}
1358 . COFF_SYMBOL_GLOBAL,
1359 . {* Common symbol. *}
1360 . COFF_SYMBOL_COMMON,
1361 . {* Undefined symbol. *}
1362 . COFF_SYMBOL_UNDEFINED,
1363 . {* Local symbol. *}
1364 . COFF_SYMBOL_LOCAL,
1365 . {* PE section symbol. *}
1366 . COFF_SYMBOL_PE_SECTION
1369 .typedef asection * (*coff_gc_mark_hook_fn)
1370 . (asection *, struct bfd_link_info *, struct internal_reloc *,
1371 . struct coff_link_hash_entry *, struct internal_syment *);
1373 Special entry points for gdb to swap in coff symbol table parts:
1376 . void (*_bfd_coff_swap_aux_in)
1377 . (bfd *, void *, int, int, int, int, void *);
1379 . void (*_bfd_coff_swap_sym_in)
1380 . (bfd *, void *, void *);
1382 . void (*_bfd_coff_swap_lineno_in)
1383 . (bfd *, void *, void *);
1385 . unsigned int (*_bfd_coff_swap_aux_out)
1386 . (bfd *, void *, int, int, int, int, void *);
1388 . unsigned int (*_bfd_coff_swap_sym_out)
1389 . (bfd *, void *, void *);
1391 . unsigned int (*_bfd_coff_swap_lineno_out)
1392 . (bfd *, void *, void *);
1394 . unsigned int (*_bfd_coff_swap_reloc_out)
1395 . (bfd *, void *, void *);
1397 . unsigned int (*_bfd_coff_swap_filehdr_out)
1398 . (bfd *, void *, void *);
1400 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1401 . (bfd *, void *, void *);
1403 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1404 . (bfd *, void *, void *);
1406 . unsigned int _bfd_filhsz;
1407 . unsigned int _bfd_aoutsz;
1408 . unsigned int _bfd_scnhsz;
1409 . unsigned int _bfd_symesz;
1410 . unsigned int _bfd_auxesz;
1411 . unsigned int _bfd_relsz;
1412 . unsigned int _bfd_linesz;
1413 . unsigned int _bfd_filnmlen;
1414 . bfd_boolean _bfd_coff_long_filenames;
1416 . bfd_boolean _bfd_coff_long_section_names;
1417 . bfd_boolean (*_bfd_coff_set_long_section_names)
1420 . unsigned int _bfd_coff_default_section_alignment_power;
1421 . bfd_boolean _bfd_coff_force_symnames_in_strings;
1422 . unsigned int _bfd_coff_debug_string_prefix_length;
1423 . unsigned int _bfd_coff_max_nscns;
1425 . void (*_bfd_coff_swap_filehdr_in)
1426 . (bfd *, void *, void *);
1428 . void (*_bfd_coff_swap_aouthdr_in)
1429 . (bfd *, void *, void *);
1431 . void (*_bfd_coff_swap_scnhdr_in)
1432 . (bfd *, void *, void *);
1434 . void (*_bfd_coff_swap_reloc_in)
1435 . (bfd *abfd, void *, void *);
1437 . bfd_boolean (*_bfd_coff_bad_format_hook)
1440 . bfd_boolean (*_bfd_coff_set_arch_mach_hook)
1443 . void * (*_bfd_coff_mkobject_hook)
1444 . (bfd *, void *, void *);
1446 . bfd_boolean (*_bfd_styp_to_sec_flags_hook)
1447 . (bfd *, void *, const char *, asection *, flagword *);
1449 . void (*_bfd_set_alignment_hook)
1450 . (bfd *, asection *, void *);
1452 . bfd_boolean (*_bfd_coff_slurp_symbol_table)
1455 . bfd_boolean (*_bfd_coff_symname_in_debug)
1456 . (bfd *, struct internal_syment *);
1458 . bfd_boolean (*_bfd_coff_pointerize_aux_hook)
1459 . (bfd *, combined_entry_type *, combined_entry_type *,
1460 . unsigned int, combined_entry_type *);
1462 . bfd_boolean (*_bfd_coff_print_aux)
1463 . (bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1464 . combined_entry_type *, unsigned int);
1466 . void (*_bfd_coff_reloc16_extra_cases)
1467 . (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1468 . bfd_byte *, unsigned int *, unsigned int *);
1470 . int (*_bfd_coff_reloc16_estimate)
1471 . (bfd *, asection *, arelent *, unsigned int,
1472 . struct bfd_link_info *);
1474 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1475 . (bfd *, struct internal_syment *);
1477 . bfd_boolean (*_bfd_coff_compute_section_file_positions)
1480 . bfd_boolean (*_bfd_coff_start_final_link)
1481 . (bfd *, struct bfd_link_info *);
1483 . bfd_boolean (*_bfd_coff_relocate_section)
1484 . (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1485 . struct internal_reloc *, struct internal_syment *, asection **);
1487 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1488 . (bfd *, asection *, struct internal_reloc *,
1489 . struct coff_link_hash_entry *, struct internal_syment *,
1492 . bfd_boolean (*_bfd_coff_adjust_symndx)
1493 . (bfd *, struct bfd_link_info *, bfd *, asection *,
1494 . struct internal_reloc *, bfd_boolean *);
1496 . bfd_boolean (*_bfd_coff_link_add_one_symbol)
1497 . (struct bfd_link_info *, bfd *, const char *, flagword,
1498 . asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
1499 . struct bfd_link_hash_entry **);
1501 . bfd_boolean (*_bfd_coff_link_output_has_begun)
1502 . (bfd *, struct coff_final_link_info *);
1504 . bfd_boolean (*_bfd_coff_final_link_postscript)
1505 . (bfd *, struct coff_final_link_info *);
1507 . bfd_boolean (*_bfd_coff_print_pdata)
1510 .} bfd_coff_backend_data;
1512 .#define coff_backend_info(abfd) \
1513 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1515 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1516 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1518 .#define bfd_coff_swap_sym_in(a,e,i) \
1519 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1521 .#define bfd_coff_swap_lineno_in(a,e,i) \
1522 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1524 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1525 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1527 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1528 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1530 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1531 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1533 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1534 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1536 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1537 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1539 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1540 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1542 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1543 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1545 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1546 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1547 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1548 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1549 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1550 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1551 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1552 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1553 .#define bfd_coff_long_filenames(abfd) \
1554 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1555 .#define bfd_coff_long_section_names(abfd) \
1556 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1557 .#define bfd_coff_set_long_section_names(abfd, enable) \
1558 . ((coff_backend_info (abfd)->_bfd_coff_set_long_section_names) (abfd, enable))
1559 .#define bfd_coff_default_section_alignment_power(abfd) \
1560 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1561 .#define bfd_coff_max_nscns(abfd) \
1562 . (coff_backend_info (abfd)->_bfd_coff_max_nscns)
1564 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1565 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1567 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1568 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1570 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1571 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1573 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1574 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1576 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1577 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1579 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1580 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1581 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1582 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1583 . (abfd, filehdr, aouthdr))
1585 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1586 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1587 . (abfd, scnhdr, name, section, flags_ptr))
1589 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1590 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1592 .#define bfd_coff_slurp_symbol_table(abfd)\
1593 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1595 .#define bfd_coff_symname_in_debug(abfd, sym)\
1596 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1598 .#define bfd_coff_force_symnames_in_strings(abfd)\
1599 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1601 .#define bfd_coff_debug_string_prefix_length(abfd)\
1602 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1604 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1605 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1606 . (abfd, file, base, symbol, aux, indaux))
1608 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1609 . reloc, data, src_ptr, dst_ptr)\
1610 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1611 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1613 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1614 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1615 . (abfd, section, reloc, shrink, link_info))
1617 .#define bfd_coff_classify_symbol(abfd, sym)\
1618 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1621 .#define bfd_coff_compute_section_file_positions(abfd)\
1622 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1625 .#define bfd_coff_start_final_link(obfd, info)\
1626 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1628 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1629 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1630 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1631 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1632 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1633 . (abfd, sec, rel, h, sym, addendp))
1634 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1635 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1636 . (obfd, info, ibfd, sec, rel, adjustedp))
1637 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1638 . value, string, cp, coll, hashp)\
1639 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1640 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1642 .#define bfd_coff_link_output_has_begun(a,p) \
1643 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p))
1644 .#define bfd_coff_final_link_postscript(a,p) \
1645 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p))
1647 .#define bfd_coff_have_print_pdata(a) \
1648 . (coff_backend_info (a)->_bfd_coff_print_pdata)
1649 .#define bfd_coff_print_pdata(a,p) \
1650 . ((coff_backend_info (a)->_bfd_coff_print_pdata) (a, p))
1652 .{* Macro: Returns true if the bfd is a PE executable as opposed to a
1653 . PE object file. *}
1654 .#define bfd_pei_p(abfd) \
1655 . (CONST_STRNEQ ((abfd)->xvec->name, "pei-"))
1658 /* See whether the magic number matches. */
1661 coff_bad_format_hook (bfd
* abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1663 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1665 if (BADMAG (*internal_f
))
1668 /* If the optional header is NULL or not the correct size then
1669 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1670 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1671 optional header is of a different size.
1673 But the mips keeps extra stuff in it's opthdr, so dont check
1676 #if defined(M88) || defined(I960)
1677 if (internal_f
->f_opthdr
!= 0 && bfd_coff_aoutsz (abfd
) != internal_f
->f_opthdr
)
1686 ticoff0_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1688 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1690 if (COFF0_BADMAG (*internal_f
))
1699 ticoff1_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1701 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1703 if (COFF1_BADMAG (*internal_f
))
1710 /* Check whether this section uses an alignment other than the
1714 coff_set_custom_section_alignment (bfd
*abfd ATTRIBUTE_UNUSED
,
1716 const struct coff_section_alignment_entry
*alignment_table
,
1717 const unsigned int table_size
)
1719 const unsigned int default_alignment
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1722 for (i
= 0; i
< table_size
; ++i
)
1724 const char *secname
= bfd_get_section_name (abfd
, section
);
1726 if (alignment_table
[i
].comparison_length
== (unsigned int) -1
1727 ? strcmp (alignment_table
[i
].name
, secname
) == 0
1728 : strncmp (alignment_table
[i
].name
, secname
,
1729 alignment_table
[i
].comparison_length
) == 0)
1732 if (i
>= table_size
)
1735 if (alignment_table
[i
].default_alignment_min
!= COFF_ALIGNMENT_FIELD_EMPTY
1736 && default_alignment
< alignment_table
[i
].default_alignment_min
)
1739 if (alignment_table
[i
].default_alignment_max
!= COFF_ALIGNMENT_FIELD_EMPTY
1740 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1741 && default_alignment
> alignment_table
[i
].default_alignment_max
1746 section
->alignment_power
= alignment_table
[i
].alignment_power
;
1749 /* Custom section alignment records. */
1751 static const struct coff_section_alignment_entry
1752 coff_section_alignment_table
[] =
1754 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1755 COFF_SECTION_ALIGNMENT_ENTRIES
,
1757 /* There must not be any gaps between .stabstr sections. */
1758 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1759 1, COFF_ALIGNMENT_FIELD_EMPTY
, 0 },
1760 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1761 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1762 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1763 /* Similarly for the .ctors and .dtors sections. */
1764 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1765 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1766 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1767 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 }
1770 static const unsigned int coff_section_alignment_table_size
=
1771 sizeof coff_section_alignment_table
/ sizeof coff_section_alignment_table
[0];
1773 /* Initialize a section structure with information peculiar to this
1774 particular implementation of COFF. */
1777 coff_new_section_hook (bfd
* abfd
, asection
* section
)
1779 combined_entry_type
*native
;
1781 unsigned char sclass
= C_STAT
;
1783 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1786 if (bfd_xcoff_text_align_power (abfd
) != 0
1787 && strcmp (bfd_get_section_name (abfd
, section
), ".text") == 0)
1788 section
->alignment_power
= bfd_xcoff_text_align_power (abfd
);
1789 else if (bfd_xcoff_data_align_power (abfd
) != 0
1790 && strcmp (bfd_get_section_name (abfd
, section
), ".data") == 0)
1791 section
->alignment_power
= bfd_xcoff_data_align_power (abfd
);
1796 for (i
= 0; i
< XCOFF_DWSECT_NBR_NAMES
; i
++)
1797 if (strcmp (bfd_get_section_name (abfd
, section
),
1798 xcoff_dwsect_names
[i
].name
) == 0)
1800 section
->alignment_power
= 0;
1807 /* Set up the section symbol. */
1808 if (!_bfd_generic_new_section_hook (abfd
, section
))
1811 /* Allocate aux records for section symbols, to store size and
1814 @@ The 10 is a guess at a plausible maximum number of aux entries
1815 (but shouldn't be a constant). */
1816 amt
= sizeof (combined_entry_type
) * 10;
1817 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
1821 /* We don't need to set up n_name, n_value, or n_scnum in the native
1822 symbol information, since they'll be overridden by the BFD symbol
1823 anyhow. However, we do need to set the type and storage class,
1824 in case this symbol winds up getting written out. The value 0
1825 for n_numaux is already correct. */
1827 native
->is_sym
= TRUE
;
1828 native
->u
.syment
.n_type
= T_NULL
;
1829 native
->u
.syment
.n_sclass
= sclass
;
1831 coffsymbol (section
->symbol
)->native
= native
;
1833 coff_set_custom_section_alignment (abfd
, section
,
1834 coff_section_alignment_table
,
1835 coff_section_alignment_table_size
);
1840 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1842 /* Set the alignment of a BFD section. */
1845 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1849 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1853 /* Extract ALIGN from 2**ALIGN stored in section header. */
1854 for (i
= 0; i
< 32; i
++)
1855 if ((1 << i
) >= hdr
->s_align
)
1858 #ifdef COFF_DECODE_ALIGNMENT
1859 i
= COFF_DECODE_ALIGNMENT(hdr
->s_flags
);
1861 section
->alignment_power
= i
;
1863 #ifdef coff_set_section_load_page
1864 coff_set_section_load_page (section
, hdr
->s_page
);
1868 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1872 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1876 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1878 unsigned int alignment_power_const
1879 = hdr
->s_flags
& IMAGE_SCN_ALIGN_POWER_BIT_MASK
;
1881 switch (alignment_power_const
)
1883 case IMAGE_SCN_ALIGN_8192BYTES
:
1884 case IMAGE_SCN_ALIGN_4096BYTES
:
1885 case IMAGE_SCN_ALIGN_2048BYTES
:
1886 case IMAGE_SCN_ALIGN_1024BYTES
:
1887 case IMAGE_SCN_ALIGN_512BYTES
:
1888 case IMAGE_SCN_ALIGN_256BYTES
:
1889 case IMAGE_SCN_ALIGN_128BYTES
:
1890 case IMAGE_SCN_ALIGN_64BYTES
:
1891 case IMAGE_SCN_ALIGN_32BYTES
:
1892 case IMAGE_SCN_ALIGN_16BYTES
:
1893 case IMAGE_SCN_ALIGN_8BYTES
:
1894 case IMAGE_SCN_ALIGN_4BYTES
:
1895 case IMAGE_SCN_ALIGN_2BYTES
:
1896 case IMAGE_SCN_ALIGN_1BYTES
:
1897 section
->alignment_power
1898 = IMAGE_SCN_ALIGN_POWER_NUM (alignment_power_const
);
1904 /* In a PE image file, the s_paddr field holds the virtual size of a
1905 section, while the s_size field holds the raw size. We also keep
1906 the original section flag value, since not every bit can be
1907 mapped onto a generic BFD section bit. */
1908 if (coff_section_data (abfd
, section
) == NULL
)
1910 amt
= sizeof (struct coff_section_tdata
);
1911 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
1912 if (section
->used_by_bfd
== NULL
)
1913 /* FIXME: Return error. */
1917 if (pei_section_data (abfd
, section
) == NULL
)
1919 amt
= sizeof (struct pei_section_tdata
);
1920 coff_section_data (abfd
, section
)->tdata
= bfd_zalloc (abfd
, amt
);
1921 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1922 /* FIXME: Return error. */
1925 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1926 pei_section_data (abfd
, section
)->pe_flags
= hdr
->s_flags
;
1928 section
->lma
= hdr
->s_vaddr
;
1930 /* Check for extended relocs. */
1931 if (hdr
->s_flags
& IMAGE_SCN_LNK_NRELOC_OVFL
)
1933 struct external_reloc dst
;
1934 struct internal_reloc n
;
1935 file_ptr oldpos
= bfd_tell (abfd
);
1936 bfd_size_type relsz
= bfd_coff_relsz (abfd
);
1938 if (bfd_seek (abfd
, (file_ptr
) hdr
->s_relptr
, 0) != 0)
1940 if (bfd_bread (& dst
, relsz
, abfd
) != relsz
)
1943 coff_swap_reloc_in (abfd
, &dst
, &n
);
1944 if (bfd_seek (abfd
, oldpos
, 0) != 0)
1946 section
->reloc_count
= hdr
->s_nreloc
= n
.r_vaddr
- 1;
1947 section
->rel_filepos
+= relsz
;
1949 else if (hdr
->s_nreloc
== 0xffff)
1951 (_("%B: warning: claims to have 0xffff relocs, without overflow"),
1955 #undef ELIFALIGN_SET
1957 #else /* ! COFF_WITH_PE */
1960 /* We grossly abuse this function to handle XCOFF overflow headers.
1961 When we see one, we correct the reloc and line number counts in the
1962 real header, and remove the section we just created. */
1965 coff_set_alignment_hook (bfd
*abfd
, asection
*section
, void * scnhdr
)
1967 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1970 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1973 real_sec
= coff_section_from_bfd_index (abfd
, (int) hdr
->s_nreloc
);
1974 if (real_sec
== NULL
)
1977 real_sec
->reloc_count
= hdr
->s_paddr
;
1978 real_sec
->lineno_count
= hdr
->s_vaddr
;
1980 if (!bfd_section_removed_from_list (abfd
, section
))
1982 bfd_section_list_remove (abfd
, section
);
1983 --abfd
->section_count
;
1987 #else /* ! RS6000COFF_C */
1989 #define coff_set_alignment_hook \
1990 ((void (*) (bfd *, asection *, void *)) bfd_void)
1992 #endif /* ! RS6000COFF_C */
1993 #endif /* ! COFF_WITH_PE */
1994 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1996 #ifndef coff_mkobject
1999 coff_mkobject (bfd
* abfd
)
2001 coff_data_type
*coff
;
2002 bfd_size_type amt
= sizeof (coff_data_type
);
2004 abfd
->tdata
.coff_obj_data
= bfd_zalloc (abfd
, amt
);
2005 if (abfd
->tdata
.coff_obj_data
== NULL
)
2007 coff
= coff_data (abfd
);
2008 coff
->symbols
= NULL
;
2009 coff
->conversion_table
= NULL
;
2010 coff
->raw_syments
= NULL
;
2011 coff
->relocbase
= 0;
2012 coff
->local_toc_sym_map
= 0;
2014 /* make_abs_section(abfd);*/
2020 /* Create the COFF backend specific information. */
2022 #ifndef coff_mkobject_hook
2024 coff_mkobject_hook (bfd
* abfd
,
2026 void * aouthdr ATTRIBUTE_UNUSED
)
2028 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
2029 coff_data_type
*coff
;
2031 if (! coff_mkobject (abfd
))
2034 coff
= coff_data (abfd
);
2036 coff
->sym_filepos
= internal_f
->f_symptr
;
2038 /* These members communicate important constants about the symbol
2039 table to GDB's symbol-reading code. These `constants'
2040 unfortunately vary among coff implementations... */
2041 coff
->local_n_btmask
= N_BTMASK
;
2042 coff
->local_n_btshft
= N_BTSHFT
;
2043 coff
->local_n_tmask
= N_TMASK
;
2044 coff
->local_n_tshift
= N_TSHIFT
;
2045 coff
->local_symesz
= bfd_coff_symesz (abfd
);
2046 coff
->local_auxesz
= bfd_coff_auxesz (abfd
);
2047 coff
->local_linesz
= bfd_coff_linesz (abfd
);
2049 coff
->timestamp
= internal_f
->f_timdat
;
2051 obj_raw_syment_count (abfd
) =
2052 obj_conv_table_size (abfd
) =
2053 internal_f
->f_nsyms
;
2056 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
2057 abfd
->flags
|= DYNAMIC
;
2058 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= bfd_coff_aoutsz (abfd
))
2060 struct internal_aouthdr
*internal_a
=
2061 (struct internal_aouthdr
*) aouthdr
;
2062 struct xcoff_tdata
*xcoff
;
2064 xcoff
= xcoff_data (abfd
);
2065 # ifdef U803XTOCMAGIC
2066 xcoff
->xcoff64
= internal_f
->f_magic
== U803XTOCMAGIC
;
2070 xcoff
->full_aouthdr
= TRUE
;
2071 xcoff
->toc
= internal_a
->o_toc
;
2072 xcoff
->sntoc
= internal_a
->o_sntoc
;
2073 xcoff
->snentry
= internal_a
->o_snentry
;
2074 bfd_xcoff_text_align_power (abfd
) = internal_a
->o_algntext
;
2075 bfd_xcoff_data_align_power (abfd
) = internal_a
->o_algndata
;
2076 xcoff
->modtype
= internal_a
->o_modtype
;
2077 xcoff
->cputype
= internal_a
->o_cputype
;
2078 xcoff
->maxdata
= internal_a
->o_maxdata
;
2079 xcoff
->maxstack
= internal_a
->o_maxstack
;
2084 /* Set the flags field from the COFF header read in. */
2085 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
2090 /* FIXME: I'm not sure this is ever executed, since peicode.h
2091 defines coff_mkobject_hook. */
2092 if ((internal_f
->f_flags
& IMAGE_FILE_DEBUG_STRIPPED
) == 0)
2093 abfd
->flags
|= HAS_DEBUG
;
2096 if ((internal_f
->f_flags
& F_GO32STUB
) != 0)
2098 coff
->go32stub
= (char *) bfd_alloc (abfd
, (bfd_size_type
) GO32_STUBSIZE
);
2099 if (coff
->go32stub
== NULL
)
2102 if (coff
->go32stub
!= NULL
)
2103 memcpy (coff
->go32stub
, internal_f
->go32stub
, GO32_STUBSIZE
);
2109 /* Determine the machine architecture and type. FIXME: This is target
2110 dependent because the magic numbers are defined in the target
2111 dependent header files. But there is no particular need for this.
2112 If the magic numbers were moved to a separate file, this function
2113 would be target independent and would also be much more successful
2114 at linking together COFF files for different architectures. */
2117 coff_set_arch_mach_hook (bfd
*abfd
, void * filehdr
)
2119 unsigned long machine
;
2120 enum bfd_architecture arch
;
2121 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
2123 /* Zero selects the default machine for an arch. */
2125 switch (internal_f
->f_magic
)
2129 arch
= bfd_arch_powerpc
;
2135 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler. */
2136 case LYNXCOFFMAGIC
: /* Shadows the m68k Lynx number below, sigh. */
2137 arch
= bfd_arch_i386
;
2142 arch
= bfd_arch_i386
;
2143 machine
= bfd_mach_x86_64
;
2148 arch
= bfd_arch_ia64
;
2155 arch
= bfd_arch_arm
;
2156 machine
= bfd_arm_get_mach_from_notes (abfd
, ARM_NOTE_SECTION
);
2157 if (machine
== bfd_mach_arm_unknown
)
2159 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
2161 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
2162 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
2163 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
2165 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
2166 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
2167 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
2168 /* The COFF header does not have enough bits available
2169 to cover all the different ARM architectures. So
2170 we interpret F_ARM_5, the highest flag value to mean
2171 "the highest ARM architecture known to BFD" which is
2172 currently the XScale. */
2173 case F_ARM_5
: machine
= bfd_mach_arm_XScale
; break;
2181 #ifdef MC68KBCSMAGIC
2184 #ifdef APOLLOM68KMAGIC
2185 case APOLLOM68KMAGIC
:
2187 #ifdef LYNXCOFFMAGIC
2190 arch
= bfd_arch_m68k
;
2191 machine
= bfd_mach_m68020
;
2198 arch
= bfd_arch_m88k
;
2204 arch
= bfd_arch_z80
;
2205 switch (internal_f
->f_flags
& F_MACHMASK
)
2208 case bfd_mach_z80strict
<< 12:
2209 case bfd_mach_z80
<< 12:
2210 case bfd_mach_z80full
<< 12:
2211 case bfd_mach_r800
<< 12:
2212 machine
= ((unsigned)internal_f
->f_flags
& F_MACHMASK
) >> 12;
2221 arch
= bfd_arch_z8k
;
2222 switch (internal_f
->f_flags
& F_MACHMASK
)
2225 machine
= bfd_mach_z8001
;
2228 machine
= bfd_mach_z8002
;
2237 arch
= bfd_arch_i860
;
2244 arch
= bfd_arch_i960
;
2245 switch (F_I960TYPE
& internal_f
->f_flags
)
2249 machine
= bfd_mach_i960_core
;
2252 machine
= bfd_mach_i960_kb_sb
;
2255 machine
= bfd_mach_i960_mc
;
2258 machine
= bfd_mach_i960_xa
;
2261 machine
= bfd_mach_i960_ca
;
2264 machine
= bfd_mach_i960_ka_sa
;
2267 machine
= bfd_mach_i960_jx
;
2270 machine
= bfd_mach_i960_hx
;
2289 if (xcoff_data (abfd
)->cputype
!= -1)
2290 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
2293 /* We did not get a value from the a.out header. If the
2294 file has not been stripped, we may be able to get the
2295 architecture information from the first symbol, if it
2296 is a .file symbol. */
2297 if (obj_raw_syment_count (abfd
) == 0)
2302 struct internal_syment sym
;
2303 bfd_size_type amt
= bfd_coff_symesz (abfd
);
2305 buf
= bfd_malloc (amt
);
2308 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
2309 || bfd_bread (buf
, amt
, abfd
) != amt
)
2314 bfd_coff_swap_sym_in (abfd
, buf
, & sym
);
2315 if (sym
.n_sclass
== C_FILE
)
2316 cputype
= sym
.n_type
& 0xff;
2323 /* FIXME: We don't handle all cases here. */
2328 arch
= bfd_xcoff_architecture (abfd
);
2329 machine
= bfd_xcoff_machine (abfd
);
2333 arch
= bfd_arch_powerpc
;
2334 machine
= bfd_mach_ppc_601
;
2336 case 2: /* 64 bit PowerPC */
2337 arch
= bfd_arch_powerpc
;
2338 machine
= bfd_mach_ppc_620
;
2341 arch
= bfd_arch_powerpc
;
2342 machine
= bfd_mach_ppc
;
2345 arch
= bfd_arch_rs6000
;
2346 machine
= bfd_mach_rs6k
;
2355 arch
= bfd_arch_we32k
;
2361 arch
= bfd_arch_h8300
;
2362 machine
= bfd_mach_h8300
;
2363 /* !! FIXME this probably isn't the right place for this. */
2364 abfd
->flags
|= BFD_IS_RELAXABLE
;
2370 arch
= bfd_arch_h8300
;
2371 machine
= bfd_mach_h8300h
;
2372 /* !! FIXME this probably isn't the right place for this. */
2373 abfd
->flags
|= BFD_IS_RELAXABLE
;
2379 arch
= bfd_arch_h8300
;
2380 machine
= bfd_mach_h8300s
;
2381 /* !! FIXME this probably isn't the right place for this. */
2382 abfd
->flags
|= BFD_IS_RELAXABLE
;
2388 arch
= bfd_arch_h8300
;
2389 machine
= bfd_mach_h8300hn
;
2390 /* !! FIXME this probably isn't the right place for this. */
2391 abfd
->flags
|= BFD_IS_RELAXABLE
;
2397 arch
= bfd_arch_h8300
;
2398 machine
= bfd_mach_h8300sn
;
2399 /* !! FIXME this probably isn't the right place for this. */
2400 abfd
->flags
|= BFD_IS_RELAXABLE
;
2404 #ifdef SH_ARCH_MAGIC_BIG
2405 case SH_ARCH_MAGIC_BIG
:
2406 case SH_ARCH_MAGIC_LITTLE
:
2408 case SH_ARCH_MAGIC_WINCE
:
2414 #ifdef MIPS_ARCH_MAGIC_WINCE
2415 case MIPS_ARCH_MAGIC_WINCE
:
2416 arch
= bfd_arch_mips
;
2422 arch
= bfd_arch_h8500
;
2428 #ifdef LYNXCOFFMAGIC
2431 arch
= bfd_arch_sparc
;
2437 arch
= bfd_arch_tic30
;
2442 #ifdef TICOFF_TARGET_ARCH
2443 /* This TI COFF section should be used by all new TI COFF v0 targets. */
2445 arch
= TICOFF_TARGET_ARCH
;
2446 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2452 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */
2453 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */
2456 switch (internal_f
->f_target_id
)
2460 arch
= TICOFF_TARGET_ARCH
;
2461 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2465 arch
= bfd_arch_obscure
;
2467 (_("Unrecognized TI COFF target id '0x%x'"),
2468 internal_f
->f_target_id
);
2474 #ifdef TIC80_ARCH_MAGIC
2475 case TIC80_ARCH_MAGIC
:
2476 arch
= bfd_arch_tic80
;
2482 arch
= bfd_arch_mcore
;
2488 arch
= bfd_arch_w65
;
2492 default: /* Unreadable input file type. */
2493 arch
= bfd_arch_obscure
;
2497 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2501 #ifdef SYMNAME_IN_DEBUG
2504 symname_in_debug_hook (bfd
* abfd ATTRIBUTE_UNUSED
, struct internal_syment
*sym
)
2506 return SYMNAME_IN_DEBUG (sym
) != 0;
2511 #define symname_in_debug_hook \
2512 (bfd_boolean (*) (bfd *, struct internal_syment *)) bfd_false
2519 #define FORCE_SYMNAMES_IN_STRINGS
2522 /* Handle the csect auxent of a C_EXT, C_AIX_WEAKEXT or C_HIDEXT symbol. */
2525 coff_pointerize_aux_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2526 combined_entry_type
*table_base
,
2527 combined_entry_type
*symbol
,
2528 unsigned int indaux
,
2529 combined_entry_type
*aux
)
2531 BFD_ASSERT (symbol
->is_sym
);
2532 int n_sclass
= symbol
->u
.syment
.n_sclass
;
2534 if (CSECT_SYM_P (n_sclass
)
2535 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2537 BFD_ASSERT (! aux
->is_sym
);
2538 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2540 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2541 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2542 aux
->fix_scnlen
= 1;
2545 /* Return TRUE to indicate that the caller should not do any
2546 further work on this auxent. */
2550 /* Return FALSE to indicate that this auxent should be handled by
2558 /* We don't want to pointerize bal entries. */
2561 coff_pointerize_aux_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2562 combined_entry_type
*table_base ATTRIBUTE_UNUSED
,
2563 combined_entry_type
*symbol
,
2564 unsigned int indaux
,
2565 combined_entry_type
*aux ATTRIBUTE_UNUSED
)
2567 /* Return TRUE if we don't want to pointerize this aux entry, which
2568 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2571 && (symbol
->u
.syment
.n_sclass
== C_LEAFPROC
2572 || symbol
->u
.syment
.n_sclass
== C_LEAFSTAT
2573 || symbol
->u
.syment
.n_sclass
== C_LEAFEXT
));
2578 #define coff_pointerize_aux_hook 0
2581 #endif /* ! RS6000COFF_C */
2583 /* Print an aux entry. This returns TRUE if it has printed it. */
2586 coff_print_aux (bfd
*abfd ATTRIBUTE_UNUSED
,
2587 FILE *file ATTRIBUTE_UNUSED
,
2588 combined_entry_type
*table_base ATTRIBUTE_UNUSED
,
2589 combined_entry_type
*symbol ATTRIBUTE_UNUSED
,
2590 combined_entry_type
*aux ATTRIBUTE_UNUSED
,
2591 unsigned int indaux ATTRIBUTE_UNUSED
)
2593 BFD_ASSERT (symbol
->is_sym
);
2594 BFD_ASSERT (! aux
->is_sym
);
2596 if (CSECT_SYM_P (symbol
->u
.syment
.n_sclass
)
2597 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2599 /* This is a csect entry. */
2600 fprintf (file
, "AUX ");
2601 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2603 BFD_ASSERT (! aux
->fix_scnlen
);
2604 fprintf (file
, "val %5" BFD_VMA_FMT
"d",
2605 aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2609 fprintf (file
, "indx ");
2610 if (! aux
->fix_scnlen
)
2611 fprintf (file
, "%4" BFD_VMA_FMT
"d",
2612 aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2614 fprintf (file
, "%4ld",
2615 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2618 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2619 aux
->u
.auxent
.x_csect
.x_parmhash
,
2620 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2621 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2622 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2623 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2624 aux
->u
.auxent
.x_csect
.x_stab
,
2625 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2630 /* Return FALSE to indicate that no special action was taken. */
2638 To write relocations, the back end steps though the
2639 canonical relocation table and create an
2640 @code{internal_reloc}. The symbol index to use is removed from
2641 the @code{offset} field in the symbol table supplied. The
2642 address comes directly from the sum of the section base
2643 address and the relocation offset; the type is dug directly
2644 from the howto field. Then the @code{internal_reloc} is
2645 swapped into the shape of an @code{external_reloc} and written
2653 /* AUX's ld wants relocations to be sorted. */
2655 compare_arelent_ptr (const void * x
, const void * y
)
2657 const arelent
**a
= (const arelent
**) x
;
2658 const arelent
**b
= (const arelent
**) y
;
2659 bfd_size_type aadr
= (*a
)->address
;
2660 bfd_size_type badr
= (*b
)->address
;
2662 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2665 #endif /* TARG_AUX */
2668 coff_write_relocs (bfd
* abfd
, int first_undef
)
2672 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2675 struct external_reloc dst
;
2682 /* Sort relocations before we write them out. */
2685 amt
= s
->reloc_count
;
2686 amt
*= sizeof (arelent
*);
2687 p
= bfd_malloc (amt
);
2690 if (s
->reloc_count
> 0)
2695 memcpy (p
, s
->orelocation
, (size_t) amt
);
2696 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2701 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2705 if (obj_pe (abfd
) && s
->reloc_count
>= 0xffff)
2707 /* Encode real count here as first reloc. */
2708 struct internal_reloc n
;
2710 memset (& n
, 0, sizeof (n
));
2711 /* Add one to count *this* reloc (grr). */
2712 n
.r_vaddr
= s
->reloc_count
+ 1;
2713 coff_swap_reloc_out (abfd
, &n
, &dst
);
2714 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2715 abfd
) != bfd_coff_relsz (abfd
))
2720 for (i
= 0; i
< s
->reloc_count
; i
++)
2722 struct internal_reloc n
;
2725 memset (& n
, 0, sizeof (n
));
2727 /* Now we've renumbered the symbols we know where the
2728 undefined symbols live in the table. Check the reloc
2729 entries for symbols who's output bfd isn't the right one.
2730 This is because the symbol was undefined (which means
2731 that all the pointers are never made to point to the same
2732 place). This is a bad thing,'cause the symbols attached
2733 to the output bfd are indexed, so that the relocation
2734 entries know which symbol index they point to. So we
2735 have to look up the output symbol here. */
2737 if (q
->sym_ptr_ptr
[0] != NULL
&& q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2740 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2741 asymbol
**outsyms
= abfd
->outsymbols
;
2743 for (j
= first_undef
; outsyms
[j
]; j
++)
2745 const char *intable
= outsyms
[j
]->name
;
2747 if (strcmp (intable
, sname
) == 0)
2749 /* Got a hit, so repoint the reloc. */
2750 q
->sym_ptr_ptr
= outsyms
+ j
;
2756 n
.r_vaddr
= q
->address
+ s
->vma
;
2759 /* The 29k const/consth reloc pair is a real kludge. The consth
2760 part doesn't have a symbol; it has an offset. So rebuilt
2762 if (q
->howto
->type
== R_IHCONST
)
2763 n
.r_symndx
= q
->addend
;
2766 if (q
->sym_ptr_ptr
&& q
->sym_ptr_ptr
[0] != NULL
)
2768 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2769 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
, s
))
2771 if ((*q
->sym_ptr_ptr
)->section
== bfd_abs_section_ptr
2772 && ((*q
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) != 0)
2774 /* This is a relocation relative to the absolute symbol. */
2778 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2779 /* Check to see if the symbol reloc points to a symbol
2780 we don't have in our symbol table. */
2781 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2783 bfd_set_error (bfd_error_bad_value
);
2784 /* xgettext:c-format */
2785 _bfd_error_handler (_("%B: reloc against a non-existent"
2786 " symbol index: %ld"),
2793 #ifdef SWAP_OUT_RELOC_OFFSET
2794 n
.r_offset
= q
->addend
;
2798 /* Work out reloc type from what is required. */
2799 SELECT_RELOC (n
, q
->howto
);
2801 n
.r_type
= q
->howto
->type
;
2803 coff_swap_reloc_out (abfd
, &n
, &dst
);
2805 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2806 abfd
) != bfd_coff_relsz (abfd
))
2819 /* Set flags and magic number of a coff file from architecture and machine
2820 type. Result is TRUE if we can represent the arch&type, FALSE if not. */
2823 coff_set_flags (bfd
* abfd
,
2824 unsigned int *magicp ATTRIBUTE_UNUSED
,
2825 unsigned short *flagsp ATTRIBUTE_UNUSED
)
2827 switch (bfd_get_arch (abfd
))
2832 switch (bfd_get_mach (abfd
))
2835 case bfd_mach_z80strict
:
2837 case bfd_mach_z80full
:
2839 *flagsp
= bfd_get_mach (abfd
) << 12;
2851 switch (bfd_get_mach (abfd
))
2853 case bfd_mach_z8001
: *flagsp
= F_Z8001
; break;
2854 case bfd_mach_z8002
: *flagsp
= F_Z8002
; break;
2855 default: return FALSE
;
2866 *magicp
= I960ROMAGIC
;
2868 switch (bfd_get_mach (abfd
))
2870 case bfd_mach_i960_core
: flags
= F_I960CORE
; break;
2871 case bfd_mach_i960_kb_sb
: flags
= F_I960KB
; break;
2872 case bfd_mach_i960_mc
: flags
= F_I960MC
; break;
2873 case bfd_mach_i960_xa
: flags
= F_I960XA
; break;
2874 case bfd_mach_i960_ca
: flags
= F_I960CA
; break;
2875 case bfd_mach_i960_ka_sa
: flags
= F_I960KA
; break;
2876 case bfd_mach_i960_jx
: flags
= F_I960JX
; break;
2877 case bfd_mach_i960_hx
: flags
= F_I960HX
; break;
2878 default: return FALSE
;
2887 case bfd_arch_tic30
:
2888 *magicp
= TIC30MAGIC
;
2892 #ifdef TICOFF_DEFAULT_MAGIC
2893 case TICOFF_TARGET_ARCH
:
2894 /* If there's no indication of which version we want, use the default. */
2896 *magicp
= TICOFF_DEFAULT_MAGIC
;
2899 /* We may want to output in a different COFF version. */
2900 switch (abfd
->xvec
->name
[4])
2903 *magicp
= TICOFF0MAGIC
;
2906 *magicp
= TICOFF1MAGIC
;
2909 *magicp
= TICOFF2MAGIC
;
2915 TICOFF_TARGET_MACHINE_SET (flagsp
, bfd_get_mach (abfd
));
2919 #ifdef TIC80_ARCH_MAGIC
2920 case bfd_arch_tic80
:
2921 *magicp
= TIC80_ARCH_MAGIC
;
2928 * magicp
= ARMPEMAGIC
;
2930 * magicp
= ARMMAGIC
;
2933 if (APCS_SET (abfd
))
2935 if (APCS_26_FLAG (abfd
))
2936 * flagsp
|= F_APCS26
;
2938 if (APCS_FLOAT_FLAG (abfd
))
2939 * flagsp
|= F_APCS_FLOAT
;
2941 if (PIC_FLAG (abfd
))
2944 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2945 * flagsp
|= F_INTERWORK
;
2946 switch (bfd_get_mach (abfd
))
2948 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2949 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2950 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2951 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2952 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2953 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2954 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2955 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2956 See also the comment in coff_set_arch_mach_hook(). */
2957 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break;
2958 case bfd_mach_arm_5TE
: * flagsp
|= F_ARM_5
; break;
2959 case bfd_mach_arm_XScale
: * flagsp
|= F_ARM_5
; break;
2965 case bfd_arch_powerpc
:
2970 #if defined(I386MAGIC) || defined(AMD64MAGIC)
2972 #if defined(I386MAGIC)
2973 *magicp
= I386MAGIC
;
2976 /* Just overwrite the usual value if we're doing Lynx. */
2977 *magicp
= LYNXCOFFMAGIC
;
2979 #if defined AMD64MAGIC
2980 *magicp
= AMD64MAGIC
;
2987 *magicp
= I860MAGIC
;
2993 *magicp
= IA64MAGIC
;
2999 #ifdef APOLLOM68KMAGIC
3000 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
3002 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
3003 #ifdef NAMES_HAVE_UNDERSCORE
3004 *magicp
= MC68KBCSMAGIC
;
3006 *magicp
= MC68MAGIC
;
3010 /* Just overwrite the usual value if we're doing Lynx. */
3011 *magicp
= LYNXCOFFMAGIC
;
3018 *magicp
= MC88OMAGIC
;
3023 case bfd_arch_h8300
:
3024 switch (bfd_get_mach (abfd
))
3026 case bfd_mach_h8300
: *magicp
= H8300MAGIC
; return TRUE
;
3027 case bfd_mach_h8300h
: *magicp
= H8300HMAGIC
; return TRUE
;
3028 case bfd_mach_h8300s
: *magicp
= H8300SMAGIC
; return TRUE
;
3029 case bfd_mach_h8300hn
: *magicp
= H8300HNMAGIC
; return TRUE
;
3030 case bfd_mach_h8300sn
: *magicp
= H8300SNMAGIC
; return TRUE
;
3036 #ifdef SH_ARCH_MAGIC_BIG
3038 #ifdef COFF_IMAGE_WITH_PE
3039 *magicp
= SH_ARCH_MAGIC_WINCE
;
3041 if (bfd_big_endian (abfd
))
3042 *magicp
= SH_ARCH_MAGIC_BIG
;
3044 *magicp
= SH_ARCH_MAGIC_LITTLE
;
3049 #ifdef MIPS_ARCH_MAGIC_WINCE
3051 *magicp
= MIPS_ARCH_MAGIC_WINCE
;
3056 case bfd_arch_sparc
:
3057 *magicp
= SPARCMAGIC
;
3059 /* Just overwrite the usual value if we're doing Lynx. */
3060 *magicp
= LYNXCOFFMAGIC
;
3066 case bfd_arch_h8500
:
3067 *magicp
= H8500MAGIC
;
3073 case bfd_arch_we32k
:
3074 *magicp
= WE32KMAGIC
;
3079 case bfd_arch_rs6000
:
3081 case bfd_arch_powerpc
:
3083 BFD_ASSERT (bfd_get_flavour (abfd
) == bfd_target_xcoff_flavour
);
3084 *magicp
= bfd_xcoff_magic_number (abfd
);
3089 case bfd_arch_mcore
:
3090 * magicp
= MCOREMAGIC
;
3100 default: /* Unknown architecture. */
3101 /* Fall through to "return FALSE" below, to avoid
3102 "statement never reached" errors on the one below. */
3110 coff_set_arch_mach (bfd
* abfd
,
3111 enum bfd_architecture arch
,
3112 unsigned long machine
)
3115 unsigned short dummy2
;
3117 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
3120 if (arch
!= bfd_arch_unknown
3121 && ! coff_set_flags (abfd
, &dummy1
, &dummy2
))
3122 return FALSE
; /* We can't represent this type. */
3124 return TRUE
; /* We're easy... */
3127 #ifdef COFF_IMAGE_WITH_PE
3129 /* This is used to sort sections by VMA, as required by PE image
3133 sort_by_secaddr (const void * arg1
, const void * arg2
)
3135 const asection
*a
= *(const asection
**) arg1
;
3136 const asection
*b
= *(const asection
**) arg2
;
3138 if (a
->vma
< b
->vma
)
3140 else if (a
->vma
> b
->vma
)
3146 #endif /* COFF_IMAGE_WITH_PE */
3148 /* Calculate the file position for each section. */
3151 #define ALIGN_SECTIONS_IN_FILE
3153 #if defined(TIC80COFF) || defined(TICOFF)
3154 #undef ALIGN_SECTIONS_IN_FILE
3158 coff_compute_section_file_positions (bfd
* abfd
)
3161 file_ptr sofar
= bfd_coff_filhsz (abfd
);
3162 bfd_boolean align_adjust
;
3163 unsigned int target_index
;
3164 #ifdef ALIGN_SECTIONS_IN_FILE
3165 asection
*previous
= NULL
;
3169 #ifdef COFF_IMAGE_WITH_PE
3172 if (coff_data (abfd
)->link_info
3173 || (pe_data (abfd
) && pe_data (abfd
)->pe_opthdr
.FileAlignment
))
3175 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
3177 /* If no file alignment has been set, default to one.
3178 This repairs 'ld -r' for arm-wince-pe target. */
3182 /* PR 17512: file: 0ac816d3. */
3185 bfd_set_error (bfd_error_file_too_big
);
3187 /* xgettext:c-format */
3188 (_("%B: page size is too large (0x%x)"), abfd
, page_size
);
3193 page_size
= PE_DEF_FILE_ALIGNMENT
;
3195 #ifdef COFF_PAGE_SIZE
3196 int page_size
= COFF_PAGE_SIZE
;
3201 /* On XCOFF, if we have symbols, set up the .debug section. */
3202 if (bfd_get_symcount (abfd
) > 0)
3205 bfd_size_type i
, symcount
;
3209 symcount
= bfd_get_symcount (abfd
);
3210 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
3212 coff_symbol_type
*cf
;
3214 cf
= coff_symbol_from (*symp
);
3216 && cf
->native
!= NULL
3217 && cf
->native
->is_sym
3218 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
3222 len
= strlen (bfd_asymbol_name (*symp
));
3223 if (len
> SYMNMLEN
|| bfd_coff_force_symnames_in_strings (abfd
))
3224 sz
+= len
+ 1 + bfd_coff_debug_string_prefix_length (abfd
);
3231 dsec
= bfd_make_section_old_way (abfd
, DOT_DEBUG
);
3235 dsec
->flags
|= SEC_HAS_CONTENTS
;
3240 if (bfd_get_start_address (abfd
))
3241 /* A start address may have been added to the original file. In this
3242 case it will need an optional header to record it. */
3243 abfd
->flags
|= EXEC_P
;
3245 if (abfd
->flags
& EXEC_P
)
3246 sofar
+= bfd_coff_aoutsz (abfd
);
3248 else if (xcoff_data (abfd
)->full_aouthdr
)
3249 sofar
+= bfd_coff_aoutsz (abfd
);
3251 sofar
+= SMALL_AOUTSZ
;
3254 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
3257 /* XCOFF handles overflows in the reloc and line number count fields
3258 by allocating a new section header to hold the correct counts. */
3259 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3260 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3261 sofar
+= bfd_coff_scnhsz (abfd
);
3264 #ifdef COFF_IMAGE_WITH_PE
3266 /* PE requires the sections to be in memory order when listed in
3267 the section headers. It also does not like empty loadable
3268 sections. The sections apparently do not have to be in the
3269 right order in the image file itself, but we do need to get the
3270 target_index values right. */
3273 asection
**section_list
;
3277 #ifdef COFF_PAGE_SIZE
3278 /* Clear D_PAGED if section alignment is smaller than
3280 if (pe_data (abfd
)->pe_opthdr
.SectionAlignment
< COFF_PAGE_SIZE
)
3281 abfd
->flags
&= ~D_PAGED
;
3285 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3288 /* We allocate an extra cell to simplify the final loop. */
3289 amt
= sizeof (struct asection
*) * (count
+ 1);
3290 section_list
= (asection
**) bfd_malloc (amt
);
3291 if (section_list
== NULL
)
3295 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3297 section_list
[i
] = current
;
3300 section_list
[i
] = NULL
;
3302 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
3304 /* Rethread the linked list into sorted order; at the same time,
3305 assign target_index values. */
3307 abfd
->sections
= NULL
;
3308 abfd
->section_last
= NULL
;
3309 for (i
= 0; i
< count
; i
++)
3311 current
= section_list
[i
];
3312 bfd_section_list_append (abfd
, current
);
3314 /* Later, if the section has zero size, we'll be throwing it
3315 away, so we don't want to number it now. Note that having
3316 a zero size and having real contents are different
3317 concepts: .bss has no contents, but (usually) non-zero
3319 if (current
->size
== 0)
3321 /* Discard. However, it still might have (valid) symbols
3322 in it, so arbitrarily set it to section 1 (indexing is
3323 1-based here; usually .text). __end__ and other
3324 contents of .endsection really have this happen.
3325 FIXME: This seems somewhat dubious. */
3326 current
->target_index
= 1;
3329 current
->target_index
= target_index
++;
3332 free (section_list
);
3334 #else /* ! COFF_IMAGE_WITH_PE */
3336 /* Set the target_index field. */
3338 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3339 current
->target_index
= target_index
++;
3341 #endif /* ! COFF_IMAGE_WITH_PE */
3343 if (target_index
>= bfd_coff_max_nscns (abfd
))
3345 bfd_set_error (bfd_error_file_too_big
);
3347 /* xgettext:c-format */
3348 (_("%B: too many sections (%d)"), abfd
, target_index
);
3352 align_adjust
= FALSE
;
3353 for (current
= abfd
->sections
;
3355 current
= current
->next
)
3357 #ifdef COFF_IMAGE_WITH_PE
3358 /* With PE we have to pad each section to be a multiple of its
3359 page size too, and remember both sizes. */
3360 if (coff_section_data (abfd
, current
) == NULL
)
3362 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
3364 current
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
3365 if (current
->used_by_bfd
== NULL
)
3368 if (pei_section_data (abfd
, current
) == NULL
)
3370 bfd_size_type amt
= sizeof (struct pei_section_tdata
);
3372 coff_section_data (abfd
, current
)->tdata
= bfd_zalloc (abfd
, amt
);
3373 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
3376 if (pei_section_data (abfd
, current
)->virt_size
== 0)
3377 pei_section_data (abfd
, current
)->virt_size
= current
->size
;
3380 /* Only deal with sections which have contents. */
3381 if (!(current
->flags
& SEC_HAS_CONTENTS
))
3384 current
->rawsize
= current
->size
;
3386 #ifdef COFF_IMAGE_WITH_PE
3387 /* Make sure we skip empty sections in a PE image. */
3388 if (current
->size
== 0)
3392 /* Align the sections in the file to the same boundary on
3393 which they are aligned in virtual memory. I960 doesn't
3394 do this (FIXME) so we can stay in sync with Intel. 960
3395 doesn't yet page from files... */
3396 #ifdef ALIGN_SECTIONS_IN_FILE
3397 if ((abfd
->flags
& EXEC_P
) != 0)
3399 /* Make sure this section is aligned on the right boundary - by
3400 padding the previous section up if necessary. */
3403 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3406 /* Make sure the file offset and the vma of .text/.data are at the
3407 same page offset, so that the file can be mmap'ed without being
3408 relocated. Failing that, AIX is able to load and execute the
3409 program, but it will be silently relocated (possible as
3410 executables are PIE). But the relocation is slightly costly and
3411 complexify the use of addr2line or gdb. So better to avoid it,
3412 like does the native linker. Usually gnu ld makes sure that
3413 the vma of .text is the file offset so this issue shouldn't
3414 appear unless you are stripping such an executable.
3416 AIX loader checks the text section alignment of (vma - filepos),
3417 and the native linker doesn't try to align the text sections.
3420 0 .text 000054cc 10000128 10000128 00000128 2**5
3421 CONTENTS, ALLOC, LOAD, CODE
3424 if (!strcmp (current
->name
, _TEXT
)
3425 || !strcmp (current
->name
, _DATA
))
3427 bfd_vma align
= 4096;
3428 bfd_vma sofar_off
= sofar
% align
;
3429 bfd_vma vma_off
= current
->vma
% align
;
3431 if (vma_off
> sofar_off
)
3432 sofar
+= vma_off
- sofar_off
;
3433 else if (vma_off
< sofar_off
)
3434 sofar
+= align
+ vma_off
- sofar_off
;
3437 if (previous
!= NULL
)
3438 previous
->size
+= sofar
- old_sofar
;
3443 /* In demand paged files the low order bits of the file offset
3444 must match the low order bits of the virtual address. */
3445 #ifdef COFF_PAGE_SIZE
3446 if ((abfd
->flags
& D_PAGED
) != 0
3447 && (current
->flags
& SEC_ALLOC
) != 0)
3448 sofar
+= (current
->vma
- (bfd_vma
) sofar
) % page_size
;
3450 current
->filepos
= sofar
;
3452 #ifdef COFF_IMAGE_WITH_PE
3453 /* Set the padded size. */
3454 current
->size
= (current
->size
+ page_size
- 1) & -page_size
;
3457 sofar
+= current
->size
;
3459 #ifdef ALIGN_SECTIONS_IN_FILE
3460 /* Make sure that this section is of the right size too. */
3461 if ((abfd
->flags
& EXEC_P
) == 0)
3463 bfd_size_type old_size
;
3465 old_size
= current
->size
;
3466 current
->size
= BFD_ALIGN (current
->size
,
3467 1 << current
->alignment_power
);
3468 align_adjust
= current
->size
!= old_size
;
3469 sofar
+= current
->size
- old_size
;
3474 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3475 align_adjust
= sofar
!= old_sofar
;
3476 current
->size
+= sofar
- old_sofar
;
3480 #ifdef COFF_IMAGE_WITH_PE
3481 /* For PE we need to make sure we pad out to the aligned
3482 size, in case the caller only writes out data to the
3484 if (pei_section_data (abfd
, current
)->virt_size
< current
->size
)
3485 align_adjust
= TRUE
;
3489 /* Force .lib sections to start at zero. The vma is then
3490 incremented in coff_set_section_contents. This is right for
3492 if (strcmp (current
->name
, _LIB
) == 0)
3493 (void) bfd_set_section_vma (abfd
, current
, 0);
3496 #ifdef ALIGN_SECTIONS_IN_FILE
3501 /* It is now safe to write to the output file. If we needed an
3502 alignment adjustment for the last section, then make sure that
3503 there is a byte at offset sofar. If there are no symbols and no
3504 relocs, then nothing follows the last section. If we don't force
3505 the last byte out, then the file may appear to be truncated. */
3511 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
3512 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3516 /* Make sure the relocations are aligned. We don't need to make
3517 sure that this byte exists, because it will only matter if there
3518 really are relocs. */
3519 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
3521 obj_relocbase (abfd
) = sofar
;
3522 abfd
->output_has_begun
= TRUE
;
3527 #ifdef COFF_IMAGE_WITH_PE
3529 static unsigned int pelength
;
3530 static unsigned int peheader
;
3533 coff_read_word (bfd
*abfd
, unsigned int *value
)
3538 status
= bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3546 *value
= (unsigned int) b
[0];
3548 *value
= (unsigned int) (b
[0] + (b
[1] << 8));
3550 pelength
+= (unsigned int) status
;
3556 coff_compute_checksum (bfd
*abfd
)
3558 bfd_boolean more_data
;
3565 filepos
= (file_ptr
) 0;
3569 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
3572 more_data
= coff_read_word (abfd
, &value
);
3574 total
= 0xffff & (total
+ (total
>> 0x10));
3579 return (0xffff & (total
+ (total
>> 0x10)));
3583 coff_apply_checksum (bfd
*abfd
)
3585 unsigned int computed
;
3586 unsigned int checksum
= 0;
3588 if (bfd_seek (abfd
, 0x3c, SEEK_SET
) != 0)
3591 if (!coff_read_word (abfd
, &peheader
))
3594 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3598 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3600 if (bfd_seek (abfd
, peheader
, SEEK_SET
) != 0)
3603 computed
= coff_compute_checksum (abfd
);
3605 checksum
= computed
+ pelength
;
3607 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3610 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3615 #endif /* COFF_IMAGE_WITH_PE */
3618 coff_write_object_contents (bfd
* abfd
)
3621 bfd_boolean hasrelocs
= FALSE
;
3622 bfd_boolean haslinno
= FALSE
;
3623 #ifdef COFF_IMAGE_WITH_PE
3624 bfd_boolean hasdebug
= FALSE
;
3627 file_ptr reloc_base
;
3628 file_ptr lineno_base
;
3630 unsigned long reloc_size
= 0, reloc_count
= 0;
3631 unsigned long lnno_size
= 0;
3632 bfd_boolean long_section_names
;
3633 asection
*text_sec
= NULL
;
3634 asection
*data_sec
= NULL
;
3635 asection
*bss_sec
= NULL
;
3636 struct internal_filehdr internal_f
;
3637 struct internal_aouthdr internal_a
;
3638 #ifdef COFF_LONG_SECTION_NAMES
3639 size_t string_size
= STRING_SIZE_SIZE
;
3642 bfd_set_error (bfd_error_system_call
);
3644 /* Make a pass through the symbol table to count line number entries and
3645 put them into the correct asections. */
3646 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3648 if (! abfd
->output_has_begun
)
3650 if (! coff_compute_section_file_positions (abfd
))
3654 reloc_base
= obj_relocbase (abfd
);
3656 /* Work out the size of the reloc and linno areas. */
3658 for (current
= abfd
->sections
; current
!= NULL
; current
=
3662 /* We store the actual reloc count in the first reloc's addr. */
3663 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3666 reloc_count
+= current
->reloc_count
;
3669 reloc_size
= reloc_count
* bfd_coff_relsz (abfd
);
3671 lineno_base
= reloc_base
+ reloc_size
;
3672 sym_base
= lineno_base
+ lnno_size
;
3674 /* Indicate in each section->line_filepos its actual file address. */
3675 for (current
= abfd
->sections
; current
!= NULL
; current
=
3678 if (current
->lineno_count
)
3680 current
->line_filepos
= lineno_base
;
3681 current
->moving_line_filepos
= lineno_base
;
3682 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3685 current
->line_filepos
= 0;
3687 if (current
->reloc_count
)
3689 current
->rel_filepos
= reloc_base
;
3690 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3692 /* Extra reloc to hold real count. */
3693 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3694 reloc_base
+= bfd_coff_relsz (abfd
);
3698 current
->rel_filepos
= 0;
3701 /* Write section headers to the file. */
3702 internal_f
.f_nscns
= 0;
3704 if ((abfd
->flags
& EXEC_P
) != 0)
3705 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3708 scn_base
= bfd_coff_filhsz (abfd
);
3711 if (xcoff_data (abfd
)->full_aouthdr
)
3712 scn_base
+= bfd_coff_aoutsz (abfd
);
3714 scn_base
+= SMALL_AOUTSZ
;
3719 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3722 long_section_names
= FALSE
;
3723 for (current
= abfd
->sections
;
3725 current
= current
->next
)
3727 struct internal_scnhdr section
;
3728 #ifdef COFF_IMAGE_WITH_PE
3729 bfd_boolean is_reloc_section
= FALSE
;
3731 if (strcmp (current
->name
, DOT_RELOC
) == 0)
3733 is_reloc_section
= TRUE
;
3735 pe_data (abfd
)->has_reloc_section
= 1;
3739 internal_f
.f_nscns
++;
3741 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3743 #ifdef COFF_LONG_SECTION_NAMES
3744 /* Handle long section names as in PE. This must be compatible
3745 with the code in coff_write_symbols and _bfd_coff_final_link. */
3746 if (bfd_coff_long_section_names (abfd
))
3750 len
= strlen (current
->name
);
3753 /* The s_name field is defined to be NUL-padded but need not be
3754 NUL-terminated. We use a temporary buffer so that we can still
3755 sprintf all eight chars without splatting a terminating NUL
3756 over the first byte of the following member (s_paddr). */
3757 /* PR 21096: The +20 is to stop a bogus warning from gcc7 about
3758 a possible buffer overflow. */
3759 char s_name_buf
[SCNNMLEN
+ 1 + 20];
3761 /* An inherent limitation of the /nnnnnnn notation used to indicate
3762 the offset of the long name in the string table is that we
3763 cannot address entries beyone the ten million byte boundary. */
3764 if (string_size
>= 10000000)
3766 bfd_set_error (bfd_error_file_too_big
);
3768 /* xgettext:c-format */
3769 (_("%B: section %A: string table overflow at offset %ld"),
3770 abfd
, current
, (unsigned long) string_size
);
3774 /* We do not need to use snprintf here as we have already verfied
3775 that string_size is not too big, plus we have an overlarge
3776 buffer, just in case. */
3777 sprintf (s_name_buf
, "/%lu", (unsigned long) string_size
);
3778 /* Then strncpy takes care of any padding for us. */
3779 strncpy (section
.s_name
, s_name_buf
, SCNNMLEN
);
3780 string_size
+= len
+ 1;
3781 long_section_names
= TRUE
;
3787 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3788 Ian Taylor <ian@cygnus.com>. */
3789 if (strcmp (current
->name
, _LIB
) == 0)
3790 section
.s_vaddr
= 0;
3793 section
.s_vaddr
= current
->vma
;
3794 section
.s_paddr
= current
->lma
;
3795 section
.s_size
= current
->size
;
3796 #ifdef coff_get_section_load_page
3797 section
.s_page
= coff_get_section_load_page (current
);
3803 section
.s_paddr
= 0;
3805 #ifdef COFF_IMAGE_WITH_PE
3806 /* Reminder: s_paddr holds the virtual size of the section. */
3807 if (coff_section_data (abfd
, current
) != NULL
3808 && pei_section_data (abfd
, current
) != NULL
)
3809 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3811 section
.s_paddr
= 0;
3814 /* If this section has no size or is unloadable then the scnptr
3816 if (current
->size
== 0
3817 || (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3818 section
.s_scnptr
= 0;
3820 section
.s_scnptr
= current
->filepos
;
3822 section
.s_relptr
= current
->rel_filepos
;
3823 section
.s_lnnoptr
= current
->line_filepos
;
3824 section
.s_nreloc
= current
->reloc_count
;
3825 section
.s_nlnno
= current
->lineno_count
;
3826 #ifndef COFF_IMAGE_WITH_PE
3827 /* In PEI, relocs come in the .reloc section. */
3828 if (current
->reloc_count
!= 0)
3831 if (current
->lineno_count
!= 0)
3833 #ifdef COFF_IMAGE_WITH_PE
3834 if ((current
->flags
& SEC_DEBUGGING
) != 0
3835 && ! is_reloc_section
)
3841 /* Indicate the use of an XCOFF overflow section header. */
3842 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3844 section
.s_nreloc
= 0xffff;
3845 section
.s_nlnno
= 0xffff;
3850 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3852 if (!strcmp (current
->name
, _TEXT
))
3854 else if (!strcmp (current
->name
, _DATA
))
3856 else if (!strcmp (current
->name
, _BSS
))
3860 section
.s_align
= (current
->alignment_power
3861 ? 1 << current
->alignment_power
3864 #ifdef COFF_ENCODE_ALIGNMENT
3865 COFF_ENCODE_ALIGNMENT(section
, current
->alignment_power
);
3866 if ((unsigned int)COFF_DECODE_ALIGNMENT(section
.s_flags
)
3867 != current
->alignment_power
)
3869 bfd_boolean warn
= coff_data (abfd
)->link_info
3870 && !bfd_link_relocatable (coff_data (abfd
)->link_info
);
3873 /* xgettext:c-format */
3874 (_("%B:%s section %s: alignment 2**%u not representable"),
3875 abfd
, warn
? " warning:" : "", current
->name
,
3876 current
->alignment_power
);
3879 bfd_set_error (bfd_error_nonrepresentable_section
);
3885 #ifdef COFF_IMAGE_WITH_PE
3886 /* Suppress output of the sections if they are null. ld
3887 includes the bss and data sections even if there is no size
3888 assigned to them. NT loader doesn't like it if these section
3889 headers are included if the sections themselves are not
3890 needed. See also coff_compute_section_file_positions. */
3891 if (section
.s_size
== 0)
3892 internal_f
.f_nscns
--;
3897 bfd_size_type amt
= bfd_coff_scnhsz (abfd
);
3899 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3900 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3905 /* PE stores COMDAT section information in the symbol table. If
3906 this section is supposed to have some COMDAT info, track down
3907 the symbol in the symbol table and modify it. */
3908 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3910 unsigned int i
, count
;
3912 coff_symbol_type
*csym
= NULL
;
3916 count
= bfd_get_symcount (abfd
);
3917 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3919 if ((*psym
)->section
!= current
)
3922 /* Remember the location of the first symbol in this
3924 if (psymsec
== NULL
)
3927 /* See if this is the section symbol. */
3928 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3930 csym
= coff_symbol_from (*psym
);
3932 || csym
->native
== NULL
3933 || ! csym
->native
->is_sym
3934 || csym
->native
->u
.syment
.n_numaux
< 1
3935 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3936 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3939 /* Here *PSYM is the section symbol for CURRENT. */
3946 Note that we might not if we're converting the file from
3947 some other object file format. */
3950 combined_entry_type
*aux
;
3952 /* We don't touch the x_checksum field. The
3953 x_associated field is not currently supported. */
3955 aux
= csym
->native
+ 1;
3956 BFD_ASSERT (! aux
->is_sym
);
3957 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3959 case SEC_LINK_DUPLICATES_DISCARD
:
3960 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3963 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3964 aux
->u
.auxent
.x_scn
.x_comdat
=
3965 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3968 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3969 aux
->u
.auxent
.x_scn
.x_comdat
=
3970 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3973 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3974 aux
->u
.auxent
.x_scn
.x_comdat
=
3975 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3979 /* The COMDAT symbol must be the first symbol from this
3980 section in the symbol table. In order to make this
3981 work, we move the COMDAT symbol before the first
3982 symbol we found in the search above. It's OK to
3983 rearrange the symbol table at this point, because
3984 coff_renumber_symbols is going to rearrange it
3985 further and fix up all the aux entries. */
3986 if (psym
!= psymsec
)
3992 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3993 pcopy
[0] = pcopy
[-1];
3998 #endif /* COFF_WITH_PE */
4003 /* XCOFF handles overflows in the reloc and line number count fields
4004 by creating a new section header to hold the correct values. */
4005 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
4007 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
4009 struct internal_scnhdr scnhdr
;
4013 internal_f
.f_nscns
++;
4014 memcpy (scnhdr
.s_name
, ".ovrflo", 8);
4015 scnhdr
.s_paddr
= current
->reloc_count
;
4016 scnhdr
.s_vaddr
= current
->lineno_count
;
4018 scnhdr
.s_scnptr
= 0;
4019 scnhdr
.s_relptr
= current
->rel_filepos
;
4020 scnhdr
.s_lnnoptr
= current
->line_filepos
;
4021 scnhdr
.s_nreloc
= current
->target_index
;
4022 scnhdr
.s_nlnno
= current
->target_index
;
4023 scnhdr
.s_flags
= STYP_OVRFLO
;
4024 amt
= bfd_coff_scnhsz (abfd
);
4025 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
4026 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
4033 /* OK, now set up the filehdr... */
4035 /* Don't include the internal abs section in the section count */
4037 /* We will NOT put a fucking timestamp in the header here. Every time you
4038 put it back, I will come in and take it out again. I'm sorry. This
4039 field does not belong here. We fill it with a 0 so it compares the
4040 same but is not a reasonable time. -- gnu@cygnus.com */
4041 internal_f
.f_timdat
= 0;
4042 internal_f
.f_flags
= 0;
4044 if (abfd
->flags
& EXEC_P
)
4045 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
4048 internal_f
.f_opthdr
= 0;
4051 if (xcoff_data (abfd
)->full_aouthdr
)
4052 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
4054 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
4060 internal_f
.f_flags
|= F_RELFLG
;
4062 internal_f
.f_flags
|= F_LNNO
;
4063 if (abfd
->flags
& EXEC_P
)
4064 internal_f
.f_flags
|= F_EXEC
;
4065 #ifdef COFF_IMAGE_WITH_PE
4067 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
4068 if (pe_data (abfd
)->real_flags
& IMAGE_FILE_LARGE_ADDRESS_AWARE
)
4069 internal_f
.f_flags
|= IMAGE_FILE_LARGE_ADDRESS_AWARE
;
4072 #ifndef COFF_WITH_pex64
4074 internal_f
.f_flags
|= IMAGE_FILE_32BIT_MACHINE
;
4076 if (bfd_little_endian (abfd
))
4077 internal_f
.f_flags
|= F_AR32WR
;
4079 internal_f
.f_flags
|= F_AR32W
;
4084 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
4085 but it doesn't hurt to set it internally. */
4086 internal_f
.f_target_id
= TI_TARGET_ID
;
4088 #ifdef TIC80_TARGET_ID
4089 internal_f
.f_target_id
= TIC80_TARGET_ID
;
4092 /* FIXME, should do something about the other byte orders and
4096 if ((abfd
->flags
& DYNAMIC
) != 0)
4097 internal_f
.f_flags
|= F_SHROBJ
;
4098 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
4099 internal_f
.f_flags
|= F_DYNLOAD
;
4102 memset (&internal_a
, 0, sizeof internal_a
);
4104 /* Set up architecture-dependent stuff. */
4106 unsigned int magic
= 0;
4107 unsigned short flags
= 0;
4109 coff_set_flags (abfd
, &magic
, &flags
);
4110 internal_f
.f_magic
= magic
;
4111 internal_f
.f_flags
|= flags
;
4112 /* ...and the "opt"hdr... */
4114 #ifdef TICOFF_AOUT_MAGIC
4115 internal_a
.magic
= TICOFF_AOUT_MAGIC
;
4116 #define __A_MAGIC_SET__
4119 internal_a
.magic
= TIC80_ARCH_MAGIC
;
4120 #define __A_MAGIC_SET__
4123 /* FIXME: What are the a.out magic numbers for the i860? */
4124 internal_a
.magic
= 0;
4125 #define __A_MAGIC_SET__
4128 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
4129 #define __A_MAGIC_SET__
4132 #define __A_MAGIC_SET__
4133 internal_a
.magic
= PAGEMAGICBCS
;
4137 #define __A_MAGIC_SET__
4138 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
4141 #if defined(M68) || defined(WE32K) || defined(M68K)
4142 #define __A_MAGIC_SET__
4144 internal_a
.magic
= LYNXCOFFMAGIC
;
4146 #if defined(TARG_AUX)
4147 internal_a
.magic
= (abfd
->flags
& D_PAGED
? PAGEMAGICPEXECPAGED
:
4148 abfd
->flags
& WP_TEXT
? PAGEMAGICPEXECSWAPPED
:
4149 PAGEMAGICEXECSWAPPED
);
4151 #if defined (PAGEMAGICPEXECPAGED)
4152 internal_a
.magic
= PAGEMAGICPEXECPAGED
;
4154 #endif /* TARG_AUX */
4156 #endif /* M68 || WE32K || M68K */
4159 #define __A_MAGIC_SET__
4160 internal_a
.magic
= ZMAGIC
;
4164 #define __A_MAGIC_SET__
4165 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
4168 #if defined MCORE_PE
4169 #define __A_MAGIC_SET__
4170 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
4174 #define __A_MAGIC_SET__
4176 internal_a
.magic
= LYNXCOFFMAGIC
;
4178 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR64_MAGIC
;
4180 internal_a
.magic
= ZMAGIC
;
4185 #define __A_MAGIC_SET__
4186 internal_a
.magic
= PE32PMAGIC
;
4190 #define __A_MAGIC_SET__
4192 internal_a
.magic
= LYNXCOFFMAGIC
;
4197 #define __A_MAGIC_SET__
4198 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
4199 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
4200 RS6K_AOUTHDR_OMAGIC
;
4203 #if defined(SH) && defined(COFF_WITH_PE)
4204 #define __A_MAGIC_SET__
4205 internal_a
.magic
= SH_PE_MAGIC
;
4208 #if defined(MIPS) && defined(COFF_WITH_PE)
4209 #define __A_MAGIC_SET__
4210 internal_a
.magic
= MIPS_PE_MAGIC
;
4213 #ifndef __A_MAGIC_SET__
4214 #include "Your aouthdr magic number is not being set!"
4216 #undef __A_MAGIC_SET__
4220 /* FIXME: Does anybody ever set this to another value? */
4221 internal_a
.vstamp
= 0;
4223 /* Now should write relocs, strings, syms. */
4224 obj_sym_filepos (abfd
) = sym_base
;
4226 if (bfd_get_symcount (abfd
) != 0)
4230 if (!coff_renumber_symbols (abfd
, &firstundef
))
4232 coff_mangle_symbols (abfd
);
4233 if (! coff_write_symbols (abfd
))
4235 if (! coff_write_linenumbers (abfd
))
4237 if (! coff_write_relocs (abfd
, firstundef
))
4240 #ifdef COFF_LONG_SECTION_NAMES
4241 else if (long_section_names
&& ! obj_coff_strings_written (abfd
))
4243 /* If we have long section names we have to write out the string
4244 table even if there are no symbols. */
4245 if (! coff_write_symbols (abfd
))
4249 #ifdef COFF_IMAGE_WITH_PE
4251 else if ((abfd
->flags
& EXEC_P
) != 0)
4255 /* PowerPC PE appears to require that all executable files be
4256 rounded up to the page size. */
4259 (file_ptr
) BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
4261 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
4267 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
4268 backend linker, and obj_raw_syment_count is not valid until after
4269 coff_write_symbols is called. */
4270 if (obj_raw_syment_count (abfd
) != 0)
4272 internal_f
.f_symptr
= sym_base
;
4274 /* AIX appears to require that F_RELFLG not be set if there are
4275 local symbols but no relocations. */
4276 internal_f
.f_flags
&=~ F_RELFLG
;
4281 if (long_section_names
)
4282 internal_f
.f_symptr
= sym_base
;
4284 internal_f
.f_symptr
= 0;
4285 internal_f
.f_flags
|= F_LSYMS
;
4290 internal_a
.tsize
= text_sec
->size
;
4291 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
4295 internal_a
.dsize
= data_sec
->size
;
4296 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
4300 internal_a
.bsize
= bss_sec
->size
;
4301 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
4302 internal_a
.data_start
= bss_sec
->vma
;
4305 internal_a
.entry
= bfd_get_start_address (abfd
);
4306 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
4309 if (xcoff_data (abfd
)->full_aouthdr
)
4312 asection
*loader_sec
;
4314 internal_a
.vstamp
= 1;
4316 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
4317 if (internal_a
.o_snentry
== 0)
4318 internal_a
.entry
= (bfd_vma
) -1;
4320 if (text_sec
!= NULL
)
4322 internal_a
.o_sntext
= text_sec
->target_index
;
4323 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
4327 internal_a
.o_sntext
= 0;
4328 internal_a
.o_algntext
= 0;
4330 if (data_sec
!= NULL
)
4332 internal_a
.o_sndata
= data_sec
->target_index
;
4333 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
4337 internal_a
.o_sndata
= 0;
4338 internal_a
.o_algndata
= 0;
4340 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
4341 if (loader_sec
!= NULL
)
4342 internal_a
.o_snloader
= loader_sec
->target_index
;
4344 internal_a
.o_snloader
= 0;
4345 if (bss_sec
!= NULL
)
4346 internal_a
.o_snbss
= bss_sec
->target_index
;
4348 internal_a
.o_snbss
= 0;
4350 toc
= xcoff_data (abfd
)->toc
;
4351 internal_a
.o_toc
= toc
;
4352 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
4354 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
4355 if (xcoff_data (abfd
)->cputype
!= -1)
4356 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
4359 switch (bfd_get_arch (abfd
))
4361 case bfd_arch_rs6000
:
4362 internal_a
.o_cputype
= 4;
4364 case bfd_arch_powerpc
:
4365 if (bfd_get_mach (abfd
) == bfd_mach_ppc
)
4366 internal_a
.o_cputype
= 3;
4368 internal_a
.o_cputype
= 1;
4374 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
4375 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
4381 /* After object contents are finalized so we can compute a reasonable hash,
4382 but before header is written so we can update it to point to debug directory. */
4383 struct pe_tdata
*pe
= pe_data (abfd
);
4385 if (pe
->build_id
.after_write_object_contents
!= NULL
)
4386 (*pe
->build_id
.after_write_object_contents
) (abfd
);
4390 /* Now write header. */
4391 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
4396 bfd_size_type amount
= bfd_coff_filhsz (abfd
);
4398 buff
= (char *) bfd_malloc (amount
);
4402 bfd_coff_swap_filehdr_out (abfd
, & internal_f
, buff
);
4403 amount
= bfd_bwrite (buff
, amount
, abfd
);
4407 if (amount
!= bfd_coff_filhsz (abfd
))
4411 if (abfd
->flags
& EXEC_P
)
4413 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4414 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4416 bfd_size_type amount
= bfd_coff_aoutsz (abfd
);
4418 buff
= (char *) bfd_malloc (amount
);
4422 coff_swap_aouthdr_out (abfd
, & internal_a
, buff
);
4423 amount
= bfd_bwrite (buff
, amount
, abfd
);
4427 if (amount
!= bfd_coff_aoutsz (abfd
))
4430 #ifdef COFF_IMAGE_WITH_PE
4431 if (! coff_apply_checksum (abfd
))
4441 /* XCOFF seems to always write at least a small a.out header. */
4442 coff_swap_aouthdr_out (abfd
, & internal_a
, & buff
);
4443 if (xcoff_data (abfd
)->full_aouthdr
)
4444 size
= bfd_coff_aoutsz (abfd
);
4446 size
= SMALL_AOUTSZ
;
4447 if (bfd_bwrite (& buff
, (bfd_size_type
) size
, abfd
) != size
)
4456 coff_set_section_contents (bfd
* abfd
,
4458 const void * location
,
4460 bfd_size_type count
)
4462 if (! abfd
->output_has_begun
) /* Set by bfd.c handler. */
4464 if (! coff_compute_section_file_positions (abfd
))
4468 #if defined(_LIB) && !defined(TARG_AUX)
4469 /* The physical address field of a .lib section is used to hold the
4470 number of shared libraries in the section. This code counts the
4471 number of sections being written, and increments the lma field
4474 I have found no documentation on the contents of this section.
4475 Experimentation indicates that the section contains zero or more
4476 records, each of which has the following structure:
4478 - a (four byte) word holding the length of this record, in words,
4479 - a word that always seems to be set to "2",
4480 - the path to a shared library, null-terminated and then padded
4481 to a whole word boundary.
4483 bfd_assert calls have been added to alert if an attempt is made
4484 to write a section which doesn't follow these assumptions. The
4485 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4486 <robertl@arnet.com> (Thanks!).
4488 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4489 if (strcmp (section
->name
, _LIB
) == 0)
4491 bfd_byte
*rec
, *recend
;
4493 rec
= (bfd_byte
*) location
;
4494 recend
= rec
+ count
;
4495 while (rec
< recend
)
4498 rec
+= bfd_get_32 (abfd
, rec
) * 4;
4501 BFD_ASSERT (rec
== recend
);
4505 /* Don't write out bss sections - one way to do this is to
4506 see if the filepos has not been set. */
4507 if (section
->filepos
== 0)
4510 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0)
4516 return bfd_bwrite (location
, count
, abfd
) == count
;
4520 buy_and_read (bfd
*abfd
, file_ptr where
, bfd_size_type size
)
4522 void * area
= bfd_alloc (abfd
, size
);
4526 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0
4527 || bfd_bread (area
, size
, abfd
) != size
)
4536 Creating the linenumber table is done by reading in the entire
4537 coff linenumber table, and creating another table for internal use.
4539 A coff linenumber table is structured so that each function
4540 is marked as having a line number of 0. Each line within the
4541 function is an offset from the first line in the function. The
4542 base of the line number information for the table is stored in
4543 the symbol associated with the function.
4545 Note: The PE format uses line number 0 for a flag indicating a
4548 The information is copied from the external to the internal
4549 table, and each symbol which marks a function is marked by
4552 How does this work ?
4556 coff_sort_func_alent (const void * arg1
, const void * arg2
)
4558 const alent
*al1
= *(const alent
**) arg1
;
4559 const alent
*al2
= *(const alent
**) arg2
;
4560 const coff_symbol_type
*s1
= (const coff_symbol_type
*) (al1
->u
.sym
);
4561 const coff_symbol_type
*s2
= (const coff_symbol_type
*) (al2
->u
.sym
);
4563 if (s1
== NULL
|| s2
== NULL
)
4565 if (s1
->symbol
.value
< s2
->symbol
.value
)
4567 else if (s1
->symbol
.value
> s2
->symbol
.value
)
4574 coff_slurp_line_table (bfd
*abfd
, asection
*asect
)
4576 LINENO
*native_lineno
;
4577 alent
*lineno_cache
;
4579 unsigned int counter
;
4581 bfd_vma prev_offset
= 0;
4582 bfd_boolean ordered
= TRUE
;
4583 unsigned int nbr_func
;
4585 bfd_boolean have_func
;
4586 bfd_boolean ret
= TRUE
;
4588 BFD_ASSERT (asect
->lineno
== NULL
);
4590 if (asect
->lineno_count
> asect
->size
)
4593 (_("%B: warning: line number count (%#lx) exceeds section size (%#lx)"),
4594 abfd
, (unsigned long) asect
->lineno_count
, (unsigned long) asect
->size
);
4598 amt
= ((bfd_size_type
) asect
->lineno_count
+ 1) * sizeof (alent
);
4599 lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
);
4600 if (lineno_cache
== NULL
)
4603 amt
= (bfd_size_type
) bfd_coff_linesz (abfd
) * asect
->lineno_count
;
4604 native_lineno
= (LINENO
*) buy_and_read (abfd
, asect
->line_filepos
, amt
);
4605 if (native_lineno
== NULL
)
4608 (_("%B: warning: line number table read failed"), abfd
);
4609 bfd_release (abfd
, lineno_cache
);
4613 cache_ptr
= lineno_cache
;
4614 asect
->lineno
= lineno_cache
;
4615 src
= native_lineno
;
4619 for (counter
= 0; counter
< asect
->lineno_count
; counter
++, src
++)
4621 struct internal_lineno dst
;
4623 bfd_coff_swap_lineno_in (abfd
, src
, &dst
);
4624 cache_ptr
->line_number
= dst
.l_lnno
;
4625 /* Appease memory checkers that get all excited about
4626 uninitialised memory when copying alents if u.offset is
4627 larger than u.sym. (64-bit BFD on 32-bit host.) */
4628 memset (&cache_ptr
->u
, 0, sizeof (cache_ptr
->u
));
4630 if (cache_ptr
->line_number
== 0)
4632 combined_entry_type
* ent
;
4633 unsigned long symndx
;
4634 coff_symbol_type
*sym
;
4637 symndx
= dst
.l_addr
.l_symndx
;
4638 if (symndx
>= obj_raw_syment_count (abfd
))
4641 /* xgettext:c-format */
4642 (_("%B: warning: illegal symbol index 0x%lx in line number entry %d"),
4643 abfd
, symndx
, counter
);
4644 cache_ptr
->line_number
= -1;
4649 ent
= obj_raw_syments (abfd
) + symndx
;
4650 /* FIXME: We should not be casting between ints and
4651 pointers like this. */
4655 /* xgettext:c-format */
4656 (_("%B: warning: illegal symbol index 0x%lx in line number entry %d"),
4657 abfd
, symndx
, counter
);
4658 cache_ptr
->line_number
= -1;
4662 sym
= (coff_symbol_type
*) (ent
->u
.syment
._n
._n_n
._n_zeroes
);
4664 /* PR 17512 file: 078-10659-0.004 */
4665 if (sym
< obj_symbols (abfd
)
4666 || sym
>= obj_symbols (abfd
) + bfd_get_symcount (abfd
))
4669 /* xgettext:c-format */
4670 (_("%B: warning: illegal symbol in line number entry %d"),
4672 cache_ptr
->line_number
= -1;
4679 cache_ptr
->u
.sym
= (asymbol
*) sym
;
4680 if (sym
->lineno
!= NULL
)
4682 /* xgettext:c-format */
4683 (_("%B: warning: duplicate line number information for `%s'"),
4684 abfd
, bfd_asymbol_name (&sym
->symbol
));
4686 sym
->lineno
= cache_ptr
;
4687 if (sym
->symbol
.value
< prev_offset
)
4689 prev_offset
= sym
->symbol
.value
;
4691 else if (!have_func
)
4692 /* Drop line information that has no associated function.
4693 PR 17521: file: 078-10659-0.004. */
4696 cache_ptr
->u
.offset
= (dst
.l_addr
.l_paddr
4697 - bfd_section_vma (abfd
, asect
));
4701 asect
->lineno_count
= cache_ptr
- lineno_cache
;
4702 memset (cache_ptr
, 0, sizeof (*cache_ptr
));
4703 bfd_release (abfd
, native_lineno
);
4705 /* On some systems (eg AIX5.3) the lineno table may not be sorted. */
4708 /* Sort the table. */
4710 alent
*n_lineno_cache
;
4712 /* Create a table of functions. */
4713 func_table
= (alent
**) bfd_alloc (abfd
, nbr_func
* sizeof (alent
*));
4714 if (func_table
!= NULL
)
4716 alent
**p
= func_table
;
4719 for (i
= 0; i
< asect
->lineno_count
; i
++)
4720 if (lineno_cache
[i
].line_number
== 0)
4721 *p
++ = &lineno_cache
[i
];
4723 BFD_ASSERT ((unsigned int) (p
- func_table
) == nbr_func
);
4725 /* Sort by functions. */
4726 qsort (func_table
, nbr_func
, sizeof (alent
*), coff_sort_func_alent
);
4728 /* Create the new sorted table. */
4729 amt
= (bfd_size_type
) asect
->lineno_count
* sizeof (alent
);
4730 n_lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
);
4731 if (n_lineno_cache
!= NULL
)
4733 alent
*n_cache_ptr
= n_lineno_cache
;
4735 for (i
= 0; i
< nbr_func
; i
++)
4737 coff_symbol_type
*sym
;
4738 alent
*old_ptr
= func_table
[i
];
4740 /* Update the function entry. */
4741 sym
= (coff_symbol_type
*) old_ptr
->u
.sym
;
4742 /* PR binutils/17512: Point the lineno to where
4743 this entry will be after the memcpy below. */
4744 sym
->lineno
= lineno_cache
+ (n_cache_ptr
- n_lineno_cache
);
4745 /* Copy the function and line number entries. */
4747 *n_cache_ptr
++ = *old_ptr
++;
4748 while (old_ptr
->line_number
!= 0);
4750 BFD_ASSERT ((bfd_size_type
) (n_cache_ptr
- n_lineno_cache
) == (amt
/ sizeof (alent
)));
4752 memcpy (lineno_cache
, n_lineno_cache
, amt
);
4756 bfd_release (abfd
, func_table
);
4765 /* Slurp in the symbol table, converting it to generic form. Note
4766 that if coff_relocate_section is defined, the linker will read
4767 symbols via coff_link_add_symbols, rather than via this routine. */
4770 coff_slurp_symbol_table (bfd
* abfd
)
4772 combined_entry_type
*native_symbols
;
4773 coff_symbol_type
*cached_area
;
4774 unsigned int *table_ptr
;
4776 unsigned int number_of_symbols
= 0;
4777 bfd_boolean ret
= TRUE
;
4779 if (obj_symbols (abfd
))
4782 /* Read in the symbol table. */
4783 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4786 /* Allocate enough room for all the symbols in cached form. */
4787 amt
= obj_raw_syment_count (abfd
);
4788 amt
*= sizeof (coff_symbol_type
);
4789 cached_area
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
4790 if (cached_area
== NULL
)
4793 amt
= obj_raw_syment_count (abfd
);
4794 amt
*= sizeof (unsigned int);
4795 table_ptr
= (unsigned int *) bfd_zalloc (abfd
, amt
);
4797 if (table_ptr
== NULL
)
4801 coff_symbol_type
*dst
= cached_area
;
4802 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4803 unsigned int this_index
= 0;
4805 while (this_index
< last_native_index
)
4807 combined_entry_type
*src
= native_symbols
+ this_index
;
4808 table_ptr
[this_index
] = number_of_symbols
;
4810 dst
->symbol
.the_bfd
= abfd
;
4811 BFD_ASSERT (src
->is_sym
);
4812 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4813 /* We use the native name field to point to the cached field. */
4814 src
->u
.syment
._n
._n_n
._n_zeroes
= (bfd_hostptr_t
) dst
;
4815 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4816 src
->u
.syment
.n_scnum
);
4817 dst
->symbol
.flags
= 0;
4818 /* PR 17512: file: 079-7098-0.001:0.1. */
4819 dst
->symbol
.value
= 0;
4820 dst
->done_lineno
= FALSE
;
4822 switch (src
->u
.syment
.n_sclass
)
4826 /* Fall through to next case. */
4833 case C_THUMBEXTFUNC
:
4837 #if ! defined _AIX52 && ! defined AIX_WEAK_SUPPORT
4842 case C_SYSTEM
: /* System Wide variable. */
4845 /* In PE, 0x68 (104) denotes a section symbol. */
4847 /* In PE, 0x69 (105) denotes a weak external symbol. */
4850 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4852 case COFF_SYMBOL_GLOBAL
:
4853 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4854 #if defined COFF_WITH_PE
4855 /* PE sets the symbol to a value relative to the
4856 start of the section. */
4857 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4859 dst
->symbol
.value
= (src
->u
.syment
.n_value
4860 - dst
->symbol
.section
->vma
);
4862 if (ISFCN ((src
->u
.syment
.n_type
)))
4863 /* A function ext does not go at the end of a
4865 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4868 case COFF_SYMBOL_COMMON
:
4869 dst
->symbol
.section
= bfd_com_section_ptr
;
4870 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4873 case COFF_SYMBOL_UNDEFINED
:
4874 dst
->symbol
.section
= bfd_und_section_ptr
;
4875 dst
->symbol
.value
= 0;
4878 case COFF_SYMBOL_PE_SECTION
:
4879 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4880 dst
->symbol
.value
= 0;
4883 case COFF_SYMBOL_LOCAL
:
4884 dst
->symbol
.flags
= BSF_LOCAL
;
4885 #if defined COFF_WITH_PE
4886 /* PE sets the symbol to a value relative to the
4887 start of the section. */
4888 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4890 dst
->symbol
.value
= (src
->u
.syment
.n_value
4891 - dst
->symbol
.section
->vma
);
4893 if (ISFCN ((src
->u
.syment
.n_type
)))
4894 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4899 /* A symbol with a csect entry should not go at the end. */
4900 if (src
->u
.syment
.n_numaux
> 0)
4901 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4905 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4906 dst
->symbol
.flags
|= BSF_WEAK
;
4908 if (src
->u
.syment
.n_sclass
== C_SECTION
4909 && src
->u
.syment
.n_scnum
> 0)
4910 dst
->symbol
.flags
= BSF_LOCAL
;
4912 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
4914 || src
->u
.syment
.n_sclass
== C_AIX_WEAKEXT
4917 dst
->symbol
.flags
|= BSF_WEAK
;
4921 case C_STAT
: /* Static. */
4923 case C_LEAFSTAT
: /* Static leaf procedure. */
4926 case C_THUMBSTAT
: /* Thumb static. */
4927 case C_THUMBLABEL
: /* Thumb label. */
4928 case C_THUMBSTATFUNC
:/* Thumb static function. */
4931 case C_DWARF
: /* A label in a dwarf section. */
4932 case C_INFO
: /* A label in a comment section. */
4934 case C_LABEL
: /* Label. */
4935 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4936 dst
->symbol
.flags
= BSF_DEBUGGING
;
4938 dst
->symbol
.flags
= BSF_LOCAL
;
4940 /* Base the value as an index from the base of the
4941 section, if there is one. */
4942 if (dst
->symbol
.section
)
4944 #if defined COFF_WITH_PE
4945 /* PE sets the symbol to a value relative to the
4946 start of the section. */
4947 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4949 dst
->symbol
.value
= (src
->u
.syment
.n_value
4950 - dst
->symbol
.section
->vma
);
4954 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4957 case C_MOS
: /* Member of structure. */
4958 case C_EOS
: /* End of structure. */
4959 case C_REGPARM
: /* Register parameter. */
4960 case C_REG
: /* register variable. */
4961 /* C_AUTOARG conflicts with TI COFF C_UEXT. */
4962 #if !defined (TIC80COFF) && !defined (TICOFF)
4964 case C_AUTOARG
: /* 960-specific storage class. */
4967 case C_TPDEF
: /* Type definition. */
4969 case C_AUTO
: /* Automatic variable. */
4970 case C_FIELD
: /* Bit field. */
4971 case C_ENTAG
: /* Enumeration tag. */
4972 case C_MOE
: /* Member of enumeration. */
4973 case C_MOU
: /* Member of union. */
4974 case C_UNTAG
: /* Union tag. */
4975 dst
->symbol
.flags
= BSF_DEBUGGING
;
4976 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4979 case C_FILE
: /* File name. */
4980 case C_STRTAG
: /* Structure tag. */
4997 dst
->symbol
.flags
= BSF_DEBUGGING
;
4998 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
5002 case C_BINCL
: /* Beginning of include file. */
5003 case C_EINCL
: /* Ending of include file. */
5004 /* The value is actually a pointer into the line numbers
5005 of the file. We locate the line number entry, and
5006 set the section to the section which contains it, and
5007 the value to the index in that section. */
5011 dst
->symbol
.flags
= BSF_DEBUGGING
;
5012 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
5013 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
5014 && ((file_ptr
) (sec
->line_filepos
5015 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
5016 > (file_ptr
) src
->u
.syment
.n_value
))
5019 dst
->symbol
.value
= 0;
5022 dst
->symbol
.section
= sec
;
5023 dst
->symbol
.value
= ((src
->u
.syment
.n_value
5024 - sec
->line_filepos
)
5025 / bfd_coff_linesz (abfd
));
5032 dst
->symbol
.flags
= BSF_DEBUGGING
;
5034 /* The value is actually a symbol index. Save a pointer
5035 to the symbol instead of the index. FIXME: This
5036 should use a union. */
5037 src
->u
.syment
.n_value
=
5038 (long) (intptr_t) (native_symbols
+ src
->u
.syment
.n_value
);
5039 dst
->symbol
.value
= src
->u
.syment
.n_value
;
5044 case C_BLOCK
: /* ".bb" or ".eb". */
5045 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf"). */
5046 case C_EFCN
: /* Physical end of function. */
5047 #if defined COFF_WITH_PE
5048 /* PE sets the symbol to a value relative to the start
5050 dst
->symbol
.value
= src
->u
.syment
.n_value
;
5051 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
5053 /* PE uses funny values for .ef and .lf; don't
5055 dst
->symbol
.flags
= BSF_DEBUGGING
;
5058 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
5060 /* Base the value as an index from the base of the
5062 dst
->symbol
.flags
= BSF_LOCAL
;
5063 dst
->symbol
.value
= (src
->u
.syment
.n_value
5064 - dst
->symbol
.section
->vma
);
5068 case C_STATLAB
: /* Static load time label. */
5069 dst
->symbol
.value
= src
->u
.syment
.n_value
;
5070 dst
->symbol
.flags
= BSF_GLOBAL
;
5074 /* PE DLLs sometimes have zeroed out symbols for some
5075 reason. Just ignore them without a warning. */
5076 if (src
->u
.syment
.n_type
== 0
5077 && src
->u
.syment
.n_value
== 0
5078 && src
->u
.syment
.n_scnum
== 0)
5081 /* XCOFF specific: deleted entry. */
5082 if (src
->u
.syment
.n_value
== C_NULL_VALUE
)
5086 case C_EXTDEF
: /* External definition. */
5087 case C_ULABEL
: /* Undefined label. */
5088 case C_USTATIC
: /* Undefined static. */
5089 #ifndef COFF_WITH_PE
5090 /* C_LINE in regular coff is 0x68. NT has taken over this storage
5091 class to represent a section symbol. */
5092 case C_LINE
: /* line # reformatted as symbol table entry. */
5093 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
5094 case C_ALIAS
: /* Duplicate tag. */
5096 /* New storage classes for TI COFF. */
5097 #if defined(TIC80COFF) || defined(TICOFF)
5098 case C_UEXT
: /* Tentative external definition. */
5100 case C_EXTLAB
: /* External load time label. */
5103 /* xgettext:c-format */
5104 (_("%B: Unrecognized storage class %d for %s symbol `%s'"),
5105 abfd
, src
->u
.syment
.n_sclass
,
5106 dst
->symbol
.section
->name
, dst
->symbol
.name
);
5109 case C_HIDDEN
: /* Ext symbol in dmert public lib. */
5110 /* PR 20722: These symbols can also be generated by
5111 building DLLs with --gc-sections enabled. */
5112 dst
->symbol
.flags
= BSF_DEBUGGING
;
5113 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
5118 dst
->symbol
.udata
.i
= 0;
5121 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
5123 number_of_symbols
++;
5127 obj_symbols (abfd
) = cached_area
;
5128 obj_raw_syments (abfd
) = native_symbols
;
5130 bfd_get_symcount (abfd
) = number_of_symbols
;
5131 obj_convert (abfd
) = table_ptr
;
5132 /* Slurp the line tables for each section too. */
5139 if (! coff_slurp_line_table (abfd
, p
))
5148 /* Classify a COFF symbol. A couple of targets have globally visible
5149 symbols which are not class C_EXT, and this handles those. It also
5150 recognizes some special PE cases. */
5152 static enum coff_symbol_classification
5153 coff_classify_symbol (bfd
*abfd
,
5154 struct internal_syment
*syment
)
5156 /* FIXME: This partially duplicates the switch in
5157 coff_slurp_symbol_table. */
5158 switch (syment
->n_sclass
)
5167 case C_THUMBEXTFUNC
:
5175 if (syment
->n_scnum
== 0)
5177 if (syment
->n_value
== 0)
5178 return COFF_SYMBOL_UNDEFINED
;
5180 return COFF_SYMBOL_COMMON
;
5182 return COFF_SYMBOL_GLOBAL
;
5189 if (syment
->n_sclass
== C_STAT
)
5191 if (syment
->n_scnum
== 0)
5192 /* The Microsoft compiler sometimes generates these if a
5193 small static function is inlined every time it is used.
5194 The function is discarded, but the symbol table entry
5196 return COFF_SYMBOL_LOCAL
;
5198 #ifdef STRICT_PE_FORMAT
5199 /* This is correct for Microsoft generated objects, but it
5200 breaks gas generated objects. */
5201 if (syment
->n_value
== 0)
5205 char buf
[SYMNMLEN
+ 1];
5207 name
= _bfd_coff_internal_syment_name (abfd
, syment
, buf
)
5208 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
5209 if (sec
!= NULL
&& name
!= NULL
5210 && (strcmp (bfd_get_section_name (abfd
, sec
), name
) == 0))
5211 return COFF_SYMBOL_PE_SECTION
;
5215 return COFF_SYMBOL_LOCAL
;
5218 if (syment
->n_sclass
== C_SECTION
)
5220 /* In some cases in a DLL generated by the Microsoft linker, the
5221 n_value field will contain garbage. FIXME: This should
5222 probably be handled by the swapping function instead. */
5223 syment
->n_value
= 0;
5224 if (syment
->n_scnum
== 0)
5225 return COFF_SYMBOL_UNDEFINED
;
5226 return COFF_SYMBOL_PE_SECTION
;
5228 #endif /* COFF_WITH_PE */
5230 /* If it is not a global symbol, we presume it is a local symbol. */
5231 if (syment
->n_scnum
== 0)
5233 char buf
[SYMNMLEN
+ 1];
5236 /* xgettext:c-format */
5237 (_("warning: %B: local symbol `%s' has no section"),
5238 abfd
, _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
5241 return COFF_SYMBOL_LOCAL
;
5248 Coff relocations are easily transformed into the internal BFD form
5251 Reading a coff relocation table is done in the following stages:
5253 o Read the entire coff relocation table into memory.
5255 o Process each relocation in turn; first swap it from the
5256 external to the internal form.
5258 o Turn the symbol referenced in the relocation's symbol index
5259 into a pointer into the canonical symbol table.
5260 This table is the same as the one returned by a call to
5261 @code{bfd_canonicalize_symtab}. The back end will call that
5262 routine and save the result if a canonicalization hasn't been done.
5264 o The reloc index is turned into a pointer to a howto
5265 structure, in a back end specific way. For instance, the 386
5266 and 960 use the @code{r_type} to directly produce an index
5267 into a howto table vector; the 88k subtracts a number from the
5268 @code{r_type} field and creates an addend field.
5272 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
5274 coff_symbol_type *coffsym = NULL; \
5276 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
5277 coffsym = (obj_symbols (abfd) \
5278 + (cache_ptr->sym_ptr_ptr - symbols)); \
5280 coffsym = coff_symbol_from (ptr); \
5281 if (coffsym != NULL \
5282 && coffsym->native->is_sym \
5283 && coffsym->native->u.syment.n_scnum == 0) \
5284 cache_ptr->addend = 0; \
5285 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
5286 && ptr->section != NULL) \
5287 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
5289 cache_ptr->addend = 0; \
5294 coff_slurp_reloc_table (bfd
* abfd
, sec_ptr asect
, asymbol
** symbols
)
5296 RELOC
*native_relocs
;
5297 arelent
*reloc_cache
;
5302 if (asect
->relocation
)
5304 if (asect
->reloc_count
== 0)
5306 if (asect
->flags
& SEC_CONSTRUCTOR
)
5308 if (!coff_slurp_symbol_table (abfd
))
5311 amt
= (bfd_size_type
) bfd_coff_relsz (abfd
) * asect
->reloc_count
;
5312 native_relocs
= (RELOC
*) buy_and_read (abfd
, asect
->rel_filepos
, amt
);
5313 amt
= (bfd_size_type
) asect
->reloc_count
* sizeof (arelent
);
5314 reloc_cache
= (arelent
*) bfd_alloc (abfd
, amt
);
5316 if (reloc_cache
== NULL
|| native_relocs
== NULL
)
5319 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
5321 struct internal_reloc dst
;
5322 struct external_reloc
*src
;
5323 #ifndef RELOC_PROCESSING
5327 cache_ptr
= reloc_cache
+ idx
;
5328 src
= native_relocs
+ idx
;
5331 coff_swap_reloc_in (abfd
, src
, &dst
);
5333 #ifdef RELOC_PROCESSING
5334 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
5336 cache_ptr
->address
= dst
.r_vaddr
;
5338 if (dst
.r_symndx
!= -1 && symbols
!= NULL
)
5340 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
5343 /* xgettext:c-format */
5344 (_("%B: warning: illegal symbol index %ld in relocs"),
5345 abfd
, dst
.r_symndx
);
5346 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5351 cache_ptr
->sym_ptr_ptr
= (symbols
5352 + obj_convert (abfd
)[dst
.r_symndx
]);
5353 ptr
= *(cache_ptr
->sym_ptr_ptr
);
5358 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5362 /* The symbols definitions that we have read in have been
5363 relocated as if their sections started at 0. But the offsets
5364 refering to the symbols in the raw data have not been
5365 modified, so we have to have a negative addend to compensate.
5367 Note that symbols which used to be common must be left alone. */
5369 /* Calculate any reloc addend by looking at the symbol. */
5370 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
5373 cache_ptr
->address
-= asect
->vma
;
5374 /* !! cache_ptr->section = NULL;*/
5376 /* Fill in the cache_ptr->howto field from dst.r_type. */
5377 RTYPE2HOWTO (cache_ptr
, &dst
);
5378 #endif /* RELOC_PROCESSING */
5380 if (cache_ptr
->howto
== NULL
)
5383 /* xgettext:c-format */
5384 (_("%B: illegal relocation type %d at address %#Lx"),
5385 abfd
, dst
.r_type
, dst
.r_vaddr
);
5386 bfd_set_error (bfd_error_bad_value
);
5391 asect
->relocation
= reloc_cache
;
5395 #ifndef coff_rtype_to_howto
5398 /* Get the howto structure for a reloc. This is only used if the file
5399 including this one defines coff_relocate_section to be
5400 _bfd_coff_generic_relocate_section, so it is OK if it does not
5401 always work. It is the responsibility of the including file to
5402 make sure it is reasonable if it is needed. */
5404 static reloc_howto_type
*
5405 coff_rtype_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
5406 asection
*sec ATTRIBUTE_UNUSED
,
5407 struct internal_reloc
*rel ATTRIBUTE_UNUSED
,
5408 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
,
5409 struct internal_syment
*sym ATTRIBUTE_UNUSED
,
5410 bfd_vma
*addendp ATTRIBUTE_UNUSED
)
5414 genrel
.howto
= NULL
;
5415 RTYPE2HOWTO (&genrel
, rel
);
5416 return genrel
.howto
;
5419 #else /* ! defined (RTYPE2HOWTO) */
5421 #define coff_rtype_to_howto NULL
5423 #endif /* ! defined (RTYPE2HOWTO) */
5424 #endif /* ! defined (coff_rtype_to_howto) */
5426 /* This is stupid. This function should be a boolean predicate. */
5429 coff_canonicalize_reloc (bfd
* abfd
,
5434 arelent
*tblptr
= section
->relocation
;
5435 unsigned int count
= 0;
5437 if (section
->flags
& SEC_CONSTRUCTOR
)
5439 /* This section has relocs made up by us, they are not in the
5440 file, so take them out of their chain and place them into
5441 the data area provided. */
5442 arelent_chain
*chain
= section
->constructor_chain
;
5444 for (count
= 0; count
< section
->reloc_count
; count
++)
5446 *relptr
++ = &chain
->relent
;
5447 chain
= chain
->next
;
5452 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
5455 tblptr
= section
->relocation
;
5457 for (; count
++ < section
->reloc_count
;)
5458 *relptr
++ = tblptr
++;
5461 return section
->reloc_count
;
5464 #ifndef coff_set_reloc
5465 #define coff_set_reloc _bfd_generic_set_reloc
5468 #ifndef coff_reloc16_estimate
5469 #define coff_reloc16_estimate dummy_reloc16_estimate
5472 dummy_reloc16_estimate (bfd
*abfd ATTRIBUTE_UNUSED
,
5473 asection
*input_section ATTRIBUTE_UNUSED
,
5474 arelent
*reloc ATTRIBUTE_UNUSED
,
5475 unsigned int shrink ATTRIBUTE_UNUSED
,
5476 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
)
5484 #ifndef coff_reloc16_extra_cases
5486 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5488 /* This works even if abort is not declared in any header file. */
5491 dummy_reloc16_extra_cases (bfd
*abfd ATTRIBUTE_UNUSED
,
5492 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
5493 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
,
5494 arelent
*reloc ATTRIBUTE_UNUSED
,
5495 bfd_byte
*data ATTRIBUTE_UNUSED
,
5496 unsigned int *src_ptr ATTRIBUTE_UNUSED
,
5497 unsigned int *dst_ptr ATTRIBUTE_UNUSED
)
5503 /* If coff_relocate_section is defined, we can use the optimized COFF
5504 backend linker. Otherwise we must continue to use the old linker. */
5506 #ifdef coff_relocate_section
5508 #ifndef coff_bfd_link_hash_table_create
5509 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5511 #ifndef coff_bfd_link_add_symbols
5512 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5514 #ifndef coff_bfd_final_link
5515 #define coff_bfd_final_link _bfd_coff_final_link
5518 #else /* ! defined (coff_relocate_section) */
5520 #define coff_relocate_section NULL
5521 #ifndef coff_bfd_link_hash_table_create
5522 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5524 #ifndef coff_bfd_link_add_symbols
5525 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5527 #define coff_bfd_final_link _bfd_generic_final_link
5529 #endif /* ! defined (coff_relocate_section) */
5531 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5532 #define coff_bfd_copy_link_hash_symbol_type \
5533 _bfd_generic_copy_link_hash_symbol_type
5534 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5536 #define coff_bfd_link_check_relocs _bfd_generic_link_check_relocs
5538 #ifndef coff_start_final_link
5539 #define coff_start_final_link NULL
5542 #ifndef coff_adjust_symndx
5543 #define coff_adjust_symndx NULL
5546 #ifndef coff_link_add_one_symbol
5547 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5550 #ifndef coff_link_output_has_begun
5553 coff_link_output_has_begun (bfd
* abfd
,
5554 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
)
5556 return abfd
->output_has_begun
;
5560 #ifndef coff_final_link_postscript
5563 coff_final_link_postscript (bfd
* abfd ATTRIBUTE_UNUSED
,
5564 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
)
5570 #ifndef coff_SWAP_aux_in
5571 #define coff_SWAP_aux_in coff_swap_aux_in
5573 #ifndef coff_SWAP_sym_in
5574 #define coff_SWAP_sym_in coff_swap_sym_in
5576 #ifndef coff_SWAP_lineno_in
5577 #define coff_SWAP_lineno_in coff_swap_lineno_in
5579 #ifndef coff_SWAP_aux_out
5580 #define coff_SWAP_aux_out coff_swap_aux_out
5582 #ifndef coff_SWAP_sym_out
5583 #define coff_SWAP_sym_out coff_swap_sym_out
5585 #ifndef coff_SWAP_lineno_out
5586 #define coff_SWAP_lineno_out coff_swap_lineno_out
5588 #ifndef coff_SWAP_reloc_out
5589 #define coff_SWAP_reloc_out coff_swap_reloc_out
5591 #ifndef coff_SWAP_filehdr_out
5592 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5594 #ifndef coff_SWAP_aouthdr_out
5595 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5597 #ifndef coff_SWAP_scnhdr_out
5598 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5600 #ifndef coff_SWAP_reloc_in
5601 #define coff_SWAP_reloc_in coff_swap_reloc_in
5603 #ifndef coff_SWAP_filehdr_in
5604 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5606 #ifndef coff_SWAP_aouthdr_in
5607 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5609 #ifndef coff_SWAP_scnhdr_in
5610 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5613 static bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED
=
5615 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5616 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5617 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5618 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5619 coff_SWAP_scnhdr_out
,
5620 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5621 #ifdef COFF_LONG_FILENAMES
5626 COFF_DEFAULT_LONG_SECTION_NAMES
,
5627 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5628 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5633 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5639 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5640 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5641 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5642 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5643 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5644 coff_classify_symbol
, coff_compute_section_file_positions
,
5645 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5646 coff_adjust_symndx
, coff_link_add_one_symbol
,
5647 coff_link_output_has_begun
, coff_final_link_postscript
,
5652 /* COFF0 differs in file/section header size and relocation entry size. */
5654 static bfd_coff_backend_data ticoff0_swap_table
=
5656 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5657 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5658 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5659 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5660 coff_SWAP_scnhdr_out
,
5661 FILHSZ_V0
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ_V0
, LINESZ
, FILNMLEN
,
5662 #ifdef COFF_LONG_FILENAMES
5667 COFF_DEFAULT_LONG_SECTION_NAMES
,
5668 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5669 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5674 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5680 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5681 coff_SWAP_reloc_in
, ticoff0_bad_format_hook
, coff_set_arch_mach_hook
,
5682 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5683 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5684 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5685 coff_classify_symbol
, coff_compute_section_file_positions
,
5686 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5687 coff_adjust_symndx
, coff_link_add_one_symbol
,
5688 coff_link_output_has_begun
, coff_final_link_postscript
,
5694 /* COFF1 differs in section header size. */
5696 static bfd_coff_backend_data ticoff1_swap_table
=
5698 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5699 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5700 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5701 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5702 coff_SWAP_scnhdr_out
,
5703 FILHSZ
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5704 #ifdef COFF_LONG_FILENAMES
5709 COFF_DEFAULT_LONG_SECTION_NAMES
,
5710 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5711 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5716 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5722 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5723 coff_SWAP_reloc_in
, ticoff1_bad_format_hook
, coff_set_arch_mach_hook
,
5724 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5725 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5726 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5727 coff_classify_symbol
, coff_compute_section_file_positions
,
5728 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5729 coff_adjust_symndx
, coff_link_add_one_symbol
,
5730 coff_link_output_has_begun
, coff_final_link_postscript
,
5731 bfd_pe_print_pdata
/* huh */
5735 #ifdef COFF_WITH_PE_BIGOBJ
5736 /* The UID for bigobj files. */
5738 static const char header_bigobj_classid
[16] =
5740 0xC7, 0xA1, 0xBA, 0xD1,
5744 0xFA, 0xF6, 0x6A, 0xA4, 0xDC, 0xB8
5747 /* Swap routines. */
5750 coff_bigobj_swap_filehdr_in (bfd
* abfd
, void * src
, void * dst
)
5752 struct external_ANON_OBJECT_HEADER_BIGOBJ
*filehdr_src
=
5753 (struct external_ANON_OBJECT_HEADER_BIGOBJ
*) src
;
5754 struct internal_filehdr
*filehdr_dst
= (struct internal_filehdr
*) dst
;
5756 filehdr_dst
->f_magic
= H_GET_16 (abfd
, filehdr_src
->Machine
);
5757 filehdr_dst
->f_nscns
= H_GET_32 (abfd
, filehdr_src
->NumberOfSections
);
5758 filehdr_dst
->f_timdat
= H_GET_32 (abfd
, filehdr_src
->TimeDateStamp
);
5759 filehdr_dst
->f_symptr
=
5760 GET_FILEHDR_SYMPTR (abfd
, filehdr_src
->PointerToSymbolTable
);
5761 filehdr_dst
->f_nsyms
= H_GET_32 (abfd
, filehdr_src
->NumberOfSymbols
);
5762 filehdr_dst
->f_opthdr
= 0;
5763 filehdr_dst
->f_flags
= 0;
5765 /* Check other magic numbers. */
5766 if (H_GET_16 (abfd
, filehdr_src
->Sig1
) != IMAGE_FILE_MACHINE_UNKNOWN
5767 || H_GET_16 (abfd
, filehdr_src
->Sig2
) != 0xffff
5768 || H_GET_16 (abfd
, filehdr_src
->Version
) != 2
5769 || memcmp (filehdr_src
->ClassID
, header_bigobj_classid
, 16) != 0)
5770 filehdr_dst
->f_opthdr
= 0xffff;
5772 /* Note that CLR metadata are ignored. */
5776 coff_bigobj_swap_filehdr_out (bfd
*abfd
, void * in
, void * out
)
5778 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
5779 struct external_ANON_OBJECT_HEADER_BIGOBJ
*filehdr_out
=
5780 (struct external_ANON_OBJECT_HEADER_BIGOBJ
*) out
;
5782 memset (filehdr_out
, 0, sizeof (*filehdr_out
));
5784 H_PUT_16 (abfd
, IMAGE_FILE_MACHINE_UNKNOWN
, filehdr_out
->Sig1
);
5785 H_PUT_16 (abfd
, 0xffff, filehdr_out
->Sig2
);
5786 H_PUT_16 (abfd
, 2, filehdr_out
->Version
);
5787 memcpy (filehdr_out
->ClassID
, header_bigobj_classid
, 16);
5788 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->Machine
);
5789 H_PUT_32 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->NumberOfSections
);
5790 H_PUT_32 (abfd
, filehdr_in
->f_timdat
, filehdr_out
->TimeDateStamp
);
5791 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
,
5792 filehdr_out
->PointerToSymbolTable
);
5793 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->NumberOfSymbols
);
5795 return bfd_coff_filhsz (abfd
);
5799 coff_bigobj_swap_sym_in (bfd
* abfd
, void * ext1
, void * in1
)
5801 SYMENT_BIGOBJ
*ext
= (SYMENT_BIGOBJ
*) ext1
;
5802 struct internal_syment
*in
= (struct internal_syment
*) in1
;
5804 if (ext
->e
.e_name
[0] == 0)
5806 in
->_n
._n_n
._n_zeroes
= 0;
5807 in
->_n
._n_n
._n_offset
= H_GET_32 (abfd
, ext
->e
.e
.e_offset
);
5811 #if SYMNMLEN != E_SYMNMLEN
5812 #error we need to cope with truncating or extending SYMNMLEN
5814 memcpy (in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
5818 in
->n_value
= H_GET_32 (abfd
, ext
->e_value
);
5819 BFD_ASSERT (sizeof (in
->n_scnum
) >= 4);
5820 in
->n_scnum
= H_GET_32 (abfd
, ext
->e_scnum
);
5821 in
->n_type
= H_GET_16 (abfd
, ext
->e_type
);
5822 in
->n_sclass
= H_GET_8 (abfd
, ext
->e_sclass
);
5823 in
->n_numaux
= H_GET_8 (abfd
, ext
->e_numaux
);
5827 coff_bigobj_swap_sym_out (bfd
* abfd
, void * inp
, void * extp
)
5829 struct internal_syment
*in
= (struct internal_syment
*) inp
;
5830 SYMENT_BIGOBJ
*ext
= (SYMENT_BIGOBJ
*) extp
;
5832 if (in
->_n
._n_name
[0] == 0)
5834 H_PUT_32 (abfd
, 0, ext
->e
.e
.e_zeroes
);
5835 H_PUT_32 (abfd
, in
->_n
._n_n
._n_offset
, ext
->e
.e
.e_offset
);
5839 #if SYMNMLEN != E_SYMNMLEN
5840 #error we need to cope with truncating or extending SYMNMLEN
5842 memcpy (ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
5846 H_PUT_32 (abfd
, in
->n_value
, ext
->e_value
);
5847 H_PUT_32 (abfd
, in
->n_scnum
, ext
->e_scnum
);
5849 H_PUT_16 (abfd
, in
->n_type
, ext
->e_type
);
5850 H_PUT_8 (abfd
, in
->n_sclass
, ext
->e_sclass
);
5851 H_PUT_8 (abfd
, in
->n_numaux
, ext
->e_numaux
);
5853 return SYMESZ_BIGOBJ
;
5857 coff_bigobj_swap_aux_in (bfd
*abfd
,
5865 AUXENT_BIGOBJ
*ext
= (AUXENT_BIGOBJ
*) ext1
;
5866 union internal_auxent
*in
= (union internal_auxent
*) in1
;
5874 memcpy (in
->x_file
.x_fname
, ext
->File
.Name
,
5875 numaux
* sizeof (AUXENT_BIGOBJ
));
5878 memcpy (in
->x_file
.x_fname
, ext
->File
.Name
, sizeof (ext
->File
.Name
));
5886 in
->x_scn
.x_scnlen
= H_GET_32 (abfd
, ext
->Section
.Length
);
5887 in
->x_scn
.x_nreloc
=
5888 H_GET_16 (abfd
, ext
->Section
.NumberOfRelocations
);
5889 in
->x_scn
.x_nlinno
=
5890 H_GET_16 (abfd
, ext
->Section
.NumberOfLinenumbers
);
5891 in
->x_scn
.x_checksum
= H_GET_32 (abfd
, ext
->Section
.Checksum
);
5892 in
->x_scn
.x_associated
= H_GET_16 (abfd
, ext
->Section
.Number
)
5893 | (H_GET_16 (abfd
, ext
->Section
.HighNumber
) << 16);
5894 in
->x_scn
.x_comdat
= H_GET_8 (abfd
, ext
->Section
.Selection
);
5900 in
->x_sym
.x_tagndx
.l
= H_GET_32 (abfd
, ext
->Sym
.WeakDefaultSymIndex
);
5901 /* Characteristics is ignored. */
5907 coff_bigobj_swap_aux_out (bfd
* abfd
,
5911 int indx ATTRIBUTE_UNUSED
,
5912 int numaux ATTRIBUTE_UNUSED
,
5915 union internal_auxent
* in
= (union internal_auxent
*) inp
;
5916 AUXENT_BIGOBJ
*ext
= (AUXENT_BIGOBJ
*) extp
;
5918 memset (ext
, 0, AUXESZ
);
5923 memcpy (ext
->File
.Name
, in
->x_file
.x_fname
, sizeof (ext
->File
.Name
));
5932 H_PUT_32 (abfd
, in
->x_scn
.x_scnlen
, ext
->Section
.Length
);
5933 H_PUT_16 (abfd
, in
->x_scn
.x_nreloc
,
5934 ext
->Section
.NumberOfRelocations
);
5935 H_PUT_16 (abfd
, in
->x_scn
.x_nlinno
,
5936 ext
->Section
.NumberOfLinenumbers
);
5937 H_PUT_32 (abfd
, in
->x_scn
.x_checksum
, ext
->Section
.Checksum
);
5938 H_PUT_16 (abfd
, in
->x_scn
.x_associated
& 0xffff,
5939 ext
->Section
.Number
);
5940 H_PUT_16 (abfd
, (in
->x_scn
.x_associated
>> 16),
5941 ext
->Section
.HighNumber
);
5942 H_PUT_8 (abfd
, in
->x_scn
.x_comdat
, ext
->Section
.Selection
);
5948 H_PUT_32 (abfd
, in
->x_sym
.x_tagndx
.l
, ext
->Sym
.WeakDefaultSymIndex
);
5949 H_PUT_32 (abfd
, 1, ext
->Sym
.WeakSearchType
);
5954 static bfd_coff_backend_data bigobj_swap_table
=
5956 coff_bigobj_swap_aux_in
, coff_bigobj_swap_sym_in
, coff_SWAP_lineno_in
,
5957 coff_bigobj_swap_aux_out
, coff_bigobj_swap_sym_out
,
5958 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5959 coff_bigobj_swap_filehdr_out
, coff_SWAP_aouthdr_out
,
5960 coff_SWAP_scnhdr_out
,
5961 FILHSZ_BIGOBJ
, AOUTSZ
, SCNHSZ
, SYMESZ_BIGOBJ
, AUXESZ_BIGOBJ
,
5962 RELSZ
, LINESZ
, FILNMLEN_BIGOBJ
,
5964 COFF_DEFAULT_LONG_SECTION_NAMES
,
5965 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5969 coff_bigobj_swap_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5970 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5971 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5972 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5973 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5974 coff_classify_symbol
, coff_compute_section_file_positions
,
5975 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5976 coff_adjust_symndx
, coff_link_add_one_symbol
,
5977 coff_link_output_has_begun
, coff_final_link_postscript
,
5978 bfd_pe_print_pdata
/* huh */
5981 #endif /* COFF_WITH_PE_BIGOBJ */
5983 #ifndef coff_close_and_cleanup
5984 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5987 #ifndef coff_bfd_free_cached_info
5988 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5991 #ifndef coff_get_section_contents
5992 #define coff_get_section_contents _bfd_generic_get_section_contents
5995 #ifndef coff_bfd_copy_private_symbol_data
5996 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5999 #ifndef coff_bfd_copy_private_header_data
6000 #define coff_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
6003 #ifndef coff_bfd_copy_private_section_data
6004 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
6007 #ifndef coff_bfd_copy_private_bfd_data
6008 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
6011 #ifndef coff_bfd_merge_private_bfd_data
6012 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
6015 #ifndef coff_bfd_set_private_flags
6016 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
6019 #ifndef coff_bfd_print_private_bfd_data
6020 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
6023 #ifndef coff_bfd_is_local_label_name
6024 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
6027 #ifndef coff_bfd_is_target_special_symbol
6028 #define coff_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
6031 #ifndef coff_read_minisymbols
6032 #define coff_read_minisymbols _bfd_generic_read_minisymbols
6035 #ifndef coff_minisymbol_to_symbol
6036 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
6039 /* The reloc lookup routine must be supplied by each individual COFF
6041 #ifndef coff_bfd_reloc_type_lookup
6042 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
6044 #ifndef coff_bfd_reloc_name_lookup
6045 #define coff_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
6048 #ifndef coff_bfd_get_relocated_section_contents
6049 #define coff_bfd_get_relocated_section_contents \
6050 bfd_generic_get_relocated_section_contents
6053 #ifndef coff_bfd_relax_section
6054 #define coff_bfd_relax_section bfd_generic_relax_section
6057 #ifndef coff_bfd_gc_sections
6058 #define coff_bfd_gc_sections bfd_coff_gc_sections
6061 #ifndef coff_bfd_lookup_section_flags
6062 #define coff_bfd_lookup_section_flags bfd_generic_lookup_section_flags
6065 #ifndef coff_bfd_merge_sections
6066 #define coff_bfd_merge_sections bfd_generic_merge_sections
6069 #ifndef coff_bfd_is_group_section
6070 #define coff_bfd_is_group_section bfd_generic_is_group_section
6073 #ifndef coff_bfd_discard_group
6074 #define coff_bfd_discard_group bfd_generic_discard_group
6077 #ifndef coff_section_already_linked
6078 #define coff_section_already_linked \
6079 _bfd_coff_section_already_linked
6082 #ifndef coff_bfd_define_common_symbol
6083 #define coff_bfd_define_common_symbol bfd_generic_define_common_symbol
6086 #ifndef coff_bfd_define_start_stop
6087 #define coff_bfd_define_start_stop bfd_generic_define_start_stop
6090 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
6091 const bfd_target VAR = \
6094 bfd_target_coff_flavour, \
6095 BFD_ENDIAN_BIG, /* Data byte order is big. */ \
6096 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
6097 /* object flags */ \
6098 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
6099 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
6100 /* section flags */ \
6101 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
6102 UNDER, /* Leading symbol underscore. */ \
6103 '/', /* AR_pad_char. */ \
6104 15, /* AR_max_namelen. */ \
6105 0, /* match priority. */ \
6107 /* Data conversion functions. */ \
6108 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
6109 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
6110 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
6112 /* Header conversion functions. */ \
6113 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
6114 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
6115 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
6117 /* bfd_check_format. */ \
6118 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
6119 _bfd_dummy_target }, \
6120 /* bfd_set_format. */ \
6121 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
6122 /* bfd_write_contents. */ \
6123 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
6126 BFD_JUMP_TABLE_GENERIC (coff), \
6127 BFD_JUMP_TABLE_COPY (coff), \
6128 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
6129 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
6130 BFD_JUMP_TABLE_SYMBOLS (coff), \
6131 BFD_JUMP_TABLE_RELOCS (coff), \
6132 BFD_JUMP_TABLE_WRITE (coff), \
6133 BFD_JUMP_TABLE_LINK (coff), \
6134 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
6141 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
6142 const bfd_target VAR = \
6145 bfd_target_coff_flavour, \
6146 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
6147 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
6148 /* object flags */ \
6149 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
6150 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
6151 /* section flags */ \
6152 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
6153 UNDER, /* Leading symbol underscore. */ \
6154 '/', /* AR_pad_char. */ \
6155 15, /* AR_max_namelen. */ \
6156 0, /* match priority. */ \
6158 /* Data conversion functions. */ \
6159 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
6160 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
6161 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
6163 /* Header conversion functions. */ \
6164 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
6165 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
6166 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
6168 /* bfd_check_format. */ \
6169 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
6170 _bfd_dummy_target }, \
6171 /* bfd_set_format. */ \
6172 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
6173 /* bfd_write_contents. */ \
6174 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
6177 BFD_JUMP_TABLE_GENERIC (coff), \
6178 BFD_JUMP_TABLE_COPY (coff), \
6179 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
6180 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
6181 BFD_JUMP_TABLE_SYMBOLS (coff), \
6182 BFD_JUMP_TABLE_RELOCS (coff), \
6183 BFD_JUMP_TABLE_WRITE (coff), \
6184 BFD_JUMP_TABLE_LINK (coff), \
6185 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
6192 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
6193 const bfd_target VAR = \
6196 bfd_target_coff_flavour, \
6197 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
6198 BFD_ENDIAN_LITTLE, /* Header byte order is little. */ \
6199 /* object flags */ \
6200 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
6201 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
6202 /* section flags */ \
6203 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
6204 UNDER, /* Leading symbol underscore. */ \
6205 '/', /* AR_pad_char. */ \
6206 15, /* AR_max_namelen. */ \
6207 0, /* match priority. */ \
6209 /* Data conversion functions. */ \
6210 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
6211 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
6212 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
6213 /* Header conversion functions. */ \
6214 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
6215 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
6216 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
6217 /* bfd_check_format. */ \
6218 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
6219 _bfd_dummy_target }, \
6220 /* bfd_set_format. */ \
6221 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
6222 /* bfd_write_contents. */ \
6223 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
6226 BFD_JUMP_TABLE_GENERIC (coff), \
6227 BFD_JUMP_TABLE_COPY (coff), \
6228 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
6229 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
6230 BFD_JUMP_TABLE_SYMBOLS (coff), \
6231 BFD_JUMP_TABLE_RELOCS (coff), \
6232 BFD_JUMP_TABLE_WRITE (coff), \
6233 BFD_JUMP_TABLE_LINK (coff), \
6234 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \