1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
5 Written by Cygnus Support.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
24 /* Most of this hacked by Steve Chamberlain,
30 BFD supports a number of different flavours of coff format.
31 The major differences between formats are the sizes and
32 alignments of fields in structures on disk, and the occasional
35 Coff in all its varieties is implemented with a few common
36 files and a number of implementation specific files. For
37 example, The 88k bcs coff format is implemented in the file
38 @file{coff-m88k.c}. This file @code{#include}s
39 @file{coff/m88k.h} which defines the external structure of the
40 coff format for the 88k, and @file{coff/internal.h} which
41 defines the internal structure. @file{coff-m88k.c} also
42 defines the relocations used by the 88k format
45 The Intel i960 processor version of coff is implemented in
46 @file{coff-i960.c}. This file has the same structure as
47 @file{coff-m88k.c}, except that it includes @file{coff/i960.h}
48 rather than @file{coff-m88k.h}.
51 Porting to a new version of coff
53 The recommended method is to select from the existing
54 implementations the version of coff which is most like the one
55 you want to use. For example, we'll say that i386 coff is
56 the one you select, and that your coff flavour is called foo.
57 Copy @file{i386coff.c} to @file{foocoff.c}, copy
58 @file{../include/coff/i386.h} to @file{../include/coff/foo.h},
59 and add the lines to @file{targets.c} and @file{Makefile.in}
60 so that your new back end is used. Alter the shapes of the
61 structures in @file{../include/coff/foo.h} so that they match
62 what you need. You will probably also have to add
63 @code{#ifdef}s to the code in @file{coff/internal.h} and
64 @file{coffcode.h} if your version of coff is too wild.
66 You can verify that your new BFD backend works quite simply by
67 building @file{objdump} from the @file{binutils} directory,
68 and making sure that its version of what's going on and your
69 host system's idea (assuming it has the pretty standard coff
70 dump utility, usually called @code{att-dump} or just
71 @code{dump}) are the same. Then clean up your code, and send
72 what you've done to Cygnus. Then your stuff will be in the
73 next release, and you won't have to keep integrating it.
76 How the coff backend works
81 The Coff backend is split into generic routines that are
82 applicable to any Coff target and routines that are specific
83 to a particular target. The target-specific routines are
84 further split into ones which are basically the same for all
85 Coff targets except that they use the external symbol format
86 or use different values for certain constants.
88 The generic routines are in @file{coffgen.c}. These routines
89 work for any Coff target. They use some hooks into the target
90 specific code; the hooks are in a @code{bfd_coff_backend_data}
91 structure, one of which exists for each target.
93 The essentially similar target-specific routines are in
94 @file{coffcode.h}. This header file includes executable C code.
95 The various Coff targets first include the appropriate Coff
96 header file, make any special defines that are needed, and
97 then include @file{coffcode.h}.
99 Some of the Coff targets then also have additional routines in
100 the target source file itself.
102 For example, @file{coff-i960.c} includes
103 @file{coff/internal.h} and @file{coff/i960.h}. It then
104 defines a few constants, such as @code{I960}, and includes
105 @file{coffcode.h}. Since the i960 has complex relocation
106 types, @file{coff-i960.c} also includes some code to
107 manipulate the i960 relocs. This code is not in
108 @file{coffcode.h} because it would not be used by any other
112 Coff long section names
114 In the standard Coff object format, section names are limited to
115 the eight bytes available in the @code{s_name} field of the
116 @code{SCNHDR} section header structure. The format requires the
117 field to be NUL-padded, but not necessarily NUL-terminated, so
118 the longest section names permitted are a full eight characters.
120 The Microsoft PE variants of the Coff object file format add
121 an extension to support the use of long section names. This
122 extension is defined in section 4 of the Microsoft PE/COFF
123 specification (rev 8.1). If a section name is too long to fit
124 into the section header's @code{s_name} field, it is instead
125 placed into the string table, and the @code{s_name} field is
126 filled with a slash ("/") followed by the ASCII decimal
127 representation of the offset of the full name relative to the
130 Note that this implies that the extension can only be used in object
131 files, as executables do not contain a string table. The standard
132 specifies that long section names from objects emitted into executable
133 images are to be truncated.
135 However, as a GNU extension, BFD can generate executable images
136 that contain a string table and long section names. This
137 would appear to be technically valid, as the standard only says
138 that Coff debugging information is deprecated, not forbidden,
139 and in practice it works, although some tools that parse PE files
140 expecting the MS standard format may become confused; @file{PEview} is
143 The functionality is supported in BFD by code implemented under
144 the control of the macro @code{COFF_LONG_SECTION_NAMES}. If not
145 defined, the format does not support long section names in any way.
146 If defined, it is used to initialise a flag,
147 @code{_bfd_coff_long_section_names}, and a hook function pointer,
148 @code{_bfd_coff_set_long_section_names}, in the Coff backend data
149 structure. The flag controls the generation of long section names
150 in output BFDs at runtime; if it is false, as it will be by default
151 when generating an executable image, long section names are truncated;
152 if true, the long section names extension is employed. The hook
153 points to a function that allows the value of the flag to be altered
154 at runtime, on formats that support long section names at all; on
155 other formats it points to a stub that returns an error indication.
157 If @code{COFF_LONG_SECTION_NAMES} is simply defined (blank), or is
158 defined to the value "1", then long section names are enabled by
159 default; if it is defined to the value zero, they are disabled by
160 default (but still accepted in input BFDs). The header @file{coffcode.h}
161 defines a macro, @code{COFF_DEFAULT_LONG_SECTION_NAMES}, which is
162 used in the backends to initialise the backend data structure fields
163 appropriately; see the comments for further detail.
168 Each flavour of coff supported in BFD has its own header file
169 describing the external layout of the structures. There is also
170 an internal description of the coff layout, in
171 @file{coff/internal.h}. A major function of the
172 coff backend is swapping the bytes and twiddling the bits to
173 translate the external form of the structures into the normal
174 internal form. This is all performed in the
175 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
176 elements are different sizes between different versions of
177 coff; it is the duty of the coff version specific include file
178 to override the definitions of various packing routines in
179 @file{coffcode.h}. E.g., the size of line number entry in coff is
180 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
181 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
182 correct one. No doubt, some day someone will find a version of
183 coff which has a varying field size not catered to at the
184 moment. To port BFD, that person will have to add more @code{#defines}.
185 Three of the bit twiddling routines are exported to
186 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
187 and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol
188 table on its own, but uses BFD to fix things up. More of the
189 bit twiddlers are exported for @code{gas};
190 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
191 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
192 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
193 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
194 of all the symbol table and reloc drudgery itself, thereby
195 saving the internal BFD overhead, but uses BFD to swap things
196 on the way out, making cross ports much safer. Doing so also
197 allows BFD (and thus the linker) to use the same header files
198 as @code{gas}, which makes one avenue to disaster disappear.
203 The simple canonical form for symbols used by BFD is not rich
204 enough to keep all the information available in a coff symbol
205 table. The back end gets around this problem by keeping the original
206 symbol table around, "behind the scenes".
208 When a symbol table is requested (through a call to
209 @code{bfd_canonicalize_symtab}), a request gets through to
210 @code{coff_get_normalized_symtab}. This reads the symbol table from
211 the coff file and swaps all the structures inside into the
212 internal form. It also fixes up all the pointers in the table
213 (represented in the file by offsets from the first symbol in
214 the table) into physical pointers to elements in the new
215 internal table. This involves some work since the meanings of
216 fields change depending upon context: a field that is a
217 pointer to another structure in the symbol table at one moment
218 may be the size in bytes of a structure at the next. Another
219 pass is made over the table. All symbols which mark file names
220 (<<C_FILE>> symbols) are modified so that the internal
221 string points to the value in the auxent (the real filename)
222 rather than the normal text associated with the symbol
225 At this time the symbol names are moved around. Coff stores
226 all symbols less than nine characters long physically
227 within the symbol table; longer strings are kept at the end of
228 the file in the string table. This pass moves all strings
229 into memory and replaces them with pointers to the strings.
231 The symbol table is massaged once again, this time to create
232 the canonical table used by the BFD application. Each symbol
233 is inspected in turn, and a decision made (using the
234 @code{sclass} field) about the various flags to set in the
235 @code{asymbol}. @xref{Symbols}. The generated canonical table
236 shares strings with the hidden internal symbol table.
238 Any linenumbers are read from the coff file too, and attached
239 to the symbols which own the functions the linenumbers belong to.
244 Writing a symbol to a coff file which didn't come from a coff
245 file will lose any debugging information. The @code{asymbol}
246 structure remembers the BFD from which the symbol was taken, and on
247 output the back end makes sure that the same destination target as
248 source target is present.
250 When the symbols have come from a coff file then all the
251 debugging information is preserved.
253 Symbol tables are provided for writing to the back end in a
254 vector of pointers to pointers. This allows applications like
255 the linker to accumulate and output large symbol tables
256 without having to do too much byte copying.
258 This function runs through the provided symbol table and
259 patches each symbol marked as a file place holder
260 (@code{C_FILE}) to point to the next file place holder in the
261 list. It also marks each @code{offset} field in the list with
262 the offset from the first symbol of the current symbol.
264 Another function of this procedure is to turn the canonical
265 value form of BFD into the form used by coff. Internally, BFD
266 expects symbol values to be offsets from a section base; so a
267 symbol physically at 0x120, but in a section starting at
268 0x100, would have the value 0x20. Coff expects symbols to
269 contain their final value, so symbols have their values
270 changed at this point to reflect their sum with their owning
271 section. This transformation uses the
272 <<output_section>> field of the @code{asymbol}'s
273 @code{asection} @xref{Sections}.
275 o <<coff_mangle_symbols>>
277 This routine runs though the provided symbol table and uses
278 the offsets generated by the previous pass and the pointers
279 generated when the symbol table was read in to create the
280 structured hierarchy required by coff. It changes each pointer
281 to a symbol into the index into the symbol table of the asymbol.
283 o <<coff_write_symbols>>
285 This routine runs through the symbol table and patches up the
286 symbols from their internal form into the coff way, calls the
287 bit twiddlers, and writes out the table to the file.
296 The hidden information for an <<asymbol>> is described in a
297 <<combined_entry_type>>:
301 .typedef struct coff_ptr_struct
303 . {* Remembers the offset from the first symbol in the file for
304 . this symbol. Generated by coff_renumber_symbols. *}
305 . unsigned int offset;
307 . {* Should the value of this symbol be renumbered. Used for
308 . XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
309 . unsigned int fix_value : 1;
311 . {* Should the tag field of this symbol be renumbered.
312 . Created by coff_pointerize_aux. *}
313 . unsigned int fix_tag : 1;
315 . {* Should the endidx field of this symbol be renumbered.
316 . Created by coff_pointerize_aux. *}
317 . unsigned int fix_end : 1;
319 . {* Should the x_csect.x_scnlen field be renumbered.
320 . Created by coff_pointerize_aux. *}
321 . unsigned int fix_scnlen : 1;
323 . {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
324 . index into the line number entries. Set by coff_slurp_symbol_table. *}
325 . unsigned int fix_line : 1;
327 . {* The container for the symbol structure as read and translated
331 . union internal_auxent auxent;
332 . struct internal_syment syment;
334 .} combined_entry_type;
337 .{* Each canonical asymbol really looks like this: *}
339 .typedef struct coff_symbol_struct
341 . {* The actual symbol which the rest of BFD works with *}
344 . {* A pointer to the hidden information for this symbol *}
345 . combined_entry_type *native;
347 . {* A pointer to the linenumber information for this symbol *}
348 . struct lineno_cache_entry *lineno;
350 . {* Have the line numbers been relocated yet ? *}
351 . bfd_boolean done_lineno;
359 #include "coffswap.h"
362 #define STRING_SIZE_SIZE 4
364 #define DOT_DEBUG ".debug"
365 #define GNU_LINKONCE_WI ".gnu.linkonce.wi."
367 #if defined (COFF_LONG_SECTION_NAMES)
368 /* Needed to expand the inputs to BLANKOR1TOODD. */
369 #define COFFLONGSECTIONCATHELPER(x,y) x ## y
370 /* If the input macro Y is blank or '1', return an odd number; if it is
371 '0', return an even number. Result undefined in all other cases. */
372 #define BLANKOR1TOODD(y) COFFLONGSECTIONCATHELPER(1,y)
373 /* Defined to numerical 0 or 1 according to whether generation of long
374 section names is disabled or enabled by default. */
375 #define COFF_ENABLE_LONG_SECTION_NAMES (BLANKOR1TOODD(COFF_LONG_SECTION_NAMES) & 1)
376 /* Where long section names are supported, we allow them to be enabled
377 and disabled at runtime, so select an appropriate hook function for
378 _bfd_coff_set_long_section_names. */
379 #define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_allowed
380 #else /* !defined (COFF_LONG_SECTION_NAMES) */
381 /* If long section names are not supported, this stub disallows any
382 attempt to enable them at run-time. */
383 #define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_disallowed
384 #endif /* defined (COFF_LONG_SECTION_NAMES) */
386 /* Define a macro that can be used to initialise both the fields relating
387 to long section names in the backend data struct simultaneously. */
388 #if COFF_ENABLE_LONG_SECTION_NAMES
389 #define COFF_DEFAULT_LONG_SECTION_NAMES (TRUE), COFF_LONG_SECTION_NAMES_SETTER
390 #else /* !COFF_ENABLE_LONG_SECTION_NAMES */
391 #define COFF_DEFAULT_LONG_SECTION_NAMES (FALSE), COFF_LONG_SECTION_NAMES_SETTER
392 #endif /* COFF_ENABLE_LONG_SECTION_NAMES */
394 #if defined (COFF_LONG_SECTION_NAMES)
395 static bfd_boolean bfd_coff_set_long_section_names_allowed
397 #else /* !defined (COFF_LONG_SECTION_NAMES) */
398 static bfd_boolean bfd_coff_set_long_section_names_disallowed
400 #endif /* defined (COFF_LONG_SECTION_NAMES) */
401 static long sec_to_styp_flags
402 (const char *, flagword
);
403 static bfd_boolean styp_to_sec_flags
404 (bfd
*, void *, const char *, asection
*, flagword
*);
405 static bfd_boolean coff_bad_format_hook
407 static void coff_set_custom_section_alignment
408 (bfd
*, asection
*, const struct coff_section_alignment_entry
*,
410 static bfd_boolean coff_new_section_hook
412 static bfd_boolean coff_set_arch_mach_hook
414 static bfd_boolean coff_write_relocs
416 static bfd_boolean coff_set_flags
417 (bfd
*, unsigned int *, unsigned short *);
418 static bfd_boolean coff_set_arch_mach
419 (bfd
*, enum bfd_architecture
, unsigned long) ATTRIBUTE_UNUSED
;
420 static bfd_boolean coff_compute_section_file_positions
422 static bfd_boolean coff_write_object_contents
423 (bfd
*) ATTRIBUTE_UNUSED
;
424 static bfd_boolean coff_set_section_contents
425 (bfd
*, asection
*, const void *, file_ptr
, bfd_size_type
);
426 static void * buy_and_read
427 (bfd
*, file_ptr
, bfd_size_type
);
428 static bfd_boolean coff_slurp_line_table
430 static bfd_boolean coff_slurp_symbol_table
432 static enum coff_symbol_classification coff_classify_symbol
433 (bfd
*, struct internal_syment
*);
434 static bfd_boolean coff_slurp_reloc_table
435 (bfd
*, asection
*, asymbol
**);
436 static long coff_canonicalize_reloc
437 (bfd
*, asection
*, arelent
**, asymbol
**);
438 #ifndef coff_mkobject_hook
439 static void * coff_mkobject_hook
440 (bfd
*, void *, void *);
443 static flagword handle_COMDAT
444 (bfd
*, flagword
, void *, const char *, asection
*);
446 #ifdef COFF_IMAGE_WITH_PE
447 static bfd_boolean coff_read_word
448 (bfd
*, unsigned int *);
449 static unsigned int coff_compute_checksum
451 static bfd_boolean coff_apply_checksum
455 static bfd_boolean ticoff0_bad_format_hook
457 static bfd_boolean ticoff1_bad_format_hook
461 /* void warning(); */
463 #if defined (COFF_LONG_SECTION_NAMES)
465 bfd_coff_set_long_section_names_allowed (bfd
*abfd
, int enable
)
467 coff_backend_info (abfd
)->_bfd_coff_long_section_names
= enable
;
470 #else /* !defined (COFF_LONG_SECTION_NAMES) */
472 bfd_coff_set_long_section_names_disallowed (bfd
*abfd
, int enable
)
478 #endif /* defined (COFF_LONG_SECTION_NAMES) */
480 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
481 the incoming SEC_* flags. The inverse of this function is
482 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
483 should probably mirror the changes in styp_to_sec_flags(). */
487 /* Macros for setting debugging flags. */
490 #define STYP_XCOFF_DEBUG STYP_DEBUG
492 #define STYP_XCOFF_DEBUG STYP_INFO
495 #ifdef COFF_ALIGN_IN_S_FLAGS
496 #define STYP_DEBUG_INFO STYP_DSECT
498 #define STYP_DEBUG_INFO STYP_INFO
502 sec_to_styp_flags (const char *sec_name
, flagword sec_flags
)
506 if (!strcmp (sec_name
, _TEXT
))
508 styp_flags
= STYP_TEXT
;
510 else if (!strcmp (sec_name
, _DATA
))
512 styp_flags
= STYP_DATA
;
514 else if (!strcmp (sec_name
, _BSS
))
516 styp_flags
= STYP_BSS
;
519 else if (!strcmp (sec_name
, _COMMENT
))
521 styp_flags
= STYP_INFO
;
522 #endif /* _COMMENT */
525 else if (!strcmp (sec_name
, _LIB
))
527 styp_flags
= STYP_LIB
;
531 else if (!strcmp (sec_name
, _LIT
))
533 styp_flags
= STYP_LIT
;
536 else if (CONST_STRNEQ (sec_name
, DOT_DEBUG
))
538 /* Handle the XCOFF debug section and DWARF2 debug sections. */
540 styp_flags
= STYP_XCOFF_DEBUG
;
542 styp_flags
= STYP_DEBUG_INFO
;
544 else if (CONST_STRNEQ (sec_name
, ".stab"))
546 styp_flags
= STYP_DEBUG_INFO
;
548 #ifdef COFF_LONG_SECTION_NAMES
549 else if (CONST_STRNEQ (sec_name
, GNU_LINKONCE_WI
))
551 styp_flags
= STYP_DEBUG_INFO
;
555 else if (!strcmp (sec_name
, _PAD
))
557 styp_flags
= STYP_PAD
;
559 else if (!strcmp (sec_name
, _LOADER
))
561 styp_flags
= STYP_LOADER
;
563 else if (!strcmp (sec_name
, _EXCEPT
))
565 styp_flags
= STYP_EXCEPT
;
567 else if (!strcmp (sec_name
, _TYPCHK
))
569 styp_flags
= STYP_TYPCHK
;
572 /* Try and figure out what it should be */
573 else if (sec_flags
& SEC_CODE
)
575 styp_flags
= STYP_TEXT
;
577 else if (sec_flags
& SEC_DATA
)
579 styp_flags
= STYP_DATA
;
581 else if (sec_flags
& SEC_READONLY
)
583 #ifdef STYP_LIT /* 29k readonly text/data section */
584 styp_flags
= STYP_LIT
;
586 styp_flags
= STYP_TEXT
;
587 #endif /* STYP_LIT */
589 else if (sec_flags
& SEC_LOAD
)
591 styp_flags
= STYP_TEXT
;
593 else if (sec_flags
& SEC_ALLOC
)
595 styp_flags
= STYP_BSS
;
599 if (sec_flags
& SEC_TIC54X_CLINK
)
600 styp_flags
|= STYP_CLINK
;
604 if (sec_flags
& SEC_TIC54X_BLOCK
)
605 styp_flags
|= STYP_BLOCK
;
609 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
610 styp_flags
|= STYP_NOLOAD
;
616 #else /* COFF_WITH_PE */
618 /* The PE version; see above for the general comments. The non-PE
619 case seems to be more guessing, and breaks PE format; specifically,
620 .rdata is readonly, but it sure ain't text. Really, all this
621 should be set up properly in gas (or whatever assembler is in use),
622 and honor whatever objcopy/strip, etc. sent us as input. */
625 sec_to_styp_flags (const char *sec_name
, flagword sec_flags
)
629 /* caution: there are at least three groups of symbols that have
630 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
631 SEC_* are the BFD internal flags, used for generic BFD
632 information. STYP_* are the COFF section flags which appear in
633 COFF files. IMAGE_SCN_* are the PE section flags which appear in
634 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
635 but there are more IMAGE_SCN_* flags. */
637 /* FIXME: There is no gas syntax to specify the debug section flag. */
638 if (CONST_STRNEQ (sec_name
, DOT_DEBUG
)
639 || CONST_STRNEQ (sec_name
, GNU_LINKONCE_WI
))
640 sec_flags
= SEC_DEBUGGING
;
645 if ((sec_flags
& SEC_CODE
) != 0)
646 styp_flags
|= IMAGE_SCN_CNT_CODE
;
647 if ((sec_flags
& SEC_DATA
) != 0)
648 styp_flags
|= IMAGE_SCN_CNT_INITIALIZED_DATA
;
649 if ((sec_flags
& SEC_ALLOC
) != 0 && (sec_flags
& SEC_LOAD
) == 0)
650 styp_flags
|= IMAGE_SCN_CNT_UNINITIALIZED_DATA
; /* ==STYP_BSS */
652 /* skip constRUCTOR */
654 if ((sec_flags
& SEC_IS_COMMON
) != 0)
655 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
656 if ((sec_flags
& SEC_DEBUGGING
) != 0)
657 styp_flags
|= IMAGE_SCN_MEM_DISCARDABLE
;
658 if ((sec_flags
& SEC_EXCLUDE
) != 0)
659 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
660 if ((sec_flags
& SEC_NEVER_LOAD
) != 0)
661 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
664 if (sec_flags
& SEC_LINK_ONCE
)
665 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
666 /* skip LINK_DUPLICATES */
667 /* skip LINKER_CREATED */
669 if (sec_flags
& (SEC_ALLOC
| SEC_LOAD
))
671 /* For now, the read/write bits are mapped onto SEC_READONLY, even
672 though the semantics don't quite match. The bits from the input
673 are retained in pei_section_data(abfd, section)->pe_flags. */
674 styp_flags
|= IMAGE_SCN_MEM_READ
; /* Always readable. */
675 if ((sec_flags
& SEC_READONLY
) == 0)
676 styp_flags
|= IMAGE_SCN_MEM_WRITE
; /* Invert READONLY for write. */
677 if (sec_flags
& SEC_CODE
)
678 styp_flags
|= IMAGE_SCN_MEM_EXECUTE
; /* CODE->EXECUTE. */
679 if (sec_flags
& SEC_COFF_SHARED
)
680 styp_flags
|= IMAGE_SCN_MEM_SHARED
; /* Shared remains meaningful. */
686 #endif /* COFF_WITH_PE */
688 /* Return a word with SEC_* flags set to represent the incoming STYP_*
689 flags (from scnhdr.s_flags). The inverse of this function is
690 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
691 should probably mirror the changes in sec_to_styp_flags(). */
696 styp_to_sec_flags (bfd
*abfd ATTRIBUTE_UNUSED
,
699 asection
*section ATTRIBUTE_UNUSED
,
702 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
703 long styp_flags
= internal_s
->s_flags
;
704 flagword sec_flags
= 0;
707 if (styp_flags
& STYP_BLOCK
)
708 sec_flags
|= SEC_TIC54X_BLOCK
;
712 if (styp_flags
& STYP_CLINK
)
713 sec_flags
|= SEC_TIC54X_CLINK
;
717 if (styp_flags
& STYP_NOLOAD
)
718 sec_flags
|= SEC_NEVER_LOAD
;
719 #endif /* STYP_NOLOAD */
721 /* For 386 COFF, at least, an unloadable text or data section is
722 actually a shared library section. */
723 if (styp_flags
& STYP_TEXT
)
725 if (sec_flags
& SEC_NEVER_LOAD
)
726 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
728 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
730 else if (styp_flags
& STYP_DATA
)
732 if (sec_flags
& SEC_NEVER_LOAD
)
733 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
735 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
737 else if (styp_flags
& STYP_BSS
)
739 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
740 if (sec_flags
& SEC_NEVER_LOAD
)
741 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
744 sec_flags
|= SEC_ALLOC
;
746 else if (styp_flags
& STYP_INFO
)
748 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
749 defined. coff_compute_section_file_positions uses
750 COFF_PAGE_SIZE to ensure that the low order bits of the
751 section VMA and the file offset match. If we don't know
752 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
753 and demand page loading of the file will fail. */
754 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
755 sec_flags
|= SEC_DEBUGGING
;
758 else if (styp_flags
& STYP_PAD
)
760 else if (strcmp (name
, _TEXT
) == 0)
762 if (sec_flags
& SEC_NEVER_LOAD
)
763 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
765 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
767 else if (strcmp (name
, _DATA
) == 0)
769 if (sec_flags
& SEC_NEVER_LOAD
)
770 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
772 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
774 else if (strcmp (name
, _BSS
) == 0)
776 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
777 if (sec_flags
& SEC_NEVER_LOAD
)
778 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
781 sec_flags
|= SEC_ALLOC
;
783 else if (CONST_STRNEQ (name
, DOT_DEBUG
)
785 || strcmp (name
, _COMMENT
) == 0
787 #ifdef COFF_LONG_SECTION_NAMES
788 || CONST_STRNEQ (name
, GNU_LINKONCE_WI
)
790 || CONST_STRNEQ (name
, ".stab"))
792 #ifdef COFF_PAGE_SIZE
793 sec_flags
|= SEC_DEBUGGING
;
797 else if (strcmp (name
, _LIB
) == 0)
801 else if (strcmp (name
, _LIT
) == 0)
802 sec_flags
= SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
805 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
807 #ifdef STYP_LIT /* A29k readonly text/data section type. */
808 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
809 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
810 #endif /* STYP_LIT */
812 #ifdef STYP_OTHER_LOAD /* Other loaded sections. */
813 if (styp_flags
& STYP_OTHER_LOAD
)
814 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
815 #endif /* STYP_SDATA */
817 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
818 /* As a GNU extension, if the name begins with .gnu.linkonce, we
819 only link a single copy of the section. This is used to support
820 g++. g++ will emit each template expansion in its own section.
821 The symbols will be defined as weak, so that multiple definitions
822 are permitted. The GNU linker extension is to actually discard
823 all but one of the sections. */
824 if (CONST_STRNEQ (name
, ".gnu.linkonce"))
825 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
828 if (flags_ptr
== NULL
)
831 * flags_ptr
= sec_flags
;
835 #else /* COFF_WITH_PE */
838 handle_COMDAT (bfd
* abfd
,
844 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
845 bfd_byte
*esymstart
, *esym
, *esymend
;
847 char *target_name
= NULL
;
849 sec_flags
|= SEC_LINK_ONCE
;
851 /* Unfortunately, the PE format stores essential information in
852 the symbol table, of all places. We need to extract that
853 information now, so that objdump and the linker will know how
854 to handle the section without worrying about the symbols. We
855 can't call slurp_symtab, because the linker doesn't want the
858 /* COMDAT sections are special. The first symbol is the section
859 symbol, which tells what kind of COMDAT section it is. The
860 second symbol is the "comdat symbol" - the one with the
861 unique name. GNU uses the section symbol for the unique
862 name; MS uses ".text" for every comdat section. Sigh. - DJ */
864 /* This is not mirrored in sec_to_styp_flags(), but there
865 doesn't seem to be a need to, either, and it would at best be
868 if (! _bfd_coff_get_external_symbols (abfd
))
871 esymstart
= esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
872 esymend
= esym
+ obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
874 while (esym
< esymend
)
876 struct internal_syment isym
;
877 char buf
[SYMNMLEN
+ 1];
880 bfd_coff_swap_sym_in (abfd
, esym
, & isym
);
882 if (sizeof (internal_s
->s_name
) > SYMNMLEN
)
884 /* This case implies that the matching
885 symbol name will be in the string table. */
889 if (isym
.n_scnum
== section
->target_index
)
891 /* According to the MSVC documentation, the first
892 TWO entries with the section # are both of
893 interest to us. The first one is the "section
894 symbol" (section name). The second is the comdat
895 symbol name. Here, we've found the first
896 qualifying entry; we distinguish it from the
897 second with a state flag.
899 In the case of gas-generated (at least until that
900 is fixed) .o files, it isn't necessarily the
901 second one. It may be some other later symbol.
903 Since gas also doesn't follow MS conventions and
904 emits the section similar to .text$<name>, where
905 <something> is the name we're looking for, we
906 distinguish the two as follows:
908 If the section name is simply a section name (no
909 $) we presume it's MS-generated, and look at
910 precisely the second symbol for the comdat name.
911 If the section name has a $, we assume it's
912 gas-generated, and look for <something> (whatever
913 follows the $) as the comdat symbol. */
915 /* All 3 branches use this. */
916 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
, buf
);
925 /* The first time we've seen the symbol. */
926 union internal_auxent aux
;
928 /* If it isn't the stuff we're expecting, die;
929 The MS documentation is vague, but it
930 appears that the second entry serves BOTH
931 as the comdat symbol and the defining
932 symbol record (either C_STAT or C_EXT,
933 possibly with an aux entry with debug
934 information if it's a function.) It
935 appears the only way to find the second one
936 is to count. (On Intel, they appear to be
937 adjacent, but on Alpha, they have been
940 Here, we think we've found the first one,
941 but there's some checking we can do to be
944 if (! (isym
.n_sclass
== C_STAT
945 && isym
.n_type
== T_NULL
946 && isym
.n_value
== 0))
949 /* FIXME LATER: MSVC generates section names
950 like .text for comdats. Gas generates
951 names like .text$foo__Fv (in the case of a
952 function). See comment above for more. */
954 if (strcmp (name
, symname
) != 0)
955 _bfd_error_handler (_("%B: warning: COMDAT symbol '%s' does not match section name '%s'"),
956 abfd
, symname
, name
);
960 /* This is the section symbol. */
961 bfd_coff_swap_aux_in (abfd
, (esym
+ bfd_coff_symesz (abfd
)),
962 isym
.n_type
, isym
.n_sclass
,
963 0, isym
.n_numaux
, & aux
);
965 target_name
= strchr (name
, '$');
966 if (target_name
!= NULL
)
974 /* FIXME: Microsoft uses NODUPLICATES and
975 ASSOCIATIVE, but gnu uses ANY and
976 SAME_SIZE. Unfortunately, gnu doesn't do
977 the comdat symbols right. So, until we can
978 fix it to do the right thing, we are
979 temporarily disabling comdats for the MS
980 types (they're used in DLLs and C++, but we
981 don't support *their* C++ libraries anyway
984 /* Cygwin does not follow the MS style, and
985 uses ANY and SAME_SIZE where NODUPLICATES
986 and ASSOCIATIVE should be used. For
987 Interix, we just do the right thing up
990 switch (aux
.x_scn
.x_comdat
)
992 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
993 #ifdef STRICT_PE_FORMAT
994 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
996 sec_flags
&= ~SEC_LINK_ONCE
;
1000 case IMAGE_COMDAT_SELECT_ANY
:
1001 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1004 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
1005 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
1008 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
1009 /* Not yet fully implemented ??? */
1010 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
1013 /* debug$S gets this case; other
1016 /* There may be no symbol... we'll search
1017 the whole table... Is this the right
1018 place to play this game? Or should we do
1019 it when reading it in. */
1020 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
1021 #ifdef STRICT_PE_FORMAT
1022 /* FIXME: This is not currently implemented. */
1023 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1025 sec_flags
&= ~SEC_LINK_ONCE
;
1029 default: /* 0 means "no symbol" */
1030 /* debug$F gets this case; other
1032 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1039 /* Gas mode: the first matching on partial name. */
1041 #ifndef TARGET_UNDERSCORE
1042 #define TARGET_UNDERSCORE 0
1044 /* Is this the name we're looking for ? */
1045 if (strcmp (target_name
,
1046 symname
+ (TARGET_UNDERSCORE
? 1 : 0)) != 0)
1048 /* Not the name we're looking for */
1049 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1054 /* MSVC mode: the lexically second symbol (or
1055 drop through from the above). */
1060 /* This must the second symbol with the
1061 section #. It is the actual symbol name.
1062 Intel puts the two adjacent, but Alpha (at
1063 least) spreads them out. */
1065 amt
= sizeof (struct coff_comdat_info
);
1066 coff_section_data (abfd
, section
)->comdat
1067 = bfd_alloc (abfd
, amt
);
1068 if (coff_section_data (abfd
, section
)->comdat
== NULL
)
1071 coff_section_data (abfd
, section
)->comdat
->symbol
=
1072 (esym
- esymstart
) / bfd_coff_symesz (abfd
);
1074 amt
= strlen (symname
) + 1;
1075 newname
= bfd_alloc (abfd
, amt
);
1076 if (newname
== NULL
)
1079 strcpy (newname
, symname
);
1080 coff_section_data (abfd
, section
)->comdat
->name
1088 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1096 /* The PE version; see above for the general comments.
1098 Since to set the SEC_LINK_ONCE and associated flags, we have to
1099 look at the symbol table anyway, we return the symbol table index
1100 of the symbol being used as the COMDAT symbol. This is admittedly
1101 ugly, but there's really nowhere else that we have access to the
1102 required information. FIXME: Is the COMDAT symbol index used for
1103 any purpose other than objdump? */
1106 styp_to_sec_flags (bfd
*abfd
,
1110 flagword
*flags_ptr
)
1112 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
1113 long styp_flags
= internal_s
->s_flags
;
1115 bfd_boolean result
= TRUE
;
1117 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
1118 sec_flags
= SEC_READONLY
;
1120 /* Process each flag bit in styp_flags in turn. */
1123 long flag
= styp_flags
& - styp_flags
;
1124 char * unhandled
= NULL
;
1126 styp_flags
&= ~ flag
;
1128 /* We infer from the distinct read/write/execute bits the settings
1129 of some of the bfd flags; the actual values, should we need them,
1130 are also in pei_section_data (abfd, section)->pe_flags. */
1135 unhandled
= "STYP_DSECT";
1138 unhandled
= "STYP_GROUP";
1141 unhandled
= "STYP_COPY";
1144 unhandled
= "STYP_OVER";
1146 #ifdef SEC_NEVER_LOAD
1148 sec_flags
|= SEC_NEVER_LOAD
;
1151 case IMAGE_SCN_MEM_READ
:
1152 /* Ignored, assume it always to be true. */
1154 case IMAGE_SCN_TYPE_NO_PAD
:
1157 case IMAGE_SCN_LNK_OTHER
:
1158 unhandled
= "IMAGE_SCN_LNK_OTHER";
1160 case IMAGE_SCN_MEM_NOT_CACHED
:
1161 unhandled
= "IMAGE_SCN_MEM_NOT_CACHED";
1163 case IMAGE_SCN_MEM_NOT_PAGED
:
1164 /* Generate a warning message rather using the 'unhandled'
1165 variable as this will allow some .sys files generate by
1166 other toolchains to be processed. See bugzilla issue 196. */
1167 _bfd_error_handler (_("%B: Warning: Ignoring section flag IMAGE_SCN_MEM_NOT_PAGED in section %s"),
1170 case IMAGE_SCN_MEM_EXECUTE
:
1171 sec_flags
|= SEC_CODE
;
1173 case IMAGE_SCN_MEM_WRITE
:
1174 sec_flags
&= ~ SEC_READONLY
;
1176 case IMAGE_SCN_MEM_DISCARDABLE
:
1177 /* The MS PE spec says that debug sections are DISCARDABLE,
1178 but the presence of a DISCARDABLE flag does not necessarily
1179 mean that a given section contains debug information. Thus
1180 we only set the SEC_DEBUGGING flag on sections that we
1181 recognise as containing debug information. */
1182 if (CONST_STRNEQ (name
, DOT_DEBUG
)
1184 || strcmp (name
, _COMMENT
) == 0
1186 #ifdef COFF_LONG_SECTION_NAMES
1187 || CONST_STRNEQ (name
, GNU_LINKONCE_WI
)
1189 || CONST_STRNEQ (name
, ".stab"))
1190 sec_flags
|= SEC_DEBUGGING
;
1192 case IMAGE_SCN_MEM_SHARED
:
1193 sec_flags
|= SEC_COFF_SHARED
;
1195 case IMAGE_SCN_LNK_REMOVE
:
1196 sec_flags
|= SEC_EXCLUDE
;
1198 case IMAGE_SCN_CNT_CODE
:
1199 sec_flags
|= SEC_CODE
| SEC_ALLOC
| SEC_LOAD
;
1201 case IMAGE_SCN_CNT_INITIALIZED_DATA
:
1202 sec_flags
|= SEC_DATA
| SEC_ALLOC
| SEC_LOAD
;
1204 case IMAGE_SCN_CNT_UNINITIALIZED_DATA
:
1205 sec_flags
|= SEC_ALLOC
;
1207 case IMAGE_SCN_LNK_INFO
:
1208 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1209 defined. coff_compute_section_file_positions uses
1210 COFF_PAGE_SIZE to ensure that the low order bits of the
1211 section VMA and the file offset match. If we don't know
1212 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1213 and demand page loading of the file will fail. */
1214 #ifdef COFF_PAGE_SIZE
1215 sec_flags
|= SEC_DEBUGGING
;
1218 case IMAGE_SCN_LNK_COMDAT
:
1219 /* COMDAT gets very special treatment. */
1220 sec_flags
= handle_COMDAT (abfd
, sec_flags
, hdr
, name
, section
);
1223 /* Silently ignore for now. */
1227 /* If the section flag was not handled, report it here. */
1228 if (unhandled
!= NULL
)
1230 (*_bfd_error_handler
)
1231 (_("%B (%s): Section flag %s (0x%x) ignored"),
1232 abfd
, name
, unhandled
, flag
);
1237 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1238 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1239 only link a single copy of the section. This is used to support
1240 g++. g++ will emit each template expansion in its own section.
1241 The symbols will be defined as weak, so that multiple definitions
1242 are permitted. The GNU linker extension is to actually discard
1243 all but one of the sections. */
1244 if (CONST_STRNEQ (name
, ".gnu.linkonce"))
1245 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1249 * flags_ptr
= sec_flags
;
1254 #endif /* COFF_WITH_PE */
1256 #define get_index(symbol) ((symbol)->udata.i)
1260 bfd_coff_backend_data
1264 .{* COFF symbol classifications. *}
1266 .enum coff_symbol_classification
1268 . {* Global symbol. *}
1269 . COFF_SYMBOL_GLOBAL,
1270 . {* Common symbol. *}
1271 . COFF_SYMBOL_COMMON,
1272 . {* Undefined symbol. *}
1273 . COFF_SYMBOL_UNDEFINED,
1274 . {* Local symbol. *}
1275 . COFF_SYMBOL_LOCAL,
1276 . {* PE section symbol. *}
1277 . COFF_SYMBOL_PE_SECTION
1280 Special entry points for gdb to swap in coff symbol table parts:
1283 . void (*_bfd_coff_swap_aux_in)
1284 . (bfd *, void *, int, int, int, int, void *);
1286 . void (*_bfd_coff_swap_sym_in)
1287 . (bfd *, void *, void *);
1289 . void (*_bfd_coff_swap_lineno_in)
1290 . (bfd *, void *, void *);
1292 . unsigned int (*_bfd_coff_swap_aux_out)
1293 . (bfd *, void *, int, int, int, int, void *);
1295 . unsigned int (*_bfd_coff_swap_sym_out)
1296 . (bfd *, void *, void *);
1298 . unsigned int (*_bfd_coff_swap_lineno_out)
1299 . (bfd *, void *, void *);
1301 . unsigned int (*_bfd_coff_swap_reloc_out)
1302 . (bfd *, void *, void *);
1304 . unsigned int (*_bfd_coff_swap_filehdr_out)
1305 . (bfd *, void *, void *);
1307 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1308 . (bfd *, void *, void *);
1310 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1311 . (bfd *, void *, void *);
1313 . unsigned int _bfd_filhsz;
1314 . unsigned int _bfd_aoutsz;
1315 . unsigned int _bfd_scnhsz;
1316 . unsigned int _bfd_symesz;
1317 . unsigned int _bfd_auxesz;
1318 . unsigned int _bfd_relsz;
1319 . unsigned int _bfd_linesz;
1320 . unsigned int _bfd_filnmlen;
1321 . bfd_boolean _bfd_coff_long_filenames;
1323 . bfd_boolean _bfd_coff_long_section_names;
1324 . bfd_boolean (*_bfd_coff_set_long_section_names)
1327 . unsigned int _bfd_coff_default_section_alignment_power;
1328 . bfd_boolean _bfd_coff_force_symnames_in_strings;
1329 . unsigned int _bfd_coff_debug_string_prefix_length;
1331 . void (*_bfd_coff_swap_filehdr_in)
1332 . (bfd *, void *, void *);
1334 . void (*_bfd_coff_swap_aouthdr_in)
1335 . (bfd *, void *, void *);
1337 . void (*_bfd_coff_swap_scnhdr_in)
1338 . (bfd *, void *, void *);
1340 . void (*_bfd_coff_swap_reloc_in)
1341 . (bfd *abfd, void *, void *);
1343 . bfd_boolean (*_bfd_coff_bad_format_hook)
1346 . bfd_boolean (*_bfd_coff_set_arch_mach_hook)
1349 . void * (*_bfd_coff_mkobject_hook)
1350 . (bfd *, void *, void *);
1352 . bfd_boolean (*_bfd_styp_to_sec_flags_hook)
1353 . (bfd *, void *, const char *, asection *, flagword *);
1355 . void (*_bfd_set_alignment_hook)
1356 . (bfd *, asection *, void *);
1358 . bfd_boolean (*_bfd_coff_slurp_symbol_table)
1361 . bfd_boolean (*_bfd_coff_symname_in_debug)
1362 . (bfd *, struct internal_syment *);
1364 . bfd_boolean (*_bfd_coff_pointerize_aux_hook)
1365 . (bfd *, combined_entry_type *, combined_entry_type *,
1366 . unsigned int, combined_entry_type *);
1368 . bfd_boolean (*_bfd_coff_print_aux)
1369 . (bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1370 . combined_entry_type *, unsigned int);
1372 . void (*_bfd_coff_reloc16_extra_cases)
1373 . (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1374 . bfd_byte *, unsigned int *, unsigned int *);
1376 . int (*_bfd_coff_reloc16_estimate)
1377 . (bfd *, asection *, arelent *, unsigned int,
1378 . struct bfd_link_info *);
1380 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1381 . (bfd *, struct internal_syment *);
1383 . bfd_boolean (*_bfd_coff_compute_section_file_positions)
1386 . bfd_boolean (*_bfd_coff_start_final_link)
1387 . (bfd *, struct bfd_link_info *);
1389 . bfd_boolean (*_bfd_coff_relocate_section)
1390 . (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1391 . struct internal_reloc *, struct internal_syment *, asection **);
1393 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1394 . (bfd *, asection *, struct internal_reloc *,
1395 . struct coff_link_hash_entry *, struct internal_syment *,
1398 . bfd_boolean (*_bfd_coff_adjust_symndx)
1399 . (bfd *, struct bfd_link_info *, bfd *, asection *,
1400 . struct internal_reloc *, bfd_boolean *);
1402 . bfd_boolean (*_bfd_coff_link_add_one_symbol)
1403 . (struct bfd_link_info *, bfd *, const char *, flagword,
1404 . asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
1405 . struct bfd_link_hash_entry **);
1407 . bfd_boolean (*_bfd_coff_link_output_has_begun)
1408 . (bfd *, struct coff_final_link_info *);
1410 . bfd_boolean (*_bfd_coff_final_link_postscript)
1411 . (bfd *, struct coff_final_link_info *);
1413 . bfd_boolean (*_bfd_coff_print_pdata)
1416 .} bfd_coff_backend_data;
1418 .#define coff_backend_info(abfd) \
1419 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1421 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1422 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1424 .#define bfd_coff_swap_sym_in(a,e,i) \
1425 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1427 .#define bfd_coff_swap_lineno_in(a,e,i) \
1428 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1430 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1431 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1433 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1434 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1436 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1437 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1439 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1440 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1442 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1443 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1445 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1446 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1448 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1449 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1451 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1452 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1453 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1454 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1455 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1456 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1457 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1458 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1459 .#define bfd_coff_long_filenames(abfd) \
1460 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1461 .#define bfd_coff_long_section_names(abfd) \
1462 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1463 .#define bfd_coff_set_long_section_names(abfd, enable) \
1464 . ((coff_backend_info (abfd)->_bfd_coff_set_long_section_names) (abfd, enable))
1465 .#define bfd_coff_default_section_alignment_power(abfd) \
1466 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1467 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1468 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1470 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1471 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1473 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1474 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1476 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1477 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1479 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1480 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1482 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1483 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1484 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1485 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1486 . (abfd, filehdr, aouthdr))
1488 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1489 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1490 . (abfd, scnhdr, name, section, flags_ptr))
1492 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1493 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1495 .#define bfd_coff_slurp_symbol_table(abfd)\
1496 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1498 .#define bfd_coff_symname_in_debug(abfd, sym)\
1499 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1501 .#define bfd_coff_force_symnames_in_strings(abfd)\
1502 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1504 .#define bfd_coff_debug_string_prefix_length(abfd)\
1505 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1507 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1508 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1509 . (abfd, file, base, symbol, aux, indaux))
1511 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1512 . reloc, data, src_ptr, dst_ptr)\
1513 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1514 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1516 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1517 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1518 . (abfd, section, reloc, shrink, link_info))
1520 .#define bfd_coff_classify_symbol(abfd, sym)\
1521 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1524 .#define bfd_coff_compute_section_file_positions(abfd)\
1525 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1528 .#define bfd_coff_start_final_link(obfd, info)\
1529 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1531 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1532 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1533 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1534 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1535 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1536 . (abfd, sec, rel, h, sym, addendp))
1537 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1538 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1539 . (obfd, info, ibfd, sec, rel, adjustedp))
1540 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1541 . value, string, cp, coll, hashp)\
1542 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1543 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1545 .#define bfd_coff_link_output_has_begun(a,p) \
1546 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p))
1547 .#define bfd_coff_final_link_postscript(a,p) \
1548 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p))
1550 .#define bfd_coff_have_print_pdata(a) \
1551 . (coff_backend_info (a)->_bfd_coff_print_pdata)
1552 .#define bfd_coff_print_pdata(a,p) \
1553 . ((coff_backend_info (a)->_bfd_coff_print_pdata) (a, p))
1557 /* See whether the magic number matches. */
1560 coff_bad_format_hook (bfd
* abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1562 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1564 if (BADMAG (*internal_f
))
1567 /* If the optional header is NULL or not the correct size then
1568 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1569 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1570 optional header is of a different size.
1572 But the mips keeps extra stuff in it's opthdr, so dont check
1575 #if defined(M88) || defined(I960)
1576 if (internal_f
->f_opthdr
!= 0 && bfd_coff_aoutsz (abfd
) != internal_f
->f_opthdr
)
1585 ticoff0_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1587 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1589 if (COFF0_BADMAG (*internal_f
))
1598 ticoff1_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1600 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1602 if (COFF1_BADMAG (*internal_f
))
1609 /* Check whether this section uses an alignment other than the
1613 coff_set_custom_section_alignment (bfd
*abfd ATTRIBUTE_UNUSED
,
1615 const struct coff_section_alignment_entry
*alignment_table
,
1616 const unsigned int table_size
)
1618 const unsigned int default_alignment
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1621 for (i
= 0; i
< table_size
; ++i
)
1623 const char *secname
= bfd_get_section_name (abfd
, section
);
1625 if (alignment_table
[i
].comparison_length
== (unsigned int) -1
1626 ? strcmp (alignment_table
[i
].name
, secname
) == 0
1627 : strncmp (alignment_table
[i
].name
, secname
,
1628 alignment_table
[i
].comparison_length
) == 0)
1631 if (i
>= table_size
)
1634 if (alignment_table
[i
].default_alignment_min
!= COFF_ALIGNMENT_FIELD_EMPTY
1635 && default_alignment
< alignment_table
[i
].default_alignment_min
)
1638 if (alignment_table
[i
].default_alignment_max
!= COFF_ALIGNMENT_FIELD_EMPTY
1639 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1640 && default_alignment
> alignment_table
[i
].default_alignment_max
1645 section
->alignment_power
= alignment_table
[i
].alignment_power
;
1648 /* Custom section alignment records. */
1650 static const struct coff_section_alignment_entry
1651 coff_section_alignment_table
[] =
1653 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1654 COFF_SECTION_ALIGNMENT_ENTRIES
,
1656 /* There must not be any gaps between .stabstr sections. */
1657 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1658 1, COFF_ALIGNMENT_FIELD_EMPTY
, 0 },
1659 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1660 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1661 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1662 /* Similarly for the .ctors and .dtors sections. */
1663 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1664 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1665 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1666 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 }
1669 static const unsigned int coff_section_alignment_table_size
=
1670 sizeof coff_section_alignment_table
/ sizeof coff_section_alignment_table
[0];
1672 /* Initialize a section structure with information peculiar to this
1673 particular implementation of COFF. */
1676 coff_new_section_hook (bfd
* abfd
, asection
* section
)
1678 combined_entry_type
*native
;
1681 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1684 if (bfd_xcoff_text_align_power (abfd
) != 0
1685 && strcmp (bfd_get_section_name (abfd
, section
), ".text") == 0)
1686 section
->alignment_power
= bfd_xcoff_text_align_power (abfd
);
1687 if (bfd_xcoff_data_align_power (abfd
) != 0
1688 && strcmp (bfd_get_section_name (abfd
, section
), ".data") == 0)
1689 section
->alignment_power
= bfd_xcoff_data_align_power (abfd
);
1692 /* Set up the section symbol. */
1693 if (!_bfd_generic_new_section_hook (abfd
, section
))
1696 /* Allocate aux records for section symbols, to store size and
1699 @@ The 10 is a guess at a plausible maximum number of aux entries
1700 (but shouldn't be a constant). */
1701 amt
= sizeof (combined_entry_type
) * 10;
1702 native
= bfd_zalloc (abfd
, amt
);
1706 /* We don't need to set up n_name, n_value, or n_scnum in the native
1707 symbol information, since they'll be overridden by the BFD symbol
1708 anyhow. However, we do need to set the type and storage class,
1709 in case this symbol winds up getting written out. The value 0
1710 for n_numaux is already correct. */
1712 native
->u
.syment
.n_type
= T_NULL
;
1713 native
->u
.syment
.n_sclass
= C_STAT
;
1715 coffsymbol (section
->symbol
)->native
= native
;
1717 coff_set_custom_section_alignment (abfd
, section
,
1718 coff_section_alignment_table
,
1719 coff_section_alignment_table_size
);
1724 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1726 /* Set the alignment of a BFD section. */
1729 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1733 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1737 /* Extract ALIGN from 2**ALIGN stored in section header. */
1738 for (i
= 0; i
< 32; i
++)
1739 if ((1 << i
) >= hdr
->s_align
)
1743 /* TI tools puts the alignment power in bits 8-11. */
1744 i
= (hdr
->s_flags
>> 8) & 0xF ;
1746 #ifdef COFF_DECODE_ALIGNMENT
1747 i
= COFF_DECODE_ALIGNMENT(hdr
->s_flags
);
1749 section
->alignment_power
= i
;
1751 #ifdef coff_set_section_load_page
1752 coff_set_section_load_page (section
, hdr
->s_page
);
1756 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1760 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1764 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1766 unsigned int alignment_power_const
1767 = hdr
->s_flags
& IMAGE_SCN_ALIGN_POWER_BIT_MASK
;
1769 switch (alignment_power_const
)
1771 case IMAGE_SCN_ALIGN_8192BYTES
:
1772 case IMAGE_SCN_ALIGN_4096BYTES
:
1773 case IMAGE_SCN_ALIGN_2048BYTES
:
1774 case IMAGE_SCN_ALIGN_1024BYTES
:
1775 case IMAGE_SCN_ALIGN_512BYTES
:
1776 case IMAGE_SCN_ALIGN_256BYTES
:
1777 case IMAGE_SCN_ALIGN_128BYTES
:
1778 case IMAGE_SCN_ALIGN_64BYTES
:
1779 case IMAGE_SCN_ALIGN_32BYTES
:
1780 case IMAGE_SCN_ALIGN_16BYTES
:
1781 case IMAGE_SCN_ALIGN_8BYTES
:
1782 case IMAGE_SCN_ALIGN_4BYTES
:
1783 case IMAGE_SCN_ALIGN_2BYTES
:
1784 case IMAGE_SCN_ALIGN_1BYTES
:
1785 section
->alignment_power
1786 = IMAGE_SCN_ALIGN_POWER_NUM (alignment_power_const
);
1792 /* In a PE image file, the s_paddr field holds the virtual size of a
1793 section, while the s_size field holds the raw size. We also keep
1794 the original section flag value, since not every bit can be
1795 mapped onto a generic BFD section bit. */
1796 if (coff_section_data (abfd
, section
) == NULL
)
1798 amt
= sizeof (struct coff_section_tdata
);
1799 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
1800 if (section
->used_by_bfd
== NULL
)
1801 /* FIXME: Return error. */
1805 if (pei_section_data (abfd
, section
) == NULL
)
1807 amt
= sizeof (struct pei_section_tdata
);
1808 coff_section_data (abfd
, section
)->tdata
= bfd_zalloc (abfd
, amt
);
1809 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1810 /* FIXME: Return error. */
1813 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1814 pei_section_data (abfd
, section
)->pe_flags
= hdr
->s_flags
;
1816 section
->lma
= hdr
->s_vaddr
;
1818 /* Check for extended relocs. */
1819 if (hdr
->s_flags
& IMAGE_SCN_LNK_NRELOC_OVFL
)
1821 struct external_reloc dst
;
1822 struct internal_reloc n
;
1823 file_ptr oldpos
= bfd_tell (abfd
);
1824 bfd_size_type relsz
= bfd_coff_relsz (abfd
);
1826 bfd_seek (abfd
, (file_ptr
) hdr
->s_relptr
, 0);
1827 if (bfd_bread (& dst
, relsz
, abfd
) != relsz
)
1830 coff_swap_reloc_in (abfd
, &dst
, &n
);
1831 bfd_seek (abfd
, oldpos
, 0);
1832 section
->reloc_count
= hdr
->s_nreloc
= n
.r_vaddr
- 1;
1833 section
->rel_filepos
+= relsz
;
1835 else if (hdr
->s_nreloc
== 0xffff)
1836 (*_bfd_error_handler
)
1837 ("%s: warning: claims to have 0xffff relocs, without overflow",
1838 bfd_get_filename (abfd
));
1841 #undef ELIFALIGN_SET
1843 #else /* ! COFF_WITH_PE */
1846 /* We grossly abuse this function to handle XCOFF overflow headers.
1847 When we see one, we correct the reloc and line number counts in the
1848 real header, and remove the section we just created. */
1851 coff_set_alignment_hook (bfd
*abfd
, asection
*section
, void * scnhdr
)
1853 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1856 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1859 real_sec
= coff_section_from_bfd_index (abfd
, (int) hdr
->s_nreloc
);
1860 if (real_sec
== NULL
)
1863 real_sec
->reloc_count
= hdr
->s_paddr
;
1864 real_sec
->lineno_count
= hdr
->s_vaddr
;
1866 if (!bfd_section_removed_from_list (abfd
, section
))
1868 bfd_section_list_remove (abfd
, section
);
1869 --abfd
->section_count
;
1873 #else /* ! RS6000COFF_C */
1875 #define coff_set_alignment_hook \
1876 ((void (*) (bfd *, asection *, void *)) bfd_void)
1878 #endif /* ! RS6000COFF_C */
1879 #endif /* ! COFF_WITH_PE */
1880 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1882 #ifndef coff_mkobject
1885 coff_mkobject (bfd
* abfd
)
1887 coff_data_type
*coff
;
1888 bfd_size_type amt
= sizeof (coff_data_type
);
1890 abfd
->tdata
.coff_obj_data
= bfd_zalloc (abfd
, amt
);
1891 if (abfd
->tdata
.coff_obj_data
== NULL
)
1893 coff
= coff_data (abfd
);
1894 coff
->symbols
= NULL
;
1895 coff
->conversion_table
= NULL
;
1896 coff
->raw_syments
= NULL
;
1897 coff
->relocbase
= 0;
1898 coff
->local_toc_sym_map
= 0;
1900 /* make_abs_section(abfd);*/
1906 /* Create the COFF backend specific information. */
1908 #ifndef coff_mkobject_hook
1910 coff_mkobject_hook (bfd
* abfd
,
1912 void * aouthdr ATTRIBUTE_UNUSED
)
1914 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1915 coff_data_type
*coff
;
1917 if (! coff_mkobject (abfd
))
1920 coff
= coff_data (abfd
);
1922 coff
->sym_filepos
= internal_f
->f_symptr
;
1924 /* These members communicate important constants about the symbol
1925 table to GDB's symbol-reading code. These `constants'
1926 unfortunately vary among coff implementations... */
1927 coff
->local_n_btmask
= N_BTMASK
;
1928 coff
->local_n_btshft
= N_BTSHFT
;
1929 coff
->local_n_tmask
= N_TMASK
;
1930 coff
->local_n_tshift
= N_TSHIFT
;
1931 coff
->local_symesz
= bfd_coff_symesz (abfd
);
1932 coff
->local_auxesz
= bfd_coff_auxesz (abfd
);
1933 coff
->local_linesz
= bfd_coff_linesz (abfd
);
1935 coff
->timestamp
= internal_f
->f_timdat
;
1937 obj_raw_syment_count (abfd
) =
1938 obj_conv_table_size (abfd
) =
1939 internal_f
->f_nsyms
;
1942 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
1943 abfd
->flags
|= DYNAMIC
;
1944 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= bfd_coff_aoutsz (abfd
))
1946 struct internal_aouthdr
*internal_a
=
1947 (struct internal_aouthdr
*) aouthdr
;
1948 struct xcoff_tdata
*xcoff
;
1950 xcoff
= xcoff_data (abfd
);
1951 # ifdef U803XTOCMAGIC
1952 xcoff
->xcoff64
= internal_f
->f_magic
== U803XTOCMAGIC
;
1956 xcoff
->full_aouthdr
= TRUE
;
1957 xcoff
->toc
= internal_a
->o_toc
;
1958 xcoff
->sntoc
= internal_a
->o_sntoc
;
1959 xcoff
->snentry
= internal_a
->o_snentry
;
1960 bfd_xcoff_text_align_power (abfd
) = internal_a
->o_algntext
;
1961 bfd_xcoff_data_align_power (abfd
) = internal_a
->o_algndata
;
1962 xcoff
->modtype
= internal_a
->o_modtype
;
1963 xcoff
->cputype
= internal_a
->o_cputype
;
1964 xcoff
->maxdata
= internal_a
->o_maxdata
;
1965 xcoff
->maxstack
= internal_a
->o_maxstack
;
1970 /* Set the flags field from the COFF header read in. */
1971 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
1976 /* FIXME: I'm not sure this is ever executed, since peicode.h
1977 defines coff_mkobject_hook. */
1978 if ((internal_f
->f_flags
& IMAGE_FILE_DEBUG_STRIPPED
) == 0)
1979 abfd
->flags
|= HAS_DEBUG
;
1986 /* Determine the machine architecture and type. FIXME: This is target
1987 dependent because the magic numbers are defined in the target
1988 dependent header files. But there is no particular need for this.
1989 If the magic numbers were moved to a separate file, this function
1990 would be target independent and would also be much more successful
1991 at linking together COFF files for different architectures. */
1994 coff_set_arch_mach_hook (bfd
*abfd
, void * filehdr
)
1996 unsigned long machine
;
1997 enum bfd_architecture arch
;
1998 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
2000 /* Zero selects the default machine for an arch. */
2002 switch (internal_f
->f_magic
)
2004 #ifdef OR32_MAGIC_BIG
2005 case OR32_MAGIC_BIG
:
2006 case OR32_MAGIC_LITTLE
:
2007 arch
= bfd_arch_or32
;
2012 arch
= bfd_arch_powerpc
;
2018 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler. */
2019 case LYNXCOFFMAGIC
: /* Shadows the m68k Lynx number below, sigh. */
2020 arch
= bfd_arch_i386
;
2025 arch
= bfd_arch_i386
;
2026 machine
= bfd_mach_x86_64
;
2031 arch
= bfd_arch_ia64
;
2038 arch
= bfd_arch_arm
;
2039 machine
= bfd_arm_get_mach_from_notes (abfd
, ARM_NOTE_SECTION
);
2040 if (machine
== bfd_mach_arm_unknown
)
2042 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
2044 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
2045 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
2046 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
2048 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
2049 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
2050 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
2051 /* The COFF header does not have enough bits available
2052 to cover all the different ARM architectures. So
2053 we interpret F_ARM_5, the highest flag value to mean
2054 "the highest ARM architecture known to BFD" which is
2055 currently the XScale. */
2056 case F_ARM_5
: machine
= bfd_mach_arm_XScale
; break;
2064 #ifdef MC68KBCSMAGIC
2067 #ifdef APOLLOM68KMAGIC
2068 case APOLLOM68KMAGIC
:
2070 #ifdef LYNXCOFFMAGIC
2073 arch
= bfd_arch_m68k
;
2074 machine
= bfd_mach_m68020
;
2079 arch
= bfd_arch_maxq
;
2080 switch (internal_f
->f_flags
& F_MACHMASK
)
2083 machine
= bfd_mach_maxq10
;
2086 machine
= bfd_mach_maxq20
;
2097 arch
= bfd_arch_m88k
;
2103 arch
= bfd_arch_z80
;
2104 switch (internal_f
->f_flags
& F_MACHMASK
)
2107 case bfd_mach_z80strict
<< 12:
2108 case bfd_mach_z80
<< 12:
2109 case bfd_mach_z80full
<< 12:
2110 case bfd_mach_r800
<< 12:
2111 machine
= ((unsigned)internal_f
->f_flags
& F_MACHMASK
) >> 12;
2120 arch
= bfd_arch_z8k
;
2121 switch (internal_f
->f_flags
& F_MACHMASK
)
2124 machine
= bfd_mach_z8001
;
2127 machine
= bfd_mach_z8002
;
2136 arch
= bfd_arch_i860
;
2143 arch
= bfd_arch_i960
;
2144 switch (F_I960TYPE
& internal_f
->f_flags
)
2148 machine
= bfd_mach_i960_core
;
2151 machine
= bfd_mach_i960_kb_sb
;
2154 machine
= bfd_mach_i960_mc
;
2157 machine
= bfd_mach_i960_xa
;
2160 machine
= bfd_mach_i960_ca
;
2163 machine
= bfd_mach_i960_ka_sa
;
2166 machine
= bfd_mach_i960_jx
;
2169 machine
= bfd_mach_i960_hx
;
2188 if (xcoff_data (abfd
)->cputype
!= -1)
2189 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
2192 /* We did not get a value from the a.out header. If the
2193 file has not been stripped, we may be able to get the
2194 architecture information from the first symbol, if it
2195 is a .file symbol. */
2196 if (obj_raw_syment_count (abfd
) == 0)
2201 struct internal_syment sym
;
2202 bfd_size_type amt
= bfd_coff_symesz (abfd
);
2204 buf
= bfd_malloc (amt
);
2205 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
2206 || bfd_bread (buf
, amt
, abfd
) != amt
)
2211 bfd_coff_swap_sym_in (abfd
, buf
, & sym
);
2212 if (sym
.n_sclass
== C_FILE
)
2213 cputype
= sym
.n_type
& 0xff;
2220 /* FIXME: We don't handle all cases here. */
2225 arch
= bfd_xcoff_architecture (abfd
);
2226 machine
= bfd_xcoff_machine (abfd
);
2230 arch
= bfd_arch_powerpc
;
2231 machine
= bfd_mach_ppc_601
;
2233 case 2: /* 64 bit PowerPC */
2234 arch
= bfd_arch_powerpc
;
2235 machine
= bfd_mach_ppc_620
;
2238 arch
= bfd_arch_powerpc
;
2239 machine
= bfd_mach_ppc
;
2242 arch
= bfd_arch_rs6000
;
2243 machine
= bfd_mach_rs6k
;
2252 arch
= bfd_arch_we32k
;
2258 arch
= bfd_arch_h8300
;
2259 machine
= bfd_mach_h8300
;
2260 /* !! FIXME this probably isn't the right place for this. */
2261 abfd
->flags
|= BFD_IS_RELAXABLE
;
2267 arch
= bfd_arch_h8300
;
2268 machine
= bfd_mach_h8300h
;
2269 /* !! FIXME this probably isn't the right place for this. */
2270 abfd
->flags
|= BFD_IS_RELAXABLE
;
2276 arch
= bfd_arch_h8300
;
2277 machine
= bfd_mach_h8300s
;
2278 /* !! FIXME this probably isn't the right place for this. */
2279 abfd
->flags
|= BFD_IS_RELAXABLE
;
2285 arch
= bfd_arch_h8300
;
2286 machine
= bfd_mach_h8300hn
;
2287 /* !! FIXME this probably isn't the right place for this. */
2288 abfd
->flags
|= BFD_IS_RELAXABLE
;
2294 arch
= bfd_arch_h8300
;
2295 machine
= bfd_mach_h8300sn
;
2296 /* !! FIXME this probably isn't the right place for this. */
2297 abfd
->flags
|= BFD_IS_RELAXABLE
;
2301 #ifdef SH_ARCH_MAGIC_BIG
2302 case SH_ARCH_MAGIC_BIG
:
2303 case SH_ARCH_MAGIC_LITTLE
:
2305 case SH_ARCH_MAGIC_WINCE
:
2311 #ifdef MIPS_ARCH_MAGIC_WINCE
2312 case MIPS_ARCH_MAGIC_WINCE
:
2313 arch
= bfd_arch_mips
;
2319 arch
= bfd_arch_h8500
;
2325 #ifdef LYNXCOFFMAGIC
2328 arch
= bfd_arch_sparc
;
2334 arch
= bfd_arch_tic30
;
2339 #ifdef TICOFF_TARGET_ARCH
2340 /* This TI COFF section should be used by all new TI COFF v0 targets. */
2342 arch
= TICOFF_TARGET_ARCH
;
2343 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2349 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */
2350 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */
2353 switch (internal_f
->f_target_id
)
2357 arch
= TICOFF_TARGET_ARCH
;
2358 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2362 arch
= bfd_arch_obscure
;
2363 (*_bfd_error_handler
)
2364 (_("Unrecognized TI COFF target id '0x%x'"),
2365 internal_f
->f_target_id
);
2371 #ifdef TIC80_ARCH_MAGIC
2372 case TIC80_ARCH_MAGIC
:
2373 arch
= bfd_arch_tic80
;
2379 arch
= bfd_arch_mcore
;
2385 arch
= bfd_arch_w65
;
2389 default: /* Unreadable input file type. */
2390 arch
= bfd_arch_obscure
;
2394 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2398 #ifdef SYMNAME_IN_DEBUG
2401 symname_in_debug_hook (bfd
* abfd ATTRIBUTE_UNUSED
, struct internal_syment
*sym
)
2403 return SYMNAME_IN_DEBUG (sym
) != 0;
2408 #define symname_in_debug_hook \
2409 (bfd_boolean (*) (bfd *, struct internal_syment *)) bfd_false
2416 #define FORCE_SYMNAMES_IN_STRINGS
2419 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
2422 coff_pointerize_aux_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2423 combined_entry_type
*table_base
,
2424 combined_entry_type
*symbol
,
2425 unsigned int indaux
,
2426 combined_entry_type
*aux
)
2428 int class = symbol
->u
.syment
.n_sclass
;
2430 if ((class == C_EXT
|| class == C_HIDEXT
)
2431 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2433 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2435 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2436 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2437 aux
->fix_scnlen
= 1;
2440 /* Return TRUE to indicate that the caller should not do any
2441 further work on this auxent. */
2445 /* Return FALSE to indicate that this auxent should be handled by
2453 /* We don't want to pointerize bal entries. */
2456 coff_pointerize_aux_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2457 combined_entry_type
*table_base ATTRIBUTE_UNUSED
,
2458 combined_entry_type
*symbol
,
2459 unsigned int indaux
,
2460 combined_entry_type
*aux ATTRIBUTE_UNUSED
)
2462 /* Return TRUE if we don't want to pointerize this aux entry, which
2463 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2465 && (symbol
->u
.syment
.n_sclass
== C_LEAFPROC
2466 || symbol
->u
.syment
.n_sclass
== C_LEAFSTAT
2467 || symbol
->u
.syment
.n_sclass
== C_LEAFEXT
));
2472 #define coff_pointerize_aux_hook 0
2475 #endif /* ! RS6000COFF_C */
2477 /* Print an aux entry. This returns TRUE if it has printed it. */
2480 coff_print_aux (bfd
*abfd ATTRIBUTE_UNUSED
,
2481 FILE *file ATTRIBUTE_UNUSED
,
2482 combined_entry_type
*table_base ATTRIBUTE_UNUSED
,
2483 combined_entry_type
*symbol ATTRIBUTE_UNUSED
,
2484 combined_entry_type
*aux ATTRIBUTE_UNUSED
,
2485 unsigned int indaux ATTRIBUTE_UNUSED
)
2488 if ((symbol
->u
.syment
.n_sclass
== C_EXT
2489 || symbol
->u
.syment
.n_sclass
== C_HIDEXT
)
2490 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2492 /* This is a csect entry. */
2493 fprintf (file
, "AUX ");
2494 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2496 BFD_ASSERT (! aux
->fix_scnlen
);
2498 fprintf (file
, "val %5lld",
2499 (long long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2501 fprintf (file
, "val %5ld", (long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2506 fprintf (file
, "indx ");
2507 if (! aux
->fix_scnlen
)
2509 fprintf (file
, "%4lld",
2510 (long long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2512 fprintf (file
, "%4ld", (long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2515 fprintf (file
, "%4ld",
2516 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2519 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2520 aux
->u
.auxent
.x_csect
.x_parmhash
,
2521 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2522 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2523 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2524 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2525 aux
->u
.auxent
.x_csect
.x_stab
,
2526 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2531 /* Return FALSE to indicate that no special action was taken. */
2539 To write relocations, the back end steps though the
2540 canonical relocation table and create an
2541 @code{internal_reloc}. The symbol index to use is removed from
2542 the @code{offset} field in the symbol table supplied. The
2543 address comes directly from the sum of the section base
2544 address and the relocation offset; the type is dug directly
2545 from the howto field. Then the @code{internal_reloc} is
2546 swapped into the shape of an @code{external_reloc} and written
2554 /* AUX's ld wants relocations to be sorted. */
2556 compare_arelent_ptr (const void * x
, const void * y
)
2558 const arelent
**a
= (const arelent
**) x
;
2559 const arelent
**b
= (const arelent
**) y
;
2560 bfd_size_type aadr
= (*a
)->address
;
2561 bfd_size_type badr
= (*b
)->address
;
2563 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2566 #endif /* TARG_AUX */
2569 coff_write_relocs (bfd
* abfd
, int first_undef
)
2573 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2576 struct external_reloc dst
;
2583 /* Sort relocations before we write them out. */
2586 amt
= s
->reloc_count
;
2587 amt
*= sizeof (arelent
*);
2588 p
= bfd_malloc (amt
);
2589 if (p
== NULL
&& s
->reloc_count
> 0)
2591 memcpy (p
, s
->orelocation
, (size_t) amt
);
2592 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2596 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2600 if (obj_pe (abfd
) && s
->reloc_count
>= 0xffff)
2602 /* Encode real count here as first reloc. */
2603 struct internal_reloc n
;
2605 memset (& n
, 0, sizeof (n
));
2606 /* Add one to count *this* reloc (grr). */
2607 n
.r_vaddr
= s
->reloc_count
+ 1;
2608 coff_swap_reloc_out (abfd
, &n
, &dst
);
2609 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2610 abfd
) != bfd_coff_relsz (abfd
))
2615 for (i
= 0; i
< s
->reloc_count
; i
++)
2617 struct internal_reloc n
;
2620 memset (& n
, 0, sizeof (n
));
2622 /* Now we've renumbered the symbols we know where the
2623 undefined symbols live in the table. Check the reloc
2624 entries for symbols who's output bfd isn't the right one.
2625 This is because the symbol was undefined (which means
2626 that all the pointers are never made to point to the same
2627 place). This is a bad thing,'cause the symbols attached
2628 to the output bfd are indexed, so that the relocation
2629 entries know which symbol index they point to. So we
2630 have to look up the output symbol here. */
2632 if (q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2635 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2636 asymbol
**outsyms
= abfd
->outsymbols
;
2638 for (j
= first_undef
; outsyms
[j
]; j
++)
2640 const char *intable
= outsyms
[j
]->name
;
2642 if (strcmp (intable
, sname
) == 0)
2644 /* Got a hit, so repoint the reloc. */
2645 q
->sym_ptr_ptr
= outsyms
+ j
;
2651 n
.r_vaddr
= q
->address
+ s
->vma
;
2654 /* The 29k const/consth reloc pair is a real kludge. The consth
2655 part doesn't have a symbol; it has an offset. So rebuilt
2657 if (q
->howto
->type
== R_IHCONST
)
2658 n
.r_symndx
= q
->addend
;
2663 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2664 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
, s
))
2666 if ((*q
->sym_ptr_ptr
)->section
== bfd_abs_section_ptr
2667 && ((*q
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) != 0)
2669 /* This is a relocation relative to the absolute symbol. */
2673 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2674 /* Check to see if the symbol reloc points to a symbol
2675 we don't have in our symbol table. */
2676 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2678 bfd_set_error (bfd_error_bad_value
);
2679 _bfd_error_handler (_("%B: reloc against a non-existant symbol index: %ld"),
2686 #ifdef SWAP_OUT_RELOC_OFFSET
2687 n
.r_offset
= q
->addend
;
2691 /* Work out reloc type from what is required. */
2692 SELECT_RELOC (n
, q
->howto
);
2694 n
.r_type
= q
->howto
->type
;
2696 coff_swap_reloc_out (abfd
, &n
, &dst
);
2698 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2699 abfd
) != bfd_coff_relsz (abfd
))
2712 /* Set flags and magic number of a coff file from architecture and machine
2713 type. Result is TRUE if we can represent the arch&type, FALSE if not. */
2716 coff_set_flags (bfd
* abfd
,
2717 unsigned int *magicp ATTRIBUTE_UNUSED
,
2718 unsigned short *flagsp ATTRIBUTE_UNUSED
)
2720 switch (bfd_get_arch (abfd
))
2725 switch (bfd_get_mach (abfd
))
2728 case bfd_mach_z80strict
:
2730 case bfd_mach_z80full
:
2732 *flagsp
= bfd_get_mach (abfd
) << 12;
2744 switch (bfd_get_mach (abfd
))
2746 case bfd_mach_z8001
: *flagsp
= F_Z8001
; break;
2747 case bfd_mach_z8002
: *flagsp
= F_Z8002
; break;
2748 default: return FALSE
;
2759 *magicp
= I960ROMAGIC
;
2761 switch (bfd_get_mach (abfd
))
2763 case bfd_mach_i960_core
: flags
= F_I960CORE
; break;
2764 case bfd_mach_i960_kb_sb
: flags
= F_I960KB
; break;
2765 case bfd_mach_i960_mc
: flags
= F_I960MC
; break;
2766 case bfd_mach_i960_xa
: flags
= F_I960XA
; break;
2767 case bfd_mach_i960_ca
: flags
= F_I960CA
; break;
2768 case bfd_mach_i960_ka_sa
: flags
= F_I960KA
; break;
2769 case bfd_mach_i960_jx
: flags
= F_I960JX
; break;
2770 case bfd_mach_i960_hx
: flags
= F_I960HX
; break;
2771 default: return FALSE
;
2780 case bfd_arch_tic30
:
2781 *magicp
= TIC30MAGIC
;
2785 #ifdef TICOFF_DEFAULT_MAGIC
2786 case TICOFF_TARGET_ARCH
:
2787 /* If there's no indication of which version we want, use the default. */
2789 *magicp
= TICOFF_DEFAULT_MAGIC
;
2792 /* We may want to output in a different COFF version. */
2793 switch (abfd
->xvec
->name
[4])
2796 *magicp
= TICOFF0MAGIC
;
2799 *magicp
= TICOFF1MAGIC
;
2802 *magicp
= TICOFF2MAGIC
;
2808 TICOFF_TARGET_MACHINE_SET (flagsp
, bfd_get_mach (abfd
));
2812 #ifdef TIC80_ARCH_MAGIC
2813 case bfd_arch_tic80
:
2814 *magicp
= TIC80_ARCH_MAGIC
;
2821 * magicp
= ARMPEMAGIC
;
2823 * magicp
= ARMMAGIC
;
2826 if (APCS_SET (abfd
))
2828 if (APCS_26_FLAG (abfd
))
2829 * flagsp
|= F_APCS26
;
2831 if (APCS_FLOAT_FLAG (abfd
))
2832 * flagsp
|= F_APCS_FLOAT
;
2834 if (PIC_FLAG (abfd
))
2837 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2838 * flagsp
|= F_INTERWORK
;
2839 switch (bfd_get_mach (abfd
))
2841 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2842 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2843 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2844 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2845 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2846 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2847 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2848 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2849 See also the comment in coff_set_arch_mach_hook(). */
2850 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break;
2851 case bfd_mach_arm_5TE
: * flagsp
|= F_ARM_5
; break;
2852 case bfd_mach_arm_XScale
: * flagsp
|= F_ARM_5
; break;
2858 case bfd_arch_powerpc
:
2863 #if defined(I386MAGIC) || defined(AMD64MAGIC)
2865 #if defined(I386MAGIC)
2866 *magicp
= I386MAGIC
;
2869 /* Just overwrite the usual value if we're doing Lynx. */
2870 *magicp
= LYNXCOFFMAGIC
;
2872 #if defined AMD64MAGIC
2873 *magicp
= AMD64MAGIC
;
2880 *magicp
= I860MAGIC
;
2886 *magicp
= IA64MAGIC
;
2892 #ifdef APOLLOM68KMAGIC
2893 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
2895 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2896 #ifdef NAMES_HAVE_UNDERSCORE
2897 *magicp
= MC68KBCSMAGIC
;
2899 *magicp
= MC68MAGIC
;
2903 /* Just overwrite the usual value if we're doing Lynx. */
2904 *magicp
= LYNXCOFFMAGIC
;
2911 *magicp
= MC88OMAGIC
;
2916 case bfd_arch_h8300
:
2917 switch (bfd_get_mach (abfd
))
2919 case bfd_mach_h8300
: *magicp
= H8300MAGIC
; return TRUE
;
2920 case bfd_mach_h8300h
: *magicp
= H8300HMAGIC
; return TRUE
;
2921 case bfd_mach_h8300s
: *magicp
= H8300SMAGIC
; return TRUE
;
2922 case bfd_mach_h8300hn
: *magicp
= H8300HNMAGIC
; return TRUE
;
2923 case bfd_mach_h8300sn
: *magicp
= H8300SNMAGIC
; return TRUE
;
2929 #ifdef SH_ARCH_MAGIC_BIG
2931 #ifdef COFF_IMAGE_WITH_PE
2932 *magicp
= SH_ARCH_MAGIC_WINCE
;
2934 if (bfd_big_endian (abfd
))
2935 *magicp
= SH_ARCH_MAGIC_BIG
;
2937 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2942 #ifdef MIPS_ARCH_MAGIC_WINCE
2944 *magicp
= MIPS_ARCH_MAGIC_WINCE
;
2949 case bfd_arch_sparc
:
2950 *magicp
= SPARCMAGIC
;
2952 /* Just overwrite the usual value if we're doing Lynx. */
2953 *magicp
= LYNXCOFFMAGIC
;
2959 case bfd_arch_h8500
:
2960 *magicp
= H8500MAGIC
;
2966 case bfd_arch_we32k
:
2967 *magicp
= WE32KMAGIC
;
2972 case bfd_arch_rs6000
:
2974 case bfd_arch_powerpc
:
2976 BFD_ASSERT (bfd_get_flavour (abfd
) == bfd_target_xcoff_flavour
);
2977 *magicp
= bfd_xcoff_magic_number (abfd
);
2982 case bfd_arch_mcore
:
2983 * magicp
= MCOREMAGIC
;
2993 #ifdef OR32_MAGIC_BIG
2995 if (bfd_big_endian (abfd
))
2996 * magicp
= OR32_MAGIC_BIG
;
2998 * magicp
= OR32_MAGIC_LITTLE
;
3004 * magicp
= MAXQ20MAGIC
;
3005 switch (bfd_get_mach (abfd
))
3007 case bfd_mach_maxq10
: * flagsp
= F_MAXQ10
; return TRUE
;
3008 case bfd_mach_maxq20
: * flagsp
= F_MAXQ20
; return TRUE
;
3009 default: return FALSE
;
3013 default: /* Unknown architecture. */
3014 /* Fall through to "return FALSE" below, to avoid
3015 "statement never reached" errors on the one below. */
3023 coff_set_arch_mach (bfd
* abfd
,
3024 enum bfd_architecture arch
,
3025 unsigned long machine
)
3028 unsigned short dummy2
;
3030 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
3033 if (arch
!= bfd_arch_unknown
3034 && ! coff_set_flags (abfd
, &dummy1
, &dummy2
))
3035 return FALSE
; /* We can't represent this type. */
3037 return TRUE
; /* We're easy... */
3040 #ifdef COFF_IMAGE_WITH_PE
3042 /* This is used to sort sections by VMA, as required by PE image
3046 sort_by_secaddr (const void * arg1
, const void * arg2
)
3048 const asection
*a
= *(const asection
**) arg1
;
3049 const asection
*b
= *(const asection
**) arg2
;
3051 if (a
->vma
< b
->vma
)
3053 else if (a
->vma
> b
->vma
)
3059 #endif /* COFF_IMAGE_WITH_PE */
3061 /* Calculate the file position for each section. */
3064 #define ALIGN_SECTIONS_IN_FILE
3066 #if defined(TIC80COFF) || defined(TICOFF)
3067 #undef ALIGN_SECTIONS_IN_FILE
3071 coff_compute_section_file_positions (bfd
* abfd
)
3074 asection
*previous
= NULL
;
3075 file_ptr sofar
= bfd_coff_filhsz (abfd
);
3076 bfd_boolean align_adjust
;
3077 #ifdef ALIGN_SECTIONS_IN_FILE
3082 /* On XCOFF, if we have symbols, set up the .debug section. */
3083 if (bfd_get_symcount (abfd
) > 0)
3086 bfd_size_type i
, symcount
;
3090 symcount
= bfd_get_symcount (abfd
);
3091 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
3093 coff_symbol_type
*cf
;
3095 cf
= coff_symbol_from (abfd
, *symp
);
3097 && cf
->native
!= NULL
3098 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
3102 len
= strlen (bfd_asymbol_name (*symp
));
3103 if (len
> SYMNMLEN
|| bfd_coff_force_symnames_in_strings (abfd
))
3104 sz
+= len
+ 1 + bfd_coff_debug_string_prefix_length (abfd
);
3111 dsec
= bfd_make_section_old_way (abfd
, DOT_DEBUG
);
3115 dsec
->flags
|= SEC_HAS_CONTENTS
;
3120 #ifdef COFF_IMAGE_WITH_PE
3123 if (coff_data (abfd
)->link_info
)
3125 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
3127 /* If no file alignment has been set, default to one.
3128 This repairs 'ld -r' for arm-wince-pe target. */
3133 page_size
= PE_DEF_FILE_ALIGNMENT
;
3135 #ifdef COFF_PAGE_SIZE
3136 int page_size
= COFF_PAGE_SIZE
;
3140 if (bfd_get_start_address (abfd
))
3141 /* A start address may have been added to the original file. In this
3142 case it will need an optional header to record it. */
3143 abfd
->flags
|= EXEC_P
;
3145 if (abfd
->flags
& EXEC_P
)
3146 sofar
+= bfd_coff_aoutsz (abfd
);
3148 else if (xcoff_data (abfd
)->full_aouthdr
)
3149 sofar
+= bfd_coff_aoutsz (abfd
);
3151 sofar
+= SMALL_AOUTSZ
;
3154 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
3157 /* XCOFF handles overflows in the reloc and line number count fields
3158 by allocating a new section header to hold the correct counts. */
3159 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3160 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3161 sofar
+= bfd_coff_scnhsz (abfd
);
3164 #ifdef COFF_IMAGE_WITH_PE
3166 /* PE requires the sections to be in memory order when listed in
3167 the section headers. It also does not like empty loadable
3168 sections. The sections apparently do not have to be in the
3169 right order in the image file itself, but we do need to get the
3170 target_index values right. */
3173 asection
**section_list
;
3179 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3182 /* We allocate an extra cell to simplify the final loop. */
3183 amt
= sizeof (struct asection
*) * (count
+ 1);
3184 section_list
= bfd_malloc (amt
);
3185 if (section_list
== NULL
)
3189 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3191 section_list
[i
] = current
;
3194 section_list
[i
] = NULL
;
3196 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
3198 /* Rethread the linked list into sorted order; at the same time,
3199 assign target_index values. */
3201 abfd
->sections
= NULL
;
3202 abfd
->section_last
= NULL
;
3203 for (i
= 0; i
< count
; i
++)
3205 current
= section_list
[i
];
3206 bfd_section_list_append (abfd
, current
);
3208 /* Later, if the section has zero size, we'll be throwing it
3209 away, so we don't want to number it now. Note that having
3210 a zero size and having real contents are different
3211 concepts: .bss has no contents, but (usually) non-zero
3213 if (current
->size
== 0)
3215 /* Discard. However, it still might have (valid) symbols
3216 in it, so arbitrarily set it to section 1 (indexing is
3217 1-based here; usually .text). __end__ and other
3218 contents of .endsection really have this happen.
3219 FIXME: This seems somewhat dubious. */
3220 current
->target_index
= 1;
3223 current
->target_index
= target_index
++;
3226 free (section_list
);
3228 #else /* ! COFF_IMAGE_WITH_PE */
3230 /* Set the target_index field. */
3234 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3235 current
->target_index
= target_index
++;
3237 #endif /* ! COFF_IMAGE_WITH_PE */
3239 align_adjust
= FALSE
;
3240 for (current
= abfd
->sections
;
3242 current
= current
->next
)
3244 #ifdef COFF_IMAGE_WITH_PE
3245 /* With PE we have to pad each section to be a multiple of its
3246 page size too, and remember both sizes. */
3247 if (coff_section_data (abfd
, current
) == NULL
)
3249 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
3251 current
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
3252 if (current
->used_by_bfd
== NULL
)
3255 if (pei_section_data (abfd
, current
) == NULL
)
3257 bfd_size_type amt
= sizeof (struct pei_section_tdata
);
3259 coff_section_data (abfd
, current
)->tdata
= bfd_zalloc (abfd
, amt
);
3260 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
3263 if (pei_section_data (abfd
, current
)->virt_size
== 0)
3264 pei_section_data (abfd
, current
)->virt_size
= current
->size
;
3267 /* Only deal with sections which have contents. */
3268 if (!(current
->flags
& SEC_HAS_CONTENTS
))
3271 #ifdef COFF_IMAGE_WITH_PE
3272 /* Make sure we skip empty sections in a PE image. */
3273 if (current
->size
== 0)
3277 /* Align the sections in the file to the same boundary on
3278 which they are aligned in virtual memory. I960 doesn't
3279 do this (FIXME) so we can stay in sync with Intel. 960
3280 doesn't yet page from files... */
3281 #ifdef ALIGN_SECTIONS_IN_FILE
3282 if ((abfd
->flags
& EXEC_P
) != 0)
3284 /* Make sure this section is aligned on the right boundary - by
3285 padding the previous section up if necessary. */
3289 /* AIX loader checks the text section alignment of (vma - filepos)
3290 So even though the filepos may be aligned wrt the o_algntext, for
3291 AIX executables, this check fails. This shows up when a native
3292 AIX executable is stripped with gnu strip because the default vma
3293 of native is 0x10000150 but default for gnu is 0x10000140. Gnu
3294 stripped gnu excutable passes this check because the filepos is
3295 0x0140. This problem also show up with 64 bit shared objects. The
3296 data section must also be aligned. */
3297 if (!strcmp (current
->name
, _TEXT
)
3298 || !strcmp (current
->name
, _DATA
))
3303 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3305 align
= 1 << current
->alignment_power
;
3306 pad
= abs (current
->vma
- sofar
) % align
;
3317 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3320 if (previous
!= NULL
)
3321 previous
->size
+= sofar
- old_sofar
;
3326 /* In demand paged files the low order bits of the file offset
3327 must match the low order bits of the virtual address. */
3328 #ifdef COFF_PAGE_SIZE
3329 if ((abfd
->flags
& D_PAGED
) != 0
3330 && (current
->flags
& SEC_ALLOC
) != 0)
3331 sofar
+= (current
->vma
- (bfd_vma
) sofar
) % page_size
;
3333 current
->filepos
= sofar
;
3335 #ifdef COFF_IMAGE_WITH_PE
3336 /* Set the padded size. */
3337 current
->size
= (current
->size
+ page_size
-1) & -page_size
;
3340 sofar
+= current
->size
;
3342 #ifdef ALIGN_SECTIONS_IN_FILE
3343 /* Make sure that this section is of the right size too. */
3344 if ((abfd
->flags
& EXEC_P
) == 0)
3346 bfd_size_type old_size
;
3348 old_size
= current
->size
;
3349 current
->size
= BFD_ALIGN (current
->size
,
3350 1 << current
->alignment_power
);
3351 align_adjust
= current
->size
!= old_size
;
3352 sofar
+= current
->size
- old_size
;
3357 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3358 align_adjust
= sofar
!= old_sofar
;
3359 current
->size
+= sofar
- old_sofar
;
3363 #ifdef COFF_IMAGE_WITH_PE
3364 /* For PE we need to make sure we pad out to the aligned
3365 size, in case the caller only writes out data to the
3367 if (pei_section_data (abfd
, current
)->virt_size
< current
->size
)
3368 align_adjust
= TRUE
;
3372 /* Force .lib sections to start at zero. The vma is then
3373 incremented in coff_set_section_contents. This is right for
3375 if (strcmp (current
->name
, _LIB
) == 0)
3376 bfd_set_section_vma (abfd
, current
, 0);
3382 /* It is now safe to write to the output file. If we needed an
3383 alignment adjustment for the last section, then make sure that
3384 there is a byte at offset sofar. If there are no symbols and no
3385 relocs, then nothing follows the last section. If we don't force
3386 the last byte out, then the file may appear to be truncated. */
3392 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
3393 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3397 /* Make sure the relocations are aligned. We don't need to make
3398 sure that this byte exists, because it will only matter if there
3399 really are relocs. */
3400 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
3402 obj_relocbase (abfd
) = sofar
;
3403 abfd
->output_has_begun
= TRUE
;
3408 #ifdef COFF_IMAGE_WITH_PE
3410 static unsigned int pelength
;
3411 static unsigned int peheader
;
3414 coff_read_word (bfd
*abfd
, unsigned int *value
)
3419 status
= bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3427 *value
= (unsigned int) b
[0];
3429 *value
= (unsigned int) (b
[0] + (b
[1] << 8));
3431 pelength
+= (unsigned int) status
;
3437 coff_compute_checksum (bfd
*abfd
)
3439 bfd_boolean more_data
;
3446 filepos
= (file_ptr
) 0;
3450 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
3453 more_data
= coff_read_word (abfd
, &value
);
3455 total
= 0xffff & (total
+ (total
>> 0x10));
3460 return (0xffff & (total
+ (total
>> 0x10)));
3464 coff_apply_checksum (bfd
*abfd
)
3466 unsigned int computed
;
3467 unsigned int checksum
= 0;
3469 if (bfd_seek (abfd
, 0x3c, SEEK_SET
) != 0)
3472 if (!coff_read_word (abfd
, &peheader
))
3475 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3479 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3481 if (bfd_seek (abfd
, peheader
, SEEK_SET
) != 0)
3484 computed
= coff_compute_checksum (abfd
);
3486 checksum
= computed
+ pelength
;
3488 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3491 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3496 #endif /* COFF_IMAGE_WITH_PE */
3499 coff_write_object_contents (bfd
* abfd
)
3502 bfd_boolean hasrelocs
= FALSE
;
3503 bfd_boolean haslinno
= FALSE
;
3504 bfd_boolean hasdebug
= FALSE
;
3506 file_ptr reloc_base
;
3507 file_ptr lineno_base
;
3509 unsigned long reloc_size
= 0, reloc_count
= 0;
3510 unsigned long lnno_size
= 0;
3511 bfd_boolean long_section_names
;
3512 asection
*text_sec
= NULL
;
3513 asection
*data_sec
= NULL
;
3514 asection
*bss_sec
= NULL
;
3515 struct internal_filehdr internal_f
;
3516 struct internal_aouthdr internal_a
;
3517 #ifdef COFF_LONG_SECTION_NAMES
3518 size_t string_size
= STRING_SIZE_SIZE
;
3521 bfd_set_error (bfd_error_system_call
);
3523 /* Make a pass through the symbol table to count line number entries and
3524 put them into the correct asections. */
3525 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3527 if (! abfd
->output_has_begun
)
3529 if (! coff_compute_section_file_positions (abfd
))
3533 reloc_base
= obj_relocbase (abfd
);
3535 /* Work out the size of the reloc and linno areas. */
3537 for (current
= abfd
->sections
; current
!= NULL
; current
=
3541 /* We store the actual reloc count in the first reloc's addr. */
3542 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3545 reloc_count
+= current
->reloc_count
;
3548 reloc_size
= reloc_count
* bfd_coff_relsz (abfd
);
3550 lineno_base
= reloc_base
+ reloc_size
;
3551 sym_base
= lineno_base
+ lnno_size
;
3553 /* Indicate in each section->line_filepos its actual file address. */
3554 for (current
= abfd
->sections
; current
!= NULL
; current
=
3557 if (current
->lineno_count
)
3559 current
->line_filepos
= lineno_base
;
3560 current
->moving_line_filepos
= lineno_base
;
3561 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3564 current
->line_filepos
= 0;
3566 if (current
->reloc_count
)
3568 current
->rel_filepos
= reloc_base
;
3569 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3571 /* Extra reloc to hold real count. */
3572 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3573 reloc_base
+= bfd_coff_relsz (abfd
);
3577 current
->rel_filepos
= 0;
3580 /* Write section headers to the file. */
3581 internal_f
.f_nscns
= 0;
3583 if ((abfd
->flags
& EXEC_P
) != 0)
3584 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3587 scn_base
= bfd_coff_filhsz (abfd
);
3590 if (xcoff_data (abfd
)->full_aouthdr
)
3591 scn_base
+= bfd_coff_aoutsz (abfd
);
3593 scn_base
+= SMALL_AOUTSZ
;
3598 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3601 long_section_names
= FALSE
;
3602 for (current
= abfd
->sections
;
3604 current
= current
->next
)
3606 struct internal_scnhdr section
;
3607 bfd_boolean is_reloc_section
= FALSE
;
3609 #ifdef COFF_IMAGE_WITH_PE
3610 if (strcmp (current
->name
, ".reloc") == 0)
3612 is_reloc_section
= TRUE
;
3614 pe_data (abfd
)->has_reloc_section
= 1;
3618 internal_f
.f_nscns
++;
3620 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3622 #ifdef COFF_LONG_SECTION_NAMES
3623 /* Handle long section names as in PE. This must be compatible
3624 with the code in coff_write_symbols and _bfd_coff_final_link. */
3625 if (bfd_coff_long_section_names (abfd
))
3629 len
= strlen (current
->name
);
3632 /* The s_name field is defined to be NUL-padded but need not be
3633 NUL-terminated. We use a temporary buffer so that we can still
3634 sprintf all eight chars without splatting a terminating NUL
3635 over the first byte of the following member (s_paddr). */
3636 char s_name_buf
[SCNNMLEN
+ 1];
3638 /* An inherent limitation of the /nnnnnnn notation used to indicate
3639 the offset of the long name in the string table is that we
3640 cannot address entries beyone the ten million byte boundary. */
3641 if (string_size
>= 10000000)
3643 bfd_set_error (bfd_error_file_too_big
);
3644 (*_bfd_error_handler
)
3645 (_("%B: section %s: string table overflow at offset %ld"),
3646 abfd
, current
->name
, string_size
);
3650 /* snprintf not strictly necessary now we've verified the value
3651 has less than eight ASCII digits, but never mind. */
3652 snprintf (s_name_buf
, SCNNMLEN
+ 1, "/%lu", (unsigned long) string_size
);
3653 /* Then strncpy takes care of any padding for us. */
3654 strncpy (section
.s_name
, s_name_buf
, SCNNMLEN
);
3655 string_size
+= len
+ 1;
3656 long_section_names
= TRUE
;
3662 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3663 Ian Taylor <ian@cygnus.com>. */
3664 if (strcmp (current
->name
, _LIB
) == 0)
3665 section
.s_vaddr
= 0;
3668 section
.s_vaddr
= current
->vma
;
3669 section
.s_paddr
= current
->lma
;
3670 section
.s_size
= current
->size
;
3671 #ifdef coff_get_section_load_page
3672 section
.s_page
= coff_get_section_load_page (current
);
3678 section
.s_paddr
= 0;
3680 #ifdef COFF_IMAGE_WITH_PE
3681 /* Reminder: s_paddr holds the virtual size of the section. */
3682 if (coff_section_data (abfd
, current
) != NULL
3683 && pei_section_data (abfd
, current
) != NULL
)
3684 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3686 section
.s_paddr
= 0;
3689 /* If this section has no size or is unloadable then the scnptr
3691 if (current
->size
== 0
3692 || (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3693 section
.s_scnptr
= 0;
3695 section
.s_scnptr
= current
->filepos
;
3697 section
.s_relptr
= current
->rel_filepos
;
3698 section
.s_lnnoptr
= current
->line_filepos
;
3699 section
.s_nreloc
= current
->reloc_count
;
3700 section
.s_nlnno
= current
->lineno_count
;
3701 #ifndef COFF_IMAGE_WITH_PE
3702 /* In PEI, relocs come in the .reloc section. */
3703 if (current
->reloc_count
!= 0)
3706 if (current
->lineno_count
!= 0)
3708 if ((current
->flags
& SEC_DEBUGGING
) != 0
3709 && ! is_reloc_section
)
3714 /* Indicate the use of an XCOFF overflow section header. */
3715 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3717 section
.s_nreloc
= 0xffff;
3718 section
.s_nlnno
= 0xffff;
3723 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3725 if (!strcmp (current
->name
, _TEXT
))
3727 else if (!strcmp (current
->name
, _DATA
))
3729 else if (!strcmp (current
->name
, _BSS
))
3733 section
.s_align
= (current
->alignment_power
3734 ? 1 << current
->alignment_power
3738 /* TI COFF puts the alignment power in bits 8-11 of the flags. */
3739 section
.s_flags
|= (current
->alignment_power
& 0xF) << 8;
3741 #ifdef COFF_ENCODE_ALIGNMENT
3742 COFF_ENCODE_ALIGNMENT(section
, current
->alignment_power
);
3745 #ifdef COFF_IMAGE_WITH_PE
3746 /* Suppress output of the sections if they are null. ld
3747 includes the bss and data sections even if there is no size
3748 assigned to them. NT loader doesn't like it if these section
3749 headers are included if the sections themselves are not
3750 needed. See also coff_compute_section_file_positions. */
3751 if (section
.s_size
== 0)
3752 internal_f
.f_nscns
--;
3757 bfd_size_type amt
= bfd_coff_scnhsz (abfd
);
3759 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3760 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3765 /* PE stores COMDAT section information in the symbol table. If
3766 this section is supposed to have some COMDAT info, track down
3767 the symbol in the symbol table and modify it. */
3768 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3770 unsigned int i
, count
;
3772 coff_symbol_type
*csym
= NULL
;
3776 count
= bfd_get_symcount (abfd
);
3777 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3779 if ((*psym
)->section
!= current
)
3782 /* Remember the location of the first symbol in this
3784 if (psymsec
== NULL
)
3787 /* See if this is the section symbol. */
3788 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3790 csym
= coff_symbol_from (abfd
, *psym
);
3792 || csym
->native
== NULL
3793 || csym
->native
->u
.syment
.n_numaux
< 1
3794 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3795 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3798 /* Here *PSYM is the section symbol for CURRENT. */
3805 Note that we might not if we're converting the file from
3806 some other object file format. */
3809 combined_entry_type
*aux
;
3811 /* We don't touch the x_checksum field. The
3812 x_associated field is not currently supported. */
3814 aux
= csym
->native
+ 1;
3815 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3817 case SEC_LINK_DUPLICATES_DISCARD
:
3818 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3821 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3822 aux
->u
.auxent
.x_scn
.x_comdat
=
3823 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3826 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3827 aux
->u
.auxent
.x_scn
.x_comdat
=
3828 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3831 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3832 aux
->u
.auxent
.x_scn
.x_comdat
=
3833 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3837 /* The COMDAT symbol must be the first symbol from this
3838 section in the symbol table. In order to make this
3839 work, we move the COMDAT symbol before the first
3840 symbol we found in the search above. It's OK to
3841 rearrange the symbol table at this point, because
3842 coff_renumber_symbols is going to rearrange it
3843 further and fix up all the aux entries. */
3844 if (psym
!= psymsec
)
3850 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3851 pcopy
[0] = pcopy
[-1];
3856 #endif /* COFF_WITH_PE */
3861 /* XCOFF handles overflows in the reloc and line number count fields
3862 by creating a new section header to hold the correct values. */
3863 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3865 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3867 struct internal_scnhdr scnhdr
;
3871 internal_f
.f_nscns
++;
3872 strncpy (&(scnhdr
.s_name
[0]), current
->name
, 8);
3873 scnhdr
.s_paddr
= current
->reloc_count
;
3874 scnhdr
.s_vaddr
= current
->lineno_count
;
3876 scnhdr
.s_scnptr
= 0;
3877 scnhdr
.s_relptr
= current
->rel_filepos
;
3878 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3879 scnhdr
.s_nreloc
= current
->target_index
;
3880 scnhdr
.s_nlnno
= current
->target_index
;
3881 scnhdr
.s_flags
= STYP_OVRFLO
;
3882 amt
= bfd_coff_scnhsz (abfd
);
3883 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3884 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3891 /* OK, now set up the filehdr... */
3893 /* Don't include the internal abs section in the section count */
3895 /* We will NOT put a fucking timestamp in the header here. Every time you
3896 put it back, I will come in and take it out again. I'm sorry. This
3897 field does not belong here. We fill it with a 0 so it compares the
3898 same but is not a reasonable time. -- gnu@cygnus.com */
3899 internal_f
.f_timdat
= 0;
3900 internal_f
.f_flags
= 0;
3902 if (abfd
->flags
& EXEC_P
)
3903 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3906 internal_f
.f_opthdr
= 0;
3909 if (xcoff_data (abfd
)->full_aouthdr
)
3910 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3912 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
3918 internal_f
.f_flags
|= F_RELFLG
;
3920 internal_f
.f_flags
|= F_LNNO
;
3921 if (abfd
->flags
& EXEC_P
)
3922 internal_f
.f_flags
|= F_EXEC
;
3923 #ifdef COFF_IMAGE_WITH_PE
3925 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
3926 if (pe_data (abfd
)->real_flags
& IMAGE_FILE_LARGE_ADDRESS_AWARE
)
3927 internal_f
.f_flags
|= IMAGE_FILE_LARGE_ADDRESS_AWARE
;
3930 #ifndef COFF_WITH_pex64
3932 internal_f
.f_flags
|= IMAGE_FILE_32BIT_MACHINE
;
3934 if (bfd_little_endian (abfd
))
3935 internal_f
.f_flags
|= F_AR32WR
;
3937 internal_f
.f_flags
|= F_AR32W
;
3942 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
3943 but it doesn't hurt to set it internally. */
3944 internal_f
.f_target_id
= TI_TARGET_ID
;
3946 #ifdef TIC80_TARGET_ID
3947 internal_f
.f_target_id
= TIC80_TARGET_ID
;
3950 /* FIXME, should do something about the other byte orders and
3954 if ((abfd
->flags
& DYNAMIC
) != 0)
3955 internal_f
.f_flags
|= F_SHROBJ
;
3956 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
3957 internal_f
.f_flags
|= F_DYNLOAD
;
3960 memset (&internal_a
, 0, sizeof internal_a
);
3962 /* Set up architecture-dependent stuff. */
3964 unsigned int magic
= 0;
3965 unsigned short flags
= 0;
3967 coff_set_flags (abfd
, &magic
, &flags
);
3968 internal_f
.f_magic
= magic
;
3969 internal_f
.f_flags
|= flags
;
3970 /* ...and the "opt"hdr... */
3972 #ifdef TICOFF_AOUT_MAGIC
3973 internal_a
.magic
= TICOFF_AOUT_MAGIC
;
3974 #define __A_MAGIC_SET__
3977 internal_a
.magic
= TIC80_ARCH_MAGIC
;
3978 #define __A_MAGIC_SET__
3981 /* FIXME: What are the a.out magic numbers for the i860? */
3982 internal_a
.magic
= 0;
3983 #define __A_MAGIC_SET__
3986 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
3987 #define __A_MAGIC_SET__
3990 #define __A_MAGIC_SET__
3991 internal_a
.magic
= PAGEMAGICBCS
;
3995 #define __A_MAGIC_SET__
3996 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
3999 #if defined(M68) || defined(WE32K) || defined(M68K)
4000 #define __A_MAGIC_SET__
4002 internal_a
.magic
= LYNXCOFFMAGIC
;
4004 #if defined(TARG_AUX)
4005 internal_a
.magic
= (abfd
->flags
& D_PAGED
? PAGEMAGICPEXECPAGED
:
4006 abfd
->flags
& WP_TEXT
? PAGEMAGICPEXECSWAPPED
:
4007 PAGEMAGICEXECSWAPPED
);
4009 #if defined (PAGEMAGICPEXECPAGED)
4010 internal_a
.magic
= PAGEMAGICPEXECPAGED
;
4012 #endif /* TARG_AUX */
4014 #endif /* M68 || WE32K || M68K */
4017 #define __A_MAGIC_SET__
4018 internal_a
.magic
= ZMAGIC
;
4022 #define __A_MAGIC_SET__
4023 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
4026 #if defined MCORE_PE
4027 #define __A_MAGIC_SET__
4028 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
4032 #define __A_MAGIC_SET__
4034 internal_a
.magic
= LYNXCOFFMAGIC
;
4036 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR64_MAGIC
;
4038 internal_a
.magic
= ZMAGIC
;
4043 #define __A_MAGIC_SET__
4044 internal_a
.magic
= PE32PMAGIC
;
4048 #define __A_MAGIC_SET__
4050 internal_a
.magic
= LYNXCOFFMAGIC
;
4055 #define __A_MAGIC_SET__
4056 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
4057 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
4058 RS6K_AOUTHDR_OMAGIC
;
4061 #if defined(SH) && defined(COFF_WITH_PE)
4062 #define __A_MAGIC_SET__
4063 internal_a
.magic
= SH_PE_MAGIC
;
4066 #if defined(MIPS) && defined(COFF_WITH_PE)
4067 #define __A_MAGIC_SET__
4068 internal_a
.magic
= MIPS_PE_MAGIC
;
4072 #define __A_MAGIC_SET__
4073 internal_a
.magic
= NMAGIC
; /* Assume separate i/d. */
4077 #define __A_MAGIC_SET__
4078 internal_a
.magic
= MAXQ20MAGIC
;
4081 #ifndef __A_MAGIC_SET__
4082 #include "Your aouthdr magic number is not being set!"
4084 #undef __A_MAGIC_SET__
4088 /* FIXME: Does anybody ever set this to another value? */
4089 internal_a
.vstamp
= 0;
4091 /* Now should write relocs, strings, syms. */
4092 obj_sym_filepos (abfd
) = sym_base
;
4094 if (bfd_get_symcount (abfd
) != 0)
4098 if (!coff_renumber_symbols (abfd
, &firstundef
))
4100 coff_mangle_symbols (abfd
);
4101 if (! coff_write_symbols (abfd
))
4103 if (! coff_write_linenumbers (abfd
))
4105 if (! coff_write_relocs (abfd
, firstundef
))
4108 #ifdef COFF_LONG_SECTION_NAMES
4109 else if (long_section_names
&& ! obj_coff_strings_written (abfd
))
4111 /* If we have long section names we have to write out the string
4112 table even if there are no symbols. */
4113 if (! coff_write_symbols (abfd
))
4117 #ifdef COFF_IMAGE_WITH_PE
4119 else if ((abfd
->flags
& EXEC_P
) != 0)
4123 /* PowerPC PE appears to require that all executable files be
4124 rounded up to the page size. */
4127 (file_ptr
) BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
4129 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
4135 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
4136 backend linker, and obj_raw_syment_count is not valid until after
4137 coff_write_symbols is called. */
4138 if (obj_raw_syment_count (abfd
) != 0)
4140 internal_f
.f_symptr
= sym_base
;
4142 /* AIX appears to require that F_RELFLG not be set if there are
4143 local symbols but no relocations. */
4144 internal_f
.f_flags
&=~ F_RELFLG
;
4149 if (long_section_names
)
4150 internal_f
.f_symptr
= sym_base
;
4152 internal_f
.f_symptr
= 0;
4153 internal_f
.f_flags
|= F_LSYMS
;
4158 internal_a
.tsize
= text_sec
->size
;
4159 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
4163 internal_a
.dsize
= data_sec
->size
;
4164 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
4168 internal_a
.bsize
= bss_sec
->size
;
4169 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
4170 internal_a
.data_start
= bss_sec
->vma
;
4173 internal_a
.entry
= bfd_get_start_address (abfd
);
4174 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
4177 if (xcoff_data (abfd
)->full_aouthdr
)
4180 asection
*loader_sec
;
4182 internal_a
.vstamp
= 1;
4184 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
4185 if (internal_a
.o_snentry
== 0)
4186 internal_a
.entry
= (bfd_vma
) -1;
4188 if (text_sec
!= NULL
)
4190 internal_a
.o_sntext
= text_sec
->target_index
;
4191 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
4195 internal_a
.o_sntext
= 0;
4196 internal_a
.o_algntext
= 0;
4198 if (data_sec
!= NULL
)
4200 internal_a
.o_sndata
= data_sec
->target_index
;
4201 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
4205 internal_a
.o_sndata
= 0;
4206 internal_a
.o_algndata
= 0;
4208 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
4209 if (loader_sec
!= NULL
)
4210 internal_a
.o_snloader
= loader_sec
->target_index
;
4212 internal_a
.o_snloader
= 0;
4213 if (bss_sec
!= NULL
)
4214 internal_a
.o_snbss
= bss_sec
->target_index
;
4216 internal_a
.o_snbss
= 0;
4218 toc
= xcoff_data (abfd
)->toc
;
4219 internal_a
.o_toc
= toc
;
4220 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
4222 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
4223 if (xcoff_data (abfd
)->cputype
!= -1)
4224 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
4227 switch (bfd_get_arch (abfd
))
4229 case bfd_arch_rs6000
:
4230 internal_a
.o_cputype
= 4;
4232 case bfd_arch_powerpc
:
4233 if (bfd_get_mach (abfd
) == bfd_mach_ppc
)
4234 internal_a
.o_cputype
= 3;
4236 internal_a
.o_cputype
= 1;
4242 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
4243 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
4247 /* Now write them. */
4248 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
4253 bfd_size_type amount
= bfd_coff_filhsz (abfd
);
4255 buff
= bfd_malloc (amount
);
4259 bfd_coff_swap_filehdr_out (abfd
, & internal_f
, buff
);
4260 amount
= bfd_bwrite (buff
, amount
, abfd
);
4264 if (amount
!= bfd_coff_filhsz (abfd
))
4268 if (abfd
->flags
& EXEC_P
)
4270 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4271 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4273 bfd_size_type amount
= bfd_coff_aoutsz (abfd
);
4275 buff
= bfd_malloc (amount
);
4279 coff_swap_aouthdr_out (abfd
, & internal_a
, buff
);
4280 amount
= bfd_bwrite (buff
, amount
, abfd
);
4284 if (amount
!= bfd_coff_aoutsz (abfd
))
4287 #ifdef COFF_IMAGE_WITH_PE
4288 if (! coff_apply_checksum (abfd
))
4298 /* XCOFF seems to always write at least a small a.out header. */
4299 coff_swap_aouthdr_out (abfd
, & internal_a
, & buff
);
4300 if (xcoff_data (abfd
)->full_aouthdr
)
4301 size
= bfd_coff_aoutsz (abfd
);
4303 size
= SMALL_AOUTSZ
;
4304 if (bfd_bwrite (& buff
, (bfd_size_type
) size
, abfd
) != size
)
4313 coff_set_section_contents (bfd
* abfd
,
4315 const void * location
,
4317 bfd_size_type count
)
4319 if (! abfd
->output_has_begun
) /* Set by bfd.c handler. */
4321 if (! coff_compute_section_file_positions (abfd
))
4325 #if defined(_LIB) && !defined(TARG_AUX)
4326 /* The physical address field of a .lib section is used to hold the
4327 number of shared libraries in the section. This code counts the
4328 number of sections being written, and increments the lma field
4331 I have found no documentation on the contents of this section.
4332 Experimentation indicates that the section contains zero or more
4333 records, each of which has the following structure:
4335 - a (four byte) word holding the length of this record, in words,
4336 - a word that always seems to be set to "2",
4337 - the path to a shared library, null-terminated and then padded
4338 to a whole word boundary.
4340 bfd_assert calls have been added to alert if an attempt is made
4341 to write a section which doesn't follow these assumptions. The
4342 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4343 <robertl@arnet.com> (Thanks!).
4345 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4346 if (strcmp (section
->name
, _LIB
) == 0)
4348 bfd_byte
*rec
, *recend
;
4350 rec
= (bfd_byte
*) location
;
4351 recend
= rec
+ count
;
4352 while (rec
< recend
)
4355 rec
+= bfd_get_32 (abfd
, rec
) * 4;
4358 BFD_ASSERT (rec
== recend
);
4362 /* Don't write out bss sections - one way to do this is to
4363 see if the filepos has not been set. */
4364 if (section
->filepos
== 0)
4367 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0)
4373 return bfd_bwrite (location
, count
, abfd
) == count
;
4377 buy_and_read (bfd
*abfd
, file_ptr where
, bfd_size_type size
)
4379 void * area
= bfd_alloc (abfd
, size
);
4383 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0
4384 || bfd_bread (area
, size
, abfd
) != size
)
4393 Creating the linenumber table is done by reading in the entire
4394 coff linenumber table, and creating another table for internal use.
4396 A coff linenumber table is structured so that each function
4397 is marked as having a line number of 0. Each line within the
4398 function is an offset from the first line in the function. The
4399 base of the line number information for the table is stored in
4400 the symbol associated with the function.
4402 Note: The PE format uses line number 0 for a flag indicating a
4405 The information is copied from the external to the internal
4406 table, and each symbol which marks a function is marked by
4409 How does this work ?
4413 coff_sort_func_alent (const void * arg1
, const void * arg2
)
4415 const alent
*al1
= *(const alent
**) arg1
;
4416 const alent
*al2
= *(const alent
**) arg2
;
4417 const coff_symbol_type
*s1
= (const coff_symbol_type
*) (al1
->u
.sym
);
4418 const coff_symbol_type
*s2
= (const coff_symbol_type
*) (al2
->u
.sym
);
4420 if (s1
->symbol
.value
< s2
->symbol
.value
)
4422 else if (s1
->symbol
.value
> s2
->symbol
.value
)
4429 coff_slurp_line_table (bfd
*abfd
, asection
*asect
)
4431 LINENO
*native_lineno
;
4432 alent
*lineno_cache
;
4434 unsigned int counter
;
4436 bfd_vma prev_offset
= 0;
4438 unsigned int nbr_func
;
4441 BFD_ASSERT (asect
->lineno
== NULL
);
4443 amt
= ((bfd_size_type
) asect
->lineno_count
+ 1) * sizeof (alent
);
4444 lineno_cache
= bfd_alloc (abfd
, amt
);
4445 if (lineno_cache
== NULL
)
4448 amt
= (bfd_size_type
) bfd_coff_linesz (abfd
) * asect
->lineno_count
;
4449 native_lineno
= (LINENO
*) buy_and_read (abfd
, asect
->line_filepos
, amt
);
4450 if (native_lineno
== NULL
)
4452 (*_bfd_error_handler
)
4453 (_("%B: warning: line number table read failed"), abfd
);
4454 bfd_release (abfd
, lineno_cache
);
4458 cache_ptr
= lineno_cache
;
4459 asect
->lineno
= lineno_cache
;
4460 src
= native_lineno
;
4463 for (counter
= 0; counter
< asect
->lineno_count
; counter
++)
4465 struct internal_lineno dst
;
4467 bfd_coff_swap_lineno_in (abfd
, src
, &dst
);
4468 cache_ptr
->line_number
= dst
.l_lnno
;
4470 if (cache_ptr
->line_number
== 0)
4473 bfd_signed_vma symndx
;
4474 coff_symbol_type
*sym
;
4478 symndx
= dst
.l_addr
.l_symndx
;
4480 || (bfd_vma
) symndx
>= obj_raw_syment_count (abfd
))
4482 (*_bfd_error_handler
)
4483 (_("%B: warning: illegal symbol index %ld in line numbers"),
4484 abfd
, dst
.l_addr
.l_symndx
);
4489 /* FIXME: We should not be casting between ints and
4490 pointers like this. */
4491 sym
= ((coff_symbol_type
*)
4492 ((symndx
+ obj_raw_syments (abfd
))
4493 ->u
.syment
._n
._n_n
._n_zeroes
));
4494 cache_ptr
->u
.sym
= (asymbol
*) sym
;
4495 if (sym
->lineno
!= NULL
&& ! warned
)
4496 (*_bfd_error_handler
)
4497 (_("%B: warning: duplicate line number information for `%s'"),
4498 abfd
, bfd_asymbol_name (&sym
->symbol
));
4500 sym
->lineno
= cache_ptr
;
4501 if (sym
->symbol
.value
< prev_offset
)
4503 prev_offset
= sym
->symbol
.value
;
4506 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
4507 - bfd_section_vma (abfd
, asect
);
4512 cache_ptr
->line_number
= 0;
4513 bfd_release (abfd
, native_lineno
);
4515 /* On some systems (eg AIX5.3) the lineno table may not be sorted. */
4518 /* Sort the table. */
4520 alent
*n_lineno_cache
;
4522 /* Create a table of functions. */
4523 func_table
= bfd_alloc (abfd
, nbr_func
* sizeof (alent
*));
4524 if (func_table
!= NULL
)
4526 alent
**p
= func_table
;
4529 for (i
= 0; i
< counter
; i
++)
4530 if (lineno_cache
[i
].line_number
== 0)
4531 *p
++ = &lineno_cache
[i
];
4533 /* Sort by functions. */
4534 qsort (func_table
, nbr_func
, sizeof (alent
*), coff_sort_func_alent
);
4536 /* Create the new sorted table. */
4537 amt
= ((bfd_size_type
) asect
->lineno_count
+ 1) * sizeof (alent
);
4538 n_lineno_cache
= bfd_alloc (abfd
, amt
);
4539 if (n_lineno_cache
!= NULL
)
4541 alent
*n_cache_ptr
= n_lineno_cache
;
4543 for (i
= 0; i
< nbr_func
; i
++)
4545 coff_symbol_type
*sym
;
4546 alent
*old_ptr
= func_table
[i
];
4548 /* Copy the function entry and update it. */
4549 *n_cache_ptr
= *old_ptr
;
4550 sym
= (coff_symbol_type
*)n_cache_ptr
->u
.sym
;
4551 sym
->lineno
= n_cache_ptr
;
4555 /* Copy the line number entries. */
4556 while (old_ptr
->line_number
!= 0)
4557 *n_cache_ptr
++ = *old_ptr
++;
4559 n_cache_ptr
->line_number
= 0;
4560 memcpy (lineno_cache
, n_lineno_cache
, amt
);
4562 bfd_release (abfd
, func_table
);
4569 /* Slurp in the symbol table, converting it to generic form. Note
4570 that if coff_relocate_section is defined, the linker will read
4571 symbols via coff_link_add_symbols, rather than via this routine. */
4574 coff_slurp_symbol_table (bfd
* abfd
)
4576 combined_entry_type
*native_symbols
;
4577 coff_symbol_type
*cached_area
;
4578 unsigned int *table_ptr
;
4580 unsigned int number_of_symbols
= 0;
4582 if (obj_symbols (abfd
))
4585 /* Read in the symbol table. */
4586 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4589 /* Allocate enough room for all the symbols in cached form. */
4590 amt
= obj_raw_syment_count (abfd
);
4591 amt
*= sizeof (coff_symbol_type
);
4592 cached_area
= bfd_alloc (abfd
, amt
);
4593 if (cached_area
== NULL
)
4596 amt
= obj_raw_syment_count (abfd
);
4597 amt
*= sizeof (unsigned int);
4598 table_ptr
= bfd_alloc (abfd
, amt
);
4600 if (table_ptr
== NULL
)
4604 coff_symbol_type
*dst
= cached_area
;
4605 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4606 unsigned int this_index
= 0;
4608 while (this_index
< last_native_index
)
4610 combined_entry_type
*src
= native_symbols
+ this_index
;
4611 table_ptr
[this_index
] = number_of_symbols
;
4612 dst
->symbol
.the_bfd
= abfd
;
4614 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4615 /* We use the native name field to point to the cached field. */
4616 src
->u
.syment
._n
._n_n
._n_zeroes
= (bfd_hostptr_t
) dst
;
4617 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4618 src
->u
.syment
.n_scnum
);
4619 dst
->symbol
.flags
= 0;
4620 dst
->done_lineno
= FALSE
;
4622 switch (src
->u
.syment
.n_sclass
)
4626 /* Fall through to next case. */
4633 case C_THUMBEXTFUNC
:
4639 case C_SYSTEM
: /* System Wide variable. */
4642 /* In PE, 0x68 (104) denotes a section symbol. */
4644 /* In PE, 0x69 (105) denotes a weak external symbol. */
4647 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4649 case COFF_SYMBOL_GLOBAL
:
4650 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4651 #if defined COFF_WITH_PE
4652 /* PE sets the symbol to a value relative to the
4653 start of the section. */
4654 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4656 dst
->symbol
.value
= (src
->u
.syment
.n_value
4657 - dst
->symbol
.section
->vma
);
4659 if (ISFCN ((src
->u
.syment
.n_type
)))
4660 /* A function ext does not go at the end of a
4662 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4665 case COFF_SYMBOL_COMMON
:
4666 dst
->symbol
.section
= bfd_com_section_ptr
;
4667 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4670 case COFF_SYMBOL_UNDEFINED
:
4671 dst
->symbol
.section
= bfd_und_section_ptr
;
4672 dst
->symbol
.value
= 0;
4675 case COFF_SYMBOL_PE_SECTION
:
4676 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4677 dst
->symbol
.value
= 0;
4680 case COFF_SYMBOL_LOCAL
:
4681 dst
->symbol
.flags
= BSF_LOCAL
;
4682 #if defined COFF_WITH_PE
4683 /* PE sets the symbol to a value relative to the
4684 start of the section. */
4685 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4687 dst
->symbol
.value
= (src
->u
.syment
.n_value
4688 - dst
->symbol
.section
->vma
);
4690 if (ISFCN ((src
->u
.syment
.n_type
)))
4691 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4696 /* A symbol with a csect entry should not go at the end. */
4697 if (src
->u
.syment
.n_numaux
> 0)
4698 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4702 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4703 dst
->symbol
.flags
|= BSF_WEAK
;
4705 if (src
->u
.syment
.n_sclass
== C_SECTION
4706 && src
->u
.syment
.n_scnum
> 0)
4707 dst
->symbol
.flags
= BSF_LOCAL
;
4709 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
)
4710 dst
->symbol
.flags
|= BSF_WEAK
;
4714 case C_STAT
: /* Static. */
4716 case C_LEAFSTAT
: /* Static leaf procedure. */
4719 case C_THUMBSTAT
: /* Thumb static. */
4720 case C_THUMBLABEL
: /* Thumb label. */
4721 case C_THUMBSTATFUNC
:/* Thumb static function. */
4723 case C_LABEL
: /* Label. */
4724 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4725 dst
->symbol
.flags
= BSF_DEBUGGING
;
4727 dst
->symbol
.flags
= BSF_LOCAL
;
4729 /* Base the value as an index from the base of the
4730 section, if there is one. */
4731 if (dst
->symbol
.section
)
4733 #if defined COFF_WITH_PE
4734 /* PE sets the symbol to a value relative to the
4735 start of the section. */
4736 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4738 dst
->symbol
.value
= (src
->u
.syment
.n_value
4739 - dst
->symbol
.section
->vma
);
4743 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4746 case C_MOS
: /* Member of structure. */
4747 case C_EOS
: /* End of structure. */
4748 case C_REGPARM
: /* Register parameter. */
4749 case C_REG
: /* register variable. */
4750 /* C_AUTOARG conflicts with TI COFF C_UEXT. */
4751 #if !defined (TIC80COFF) && !defined (TICOFF)
4753 case C_AUTOARG
: /* 960-specific storage class. */
4756 case C_TPDEF
: /* Type definition. */
4758 case C_AUTO
: /* Automatic variable. */
4759 case C_FIELD
: /* Bit field. */
4760 case C_ENTAG
: /* Enumeration tag. */
4761 case C_MOE
: /* Member of enumeration. */
4762 case C_MOU
: /* Member of union. */
4763 case C_UNTAG
: /* Union tag. */
4764 dst
->symbol
.flags
= BSF_DEBUGGING
;
4765 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4768 case C_FILE
: /* File name. */
4769 case C_STRTAG
: /* Structure tag. */
4786 dst
->symbol
.flags
= BSF_DEBUGGING
;
4787 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4791 case C_BINCL
: /* Beginning of include file. */
4792 case C_EINCL
: /* Ending of include file. */
4793 /* The value is actually a pointer into the line numbers
4794 of the file. We locate the line number entry, and
4795 set the section to the section which contains it, and
4796 the value to the index in that section. */
4800 dst
->symbol
.flags
= BSF_DEBUGGING
;
4801 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4802 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4803 && ((file_ptr
) (sec
->line_filepos
4804 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4805 > (file_ptr
) src
->u
.syment
.n_value
))
4808 dst
->symbol
.value
= 0;
4811 dst
->symbol
.section
= sec
;
4812 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4813 - sec
->line_filepos
)
4814 / bfd_coff_linesz (abfd
));
4821 dst
->symbol
.flags
= BSF_DEBUGGING
;
4823 /* The value is actually a symbol index. Save a pointer
4824 to the symbol instead of the index. FIXME: This
4825 should use a union. */
4826 src
->u
.syment
.n_value
=
4827 (long) (native_symbols
+ src
->u
.syment
.n_value
);
4828 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4833 case C_BLOCK
: /* ".bb" or ".eb". */
4834 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf"). */
4835 case C_EFCN
: /* Physical end of function. */
4836 #if defined COFF_WITH_PE
4837 /* PE sets the symbol to a value relative to the start
4839 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4840 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4842 /* PE uses funny values for .ef and .lf; don't
4844 dst
->symbol
.flags
= BSF_DEBUGGING
;
4847 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4849 /* Base the value as an index from the base of the
4851 dst
->symbol
.flags
= BSF_LOCAL
;
4852 dst
->symbol
.value
= (src
->u
.syment
.n_value
4853 - dst
->symbol
.section
->vma
);
4857 case C_STATLAB
: /* Static load time label. */
4858 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4859 dst
->symbol
.flags
= BSF_GLOBAL
;
4863 /* PE DLLs sometimes have zeroed out symbols for some
4864 reason. Just ignore them without a warning. */
4865 if (src
->u
.syment
.n_type
== 0
4866 && src
->u
.syment
.n_value
== 0
4867 && src
->u
.syment
.n_scnum
== 0)
4870 case C_EXTDEF
: /* External definition. */
4871 case C_ULABEL
: /* Undefined label. */
4872 case C_USTATIC
: /* Undefined static. */
4873 #ifndef COFF_WITH_PE
4874 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4875 class to represent a section symbol. */
4876 case C_LINE
: /* line # reformatted as symbol table entry. */
4877 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4878 case C_ALIAS
: /* Duplicate tag. */
4880 /* New storage classes for TI COFF. */
4881 #if defined(TIC80COFF) || defined(TICOFF)
4882 case C_UEXT
: /* Tentative external definition. */
4884 case C_EXTLAB
: /* External load time label. */
4885 case C_HIDDEN
: /* Ext symbol in dmert public lib. */
4887 (*_bfd_error_handler
)
4888 (_("%B: Unrecognized storage class %d for %s symbol `%s'"),
4889 abfd
, src
->u
.syment
.n_sclass
,
4890 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4891 dst
->symbol
.flags
= BSF_DEBUGGING
;
4892 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4898 dst
->symbol
.udata
.i
= 0;
4900 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
4902 number_of_symbols
++;
4906 obj_symbols (abfd
) = cached_area
;
4907 obj_raw_syments (abfd
) = native_symbols
;
4909 bfd_get_symcount (abfd
) = number_of_symbols
;
4910 obj_convert (abfd
) = table_ptr
;
4911 /* Slurp the line tables for each section too. */
4918 coff_slurp_line_table (abfd
, p
);
4926 /* Classify a COFF symbol. A couple of targets have globally visible
4927 symbols which are not class C_EXT, and this handles those. It also
4928 recognizes some special PE cases. */
4930 static enum coff_symbol_classification
4931 coff_classify_symbol (bfd
*abfd
,
4932 struct internal_syment
*syment
)
4934 /* FIXME: This partially duplicates the switch in
4935 coff_slurp_symbol_table. */
4936 switch (syment
->n_sclass
)
4945 case C_THUMBEXTFUNC
:
4953 if (syment
->n_scnum
== 0)
4955 if (syment
->n_value
== 0)
4956 return COFF_SYMBOL_UNDEFINED
;
4958 return COFF_SYMBOL_COMMON
;
4960 return COFF_SYMBOL_GLOBAL
;
4967 if (syment
->n_sclass
== C_STAT
)
4969 if (syment
->n_scnum
== 0)
4970 /* The Microsoft compiler sometimes generates these if a
4971 small static function is inlined every time it is used.
4972 The function is discarded, but the symbol table entry
4974 return COFF_SYMBOL_LOCAL
;
4976 #ifdef STRICT_PE_FORMAT
4977 /* This is correct for Microsoft generated objects, but it
4978 breaks gas generated objects. */
4979 if (syment
->n_value
== 0)
4982 char buf
[SYMNMLEN
+ 1];
4984 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
4986 && (strcmp (bfd_get_section_name (abfd
, sec
),
4987 _bfd_coff_internal_syment_name (abfd
, syment
, buf
))
4989 return COFF_SYMBOL_PE_SECTION
;
4993 return COFF_SYMBOL_LOCAL
;
4996 if (syment
->n_sclass
== C_SECTION
)
4998 /* In some cases in a DLL generated by the Microsoft linker, the
4999 n_value field will contain garbage. FIXME: This should
5000 probably be handled by the swapping function instead. */
5001 syment
->n_value
= 0;
5002 if (syment
->n_scnum
== 0)
5003 return COFF_SYMBOL_UNDEFINED
;
5004 return COFF_SYMBOL_PE_SECTION
;
5006 #endif /* COFF_WITH_PE */
5008 /* If it is not a global symbol, we presume it is a local symbol. */
5009 if (syment
->n_scnum
== 0)
5011 char buf
[SYMNMLEN
+ 1];
5013 (*_bfd_error_handler
)
5014 (_("warning: %B: local symbol `%s' has no section"),
5015 abfd
, _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
5018 return COFF_SYMBOL_LOCAL
;
5025 Coff relocations are easily transformed into the internal BFD form
5028 Reading a coff relocation table is done in the following stages:
5030 o Read the entire coff relocation table into memory.
5032 o Process each relocation in turn; first swap it from the
5033 external to the internal form.
5035 o Turn the symbol referenced in the relocation's symbol index
5036 into a pointer into the canonical symbol table.
5037 This table is the same as the one returned by a call to
5038 @code{bfd_canonicalize_symtab}. The back end will call that
5039 routine and save the result if a canonicalization hasn't been done.
5041 o The reloc index is turned into a pointer to a howto
5042 structure, in a back end specific way. For instance, the 386
5043 and 960 use the @code{r_type} to directly produce an index
5044 into a howto table vector; the 88k subtracts a number from the
5045 @code{r_type} field and creates an addend field.
5049 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
5051 coff_symbol_type *coffsym = NULL; \
5053 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
5054 coffsym = (obj_symbols (abfd) \
5055 + (cache_ptr->sym_ptr_ptr - symbols)); \
5057 coffsym = coff_symbol_from (abfd, ptr); \
5058 if (coffsym != NULL \
5059 && coffsym->native->u.syment.n_scnum == 0) \
5060 cache_ptr->addend = 0; \
5061 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
5062 && ptr->section != NULL) \
5063 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
5065 cache_ptr->addend = 0; \
5070 coff_slurp_reloc_table (bfd
* abfd
, sec_ptr asect
, asymbol
** symbols
)
5072 RELOC
*native_relocs
;
5073 arelent
*reloc_cache
;
5078 if (asect
->relocation
)
5080 if (asect
->reloc_count
== 0)
5082 if (asect
->flags
& SEC_CONSTRUCTOR
)
5084 if (!coff_slurp_symbol_table (abfd
))
5087 amt
= (bfd_size_type
) bfd_coff_relsz (abfd
) * asect
->reloc_count
;
5088 native_relocs
= (RELOC
*) buy_and_read (abfd
, asect
->rel_filepos
, amt
);
5089 amt
= (bfd_size_type
) asect
->reloc_count
* sizeof (arelent
);
5090 reloc_cache
= bfd_alloc (abfd
, amt
);
5092 if (reloc_cache
== NULL
|| native_relocs
== NULL
)
5095 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
5097 struct internal_reloc dst
;
5098 struct external_reloc
*src
;
5099 #ifndef RELOC_PROCESSING
5103 cache_ptr
= reloc_cache
+ idx
;
5104 src
= native_relocs
+ idx
;
5107 coff_swap_reloc_in (abfd
, src
, &dst
);
5109 #ifdef RELOC_PROCESSING
5110 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
5112 cache_ptr
->address
= dst
.r_vaddr
;
5114 if (dst
.r_symndx
!= -1)
5116 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
5118 (*_bfd_error_handler
)
5119 (_("%B: warning: illegal symbol index %ld in relocs"),
5120 abfd
, dst
.r_symndx
);
5121 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5126 cache_ptr
->sym_ptr_ptr
= (symbols
5127 + obj_convert (abfd
)[dst
.r_symndx
]);
5128 ptr
= *(cache_ptr
->sym_ptr_ptr
);
5133 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5137 /* The symbols definitions that we have read in have been
5138 relocated as if their sections started at 0. But the offsets
5139 refering to the symbols in the raw data have not been
5140 modified, so we have to have a negative addend to compensate.
5142 Note that symbols which used to be common must be left alone. */
5144 /* Calculate any reloc addend by looking at the symbol. */
5145 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
5147 cache_ptr
->address
-= asect
->vma
;
5148 /* !! cache_ptr->section = NULL;*/
5150 /* Fill in the cache_ptr->howto field from dst.r_type. */
5151 RTYPE2HOWTO (cache_ptr
, &dst
);
5152 #endif /* RELOC_PROCESSING */
5154 if (cache_ptr
->howto
== NULL
)
5156 (*_bfd_error_handler
)
5157 (_("%B: illegal relocation type %d at address 0x%lx"),
5158 abfd
, dst
.r_type
, (long) dst
.r_vaddr
);
5159 bfd_set_error (bfd_error_bad_value
);
5164 asect
->relocation
= reloc_cache
;
5168 #ifndef coff_rtype_to_howto
5171 /* Get the howto structure for a reloc. This is only used if the file
5172 including this one defines coff_relocate_section to be
5173 _bfd_coff_generic_relocate_section, so it is OK if it does not
5174 always work. It is the responsibility of the including file to
5175 make sure it is reasonable if it is needed. */
5177 static reloc_howto_type
*
5178 coff_rtype_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
5179 asection
*sec ATTRIBUTE_UNUSED
,
5180 struct internal_reloc
*rel
,
5181 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
,
5182 struct internal_syment
*sym ATTRIBUTE_UNUSED
,
5183 bfd_vma
*addendp ATTRIBUTE_UNUSED
)
5187 genrel
.howto
= NULL
;
5188 RTYPE2HOWTO (&genrel
, rel
);
5189 return genrel
.howto
;
5192 #else /* ! defined (RTYPE2HOWTO) */
5194 #define coff_rtype_to_howto NULL
5196 #endif /* ! defined (RTYPE2HOWTO) */
5197 #endif /* ! defined (coff_rtype_to_howto) */
5199 /* This is stupid. This function should be a boolean predicate. */
5202 coff_canonicalize_reloc (bfd
* abfd
,
5207 arelent
*tblptr
= section
->relocation
;
5208 unsigned int count
= 0;
5210 if (section
->flags
& SEC_CONSTRUCTOR
)
5212 /* This section has relocs made up by us, they are not in the
5213 file, so take them out of their chain and place them into
5214 the data area provided. */
5215 arelent_chain
*chain
= section
->constructor_chain
;
5217 for (count
= 0; count
< section
->reloc_count
; count
++)
5219 *relptr
++ = &chain
->relent
;
5220 chain
= chain
->next
;
5225 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
5228 tblptr
= section
->relocation
;
5230 for (; count
++ < section
->reloc_count
;)
5231 *relptr
++ = tblptr
++;
5234 return section
->reloc_count
;
5237 #ifndef coff_reloc16_estimate
5238 #define coff_reloc16_estimate dummy_reloc16_estimate
5241 dummy_reloc16_estimate (bfd
*abfd ATTRIBUTE_UNUSED
,
5242 asection
*input_section ATTRIBUTE_UNUSED
,
5243 arelent
*reloc ATTRIBUTE_UNUSED
,
5244 unsigned int shrink ATTRIBUTE_UNUSED
,
5245 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
)
5253 #ifndef coff_reloc16_extra_cases
5255 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5257 /* This works even if abort is not declared in any header file. */
5260 dummy_reloc16_extra_cases (bfd
*abfd ATTRIBUTE_UNUSED
,
5261 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
5262 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
,
5263 arelent
*reloc ATTRIBUTE_UNUSED
,
5264 bfd_byte
*data ATTRIBUTE_UNUSED
,
5265 unsigned int *src_ptr ATTRIBUTE_UNUSED
,
5266 unsigned int *dst_ptr ATTRIBUTE_UNUSED
)
5272 #ifndef coff_bfd_link_hash_table_free
5273 #define coff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
5276 /* If coff_relocate_section is defined, we can use the optimized COFF
5277 backend linker. Otherwise we must continue to use the old linker. */
5279 #ifdef coff_relocate_section
5281 #ifndef coff_bfd_link_hash_table_create
5282 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5284 #ifndef coff_bfd_link_add_symbols
5285 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5287 #ifndef coff_bfd_final_link
5288 #define coff_bfd_final_link _bfd_coff_final_link
5291 #else /* ! defined (coff_relocate_section) */
5293 #define coff_relocate_section NULL
5294 #ifndef coff_bfd_link_hash_table_create
5295 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5297 #ifndef coff_bfd_link_add_symbols
5298 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5300 #define coff_bfd_final_link _bfd_generic_final_link
5302 #endif /* ! defined (coff_relocate_section) */
5304 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5305 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5307 #ifndef coff_start_final_link
5308 #define coff_start_final_link NULL
5311 #ifndef coff_adjust_symndx
5312 #define coff_adjust_symndx NULL
5315 #ifndef coff_link_add_one_symbol
5316 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5319 #ifndef coff_link_output_has_begun
5322 coff_link_output_has_begun (bfd
* abfd
,
5323 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
)
5325 return abfd
->output_has_begun
;
5329 #ifndef coff_final_link_postscript
5332 coff_final_link_postscript (bfd
* abfd ATTRIBUTE_UNUSED
,
5333 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
)
5339 #ifndef coff_SWAP_aux_in
5340 #define coff_SWAP_aux_in coff_swap_aux_in
5342 #ifndef coff_SWAP_sym_in
5343 #define coff_SWAP_sym_in coff_swap_sym_in
5345 #ifndef coff_SWAP_lineno_in
5346 #define coff_SWAP_lineno_in coff_swap_lineno_in
5348 #ifndef coff_SWAP_aux_out
5349 #define coff_SWAP_aux_out coff_swap_aux_out
5351 #ifndef coff_SWAP_sym_out
5352 #define coff_SWAP_sym_out coff_swap_sym_out
5354 #ifndef coff_SWAP_lineno_out
5355 #define coff_SWAP_lineno_out coff_swap_lineno_out
5357 #ifndef coff_SWAP_reloc_out
5358 #define coff_SWAP_reloc_out coff_swap_reloc_out
5360 #ifndef coff_SWAP_filehdr_out
5361 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5363 #ifndef coff_SWAP_aouthdr_out
5364 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5366 #ifndef coff_SWAP_scnhdr_out
5367 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5369 #ifndef coff_SWAP_reloc_in
5370 #define coff_SWAP_reloc_in coff_swap_reloc_in
5372 #ifndef coff_SWAP_filehdr_in
5373 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5375 #ifndef coff_SWAP_aouthdr_in
5376 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5378 #ifndef coff_SWAP_scnhdr_in
5379 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5382 static bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED
=
5384 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5385 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5386 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5387 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5388 coff_SWAP_scnhdr_out
,
5389 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5390 #ifdef COFF_LONG_FILENAMES
5395 COFF_DEFAULT_LONG_SECTION_NAMES
,
5396 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5397 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5402 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5407 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5408 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5409 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5410 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5411 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5412 coff_classify_symbol
, coff_compute_section_file_positions
,
5413 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5414 coff_adjust_symndx
, coff_link_add_one_symbol
,
5415 coff_link_output_has_begun
, coff_final_link_postscript
,
5420 /* COFF0 differs in file/section header size and relocation entry size. */
5422 static bfd_coff_backend_data ticoff0_swap_table
=
5424 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5425 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5426 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5427 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5428 coff_SWAP_scnhdr_out
,
5429 FILHSZ_V0
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ_V0
, LINESZ
, FILNMLEN
,
5430 #ifdef COFF_LONG_FILENAMES
5435 COFF_DEFAULT_LONG_SECTION_NAMES
,
5436 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5437 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5442 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5447 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5448 coff_SWAP_reloc_in
, ticoff0_bad_format_hook
, coff_set_arch_mach_hook
,
5449 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5450 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5451 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5452 coff_classify_symbol
, coff_compute_section_file_positions
,
5453 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5454 coff_adjust_symndx
, coff_link_add_one_symbol
,
5455 coff_link_output_has_begun
, coff_final_link_postscript
,
5461 /* COFF1 differs in section header size. */
5463 static bfd_coff_backend_data ticoff1_swap_table
=
5465 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5466 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5467 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5468 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5469 coff_SWAP_scnhdr_out
,
5470 FILHSZ
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5471 #ifdef COFF_LONG_FILENAMES
5476 COFF_DEFAULT_LONG_SECTION_NAMES
,
5477 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5478 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5483 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5488 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5489 coff_SWAP_reloc_in
, ticoff1_bad_format_hook
, coff_set_arch_mach_hook
,
5490 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5491 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5492 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5493 coff_classify_symbol
, coff_compute_section_file_positions
,
5494 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5495 coff_adjust_symndx
, coff_link_add_one_symbol
,
5496 coff_link_output_has_begun
, coff_final_link_postscript
,
5497 bfd_pe_print_pdata
/* huh */
5501 #ifndef coff_close_and_cleanup
5502 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5505 #ifndef coff_bfd_free_cached_info
5506 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5509 #ifndef coff_get_section_contents
5510 #define coff_get_section_contents _bfd_generic_get_section_contents
5513 #ifndef coff_bfd_copy_private_symbol_data
5514 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5517 #ifndef coff_bfd_copy_private_header_data
5518 #define coff_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
5521 #ifndef coff_bfd_copy_private_section_data
5522 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5525 #ifndef coff_bfd_copy_private_bfd_data
5526 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5529 #ifndef coff_bfd_merge_private_bfd_data
5530 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5533 #ifndef coff_bfd_set_private_flags
5534 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5537 #ifndef coff_bfd_print_private_bfd_data
5538 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5541 #ifndef coff_bfd_is_local_label_name
5542 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5545 #ifndef coff_bfd_is_target_special_symbol
5546 #define coff_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
5549 #ifndef coff_read_minisymbols
5550 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5553 #ifndef coff_minisymbol_to_symbol
5554 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5557 /* The reloc lookup routine must be supplied by each individual COFF
5559 #ifndef coff_bfd_reloc_type_lookup
5560 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5562 #ifndef coff_bfd_reloc_name_lookup
5563 #define coff_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5566 #ifndef coff_bfd_get_relocated_section_contents
5567 #define coff_bfd_get_relocated_section_contents \
5568 bfd_generic_get_relocated_section_contents
5571 #ifndef coff_bfd_relax_section
5572 #define coff_bfd_relax_section bfd_generic_relax_section
5575 #ifndef coff_bfd_gc_sections
5576 #define coff_bfd_gc_sections bfd_generic_gc_sections
5579 #ifndef coff_bfd_merge_sections
5580 #define coff_bfd_merge_sections bfd_generic_merge_sections
5583 #ifndef coff_bfd_is_group_section
5584 #define coff_bfd_is_group_section bfd_generic_is_group_section
5587 #ifndef coff_bfd_discard_group
5588 #define coff_bfd_discard_group bfd_generic_discard_group
5591 #ifndef coff_section_already_linked
5592 #define coff_section_already_linked \
5593 _bfd_generic_section_already_linked
5596 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5597 const bfd_target VAR = \
5600 bfd_target_coff_flavour, \
5601 BFD_ENDIAN_BIG, /* Data byte order is big. */ \
5602 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5603 /* object flags */ \
5604 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5605 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5606 /* section flags */ \
5607 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5608 UNDER, /* Leading symbol underscore. */ \
5609 '/', /* AR_pad_char. */ \
5610 15, /* AR_max_namelen. */ \
5612 /* Data conversion functions. */ \
5613 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5614 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5615 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5617 /* Header conversion functions. */ \
5618 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5619 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5620 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5622 /* bfd_check_format. */ \
5623 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5624 _bfd_dummy_target }, \
5625 /* bfd_set_format. */ \
5626 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5627 /* bfd_write_contents. */ \
5628 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5631 BFD_JUMP_TABLE_GENERIC (coff), \
5632 BFD_JUMP_TABLE_COPY (coff), \
5633 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5634 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5635 BFD_JUMP_TABLE_SYMBOLS (coff), \
5636 BFD_JUMP_TABLE_RELOCS (coff), \
5637 BFD_JUMP_TABLE_WRITE (coff), \
5638 BFD_JUMP_TABLE_LINK (coff), \
5639 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5646 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5647 const bfd_target VAR = \
5650 bfd_target_coff_flavour, \
5651 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5652 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5653 /* object flags */ \
5654 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5655 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5656 /* section flags */ \
5657 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5658 UNDER, /* Leading symbol underscore. */ \
5659 '/', /* AR_pad_char. */ \
5660 15, /* AR_max_namelen. */ \
5662 /* Data conversion functions. */ \
5663 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5664 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5665 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5667 /* Header conversion functions. */ \
5668 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5669 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5670 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5672 /* bfd_check_format. */ \
5673 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5674 _bfd_dummy_target }, \
5675 /* bfd_set_format. */ \
5676 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5677 /* bfd_write_contents. */ \
5678 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5681 BFD_JUMP_TABLE_GENERIC (coff), \
5682 BFD_JUMP_TABLE_COPY (coff), \
5683 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5684 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5685 BFD_JUMP_TABLE_SYMBOLS (coff), \
5686 BFD_JUMP_TABLE_RELOCS (coff), \
5687 BFD_JUMP_TABLE_WRITE (coff), \
5688 BFD_JUMP_TABLE_LINK (coff), \
5689 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5696 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5697 const bfd_target VAR = \
5700 bfd_target_coff_flavour, \
5701 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5702 BFD_ENDIAN_LITTLE, /* Header byte order is little. */ \
5703 /* object flags */ \
5704 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5705 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5706 /* section flags */ \
5707 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5708 UNDER, /* Leading symbol underscore. */ \
5709 '/', /* AR_pad_char. */ \
5710 15, /* AR_max_namelen. */ \
5712 /* Data conversion functions. */ \
5713 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5714 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5715 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5716 /* Header conversion functions. */ \
5717 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5718 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5719 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5720 /* bfd_check_format. */ \
5721 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5722 _bfd_dummy_target }, \
5723 /* bfd_set_format. */ \
5724 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5725 /* bfd_write_contents. */ \
5726 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5729 BFD_JUMP_TABLE_GENERIC (coff), \
5730 BFD_JUMP_TABLE_COPY (coff), \
5731 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5732 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5733 BFD_JUMP_TABLE_SYMBOLS (coff), \
5734 BFD_JUMP_TABLE_RELOCS (coff), \
5735 BFD_JUMP_TABLE_WRITE (coff), \
5736 BFD_JUMP_TABLE_LINK (coff), \
5737 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \