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, 2010
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 With input BFDs, the flag is set according to whether any long section
158 names are detected while reading the section headers. For a completely
159 new BFD, the flag is set to the default for the target format. This
160 information can be used by a client of the BFD library when deciding
161 what output format to generate, and means that a BFD that is opened
162 for read and subsequently converted to a writeable BFD and modified
163 in-place will retain whatever format it had on input.
165 If @code{COFF_LONG_SECTION_NAMES} is simply defined (blank), or is
166 defined to the value "1", then long section names are enabled by
167 default; if it is defined to the value zero, they are disabled by
168 default (but still accepted in input BFDs). The header @file{coffcode.h}
169 defines a macro, @code{COFF_DEFAULT_LONG_SECTION_NAMES}, which is
170 used in the backends to initialise the backend data structure fields
171 appropriately; see the comments for further detail.
176 Each flavour of coff supported in BFD has its own header file
177 describing the external layout of the structures. There is also
178 an internal description of the coff layout, in
179 @file{coff/internal.h}. A major function of the
180 coff backend is swapping the bytes and twiddling the bits to
181 translate the external form of the structures into the normal
182 internal form. This is all performed in the
183 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
184 elements are different sizes between different versions of
185 coff; it is the duty of the coff version specific include file
186 to override the definitions of various packing routines in
187 @file{coffcode.h}. E.g., the size of line number entry in coff is
188 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
189 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
190 correct one. No doubt, some day someone will find a version of
191 coff which has a varying field size not catered to at the
192 moment. To port BFD, that person will have to add more @code{#defines}.
193 Three of the bit twiddling routines are exported to
194 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
195 and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol
196 table on its own, but uses BFD to fix things up. More of the
197 bit twiddlers are exported for @code{gas};
198 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
199 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
200 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
201 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
202 of all the symbol table and reloc drudgery itself, thereby
203 saving the internal BFD overhead, but uses BFD to swap things
204 on the way out, making cross ports much safer. Doing so also
205 allows BFD (and thus the linker) to use the same header files
206 as @code{gas}, which makes one avenue to disaster disappear.
211 The simple canonical form for symbols used by BFD is not rich
212 enough to keep all the information available in a coff symbol
213 table. The back end gets around this problem by keeping the original
214 symbol table around, "behind the scenes".
216 When a symbol table is requested (through a call to
217 @code{bfd_canonicalize_symtab}), a request gets through to
218 @code{coff_get_normalized_symtab}. This reads the symbol table from
219 the coff file and swaps all the structures inside into the
220 internal form. It also fixes up all the pointers in the table
221 (represented in the file by offsets from the first symbol in
222 the table) into physical pointers to elements in the new
223 internal table. This involves some work since the meanings of
224 fields change depending upon context: a field that is a
225 pointer to another structure in the symbol table at one moment
226 may be the size in bytes of a structure at the next. Another
227 pass is made over the table. All symbols which mark file names
228 (<<C_FILE>> symbols) are modified so that the internal
229 string points to the value in the auxent (the real filename)
230 rather than the normal text associated with the symbol
233 At this time the symbol names are moved around. Coff stores
234 all symbols less than nine characters long physically
235 within the symbol table; longer strings are kept at the end of
236 the file in the string table. This pass moves all strings
237 into memory and replaces them with pointers to the strings.
239 The symbol table is massaged once again, this time to create
240 the canonical table used by the BFD application. Each symbol
241 is inspected in turn, and a decision made (using the
242 @code{sclass} field) about the various flags to set in the
243 @code{asymbol}. @xref{Symbols}. The generated canonical table
244 shares strings with the hidden internal symbol table.
246 Any linenumbers are read from the coff file too, and attached
247 to the symbols which own the functions the linenumbers belong to.
252 Writing a symbol to a coff file which didn't come from a coff
253 file will lose any debugging information. The @code{asymbol}
254 structure remembers the BFD from which the symbol was taken, and on
255 output the back end makes sure that the same destination target as
256 source target is present.
258 When the symbols have come from a coff file then all the
259 debugging information is preserved.
261 Symbol tables are provided for writing to the back end in a
262 vector of pointers to pointers. This allows applications like
263 the linker to accumulate and output large symbol tables
264 without having to do too much byte copying.
266 This function runs through the provided symbol table and
267 patches each symbol marked as a file place holder
268 (@code{C_FILE}) to point to the next file place holder in the
269 list. It also marks each @code{offset} field in the list with
270 the offset from the first symbol of the current symbol.
272 Another function of this procedure is to turn the canonical
273 value form of BFD into the form used by coff. Internally, BFD
274 expects symbol values to be offsets from a section base; so a
275 symbol physically at 0x120, but in a section starting at
276 0x100, would have the value 0x20. Coff expects symbols to
277 contain their final value, so symbols have their values
278 changed at this point to reflect their sum with their owning
279 section. This transformation uses the
280 <<output_section>> field of the @code{asymbol}'s
281 @code{asection} @xref{Sections}.
283 o <<coff_mangle_symbols>>
285 This routine runs though the provided symbol table and uses
286 the offsets generated by the previous pass and the pointers
287 generated when the symbol table was read in to create the
288 structured hierarchy required by coff. It changes each pointer
289 to a symbol into the index into the symbol table of the asymbol.
291 o <<coff_write_symbols>>
293 This routine runs through the symbol table and patches up the
294 symbols from their internal form into the coff way, calls the
295 bit twiddlers, and writes out the table to the file.
304 The hidden information for an <<asymbol>> is described in a
305 <<combined_entry_type>>:
309 .typedef struct coff_ptr_struct
311 . {* Remembers the offset from the first symbol in the file for
312 . this symbol. Generated by coff_renumber_symbols. *}
313 . unsigned int offset;
315 . {* Should the value of this symbol be renumbered. Used for
316 . XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
317 . unsigned int fix_value : 1;
319 . {* Should the tag field of this symbol be renumbered.
320 . Created by coff_pointerize_aux. *}
321 . unsigned int fix_tag : 1;
323 . {* Should the endidx field of this symbol be renumbered.
324 . Created by coff_pointerize_aux. *}
325 . unsigned int fix_end : 1;
327 . {* Should the x_csect.x_scnlen field be renumbered.
328 . Created by coff_pointerize_aux. *}
329 . unsigned int fix_scnlen : 1;
331 . {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
332 . index into the line number entries. Set by coff_slurp_symbol_table. *}
333 . unsigned int fix_line : 1;
335 . {* The container for the symbol structure as read and translated
339 . union internal_auxent auxent;
340 . struct internal_syment syment;
342 .} combined_entry_type;
345 .{* Each canonical asymbol really looks like this: *}
347 .typedef struct coff_symbol_struct
349 . {* The actual symbol which the rest of BFD works with *}
352 . {* A pointer to the hidden information for this symbol *}
353 . combined_entry_type *native;
355 . {* A pointer to the linenumber information for this symbol *}
356 . struct lineno_cache_entry *lineno;
358 . {* Have the line numbers been relocated yet ? *}
359 . bfd_boolean done_lineno;
364 #include "libiberty.h"
369 #include "coffswap.h"
372 #define STRING_SIZE_SIZE 4
374 #define DOT_DEBUG ".debug"
375 #define GNU_LINKONCE_WI ".gnu.linkonce.wi."
376 #define DOT_RELOC ".reloc"
378 #if defined (COFF_LONG_SECTION_NAMES)
379 /* Needed to expand the inputs to BLANKOR1TOODD. */
380 #define COFFLONGSECTIONCATHELPER(x,y) x ## y
381 /* If the input macro Y is blank or '1', return an odd number; if it is
382 '0', return an even number. Result undefined in all other cases. */
383 #define BLANKOR1TOODD(y) COFFLONGSECTIONCATHELPER(1,y)
384 /* Defined to numerical 0 or 1 according to whether generation of long
385 section names is disabled or enabled by default. */
386 #define COFF_ENABLE_LONG_SECTION_NAMES (BLANKOR1TOODD(COFF_LONG_SECTION_NAMES) & 1)
387 /* Where long section names are supported, we allow them to be enabled
388 and disabled at runtime, so select an appropriate hook function for
389 _bfd_coff_set_long_section_names. */
390 #define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_allowed
391 #else /* !defined (COFF_LONG_SECTION_NAMES) */
392 /* If long section names are not supported, this stub disallows any
393 attempt to enable them at run-time. */
394 #define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_disallowed
395 #endif /* defined (COFF_LONG_SECTION_NAMES) */
397 /* Define a macro that can be used to initialise both the fields relating
398 to long section names in the backend data struct simultaneously. */
399 #if COFF_ENABLE_LONG_SECTION_NAMES
400 #define COFF_DEFAULT_LONG_SECTION_NAMES (TRUE), COFF_LONG_SECTION_NAMES_SETTER
401 #else /* !COFF_ENABLE_LONG_SECTION_NAMES */
402 #define COFF_DEFAULT_LONG_SECTION_NAMES (FALSE), COFF_LONG_SECTION_NAMES_SETTER
403 #endif /* COFF_ENABLE_LONG_SECTION_NAMES */
405 #if defined (COFF_LONG_SECTION_NAMES)
406 static bfd_boolean bfd_coff_set_long_section_names_allowed
408 #else /* !defined (COFF_LONG_SECTION_NAMES) */
409 static bfd_boolean bfd_coff_set_long_section_names_disallowed
411 #endif /* defined (COFF_LONG_SECTION_NAMES) */
412 static long sec_to_styp_flags
413 (const char *, flagword
);
414 static bfd_boolean styp_to_sec_flags
415 (bfd
*, void *, const char *, asection
*, flagword
*);
416 static bfd_boolean coff_bad_format_hook
418 static void coff_set_custom_section_alignment
419 (bfd
*, asection
*, const struct coff_section_alignment_entry
*,
421 static bfd_boolean coff_new_section_hook
423 static bfd_boolean coff_set_arch_mach_hook
425 static bfd_boolean coff_write_relocs
427 static bfd_boolean coff_set_flags
428 (bfd
*, unsigned int *, unsigned short *);
429 static bfd_boolean coff_set_arch_mach
430 (bfd
*, enum bfd_architecture
, unsigned long) ATTRIBUTE_UNUSED
;
431 static bfd_boolean coff_compute_section_file_positions
433 static bfd_boolean coff_write_object_contents
434 (bfd
*) ATTRIBUTE_UNUSED
;
435 static bfd_boolean coff_set_section_contents
436 (bfd
*, asection
*, const void *, file_ptr
, bfd_size_type
);
437 static void * buy_and_read
438 (bfd
*, file_ptr
, bfd_size_type
);
439 static bfd_boolean coff_slurp_line_table
441 static bfd_boolean coff_slurp_symbol_table
443 static enum coff_symbol_classification coff_classify_symbol
444 (bfd
*, struct internal_syment
*);
445 static bfd_boolean coff_slurp_reloc_table
446 (bfd
*, asection
*, asymbol
**);
447 static long coff_canonicalize_reloc
448 (bfd
*, asection
*, arelent
**, asymbol
**);
449 #ifndef coff_mkobject_hook
450 static void * coff_mkobject_hook
451 (bfd
*, void *, void *);
454 static flagword handle_COMDAT
455 (bfd
*, flagword
, void *, const char *, asection
*);
457 #ifdef COFF_IMAGE_WITH_PE
458 static bfd_boolean coff_read_word
459 (bfd
*, unsigned int *);
460 static unsigned int coff_compute_checksum
462 static bfd_boolean coff_apply_checksum
466 static bfd_boolean ticoff0_bad_format_hook
468 static bfd_boolean ticoff1_bad_format_hook
472 /* void warning(); */
474 #if defined (COFF_LONG_SECTION_NAMES)
476 bfd_coff_set_long_section_names_allowed (bfd
*abfd
, int enable
)
478 coff_backend_info (abfd
)->_bfd_coff_long_section_names
= enable
;
481 #else /* !defined (COFF_LONG_SECTION_NAMES) */
483 bfd_coff_set_long_section_names_disallowed (bfd
*abfd
, int enable
)
489 #endif /* defined (COFF_LONG_SECTION_NAMES) */
491 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
492 the incoming SEC_* flags. The inverse of this function is
493 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
494 should probably mirror the changes in styp_to_sec_flags(). */
498 /* Macros for setting debugging flags. */
501 #define STYP_XCOFF_DEBUG STYP_DEBUG
503 #define STYP_XCOFF_DEBUG STYP_INFO
506 #ifdef COFF_ALIGN_IN_S_FLAGS
507 #define STYP_DEBUG_INFO STYP_DSECT
509 #define STYP_DEBUG_INFO STYP_INFO
513 sec_to_styp_flags (const char *sec_name
, flagword sec_flags
)
517 if (!strcmp (sec_name
, _TEXT
))
519 styp_flags
= STYP_TEXT
;
521 else if (!strcmp (sec_name
, _DATA
))
523 styp_flags
= STYP_DATA
;
525 else if (!strcmp (sec_name
, _BSS
))
527 styp_flags
= STYP_BSS
;
530 else if (!strcmp (sec_name
, _COMMENT
))
532 styp_flags
= STYP_INFO
;
533 #endif /* _COMMENT */
536 else if (!strcmp (sec_name
, _LIB
))
538 styp_flags
= STYP_LIB
;
542 else if (!strcmp (sec_name
, _LIT
))
544 styp_flags
= STYP_LIT
;
547 else if (CONST_STRNEQ (sec_name
, DOT_DEBUG
))
549 /* Handle the XCOFF debug section and DWARF2 debug sections. */
551 styp_flags
= STYP_XCOFF_DEBUG
;
553 styp_flags
= STYP_DEBUG_INFO
;
555 else if (CONST_STRNEQ (sec_name
, ".stab"))
557 styp_flags
= STYP_DEBUG_INFO
;
559 #ifdef COFF_LONG_SECTION_NAMES
560 else if (CONST_STRNEQ (sec_name
, GNU_LINKONCE_WI
))
562 styp_flags
= STYP_DEBUG_INFO
;
566 else if (!strcmp (sec_name
, _PAD
))
568 styp_flags
= STYP_PAD
;
570 else if (!strcmp (sec_name
, _LOADER
))
572 styp_flags
= STYP_LOADER
;
574 else if (!strcmp (sec_name
, _EXCEPT
))
576 styp_flags
= STYP_EXCEPT
;
578 else if (!strcmp (sec_name
, _TYPCHK
))
580 styp_flags
= STYP_TYPCHK
;
583 /* Try and figure out what it should be */
584 else if (sec_flags
& SEC_CODE
)
586 styp_flags
= STYP_TEXT
;
588 else if (sec_flags
& SEC_DATA
)
590 styp_flags
= STYP_DATA
;
592 else if (sec_flags
& SEC_READONLY
)
594 #ifdef STYP_LIT /* 29k readonly text/data section */
595 styp_flags
= STYP_LIT
;
597 styp_flags
= STYP_TEXT
;
598 #endif /* STYP_LIT */
600 else if (sec_flags
& SEC_LOAD
)
602 styp_flags
= STYP_TEXT
;
604 else if (sec_flags
& SEC_ALLOC
)
606 styp_flags
= STYP_BSS
;
610 if (sec_flags
& SEC_TIC54X_CLINK
)
611 styp_flags
|= STYP_CLINK
;
615 if (sec_flags
& SEC_TIC54X_BLOCK
)
616 styp_flags
|= STYP_BLOCK
;
620 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
621 styp_flags
|= STYP_NOLOAD
;
627 #else /* COFF_WITH_PE */
629 /* The PE version; see above for the general comments. The non-PE
630 case seems to be more guessing, and breaks PE format; specifically,
631 .rdata is readonly, but it sure ain't text. Really, all this
632 should be set up properly in gas (or whatever assembler is in use),
633 and honor whatever objcopy/strip, etc. sent us as input. */
636 sec_to_styp_flags (const char *sec_name
, flagword sec_flags
)
640 /* caution: there are at least three groups of symbols that have
641 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
642 SEC_* are the BFD internal flags, used for generic BFD
643 information. STYP_* are the COFF section flags which appear in
644 COFF files. IMAGE_SCN_* are the PE section flags which appear in
645 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
646 but there are more IMAGE_SCN_* flags. */
648 /* FIXME: There is no gas syntax to specify the debug section flag. */
649 if (CONST_STRNEQ (sec_name
, DOT_DEBUG
)
650 || CONST_STRNEQ (sec_name
, GNU_LINKONCE_WI
))
651 sec_flags
= SEC_DEBUGGING
| SEC_READONLY
;
656 if ((sec_flags
& SEC_CODE
) != 0)
657 styp_flags
|= IMAGE_SCN_CNT_CODE
;
658 if ((sec_flags
& SEC_DATA
) != 0)
659 styp_flags
|= IMAGE_SCN_CNT_INITIALIZED_DATA
;
660 if ((sec_flags
& SEC_ALLOC
) != 0 && (sec_flags
& SEC_LOAD
) == 0)
661 styp_flags
|= IMAGE_SCN_CNT_UNINITIALIZED_DATA
; /* ==STYP_BSS */
663 /* skip constRUCTOR */
665 if ((sec_flags
& SEC_IS_COMMON
) != 0)
666 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
667 if ((sec_flags
& SEC_DEBUGGING
) != 0)
668 styp_flags
|= IMAGE_SCN_MEM_DISCARDABLE
;
669 if ((sec_flags
& SEC_EXCLUDE
) != 0)
670 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
671 if ((sec_flags
& SEC_NEVER_LOAD
) != 0)
672 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
675 if (sec_flags
& SEC_LINK_ONCE
)
676 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
677 /* skip LINK_DUPLICATES */
678 /* skip LINKER_CREATED */
680 if ((sec_flags
& SEC_COFF_NOREAD
) == 0)
681 styp_flags
|= IMAGE_SCN_MEM_READ
; /* Invert NOREAD for read. */
682 if ((sec_flags
& SEC_READONLY
) == 0)
683 styp_flags
|= IMAGE_SCN_MEM_WRITE
; /* Invert READONLY for write. */
684 if (sec_flags
& SEC_CODE
)
685 styp_flags
|= IMAGE_SCN_MEM_EXECUTE
; /* CODE->EXECUTE. */
686 if (sec_flags
& SEC_COFF_SHARED
)
687 styp_flags
|= IMAGE_SCN_MEM_SHARED
; /* Shared remains meaningful. */
692 #endif /* COFF_WITH_PE */
694 /* Return a word with SEC_* flags set to represent the incoming STYP_*
695 flags (from scnhdr.s_flags). The inverse of this function is
696 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
697 should probably mirror the changes in sec_to_styp_flags(). */
702 styp_to_sec_flags (bfd
*abfd ATTRIBUTE_UNUSED
,
705 asection
*section ATTRIBUTE_UNUSED
,
708 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
709 long styp_flags
= internal_s
->s_flags
;
710 flagword sec_flags
= 0;
713 if (styp_flags
& STYP_BLOCK
)
714 sec_flags
|= SEC_TIC54X_BLOCK
;
718 if (styp_flags
& STYP_CLINK
)
719 sec_flags
|= SEC_TIC54X_CLINK
;
723 if (styp_flags
& STYP_NOLOAD
)
724 sec_flags
|= SEC_NEVER_LOAD
;
725 #endif /* STYP_NOLOAD */
727 /* For 386 COFF, at least, an unloadable text or data section is
728 actually a shared library section. */
729 if (styp_flags
& STYP_TEXT
)
731 if (sec_flags
& SEC_NEVER_LOAD
)
732 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
734 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
736 else if (styp_flags
& STYP_DATA
)
738 if (sec_flags
& SEC_NEVER_LOAD
)
739 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
741 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
743 else if (styp_flags
& STYP_BSS
)
745 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
746 if (sec_flags
& SEC_NEVER_LOAD
)
747 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
750 sec_flags
|= SEC_ALLOC
;
752 else if (styp_flags
& STYP_INFO
)
754 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
755 defined. coff_compute_section_file_positions uses
756 COFF_PAGE_SIZE to ensure that the low order bits of the
757 section VMA and the file offset match. If we don't know
758 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
759 and demand page loading of the file will fail. */
760 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
761 sec_flags
|= SEC_DEBUGGING
;
764 else if (styp_flags
& STYP_PAD
)
766 else if (strcmp (name
, _TEXT
) == 0)
768 if (sec_flags
& SEC_NEVER_LOAD
)
769 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
771 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
773 else if (strcmp (name
, _DATA
) == 0)
775 if (sec_flags
& SEC_NEVER_LOAD
)
776 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
778 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
780 else if (strcmp (name
, _BSS
) == 0)
782 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
783 if (sec_flags
& SEC_NEVER_LOAD
)
784 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
787 sec_flags
|= SEC_ALLOC
;
789 else if (CONST_STRNEQ (name
, DOT_DEBUG
)
791 || strcmp (name
, _COMMENT
) == 0
793 #ifdef COFF_LONG_SECTION_NAMES
794 || CONST_STRNEQ (name
, GNU_LINKONCE_WI
)
796 || CONST_STRNEQ (name
, ".stab"))
798 #ifdef COFF_PAGE_SIZE
799 sec_flags
|= SEC_DEBUGGING
;
803 else if (strcmp (name
, _LIB
) == 0)
807 else if (strcmp (name
, _LIT
) == 0)
808 sec_flags
= SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
811 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
813 #ifdef STYP_LIT /* A29k readonly text/data section type. */
814 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
815 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
816 #endif /* STYP_LIT */
818 #ifdef STYP_OTHER_LOAD /* Other loaded sections. */
819 if (styp_flags
& STYP_OTHER_LOAD
)
820 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
821 #endif /* STYP_SDATA */
823 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
824 /* As a GNU extension, if the name begins with .gnu.linkonce, we
825 only link a single copy of the section. This is used to support
826 g++. g++ will emit each template expansion in its own section.
827 The symbols will be defined as weak, so that multiple definitions
828 are permitted. The GNU linker extension is to actually discard
829 all but one of the sections. */
830 if (CONST_STRNEQ (name
, ".gnu.linkonce"))
831 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
834 if (flags_ptr
== NULL
)
837 * flags_ptr
= sec_flags
;
841 #else /* COFF_WITH_PE */
844 handle_COMDAT (bfd
* abfd
,
850 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
851 bfd_byte
*esymstart
, *esym
, *esymend
;
853 char *target_name
= NULL
;
855 sec_flags
|= SEC_LINK_ONCE
;
857 /* Unfortunately, the PE format stores essential information in
858 the symbol table, of all places. We need to extract that
859 information now, so that objdump and the linker will know how
860 to handle the section without worrying about the symbols. We
861 can't call slurp_symtab, because the linker doesn't want the
864 /* COMDAT sections are special. The first symbol is the section
865 symbol, which tells what kind of COMDAT section it is. The
866 second symbol is the "comdat symbol" - the one with the
867 unique name. GNU uses the section symbol for the unique
868 name; MS uses ".text" for every comdat section. Sigh. - DJ */
870 /* This is not mirrored in sec_to_styp_flags(), but there
871 doesn't seem to be a need to, either, and it would at best be
874 if (! _bfd_coff_get_external_symbols (abfd
))
877 esymstart
= esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
878 esymend
= esym
+ obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
880 while (esym
< esymend
)
882 struct internal_syment isym
;
883 char buf
[SYMNMLEN
+ 1];
886 bfd_coff_swap_sym_in (abfd
, esym
, & isym
);
888 if (sizeof (internal_s
->s_name
) > SYMNMLEN
)
890 /* This case implies that the matching
891 symbol name will be in the string table. */
895 if (isym
.n_scnum
== section
->target_index
)
897 /* According to the MSVC documentation, the first
898 TWO entries with the section # are both of
899 interest to us. The first one is the "section
900 symbol" (section name). The second is the comdat
901 symbol name. Here, we've found the first
902 qualifying entry; we distinguish it from the
903 second with a state flag.
905 In the case of gas-generated (at least until that
906 is fixed) .o files, it isn't necessarily the
907 second one. It may be some other later symbol.
909 Since gas also doesn't follow MS conventions and
910 emits the section similar to .text$<name>, where
911 <something> is the name we're looking for, we
912 distinguish the two as follows:
914 If the section name is simply a section name (no
915 $) we presume it's MS-generated, and look at
916 precisely the second symbol for the comdat name.
917 If the section name has a $, we assume it's
918 gas-generated, and look for <something> (whatever
919 follows the $) as the comdat symbol. */
921 /* All 3 branches use this. */
922 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
, buf
);
931 /* The first time we've seen the symbol. */
932 union internal_auxent aux
;
934 /* If it isn't the stuff we're expecting, die;
935 The MS documentation is vague, but it
936 appears that the second entry serves BOTH
937 as the comdat symbol and the defining
938 symbol record (either C_STAT or C_EXT,
939 possibly with an aux entry with debug
940 information if it's a function.) It
941 appears the only way to find the second one
942 is to count. (On Intel, they appear to be
943 adjacent, but on Alpha, they have been
946 Here, we think we've found the first one,
947 but there's some checking we can do to be
950 if (! ((isym
.n_sclass
== C_STAT
951 || isym
.n_sclass
== C_EXT
)
952 && isym
.n_type
== T_NULL
953 && isym
.n_value
== 0))
956 /* FIXME LATER: MSVC generates section names
957 like .text for comdats. Gas generates
958 names like .text$foo__Fv (in the case of a
959 function). See comment above for more. */
961 if (isym
.n_sclass
== C_STAT
&& strcmp (name
, symname
) != 0)
962 _bfd_error_handler (_("%B: warning: COMDAT symbol '%s' does not match section name '%s'"),
963 abfd
, symname
, name
);
967 /* This is the section symbol. */
968 bfd_coff_swap_aux_in (abfd
, (esym
+ bfd_coff_symesz (abfd
)),
969 isym
.n_type
, isym
.n_sclass
,
970 0, isym
.n_numaux
, & aux
);
972 target_name
= strchr (name
, '$');
973 if (target_name
!= NULL
)
981 /* FIXME: Microsoft uses NODUPLICATES and
982 ASSOCIATIVE, but gnu uses ANY and
983 SAME_SIZE. Unfortunately, gnu doesn't do
984 the comdat symbols right. So, until we can
985 fix it to do the right thing, we are
986 temporarily disabling comdats for the MS
987 types (they're used in DLLs and C++, but we
988 don't support *their* C++ libraries anyway
991 /* Cygwin does not follow the MS style, and
992 uses ANY and SAME_SIZE where NODUPLICATES
993 and ASSOCIATIVE should be used. For
994 Interix, we just do the right thing up
997 switch (aux
.x_scn
.x_comdat
)
999 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
1000 #ifdef STRICT_PE_FORMAT
1001 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
1003 sec_flags
&= ~SEC_LINK_ONCE
;
1007 case IMAGE_COMDAT_SELECT_ANY
:
1008 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1011 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
1012 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
1015 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
1016 /* Not yet fully implemented ??? */
1017 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
1020 /* debug$S gets this case; other
1023 /* There may be no symbol... we'll search
1024 the whole table... Is this the right
1025 place to play this game? Or should we do
1026 it when reading it in. */
1027 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
1028 #ifdef STRICT_PE_FORMAT
1029 /* FIXME: This is not currently implemented. */
1030 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1032 sec_flags
&= ~SEC_LINK_ONCE
;
1036 default: /* 0 means "no symbol" */
1037 /* debug$F gets this case; other
1039 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1046 /* Gas mode: the first matching on partial name. */
1048 #ifndef TARGET_UNDERSCORE
1049 #define TARGET_UNDERSCORE 0
1051 /* Is this the name we're looking for ? */
1052 if (strcmp (target_name
,
1053 symname
+ (TARGET_UNDERSCORE
? 1 : 0)) != 0)
1055 /* Not the name we're looking for */
1056 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1061 /* MSVC mode: the lexically second symbol (or
1062 drop through from the above). */
1067 /* This must the second symbol with the
1068 section #. It is the actual symbol name.
1069 Intel puts the two adjacent, but Alpha (at
1070 least) spreads them out. */
1072 amt
= sizeof (struct coff_comdat_info
);
1073 coff_section_data (abfd
, section
)->comdat
1074 = (struct coff_comdat_info
*) bfd_alloc (abfd
, amt
);
1075 if (coff_section_data (abfd
, section
)->comdat
== NULL
)
1078 coff_section_data (abfd
, section
)->comdat
->symbol
=
1079 (esym
- esymstart
) / bfd_coff_symesz (abfd
);
1081 amt
= strlen (symname
) + 1;
1082 newname
= (char *) bfd_alloc (abfd
, amt
);
1083 if (newname
== NULL
)
1086 strcpy (newname
, symname
);
1087 coff_section_data (abfd
, section
)->comdat
->name
1095 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1103 /* The PE version; see above for the general comments.
1105 Since to set the SEC_LINK_ONCE and associated flags, we have to
1106 look at the symbol table anyway, we return the symbol table index
1107 of the symbol being used as the COMDAT symbol. This is admittedly
1108 ugly, but there's really nowhere else that we have access to the
1109 required information. FIXME: Is the COMDAT symbol index used for
1110 any purpose other than objdump? */
1113 styp_to_sec_flags (bfd
*abfd
,
1117 flagword
*flags_ptr
)
1119 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
1120 long styp_flags
= internal_s
->s_flags
;
1122 bfd_boolean result
= TRUE
;
1124 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
1125 sec_flags
= SEC_READONLY
;
1127 /* If section disallows read, then set the NOREAD flag. */
1128 if ((styp_flags
& IMAGE_SCN_MEM_READ
) == 0)
1129 sec_flags
|= SEC_COFF_NOREAD
;
1131 /* Process each flag bit in styp_flags in turn. */
1134 long flag
= styp_flags
& - styp_flags
;
1135 char * unhandled
= NULL
;
1137 styp_flags
&= ~ flag
;
1139 /* We infer from the distinct read/write/execute bits the settings
1140 of some of the bfd flags; the actual values, should we need them,
1141 are also in pei_section_data (abfd, section)->pe_flags. */
1146 unhandled
= "STYP_DSECT";
1149 unhandled
= "STYP_GROUP";
1152 unhandled
= "STYP_COPY";
1155 unhandled
= "STYP_OVER";
1157 #ifdef SEC_NEVER_LOAD
1159 sec_flags
|= SEC_NEVER_LOAD
;
1162 case IMAGE_SCN_MEM_READ
:
1163 sec_flags
&= ~SEC_COFF_NOREAD
;
1165 case IMAGE_SCN_TYPE_NO_PAD
:
1168 case IMAGE_SCN_LNK_OTHER
:
1169 unhandled
= "IMAGE_SCN_LNK_OTHER";
1171 case IMAGE_SCN_MEM_NOT_CACHED
:
1172 unhandled
= "IMAGE_SCN_MEM_NOT_CACHED";
1174 case IMAGE_SCN_MEM_NOT_PAGED
:
1175 /* Generate a warning message rather using the 'unhandled'
1176 variable as this will allow some .sys files generate by
1177 other toolchains to be processed. See bugzilla issue 196. */
1178 _bfd_error_handler (_("%B: Warning: Ignoring section flag IMAGE_SCN_MEM_NOT_PAGED in section %s"),
1181 case IMAGE_SCN_MEM_EXECUTE
:
1182 sec_flags
|= SEC_CODE
;
1184 case IMAGE_SCN_MEM_WRITE
:
1185 sec_flags
&= ~ SEC_READONLY
;
1187 case IMAGE_SCN_MEM_DISCARDABLE
:
1188 /* The MS PE spec says that debug sections are DISCARDABLE,
1189 but the presence of a DISCARDABLE flag does not necessarily
1190 mean that a given section contains debug information. Thus
1191 we only set the SEC_DEBUGGING flag on sections that we
1192 recognise as containing debug information. */
1193 if (CONST_STRNEQ (name
, DOT_DEBUG
)
1195 || strcmp (name
, _COMMENT
) == 0
1197 #ifdef COFF_LONG_SECTION_NAMES
1198 || CONST_STRNEQ (name
, GNU_LINKONCE_WI
)
1200 || CONST_STRNEQ (name
, ".stab"))
1201 sec_flags
|= SEC_DEBUGGING
;
1203 case IMAGE_SCN_MEM_SHARED
:
1204 sec_flags
|= SEC_COFF_SHARED
;
1206 case IMAGE_SCN_LNK_REMOVE
:
1207 sec_flags
|= SEC_EXCLUDE
;
1209 case IMAGE_SCN_CNT_CODE
:
1210 sec_flags
|= SEC_CODE
| SEC_ALLOC
| SEC_LOAD
;
1212 case IMAGE_SCN_CNT_INITIALIZED_DATA
:
1213 sec_flags
|= SEC_DATA
| SEC_ALLOC
| SEC_LOAD
;
1215 case IMAGE_SCN_CNT_UNINITIALIZED_DATA
:
1216 sec_flags
|= SEC_ALLOC
;
1218 case IMAGE_SCN_LNK_INFO
:
1219 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1220 defined. coff_compute_section_file_positions uses
1221 COFF_PAGE_SIZE to ensure that the low order bits of the
1222 section VMA and the file offset match. If we don't know
1223 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1224 and demand page loading of the file will fail. */
1225 #ifdef COFF_PAGE_SIZE
1226 sec_flags
|= SEC_DEBUGGING
;
1229 case IMAGE_SCN_LNK_COMDAT
:
1230 /* COMDAT gets very special treatment. */
1231 sec_flags
= handle_COMDAT (abfd
, sec_flags
, hdr
, name
, section
);
1234 /* Silently ignore for now. */
1238 /* If the section flag was not handled, report it here. */
1239 if (unhandled
!= NULL
)
1241 (*_bfd_error_handler
)
1242 (_("%B (%s): Section flag %s (0x%x) ignored"),
1243 abfd
, name
, unhandled
, flag
);
1248 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1249 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1250 only link a single copy of the section. This is used to support
1251 g++. g++ will emit each template expansion in its own section.
1252 The symbols will be defined as weak, so that multiple definitions
1253 are permitted. The GNU linker extension is to actually discard
1254 all but one of the sections. */
1255 if (CONST_STRNEQ (name
, ".gnu.linkonce"))
1256 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1260 * flags_ptr
= sec_flags
;
1265 #endif /* COFF_WITH_PE */
1267 #define get_index(symbol) ((symbol)->udata.i)
1271 bfd_coff_backend_data
1275 .{* COFF symbol classifications. *}
1277 .enum coff_symbol_classification
1279 . {* Global symbol. *}
1280 . COFF_SYMBOL_GLOBAL,
1281 . {* Common symbol. *}
1282 . COFF_SYMBOL_COMMON,
1283 . {* Undefined symbol. *}
1284 . COFF_SYMBOL_UNDEFINED,
1285 . {* Local symbol. *}
1286 . COFF_SYMBOL_LOCAL,
1287 . {* PE section symbol. *}
1288 . COFF_SYMBOL_PE_SECTION
1291 Special entry points for gdb to swap in coff symbol table parts:
1294 . void (*_bfd_coff_swap_aux_in)
1295 . (bfd *, void *, int, int, int, int, void *);
1297 . void (*_bfd_coff_swap_sym_in)
1298 . (bfd *, void *, void *);
1300 . void (*_bfd_coff_swap_lineno_in)
1301 . (bfd *, void *, void *);
1303 . unsigned int (*_bfd_coff_swap_aux_out)
1304 . (bfd *, void *, int, int, int, int, void *);
1306 . unsigned int (*_bfd_coff_swap_sym_out)
1307 . (bfd *, void *, void *);
1309 . unsigned int (*_bfd_coff_swap_lineno_out)
1310 . (bfd *, void *, void *);
1312 . unsigned int (*_bfd_coff_swap_reloc_out)
1313 . (bfd *, void *, void *);
1315 . unsigned int (*_bfd_coff_swap_filehdr_out)
1316 . (bfd *, void *, void *);
1318 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1319 . (bfd *, void *, void *);
1321 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1322 . (bfd *, void *, void *);
1324 . unsigned int _bfd_filhsz;
1325 . unsigned int _bfd_aoutsz;
1326 . unsigned int _bfd_scnhsz;
1327 . unsigned int _bfd_symesz;
1328 . unsigned int _bfd_auxesz;
1329 . unsigned int _bfd_relsz;
1330 . unsigned int _bfd_linesz;
1331 . unsigned int _bfd_filnmlen;
1332 . bfd_boolean _bfd_coff_long_filenames;
1334 . bfd_boolean _bfd_coff_long_section_names;
1335 . bfd_boolean (*_bfd_coff_set_long_section_names)
1338 . unsigned int _bfd_coff_default_section_alignment_power;
1339 . bfd_boolean _bfd_coff_force_symnames_in_strings;
1340 . unsigned int _bfd_coff_debug_string_prefix_length;
1342 . void (*_bfd_coff_swap_filehdr_in)
1343 . (bfd *, void *, void *);
1345 . void (*_bfd_coff_swap_aouthdr_in)
1346 . (bfd *, void *, void *);
1348 . void (*_bfd_coff_swap_scnhdr_in)
1349 . (bfd *, void *, void *);
1351 . void (*_bfd_coff_swap_reloc_in)
1352 . (bfd *abfd, void *, void *);
1354 . bfd_boolean (*_bfd_coff_bad_format_hook)
1357 . bfd_boolean (*_bfd_coff_set_arch_mach_hook)
1360 . void * (*_bfd_coff_mkobject_hook)
1361 . (bfd *, void *, void *);
1363 . bfd_boolean (*_bfd_styp_to_sec_flags_hook)
1364 . (bfd *, void *, const char *, asection *, flagword *);
1366 . void (*_bfd_set_alignment_hook)
1367 . (bfd *, asection *, void *);
1369 . bfd_boolean (*_bfd_coff_slurp_symbol_table)
1372 . bfd_boolean (*_bfd_coff_symname_in_debug)
1373 . (bfd *, struct internal_syment *);
1375 . bfd_boolean (*_bfd_coff_pointerize_aux_hook)
1376 . (bfd *, combined_entry_type *, combined_entry_type *,
1377 . unsigned int, combined_entry_type *);
1379 . bfd_boolean (*_bfd_coff_print_aux)
1380 . (bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1381 . combined_entry_type *, unsigned int);
1383 . void (*_bfd_coff_reloc16_extra_cases)
1384 . (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1385 . bfd_byte *, unsigned int *, unsigned int *);
1387 . int (*_bfd_coff_reloc16_estimate)
1388 . (bfd *, asection *, arelent *, unsigned int,
1389 . struct bfd_link_info *);
1391 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1392 . (bfd *, struct internal_syment *);
1394 . bfd_boolean (*_bfd_coff_compute_section_file_positions)
1397 . bfd_boolean (*_bfd_coff_start_final_link)
1398 . (bfd *, struct bfd_link_info *);
1400 . bfd_boolean (*_bfd_coff_relocate_section)
1401 . (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1402 . struct internal_reloc *, struct internal_syment *, asection **);
1404 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1405 . (bfd *, asection *, struct internal_reloc *,
1406 . struct coff_link_hash_entry *, struct internal_syment *,
1409 . bfd_boolean (*_bfd_coff_adjust_symndx)
1410 . (bfd *, struct bfd_link_info *, bfd *, asection *,
1411 . struct internal_reloc *, bfd_boolean *);
1413 . bfd_boolean (*_bfd_coff_link_add_one_symbol)
1414 . (struct bfd_link_info *, bfd *, const char *, flagword,
1415 . asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
1416 . struct bfd_link_hash_entry **);
1418 . bfd_boolean (*_bfd_coff_link_output_has_begun)
1419 . (bfd *, struct coff_final_link_info *);
1421 . bfd_boolean (*_bfd_coff_final_link_postscript)
1422 . (bfd *, struct coff_final_link_info *);
1424 . bfd_boolean (*_bfd_coff_print_pdata)
1427 .} bfd_coff_backend_data;
1429 .#define coff_backend_info(abfd) \
1430 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1432 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1433 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1435 .#define bfd_coff_swap_sym_in(a,e,i) \
1436 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1438 .#define bfd_coff_swap_lineno_in(a,e,i) \
1439 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1441 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1442 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1444 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1445 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1447 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1448 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1450 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1451 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1453 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1454 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1456 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1457 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1459 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1460 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1462 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1463 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1464 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1465 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1466 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1467 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1468 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1469 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1470 .#define bfd_coff_long_filenames(abfd) \
1471 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1472 .#define bfd_coff_long_section_names(abfd) \
1473 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1474 .#define bfd_coff_set_long_section_names(abfd, enable) \
1475 . ((coff_backend_info (abfd)->_bfd_coff_set_long_section_names) (abfd, enable))
1476 .#define bfd_coff_default_section_alignment_power(abfd) \
1477 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1478 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1479 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1481 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1482 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1484 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1485 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1487 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1488 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1490 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1491 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1493 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1494 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1495 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1496 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1497 . (abfd, filehdr, aouthdr))
1499 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1500 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1501 . (abfd, scnhdr, name, section, flags_ptr))
1503 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1504 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1506 .#define bfd_coff_slurp_symbol_table(abfd)\
1507 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1509 .#define bfd_coff_symname_in_debug(abfd, sym)\
1510 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1512 .#define bfd_coff_force_symnames_in_strings(abfd)\
1513 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1515 .#define bfd_coff_debug_string_prefix_length(abfd)\
1516 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1518 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1519 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1520 . (abfd, file, base, symbol, aux, indaux))
1522 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1523 . reloc, data, src_ptr, dst_ptr)\
1524 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1525 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1527 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1528 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1529 . (abfd, section, reloc, shrink, link_info))
1531 .#define bfd_coff_classify_symbol(abfd, sym)\
1532 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1535 .#define bfd_coff_compute_section_file_positions(abfd)\
1536 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1539 .#define bfd_coff_start_final_link(obfd, info)\
1540 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1542 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1543 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1544 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1545 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1546 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1547 . (abfd, sec, rel, h, sym, addendp))
1548 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1549 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1550 . (obfd, info, ibfd, sec, rel, adjustedp))
1551 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1552 . value, string, cp, coll, hashp)\
1553 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1554 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1556 .#define bfd_coff_link_output_has_begun(a,p) \
1557 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p))
1558 .#define bfd_coff_final_link_postscript(a,p) \
1559 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p))
1561 .#define bfd_coff_have_print_pdata(a) \
1562 . (coff_backend_info (a)->_bfd_coff_print_pdata)
1563 .#define bfd_coff_print_pdata(a,p) \
1564 . ((coff_backend_info (a)->_bfd_coff_print_pdata) (a, p))
1566 .{* Macro: Returns true if the bfd is a PE executable as opposed to a
1567 . PE object file. *}
1568 .#define bfd_pei_p(abfd) \
1569 . (CONST_STRNEQ ((abfd)->xvec->name, "pei-"))
1572 /* See whether the magic number matches. */
1575 coff_bad_format_hook (bfd
* abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1577 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1579 if (BADMAG (*internal_f
))
1582 /* If the optional header is NULL or not the correct size then
1583 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1584 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1585 optional header is of a different size.
1587 But the mips keeps extra stuff in it's opthdr, so dont check
1590 #if defined(M88) || defined(I960)
1591 if (internal_f
->f_opthdr
!= 0 && bfd_coff_aoutsz (abfd
) != internal_f
->f_opthdr
)
1600 ticoff0_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1602 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1604 if (COFF0_BADMAG (*internal_f
))
1613 ticoff1_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1615 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1617 if (COFF1_BADMAG (*internal_f
))
1624 /* Check whether this section uses an alignment other than the
1628 coff_set_custom_section_alignment (bfd
*abfd ATTRIBUTE_UNUSED
,
1630 const struct coff_section_alignment_entry
*alignment_table
,
1631 const unsigned int table_size
)
1633 const unsigned int default_alignment
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1636 for (i
= 0; i
< table_size
; ++i
)
1638 const char *secname
= bfd_get_section_name (abfd
, section
);
1640 if (alignment_table
[i
].comparison_length
== (unsigned int) -1
1641 ? strcmp (alignment_table
[i
].name
, secname
) == 0
1642 : strncmp (alignment_table
[i
].name
, secname
,
1643 alignment_table
[i
].comparison_length
) == 0)
1646 if (i
>= table_size
)
1649 if (alignment_table
[i
].default_alignment_min
!= COFF_ALIGNMENT_FIELD_EMPTY
1650 && default_alignment
< alignment_table
[i
].default_alignment_min
)
1653 if (alignment_table
[i
].default_alignment_max
!= COFF_ALIGNMENT_FIELD_EMPTY
1654 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1655 && default_alignment
> alignment_table
[i
].default_alignment_max
1660 section
->alignment_power
= alignment_table
[i
].alignment_power
;
1663 /* Custom section alignment records. */
1665 static const struct coff_section_alignment_entry
1666 coff_section_alignment_table
[] =
1668 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1669 COFF_SECTION_ALIGNMENT_ENTRIES
,
1671 /* There must not be any gaps between .stabstr sections. */
1672 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1673 1, COFF_ALIGNMENT_FIELD_EMPTY
, 0 },
1674 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1675 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1676 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1677 /* Similarly for the .ctors and .dtors sections. */
1678 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1679 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1680 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1681 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 }
1684 static const unsigned int coff_section_alignment_table_size
=
1685 sizeof coff_section_alignment_table
/ sizeof coff_section_alignment_table
[0];
1687 /* Initialize a section structure with information peculiar to this
1688 particular implementation of COFF. */
1691 coff_new_section_hook (bfd
* abfd
, asection
* section
)
1693 combined_entry_type
*native
;
1696 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1699 if (bfd_xcoff_text_align_power (abfd
) != 0
1700 && strcmp (bfd_get_section_name (abfd
, section
), ".text") == 0)
1701 section
->alignment_power
= bfd_xcoff_text_align_power (abfd
);
1702 if (bfd_xcoff_data_align_power (abfd
) != 0
1703 && strcmp (bfd_get_section_name (abfd
, section
), ".data") == 0)
1704 section
->alignment_power
= bfd_xcoff_data_align_power (abfd
);
1707 /* Set up the section symbol. */
1708 if (!_bfd_generic_new_section_hook (abfd
, section
))
1711 /* Allocate aux records for section symbols, to store size and
1714 @@ The 10 is a guess at a plausible maximum number of aux entries
1715 (but shouldn't be a constant). */
1716 amt
= sizeof (combined_entry_type
) * 10;
1717 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
1721 /* We don't need to set up n_name, n_value, or n_scnum in the native
1722 symbol information, since they'll be overridden by the BFD symbol
1723 anyhow. However, we do need to set the type and storage class,
1724 in case this symbol winds up getting written out. The value 0
1725 for n_numaux is already correct. */
1727 native
->u
.syment
.n_type
= T_NULL
;
1728 native
->u
.syment
.n_sclass
= C_STAT
;
1730 coffsymbol (section
->symbol
)->native
= native
;
1732 coff_set_custom_section_alignment (abfd
, section
,
1733 coff_section_alignment_table
,
1734 coff_section_alignment_table_size
);
1739 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1741 /* Set the alignment of a BFD section. */
1744 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1748 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1752 /* Extract ALIGN from 2**ALIGN stored in section header. */
1753 for (i
= 0; i
< 32; i
++)
1754 if ((1 << i
) >= hdr
->s_align
)
1758 /* TI tools puts the alignment power in bits 8-11. */
1759 i
= (hdr
->s_flags
>> 8) & 0xF ;
1761 #ifdef COFF_DECODE_ALIGNMENT
1762 i
= COFF_DECODE_ALIGNMENT(hdr
->s_flags
);
1764 section
->alignment_power
= i
;
1766 #ifdef coff_set_section_load_page
1767 coff_set_section_load_page (section
, hdr
->s_page
);
1771 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1775 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1779 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1781 unsigned int alignment_power_const
1782 = hdr
->s_flags
& IMAGE_SCN_ALIGN_POWER_BIT_MASK
;
1784 switch (alignment_power_const
)
1786 case IMAGE_SCN_ALIGN_8192BYTES
:
1787 case IMAGE_SCN_ALIGN_4096BYTES
:
1788 case IMAGE_SCN_ALIGN_2048BYTES
:
1789 case IMAGE_SCN_ALIGN_1024BYTES
:
1790 case IMAGE_SCN_ALIGN_512BYTES
:
1791 case IMAGE_SCN_ALIGN_256BYTES
:
1792 case IMAGE_SCN_ALIGN_128BYTES
:
1793 case IMAGE_SCN_ALIGN_64BYTES
:
1794 case IMAGE_SCN_ALIGN_32BYTES
:
1795 case IMAGE_SCN_ALIGN_16BYTES
:
1796 case IMAGE_SCN_ALIGN_8BYTES
:
1797 case IMAGE_SCN_ALIGN_4BYTES
:
1798 case IMAGE_SCN_ALIGN_2BYTES
:
1799 case IMAGE_SCN_ALIGN_1BYTES
:
1800 section
->alignment_power
1801 = IMAGE_SCN_ALIGN_POWER_NUM (alignment_power_const
);
1807 /* In a PE image file, the s_paddr field holds the virtual size of a
1808 section, while the s_size field holds the raw size. We also keep
1809 the original section flag value, since not every bit can be
1810 mapped onto a generic BFD section bit. */
1811 if (coff_section_data (abfd
, section
) == NULL
)
1813 amt
= sizeof (struct coff_section_tdata
);
1814 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
1815 if (section
->used_by_bfd
== NULL
)
1816 /* FIXME: Return error. */
1820 if (pei_section_data (abfd
, section
) == NULL
)
1822 amt
= sizeof (struct pei_section_tdata
);
1823 coff_section_data (abfd
, section
)->tdata
= bfd_zalloc (abfd
, amt
);
1824 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1825 /* FIXME: Return error. */
1828 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1829 pei_section_data (abfd
, section
)->pe_flags
= hdr
->s_flags
;
1831 section
->lma
= hdr
->s_vaddr
;
1833 /* Check for extended relocs. */
1834 if (hdr
->s_flags
& IMAGE_SCN_LNK_NRELOC_OVFL
)
1836 struct external_reloc dst
;
1837 struct internal_reloc n
;
1838 file_ptr oldpos
= bfd_tell (abfd
);
1839 bfd_size_type relsz
= bfd_coff_relsz (abfd
);
1841 bfd_seek (abfd
, (file_ptr
) hdr
->s_relptr
, 0);
1842 if (bfd_bread (& dst
, relsz
, abfd
) != relsz
)
1845 coff_swap_reloc_in (abfd
, &dst
, &n
);
1846 bfd_seek (abfd
, oldpos
, 0);
1847 section
->reloc_count
= hdr
->s_nreloc
= n
.r_vaddr
- 1;
1848 section
->rel_filepos
+= relsz
;
1850 else if (hdr
->s_nreloc
== 0xffff)
1851 (*_bfd_error_handler
)
1852 ("%s: warning: claims to have 0xffff relocs, without overflow",
1853 bfd_get_filename (abfd
));
1856 #undef ELIFALIGN_SET
1858 #else /* ! COFF_WITH_PE */
1861 /* We grossly abuse this function to handle XCOFF overflow headers.
1862 When we see one, we correct the reloc and line number counts in the
1863 real header, and remove the section we just created. */
1866 coff_set_alignment_hook (bfd
*abfd
, asection
*section
, void * scnhdr
)
1868 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1871 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1874 real_sec
= coff_section_from_bfd_index (abfd
, (int) hdr
->s_nreloc
);
1875 if (real_sec
== NULL
)
1878 real_sec
->reloc_count
= hdr
->s_paddr
;
1879 real_sec
->lineno_count
= hdr
->s_vaddr
;
1881 if (!bfd_section_removed_from_list (abfd
, section
))
1883 bfd_section_list_remove (abfd
, section
);
1884 --abfd
->section_count
;
1888 #else /* ! RS6000COFF_C */
1890 #define coff_set_alignment_hook \
1891 ((void (*) (bfd *, asection *, void *)) bfd_void)
1893 #endif /* ! RS6000COFF_C */
1894 #endif /* ! COFF_WITH_PE */
1895 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1897 #ifndef coff_mkobject
1900 coff_mkobject (bfd
* abfd
)
1902 coff_data_type
*coff
;
1903 bfd_size_type amt
= sizeof (coff_data_type
);
1905 abfd
->tdata
.coff_obj_data
= bfd_zalloc (abfd
, amt
);
1906 if (abfd
->tdata
.coff_obj_data
== NULL
)
1908 coff
= coff_data (abfd
);
1909 coff
->symbols
= NULL
;
1910 coff
->conversion_table
= NULL
;
1911 coff
->raw_syments
= NULL
;
1912 coff
->relocbase
= 0;
1913 coff
->local_toc_sym_map
= 0;
1915 /* make_abs_section(abfd);*/
1921 /* Create the COFF backend specific information. */
1923 #ifndef coff_mkobject_hook
1925 coff_mkobject_hook (bfd
* abfd
,
1927 void * aouthdr ATTRIBUTE_UNUSED
)
1929 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1930 coff_data_type
*coff
;
1932 if (! coff_mkobject (abfd
))
1935 coff
= coff_data (abfd
);
1937 coff
->sym_filepos
= internal_f
->f_symptr
;
1939 /* These members communicate important constants about the symbol
1940 table to GDB's symbol-reading code. These `constants'
1941 unfortunately vary among coff implementations... */
1942 coff
->local_n_btmask
= N_BTMASK
;
1943 coff
->local_n_btshft
= N_BTSHFT
;
1944 coff
->local_n_tmask
= N_TMASK
;
1945 coff
->local_n_tshift
= N_TSHIFT
;
1946 coff
->local_symesz
= bfd_coff_symesz (abfd
);
1947 coff
->local_auxesz
= bfd_coff_auxesz (abfd
);
1948 coff
->local_linesz
= bfd_coff_linesz (abfd
);
1950 coff
->timestamp
= internal_f
->f_timdat
;
1952 obj_raw_syment_count (abfd
) =
1953 obj_conv_table_size (abfd
) =
1954 internal_f
->f_nsyms
;
1957 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
1958 abfd
->flags
|= DYNAMIC
;
1959 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= bfd_coff_aoutsz (abfd
))
1961 struct internal_aouthdr
*internal_a
=
1962 (struct internal_aouthdr
*) aouthdr
;
1963 struct xcoff_tdata
*xcoff
;
1965 xcoff
= xcoff_data (abfd
);
1966 # ifdef U803XTOCMAGIC
1967 xcoff
->xcoff64
= internal_f
->f_magic
== U803XTOCMAGIC
;
1971 xcoff
->full_aouthdr
= TRUE
;
1972 xcoff
->toc
= internal_a
->o_toc
;
1973 xcoff
->sntoc
= internal_a
->o_sntoc
;
1974 xcoff
->snentry
= internal_a
->o_snentry
;
1975 bfd_xcoff_text_align_power (abfd
) = internal_a
->o_algntext
;
1976 bfd_xcoff_data_align_power (abfd
) = internal_a
->o_algndata
;
1977 xcoff
->modtype
= internal_a
->o_modtype
;
1978 xcoff
->cputype
= internal_a
->o_cputype
;
1979 xcoff
->maxdata
= internal_a
->o_maxdata
;
1980 xcoff
->maxstack
= internal_a
->o_maxstack
;
1985 /* Set the flags field from the COFF header read in. */
1986 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
1991 /* FIXME: I'm not sure this is ever executed, since peicode.h
1992 defines coff_mkobject_hook. */
1993 if ((internal_f
->f_flags
& IMAGE_FILE_DEBUG_STRIPPED
) == 0)
1994 abfd
->flags
|= HAS_DEBUG
;
1997 if ((internal_f
->f_flags
& F_GO32STUB
) != 0)
1998 coff
->go32stub
= (char *) bfd_alloc (abfd
, (bfd_size_type
) GO32_STUBSIZE
);
1999 if (coff
->go32stub
!= NULL
)
2000 memcpy (coff
->go32stub
, internal_f
->go32stub
, GO32_STUBSIZE
);
2006 /* Determine the machine architecture and type. FIXME: This is target
2007 dependent because the magic numbers are defined in the target
2008 dependent header files. But there is no particular need for this.
2009 If the magic numbers were moved to a separate file, this function
2010 would be target independent and would also be much more successful
2011 at linking together COFF files for different architectures. */
2014 coff_set_arch_mach_hook (bfd
*abfd
, void * filehdr
)
2016 unsigned long machine
;
2017 enum bfd_architecture arch
;
2018 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
2020 /* Zero selects the default machine for an arch. */
2022 switch (internal_f
->f_magic
)
2024 #ifdef OR32_MAGIC_BIG
2025 case OR32_MAGIC_BIG
:
2026 case OR32_MAGIC_LITTLE
:
2027 arch
= bfd_arch_or32
;
2032 arch
= bfd_arch_powerpc
;
2038 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler. */
2039 case LYNXCOFFMAGIC
: /* Shadows the m68k Lynx number below, sigh. */
2040 arch
= bfd_arch_i386
;
2045 arch
= bfd_arch_i386
;
2046 machine
= bfd_mach_x86_64
;
2051 arch
= bfd_arch_ia64
;
2058 arch
= bfd_arch_arm
;
2059 machine
= bfd_arm_get_mach_from_notes (abfd
, ARM_NOTE_SECTION
);
2060 if (machine
== bfd_mach_arm_unknown
)
2062 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
2064 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
2065 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
2066 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
2068 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
2069 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
2070 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
2071 /* The COFF header does not have enough bits available
2072 to cover all the different ARM architectures. So
2073 we interpret F_ARM_5, the highest flag value to mean
2074 "the highest ARM architecture known to BFD" which is
2075 currently the XScale. */
2076 case F_ARM_5
: machine
= bfd_mach_arm_XScale
; break;
2084 #ifdef MC68KBCSMAGIC
2087 #ifdef APOLLOM68KMAGIC
2088 case APOLLOM68KMAGIC
:
2090 #ifdef LYNXCOFFMAGIC
2093 arch
= bfd_arch_m68k
;
2094 machine
= bfd_mach_m68020
;
2099 arch
= bfd_arch_maxq
;
2100 switch (internal_f
->f_flags
& F_MACHMASK
)
2103 machine
= bfd_mach_maxq10
;
2106 machine
= bfd_mach_maxq20
;
2117 arch
= bfd_arch_m88k
;
2123 arch
= bfd_arch_z80
;
2124 switch (internal_f
->f_flags
& F_MACHMASK
)
2127 case bfd_mach_z80strict
<< 12:
2128 case bfd_mach_z80
<< 12:
2129 case bfd_mach_z80full
<< 12:
2130 case bfd_mach_r800
<< 12:
2131 machine
= ((unsigned)internal_f
->f_flags
& F_MACHMASK
) >> 12;
2140 arch
= bfd_arch_z8k
;
2141 switch (internal_f
->f_flags
& F_MACHMASK
)
2144 machine
= bfd_mach_z8001
;
2147 machine
= bfd_mach_z8002
;
2156 arch
= bfd_arch_i860
;
2163 arch
= bfd_arch_i960
;
2164 switch (F_I960TYPE
& internal_f
->f_flags
)
2168 machine
= bfd_mach_i960_core
;
2171 machine
= bfd_mach_i960_kb_sb
;
2174 machine
= bfd_mach_i960_mc
;
2177 machine
= bfd_mach_i960_xa
;
2180 machine
= bfd_mach_i960_ca
;
2183 machine
= bfd_mach_i960_ka_sa
;
2186 machine
= bfd_mach_i960_jx
;
2189 machine
= bfd_mach_i960_hx
;
2208 if (xcoff_data (abfd
)->cputype
!= -1)
2209 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
2212 /* We did not get a value from the a.out header. If the
2213 file has not been stripped, we may be able to get the
2214 architecture information from the first symbol, if it
2215 is a .file symbol. */
2216 if (obj_raw_syment_count (abfd
) == 0)
2221 struct internal_syment sym
;
2222 bfd_size_type amt
= bfd_coff_symesz (abfd
);
2224 buf
= bfd_malloc (amt
);
2225 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
2226 || bfd_bread (buf
, amt
, abfd
) != amt
)
2231 bfd_coff_swap_sym_in (abfd
, buf
, & sym
);
2232 if (sym
.n_sclass
== C_FILE
)
2233 cputype
= sym
.n_type
& 0xff;
2240 /* FIXME: We don't handle all cases here. */
2245 arch
= bfd_xcoff_architecture (abfd
);
2246 machine
= bfd_xcoff_machine (abfd
);
2250 arch
= bfd_arch_powerpc
;
2251 machine
= bfd_mach_ppc_601
;
2253 case 2: /* 64 bit PowerPC */
2254 arch
= bfd_arch_powerpc
;
2255 machine
= bfd_mach_ppc_620
;
2258 arch
= bfd_arch_powerpc
;
2259 machine
= bfd_mach_ppc
;
2262 arch
= bfd_arch_rs6000
;
2263 machine
= bfd_mach_rs6k
;
2272 arch
= bfd_arch_we32k
;
2278 arch
= bfd_arch_h8300
;
2279 machine
= bfd_mach_h8300
;
2280 /* !! FIXME this probably isn't the right place for this. */
2281 abfd
->flags
|= BFD_IS_RELAXABLE
;
2287 arch
= bfd_arch_h8300
;
2288 machine
= bfd_mach_h8300h
;
2289 /* !! FIXME this probably isn't the right place for this. */
2290 abfd
->flags
|= BFD_IS_RELAXABLE
;
2296 arch
= bfd_arch_h8300
;
2297 machine
= bfd_mach_h8300s
;
2298 /* !! FIXME this probably isn't the right place for this. */
2299 abfd
->flags
|= BFD_IS_RELAXABLE
;
2305 arch
= bfd_arch_h8300
;
2306 machine
= bfd_mach_h8300hn
;
2307 /* !! FIXME this probably isn't the right place for this. */
2308 abfd
->flags
|= BFD_IS_RELAXABLE
;
2314 arch
= bfd_arch_h8300
;
2315 machine
= bfd_mach_h8300sn
;
2316 /* !! FIXME this probably isn't the right place for this. */
2317 abfd
->flags
|= BFD_IS_RELAXABLE
;
2321 #ifdef SH_ARCH_MAGIC_BIG
2322 case SH_ARCH_MAGIC_BIG
:
2323 case SH_ARCH_MAGIC_LITTLE
:
2325 case SH_ARCH_MAGIC_WINCE
:
2331 #ifdef MIPS_ARCH_MAGIC_WINCE
2332 case MIPS_ARCH_MAGIC_WINCE
:
2333 arch
= bfd_arch_mips
;
2339 arch
= bfd_arch_h8500
;
2345 #ifdef LYNXCOFFMAGIC
2348 arch
= bfd_arch_sparc
;
2354 arch
= bfd_arch_tic30
;
2359 #ifdef TICOFF_TARGET_ARCH
2360 /* This TI COFF section should be used by all new TI COFF v0 targets. */
2362 arch
= TICOFF_TARGET_ARCH
;
2363 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2369 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */
2370 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */
2373 switch (internal_f
->f_target_id
)
2377 arch
= TICOFF_TARGET_ARCH
;
2378 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2382 arch
= bfd_arch_obscure
;
2383 (*_bfd_error_handler
)
2384 (_("Unrecognized TI COFF target id '0x%x'"),
2385 internal_f
->f_target_id
);
2391 #ifdef TIC80_ARCH_MAGIC
2392 case TIC80_ARCH_MAGIC
:
2393 arch
= bfd_arch_tic80
;
2399 arch
= bfd_arch_mcore
;
2405 arch
= bfd_arch_w65
;
2409 default: /* Unreadable input file type. */
2410 arch
= bfd_arch_obscure
;
2414 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2418 #ifdef SYMNAME_IN_DEBUG
2421 symname_in_debug_hook (bfd
* abfd ATTRIBUTE_UNUSED
, struct internal_syment
*sym
)
2423 return SYMNAME_IN_DEBUG (sym
) != 0;
2428 #define symname_in_debug_hook \
2429 (bfd_boolean (*) (bfd *, struct internal_syment *)) bfd_false
2436 #define FORCE_SYMNAMES_IN_STRINGS
2439 /* Handle the csect auxent of a C_EXT, C_AIX_WEAKEXT or C_HIDEXT symbol. */
2442 coff_pointerize_aux_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2443 combined_entry_type
*table_base
,
2444 combined_entry_type
*symbol
,
2445 unsigned int indaux
,
2446 combined_entry_type
*aux
)
2448 int n_sclass
= symbol
->u
.syment
.n_sclass
;
2450 if (CSECT_SYM_P (n_sclass
)
2451 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2453 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2455 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2456 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2457 aux
->fix_scnlen
= 1;
2460 /* Return TRUE to indicate that the caller should not do any
2461 further work on this auxent. */
2465 /* Return FALSE to indicate that this auxent should be handled by
2473 /* We don't want to pointerize bal entries. */
2476 coff_pointerize_aux_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2477 combined_entry_type
*table_base ATTRIBUTE_UNUSED
,
2478 combined_entry_type
*symbol
,
2479 unsigned int indaux
,
2480 combined_entry_type
*aux ATTRIBUTE_UNUSED
)
2482 /* Return TRUE if we don't want to pointerize this aux entry, which
2483 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2485 && (symbol
->u
.syment
.n_sclass
== C_LEAFPROC
2486 || symbol
->u
.syment
.n_sclass
== C_LEAFSTAT
2487 || symbol
->u
.syment
.n_sclass
== C_LEAFEXT
));
2492 #define coff_pointerize_aux_hook 0
2495 #endif /* ! RS6000COFF_C */
2497 /* Print an aux entry. This returns TRUE if it has printed it. */
2500 coff_print_aux (bfd
*abfd ATTRIBUTE_UNUSED
,
2501 FILE *file ATTRIBUTE_UNUSED
,
2502 combined_entry_type
*table_base ATTRIBUTE_UNUSED
,
2503 combined_entry_type
*symbol ATTRIBUTE_UNUSED
,
2504 combined_entry_type
*aux ATTRIBUTE_UNUSED
,
2505 unsigned int indaux ATTRIBUTE_UNUSED
)
2508 if (CSECT_SYM_P (symbol
->u
.syment
.n_sclass
)
2509 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2511 /* This is a csect entry. */
2512 fprintf (file
, "AUX ");
2513 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2515 BFD_ASSERT (! aux
->fix_scnlen
);
2517 fprintf (file
, "val %5lld",
2518 (long long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2520 fprintf (file
, "val %5ld", (long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2525 fprintf (file
, "indx ");
2526 if (! aux
->fix_scnlen
)
2528 fprintf (file
, "%4lld",
2529 (long long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2531 fprintf (file
, "%4ld", (long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2534 fprintf (file
, "%4ld",
2535 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2538 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2539 aux
->u
.auxent
.x_csect
.x_parmhash
,
2540 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2541 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2542 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2543 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2544 aux
->u
.auxent
.x_csect
.x_stab
,
2545 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2550 /* Return FALSE to indicate that no special action was taken. */
2558 To write relocations, the back end steps though the
2559 canonical relocation table and create an
2560 @code{internal_reloc}. The symbol index to use is removed from
2561 the @code{offset} field in the symbol table supplied. The
2562 address comes directly from the sum of the section base
2563 address and the relocation offset; the type is dug directly
2564 from the howto field. Then the @code{internal_reloc} is
2565 swapped into the shape of an @code{external_reloc} and written
2573 /* AUX's ld wants relocations to be sorted. */
2575 compare_arelent_ptr (const void * x
, const void * y
)
2577 const arelent
**a
= (const arelent
**) x
;
2578 const arelent
**b
= (const arelent
**) y
;
2579 bfd_size_type aadr
= (*a
)->address
;
2580 bfd_size_type badr
= (*b
)->address
;
2582 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2585 #endif /* TARG_AUX */
2588 coff_write_relocs (bfd
* abfd
, int first_undef
)
2592 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2595 struct external_reloc dst
;
2602 /* Sort relocations before we write them out. */
2605 amt
= s
->reloc_count
;
2606 amt
*= sizeof (arelent
*);
2607 p
= bfd_malloc (amt
);
2608 if (p
== NULL
&& s
->reloc_count
> 0)
2610 memcpy (p
, s
->orelocation
, (size_t) amt
);
2611 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2615 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2619 if (obj_pe (abfd
) && s
->reloc_count
>= 0xffff)
2621 /* Encode real count here as first reloc. */
2622 struct internal_reloc n
;
2624 memset (& n
, 0, sizeof (n
));
2625 /* Add one to count *this* reloc (grr). */
2626 n
.r_vaddr
= s
->reloc_count
+ 1;
2627 coff_swap_reloc_out (abfd
, &n
, &dst
);
2628 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2629 abfd
) != bfd_coff_relsz (abfd
))
2634 for (i
= 0; i
< s
->reloc_count
; i
++)
2636 struct internal_reloc n
;
2639 memset (& n
, 0, sizeof (n
));
2641 /* Now we've renumbered the symbols we know where the
2642 undefined symbols live in the table. Check the reloc
2643 entries for symbols who's output bfd isn't the right one.
2644 This is because the symbol was undefined (which means
2645 that all the pointers are never made to point to the same
2646 place). This is a bad thing,'cause the symbols attached
2647 to the output bfd are indexed, so that the relocation
2648 entries know which symbol index they point to. So we
2649 have to look up the output symbol here. */
2651 if (q
->sym_ptr_ptr
[0] != NULL
&& q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2654 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2655 asymbol
**outsyms
= abfd
->outsymbols
;
2657 for (j
= first_undef
; outsyms
[j
]; j
++)
2659 const char *intable
= outsyms
[j
]->name
;
2661 if (strcmp (intable
, sname
) == 0)
2663 /* Got a hit, so repoint the reloc. */
2664 q
->sym_ptr_ptr
= outsyms
+ j
;
2670 n
.r_vaddr
= q
->address
+ s
->vma
;
2673 /* The 29k const/consth reloc pair is a real kludge. The consth
2674 part doesn't have a symbol; it has an offset. So rebuilt
2676 if (q
->howto
->type
== R_IHCONST
)
2677 n
.r_symndx
= q
->addend
;
2680 if (q
->sym_ptr_ptr
&& q
->sym_ptr_ptr
[0] != NULL
)
2682 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2683 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
, s
))
2685 if ((*q
->sym_ptr_ptr
)->section
== bfd_abs_section_ptr
2686 && ((*q
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) != 0)
2688 /* This is a relocation relative to the absolute symbol. */
2692 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2693 /* Check to see if the symbol reloc points to a symbol
2694 we don't have in our symbol table. */
2695 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2697 bfd_set_error (bfd_error_bad_value
);
2698 _bfd_error_handler (_("%B: reloc against a non-existant symbol index: %ld"),
2705 #ifdef SWAP_OUT_RELOC_OFFSET
2706 n
.r_offset
= q
->addend
;
2710 /* Work out reloc type from what is required. */
2711 SELECT_RELOC (n
, q
->howto
);
2713 n
.r_type
= q
->howto
->type
;
2715 coff_swap_reloc_out (abfd
, &n
, &dst
);
2717 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2718 abfd
) != bfd_coff_relsz (abfd
))
2731 /* Set flags and magic number of a coff file from architecture and machine
2732 type. Result is TRUE if we can represent the arch&type, FALSE if not. */
2735 coff_set_flags (bfd
* abfd
,
2736 unsigned int *magicp ATTRIBUTE_UNUSED
,
2737 unsigned short *flagsp ATTRIBUTE_UNUSED
)
2739 switch (bfd_get_arch (abfd
))
2744 switch (bfd_get_mach (abfd
))
2747 case bfd_mach_z80strict
:
2749 case bfd_mach_z80full
:
2751 *flagsp
= bfd_get_mach (abfd
) << 12;
2763 switch (bfd_get_mach (abfd
))
2765 case bfd_mach_z8001
: *flagsp
= F_Z8001
; break;
2766 case bfd_mach_z8002
: *flagsp
= F_Z8002
; break;
2767 default: return FALSE
;
2778 *magicp
= I960ROMAGIC
;
2780 switch (bfd_get_mach (abfd
))
2782 case bfd_mach_i960_core
: flags
= F_I960CORE
; break;
2783 case bfd_mach_i960_kb_sb
: flags
= F_I960KB
; break;
2784 case bfd_mach_i960_mc
: flags
= F_I960MC
; break;
2785 case bfd_mach_i960_xa
: flags
= F_I960XA
; break;
2786 case bfd_mach_i960_ca
: flags
= F_I960CA
; break;
2787 case bfd_mach_i960_ka_sa
: flags
= F_I960KA
; break;
2788 case bfd_mach_i960_jx
: flags
= F_I960JX
; break;
2789 case bfd_mach_i960_hx
: flags
= F_I960HX
; break;
2790 default: return FALSE
;
2799 case bfd_arch_tic30
:
2800 *magicp
= TIC30MAGIC
;
2804 #ifdef TICOFF_DEFAULT_MAGIC
2805 case TICOFF_TARGET_ARCH
:
2806 /* If there's no indication of which version we want, use the default. */
2808 *magicp
= TICOFF_DEFAULT_MAGIC
;
2811 /* We may want to output in a different COFF version. */
2812 switch (abfd
->xvec
->name
[4])
2815 *magicp
= TICOFF0MAGIC
;
2818 *magicp
= TICOFF1MAGIC
;
2821 *magicp
= TICOFF2MAGIC
;
2827 TICOFF_TARGET_MACHINE_SET (flagsp
, bfd_get_mach (abfd
));
2831 #ifdef TIC80_ARCH_MAGIC
2832 case bfd_arch_tic80
:
2833 *magicp
= TIC80_ARCH_MAGIC
;
2840 * magicp
= ARMPEMAGIC
;
2842 * magicp
= ARMMAGIC
;
2845 if (APCS_SET (abfd
))
2847 if (APCS_26_FLAG (abfd
))
2848 * flagsp
|= F_APCS26
;
2850 if (APCS_FLOAT_FLAG (abfd
))
2851 * flagsp
|= F_APCS_FLOAT
;
2853 if (PIC_FLAG (abfd
))
2856 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2857 * flagsp
|= F_INTERWORK
;
2858 switch (bfd_get_mach (abfd
))
2860 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2861 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2862 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2863 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2864 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2865 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2866 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2867 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2868 See also the comment in coff_set_arch_mach_hook(). */
2869 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break;
2870 case bfd_mach_arm_5TE
: * flagsp
|= F_ARM_5
; break;
2871 case bfd_mach_arm_XScale
: * flagsp
|= F_ARM_5
; break;
2877 case bfd_arch_powerpc
:
2882 #if defined(I386MAGIC) || defined(AMD64MAGIC)
2884 #if defined(I386MAGIC)
2885 *magicp
= I386MAGIC
;
2888 /* Just overwrite the usual value if we're doing Lynx. */
2889 *magicp
= LYNXCOFFMAGIC
;
2891 #if defined AMD64MAGIC
2892 *magicp
= AMD64MAGIC
;
2899 *magicp
= I860MAGIC
;
2905 *magicp
= IA64MAGIC
;
2911 #ifdef APOLLOM68KMAGIC
2912 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
2914 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2915 #ifdef NAMES_HAVE_UNDERSCORE
2916 *magicp
= MC68KBCSMAGIC
;
2918 *magicp
= MC68MAGIC
;
2922 /* Just overwrite the usual value if we're doing Lynx. */
2923 *magicp
= LYNXCOFFMAGIC
;
2930 *magicp
= MC88OMAGIC
;
2935 case bfd_arch_h8300
:
2936 switch (bfd_get_mach (abfd
))
2938 case bfd_mach_h8300
: *magicp
= H8300MAGIC
; return TRUE
;
2939 case bfd_mach_h8300h
: *magicp
= H8300HMAGIC
; return TRUE
;
2940 case bfd_mach_h8300s
: *magicp
= H8300SMAGIC
; return TRUE
;
2941 case bfd_mach_h8300hn
: *magicp
= H8300HNMAGIC
; return TRUE
;
2942 case bfd_mach_h8300sn
: *magicp
= H8300SNMAGIC
; return TRUE
;
2948 #ifdef SH_ARCH_MAGIC_BIG
2950 #ifdef COFF_IMAGE_WITH_PE
2951 *magicp
= SH_ARCH_MAGIC_WINCE
;
2953 if (bfd_big_endian (abfd
))
2954 *magicp
= SH_ARCH_MAGIC_BIG
;
2956 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2961 #ifdef MIPS_ARCH_MAGIC_WINCE
2963 *magicp
= MIPS_ARCH_MAGIC_WINCE
;
2968 case bfd_arch_sparc
:
2969 *magicp
= SPARCMAGIC
;
2971 /* Just overwrite the usual value if we're doing Lynx. */
2972 *magicp
= LYNXCOFFMAGIC
;
2978 case bfd_arch_h8500
:
2979 *magicp
= H8500MAGIC
;
2985 case bfd_arch_we32k
:
2986 *magicp
= WE32KMAGIC
;
2991 case bfd_arch_rs6000
:
2993 case bfd_arch_powerpc
:
2995 BFD_ASSERT (bfd_get_flavour (abfd
) == bfd_target_xcoff_flavour
);
2996 *magicp
= bfd_xcoff_magic_number (abfd
);
3001 case bfd_arch_mcore
:
3002 * magicp
= MCOREMAGIC
;
3012 #ifdef OR32_MAGIC_BIG
3014 if (bfd_big_endian (abfd
))
3015 * magicp
= OR32_MAGIC_BIG
;
3017 * magicp
= OR32_MAGIC_LITTLE
;
3023 * magicp
= MAXQ20MAGIC
;
3024 switch (bfd_get_mach (abfd
))
3026 case bfd_mach_maxq10
: * flagsp
= F_MAXQ10
; return TRUE
;
3027 case bfd_mach_maxq20
: * flagsp
= F_MAXQ20
; return TRUE
;
3028 default: return FALSE
;
3032 default: /* Unknown architecture. */
3033 /* Fall through to "return FALSE" below, to avoid
3034 "statement never reached" errors on the one below. */
3042 coff_set_arch_mach (bfd
* abfd
,
3043 enum bfd_architecture arch
,
3044 unsigned long machine
)
3047 unsigned short dummy2
;
3049 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
3052 if (arch
!= bfd_arch_unknown
3053 && ! coff_set_flags (abfd
, &dummy1
, &dummy2
))
3054 return FALSE
; /* We can't represent this type. */
3056 return TRUE
; /* We're easy... */
3059 #ifdef COFF_IMAGE_WITH_PE
3061 /* This is used to sort sections by VMA, as required by PE image
3065 sort_by_secaddr (const void * arg1
, const void * arg2
)
3067 const asection
*a
= *(const asection
**) arg1
;
3068 const asection
*b
= *(const asection
**) arg2
;
3070 if (a
->vma
< b
->vma
)
3072 else if (a
->vma
> b
->vma
)
3078 #endif /* COFF_IMAGE_WITH_PE */
3080 /* Calculate the file position for each section. */
3083 #define ALIGN_SECTIONS_IN_FILE
3085 #if defined(TIC80COFF) || defined(TICOFF)
3086 #undef ALIGN_SECTIONS_IN_FILE
3090 coff_compute_section_file_positions (bfd
* abfd
)
3093 asection
*previous
= NULL
;
3094 file_ptr sofar
= bfd_coff_filhsz (abfd
);
3095 bfd_boolean align_adjust
;
3097 #ifdef ALIGN_SECTIONS_IN_FILE
3101 #ifdef COFF_IMAGE_WITH_PE
3104 if (coff_data (abfd
)->link_info
)
3106 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
3108 /* If no file alignment has been set, default to one.
3109 This repairs 'ld -r' for arm-wince-pe target. */
3114 page_size
= PE_DEF_FILE_ALIGNMENT
;
3116 #ifdef COFF_PAGE_SIZE
3117 int page_size
= COFF_PAGE_SIZE
;
3122 /* On XCOFF, if we have symbols, set up the .debug section. */
3123 if (bfd_get_symcount (abfd
) > 0)
3126 bfd_size_type i
, symcount
;
3130 symcount
= bfd_get_symcount (abfd
);
3131 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
3133 coff_symbol_type
*cf
;
3135 cf
= coff_symbol_from (abfd
, *symp
);
3137 && cf
->native
!= NULL
3138 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
3142 len
= strlen (bfd_asymbol_name (*symp
));
3143 if (len
> SYMNMLEN
|| bfd_coff_force_symnames_in_strings (abfd
))
3144 sz
+= len
+ 1 + bfd_coff_debug_string_prefix_length (abfd
);
3151 dsec
= bfd_make_section_old_way (abfd
, DOT_DEBUG
);
3155 dsec
->flags
|= SEC_HAS_CONTENTS
;
3160 if (bfd_get_start_address (abfd
))
3161 /* A start address may have been added to the original file. In this
3162 case it will need an optional header to record it. */
3163 abfd
->flags
|= EXEC_P
;
3165 if (abfd
->flags
& EXEC_P
)
3166 sofar
+= bfd_coff_aoutsz (abfd
);
3168 else if (xcoff_data (abfd
)->full_aouthdr
)
3169 sofar
+= bfd_coff_aoutsz (abfd
);
3171 sofar
+= SMALL_AOUTSZ
;
3174 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
3177 /* XCOFF handles overflows in the reloc and line number count fields
3178 by allocating a new section header to hold the correct counts. */
3179 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3180 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3181 sofar
+= bfd_coff_scnhsz (abfd
);
3184 #ifdef COFF_IMAGE_WITH_PE
3186 /* PE requires the sections to be in memory order when listed in
3187 the section headers. It also does not like empty loadable
3188 sections. The sections apparently do not have to be in the
3189 right order in the image file itself, but we do need to get the
3190 target_index values right. */
3193 asection
**section_list
;
3197 #ifdef COFF_PAGE_SIZE
3198 /* Clear D_PAGED if section alignment is smaller than
3200 if (pe_data (abfd
)->pe_opthdr
.SectionAlignment
< COFF_PAGE_SIZE
)
3201 abfd
->flags
&= ~D_PAGED
;
3205 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3208 /* We allocate an extra cell to simplify the final loop. */
3209 amt
= sizeof (struct asection
*) * (count
+ 1);
3210 section_list
= (asection
**) bfd_malloc (amt
);
3211 if (section_list
== NULL
)
3215 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3217 section_list
[i
] = current
;
3220 section_list
[i
] = NULL
;
3222 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
3224 /* Rethread the linked list into sorted order; at the same time,
3225 assign target_index values. */
3227 abfd
->sections
= NULL
;
3228 abfd
->section_last
= NULL
;
3229 for (i
= 0; i
< count
; i
++)
3231 current
= section_list
[i
];
3232 bfd_section_list_append (abfd
, current
);
3234 /* Later, if the section has zero size, we'll be throwing it
3235 away, so we don't want to number it now. Note that having
3236 a zero size and having real contents are different
3237 concepts: .bss has no contents, but (usually) non-zero
3239 if (current
->size
== 0)
3241 /* Discard. However, it still might have (valid) symbols
3242 in it, so arbitrarily set it to section 1 (indexing is
3243 1-based here; usually .text). __end__ and other
3244 contents of .endsection really have this happen.
3245 FIXME: This seems somewhat dubious. */
3246 current
->target_index
= 1;
3249 current
->target_index
= target_index
++;
3252 free (section_list
);
3254 #else /* ! COFF_IMAGE_WITH_PE */
3256 /* Set the target_index field. */
3258 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3259 current
->target_index
= target_index
++;
3261 #endif /* ! COFF_IMAGE_WITH_PE */
3263 if (target_index
>= 32768)
3265 bfd_set_error (bfd_error_file_too_big
);
3266 (*_bfd_error_handler
)
3267 (_("%B: too many sections (%d)"), abfd
, target_index
);
3271 align_adjust
= FALSE
;
3272 for (current
= abfd
->sections
;
3274 current
= current
->next
)
3276 #ifdef COFF_IMAGE_WITH_PE
3277 /* With PE we have to pad each section to be a multiple of its
3278 page size too, and remember both sizes. */
3279 if (coff_section_data (abfd
, current
) == NULL
)
3281 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
3283 current
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
3284 if (current
->used_by_bfd
== NULL
)
3287 if (pei_section_data (abfd
, current
) == NULL
)
3289 bfd_size_type amt
= sizeof (struct pei_section_tdata
);
3291 coff_section_data (abfd
, current
)->tdata
= bfd_zalloc (abfd
, amt
);
3292 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
3295 if (pei_section_data (abfd
, current
)->virt_size
== 0)
3296 pei_section_data (abfd
, current
)->virt_size
= current
->size
;
3299 /* Only deal with sections which have contents. */
3300 if (!(current
->flags
& SEC_HAS_CONTENTS
))
3303 #ifdef COFF_IMAGE_WITH_PE
3304 /* Make sure we skip empty sections in a PE image. */
3305 if (current
->size
== 0)
3309 /* Align the sections in the file to the same boundary on
3310 which they are aligned in virtual memory. I960 doesn't
3311 do this (FIXME) so we can stay in sync with Intel. 960
3312 doesn't yet page from files... */
3313 #ifdef ALIGN_SECTIONS_IN_FILE
3314 if ((abfd
->flags
& EXEC_P
) != 0)
3316 /* Make sure this section is aligned on the right boundary - by
3317 padding the previous section up if necessary. */
3321 /* AIX loader checks the text section alignment of (vma - filepos)
3322 So even though the filepos may be aligned wrt the o_algntext, for
3323 AIX executables, this check fails. This shows up when a native
3324 AIX executable is stripped with gnu strip because the default vma
3325 of native is 0x10000150 but default for gnu is 0x10000140. Gnu
3326 stripped gnu excutable passes this check because the filepos is
3327 0x0140. This problem also show up with 64 bit shared objects. The
3328 data section must also be aligned. */
3329 if (!strcmp (current
->name
, _TEXT
)
3330 || !strcmp (current
->name
, _DATA
))
3335 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3337 align
= 1 << current
->alignment_power
;
3338 pad
= abs (current
->vma
- sofar
) % align
;
3349 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3352 if (previous
!= NULL
)
3353 previous
->size
+= sofar
- old_sofar
;
3358 /* In demand paged files the low order bits of the file offset
3359 must match the low order bits of the virtual address. */
3360 #ifdef COFF_PAGE_SIZE
3361 if ((abfd
->flags
& D_PAGED
) != 0
3362 && (current
->flags
& SEC_ALLOC
) != 0)
3363 sofar
+= (current
->vma
- (bfd_vma
) sofar
) % page_size
;
3365 current
->filepos
= sofar
;
3367 #ifdef COFF_IMAGE_WITH_PE
3368 /* Set the padded size. */
3369 current
->size
= (current
->size
+ page_size
-1) & -page_size
;
3372 sofar
+= current
->size
;
3374 #ifdef ALIGN_SECTIONS_IN_FILE
3375 /* Make sure that this section is of the right size too. */
3376 if ((abfd
->flags
& EXEC_P
) == 0)
3378 bfd_size_type old_size
;
3380 old_size
= current
->size
;
3381 current
->size
= BFD_ALIGN (current
->size
,
3382 1 << current
->alignment_power
);
3383 align_adjust
= current
->size
!= old_size
;
3384 sofar
+= current
->size
- old_size
;
3389 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3390 align_adjust
= sofar
!= old_sofar
;
3391 current
->size
+= sofar
- old_sofar
;
3395 #ifdef COFF_IMAGE_WITH_PE
3396 /* For PE we need to make sure we pad out to the aligned
3397 size, in case the caller only writes out data to the
3399 if (pei_section_data (abfd
, current
)->virt_size
< current
->size
)
3400 align_adjust
= TRUE
;
3404 /* Force .lib sections to start at zero. The vma is then
3405 incremented in coff_set_section_contents. This is right for
3407 if (strcmp (current
->name
, _LIB
) == 0)
3408 bfd_set_section_vma (abfd
, current
, 0);
3414 /* It is now safe to write to the output file. If we needed an
3415 alignment adjustment for the last section, then make sure that
3416 there is a byte at offset sofar. If there are no symbols and no
3417 relocs, then nothing follows the last section. If we don't force
3418 the last byte out, then the file may appear to be truncated. */
3424 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
3425 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3429 /* Make sure the relocations are aligned. We don't need to make
3430 sure that this byte exists, because it will only matter if there
3431 really are relocs. */
3432 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
3434 obj_relocbase (abfd
) = sofar
;
3435 abfd
->output_has_begun
= TRUE
;
3440 #ifdef COFF_IMAGE_WITH_PE
3442 static unsigned int pelength
;
3443 static unsigned int peheader
;
3446 coff_read_word (bfd
*abfd
, unsigned int *value
)
3451 status
= bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3459 *value
= (unsigned int) b
[0];
3461 *value
= (unsigned int) (b
[0] + (b
[1] << 8));
3463 pelength
+= (unsigned int) status
;
3469 coff_compute_checksum (bfd
*abfd
)
3471 bfd_boolean more_data
;
3478 filepos
= (file_ptr
) 0;
3482 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
3485 more_data
= coff_read_word (abfd
, &value
);
3487 total
= 0xffff & (total
+ (total
>> 0x10));
3492 return (0xffff & (total
+ (total
>> 0x10)));
3496 coff_apply_checksum (bfd
*abfd
)
3498 unsigned int computed
;
3499 unsigned int checksum
= 0;
3501 if (bfd_seek (abfd
, 0x3c, SEEK_SET
) != 0)
3504 if (!coff_read_word (abfd
, &peheader
))
3507 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3511 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3513 if (bfd_seek (abfd
, peheader
, SEEK_SET
) != 0)
3516 computed
= coff_compute_checksum (abfd
);
3518 checksum
= computed
+ pelength
;
3520 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3523 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3528 #endif /* COFF_IMAGE_WITH_PE */
3531 coff_write_object_contents (bfd
* abfd
)
3534 bfd_boolean hasrelocs
= FALSE
;
3535 bfd_boolean haslinno
= FALSE
;
3536 #ifdef COFF_IMAGE_WITH_PE
3537 bfd_boolean hasdebug
= FALSE
;
3540 file_ptr reloc_base
;
3541 file_ptr lineno_base
;
3543 unsigned long reloc_size
= 0, reloc_count
= 0;
3544 unsigned long lnno_size
= 0;
3545 bfd_boolean long_section_names
;
3546 asection
*text_sec
= NULL
;
3547 asection
*data_sec
= NULL
;
3548 asection
*bss_sec
= NULL
;
3549 struct internal_filehdr internal_f
;
3550 struct internal_aouthdr internal_a
;
3551 #ifdef COFF_LONG_SECTION_NAMES
3552 size_t string_size
= STRING_SIZE_SIZE
;
3555 bfd_set_error (bfd_error_system_call
);
3557 /* Make a pass through the symbol table to count line number entries and
3558 put them into the correct asections. */
3559 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3561 if (! abfd
->output_has_begun
)
3563 if (! coff_compute_section_file_positions (abfd
))
3567 reloc_base
= obj_relocbase (abfd
);
3569 /* Work out the size of the reloc and linno areas. */
3571 for (current
= abfd
->sections
; current
!= NULL
; current
=
3575 /* We store the actual reloc count in the first reloc's addr. */
3576 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3579 reloc_count
+= current
->reloc_count
;
3582 reloc_size
= reloc_count
* bfd_coff_relsz (abfd
);
3584 lineno_base
= reloc_base
+ reloc_size
;
3585 sym_base
= lineno_base
+ lnno_size
;
3587 /* Indicate in each section->line_filepos its actual file address. */
3588 for (current
= abfd
->sections
; current
!= NULL
; current
=
3591 if (current
->lineno_count
)
3593 current
->line_filepos
= lineno_base
;
3594 current
->moving_line_filepos
= lineno_base
;
3595 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3598 current
->line_filepos
= 0;
3600 if (current
->reloc_count
)
3602 current
->rel_filepos
= reloc_base
;
3603 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3605 /* Extra reloc to hold real count. */
3606 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3607 reloc_base
+= bfd_coff_relsz (abfd
);
3611 current
->rel_filepos
= 0;
3614 /* Write section headers to the file. */
3615 internal_f
.f_nscns
= 0;
3617 if ((abfd
->flags
& EXEC_P
) != 0)
3618 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3621 scn_base
= bfd_coff_filhsz (abfd
);
3624 if (xcoff_data (abfd
)->full_aouthdr
)
3625 scn_base
+= bfd_coff_aoutsz (abfd
);
3627 scn_base
+= SMALL_AOUTSZ
;
3632 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3635 long_section_names
= FALSE
;
3636 for (current
= abfd
->sections
;
3638 current
= current
->next
)
3640 struct internal_scnhdr section
;
3641 #ifdef COFF_IMAGE_WITH_PE
3642 bfd_boolean is_reloc_section
= FALSE
;
3644 if (strcmp (current
->name
, DOT_RELOC
) == 0)
3646 is_reloc_section
= TRUE
;
3648 pe_data (abfd
)->has_reloc_section
= 1;
3652 internal_f
.f_nscns
++;
3654 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3656 #ifdef COFF_LONG_SECTION_NAMES
3657 /* Handle long section names as in PE. This must be compatible
3658 with the code in coff_write_symbols and _bfd_coff_final_link. */
3659 if (bfd_coff_long_section_names (abfd
))
3663 len
= strlen (current
->name
);
3666 /* The s_name field is defined to be NUL-padded but need not be
3667 NUL-terminated. We use a temporary buffer so that we can still
3668 sprintf all eight chars without splatting a terminating NUL
3669 over the first byte of the following member (s_paddr). */
3670 char s_name_buf
[SCNNMLEN
+ 1];
3672 /* An inherent limitation of the /nnnnnnn notation used to indicate
3673 the offset of the long name in the string table is that we
3674 cannot address entries beyone the ten million byte boundary. */
3675 if (string_size
>= 10000000)
3677 bfd_set_error (bfd_error_file_too_big
);
3678 (*_bfd_error_handler
)
3679 (_("%B: section %s: string table overflow at offset %ld"),
3680 abfd
, current
->name
, string_size
);
3684 /* snprintf not strictly necessary now we've verified the value
3685 has less than eight ASCII digits, but never mind. */
3686 snprintf (s_name_buf
, SCNNMLEN
+ 1, "/%lu", (unsigned long) string_size
);
3687 /* Then strncpy takes care of any padding for us. */
3688 strncpy (section
.s_name
, s_name_buf
, SCNNMLEN
);
3689 string_size
+= len
+ 1;
3690 long_section_names
= TRUE
;
3696 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3697 Ian Taylor <ian@cygnus.com>. */
3698 if (strcmp (current
->name
, _LIB
) == 0)
3699 section
.s_vaddr
= 0;
3702 section
.s_vaddr
= current
->vma
;
3703 section
.s_paddr
= current
->lma
;
3704 section
.s_size
= current
->size
;
3705 #ifdef coff_get_section_load_page
3706 section
.s_page
= coff_get_section_load_page (current
);
3712 section
.s_paddr
= 0;
3714 #ifdef COFF_IMAGE_WITH_PE
3715 /* Reminder: s_paddr holds the virtual size of the section. */
3716 if (coff_section_data (abfd
, current
) != NULL
3717 && pei_section_data (abfd
, current
) != NULL
)
3718 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3720 section
.s_paddr
= 0;
3723 /* If this section has no size or is unloadable then the scnptr
3725 if (current
->size
== 0
3726 || (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3727 section
.s_scnptr
= 0;
3729 section
.s_scnptr
= current
->filepos
;
3731 section
.s_relptr
= current
->rel_filepos
;
3732 section
.s_lnnoptr
= current
->line_filepos
;
3733 section
.s_nreloc
= current
->reloc_count
;
3734 section
.s_nlnno
= current
->lineno_count
;
3735 #ifndef COFF_IMAGE_WITH_PE
3736 /* In PEI, relocs come in the .reloc section. */
3737 if (current
->reloc_count
!= 0)
3740 if (current
->lineno_count
!= 0)
3742 #ifdef COFF_IMAGE_WITH_PE
3743 if ((current
->flags
& SEC_DEBUGGING
) != 0
3744 && ! is_reloc_section
)
3750 /* Indicate the use of an XCOFF overflow section header. */
3751 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3753 section
.s_nreloc
= 0xffff;
3754 section
.s_nlnno
= 0xffff;
3759 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3761 if (!strcmp (current
->name
, _TEXT
))
3763 else if (!strcmp (current
->name
, _DATA
))
3765 else if (!strcmp (current
->name
, _BSS
))
3769 section
.s_align
= (current
->alignment_power
3770 ? 1 << current
->alignment_power
3774 /* TI COFF puts the alignment power in bits 8-11 of the flags. */
3775 section
.s_flags
|= (current
->alignment_power
& 0xF) << 8;
3777 #ifdef COFF_ENCODE_ALIGNMENT
3778 COFF_ENCODE_ALIGNMENT(section
, current
->alignment_power
);
3781 #ifdef COFF_IMAGE_WITH_PE
3782 /* Suppress output of the sections if they are null. ld
3783 includes the bss and data sections even if there is no size
3784 assigned to them. NT loader doesn't like it if these section
3785 headers are included if the sections themselves are not
3786 needed. See also coff_compute_section_file_positions. */
3787 if (section
.s_size
== 0)
3788 internal_f
.f_nscns
--;
3793 bfd_size_type amt
= bfd_coff_scnhsz (abfd
);
3795 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3796 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3801 /* PE stores COMDAT section information in the symbol table. If
3802 this section is supposed to have some COMDAT info, track down
3803 the symbol in the symbol table and modify it. */
3804 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3806 unsigned int i
, count
;
3808 coff_symbol_type
*csym
= NULL
;
3812 count
= bfd_get_symcount (abfd
);
3813 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3815 if ((*psym
)->section
!= current
)
3818 /* Remember the location of the first symbol in this
3820 if (psymsec
== NULL
)
3823 /* See if this is the section symbol. */
3824 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3826 csym
= coff_symbol_from (abfd
, *psym
);
3828 || csym
->native
== NULL
3829 || csym
->native
->u
.syment
.n_numaux
< 1
3830 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3831 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3834 /* Here *PSYM is the section symbol for CURRENT. */
3841 Note that we might not if we're converting the file from
3842 some other object file format. */
3845 combined_entry_type
*aux
;
3847 /* We don't touch the x_checksum field. The
3848 x_associated field is not currently supported. */
3850 aux
= csym
->native
+ 1;
3851 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3853 case SEC_LINK_DUPLICATES_DISCARD
:
3854 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3857 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3858 aux
->u
.auxent
.x_scn
.x_comdat
=
3859 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3862 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3863 aux
->u
.auxent
.x_scn
.x_comdat
=
3864 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3867 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3868 aux
->u
.auxent
.x_scn
.x_comdat
=
3869 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3873 /* The COMDAT symbol must be the first symbol from this
3874 section in the symbol table. In order to make this
3875 work, we move the COMDAT symbol before the first
3876 symbol we found in the search above. It's OK to
3877 rearrange the symbol table at this point, because
3878 coff_renumber_symbols is going to rearrange it
3879 further and fix up all the aux entries. */
3880 if (psym
!= psymsec
)
3886 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3887 pcopy
[0] = pcopy
[-1];
3892 #endif /* COFF_WITH_PE */
3897 /* XCOFF handles overflows in the reloc and line number count fields
3898 by creating a new section header to hold the correct values. */
3899 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3901 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3903 struct internal_scnhdr scnhdr
;
3907 internal_f
.f_nscns
++;
3908 strncpy (&(scnhdr
.s_name
[0]), current
->name
, 8);
3909 scnhdr
.s_paddr
= current
->reloc_count
;
3910 scnhdr
.s_vaddr
= current
->lineno_count
;
3912 scnhdr
.s_scnptr
= 0;
3913 scnhdr
.s_relptr
= current
->rel_filepos
;
3914 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3915 scnhdr
.s_nreloc
= current
->target_index
;
3916 scnhdr
.s_nlnno
= current
->target_index
;
3917 scnhdr
.s_flags
= STYP_OVRFLO
;
3918 amt
= bfd_coff_scnhsz (abfd
);
3919 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3920 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3927 /* OK, now set up the filehdr... */
3929 /* Don't include the internal abs section in the section count */
3931 /* We will NOT put a fucking timestamp in the header here. Every time you
3932 put it back, I will come in and take it out again. I'm sorry. This
3933 field does not belong here. We fill it with a 0 so it compares the
3934 same but is not a reasonable time. -- gnu@cygnus.com */
3935 internal_f
.f_timdat
= 0;
3936 internal_f
.f_flags
= 0;
3938 if (abfd
->flags
& EXEC_P
)
3939 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3942 internal_f
.f_opthdr
= 0;
3945 if (xcoff_data (abfd
)->full_aouthdr
)
3946 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3948 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
3954 internal_f
.f_flags
|= F_RELFLG
;
3956 internal_f
.f_flags
|= F_LNNO
;
3957 if (abfd
->flags
& EXEC_P
)
3958 internal_f
.f_flags
|= F_EXEC
;
3959 #ifdef COFF_IMAGE_WITH_PE
3961 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
3962 if (pe_data (abfd
)->real_flags
& IMAGE_FILE_LARGE_ADDRESS_AWARE
)
3963 internal_f
.f_flags
|= IMAGE_FILE_LARGE_ADDRESS_AWARE
;
3966 #ifndef COFF_WITH_pex64
3968 internal_f
.f_flags
|= IMAGE_FILE_32BIT_MACHINE
;
3970 if (bfd_little_endian (abfd
))
3971 internal_f
.f_flags
|= F_AR32WR
;
3973 internal_f
.f_flags
|= F_AR32W
;
3978 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
3979 but it doesn't hurt to set it internally. */
3980 internal_f
.f_target_id
= TI_TARGET_ID
;
3982 #ifdef TIC80_TARGET_ID
3983 internal_f
.f_target_id
= TIC80_TARGET_ID
;
3986 /* FIXME, should do something about the other byte orders and
3990 if ((abfd
->flags
& DYNAMIC
) != 0)
3991 internal_f
.f_flags
|= F_SHROBJ
;
3992 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
3993 internal_f
.f_flags
|= F_DYNLOAD
;
3996 memset (&internal_a
, 0, sizeof internal_a
);
3998 /* Set up architecture-dependent stuff. */
4000 unsigned int magic
= 0;
4001 unsigned short flags
= 0;
4003 coff_set_flags (abfd
, &magic
, &flags
);
4004 internal_f
.f_magic
= magic
;
4005 internal_f
.f_flags
|= flags
;
4006 /* ...and the "opt"hdr... */
4008 #ifdef TICOFF_AOUT_MAGIC
4009 internal_a
.magic
= TICOFF_AOUT_MAGIC
;
4010 #define __A_MAGIC_SET__
4013 internal_a
.magic
= TIC80_ARCH_MAGIC
;
4014 #define __A_MAGIC_SET__
4017 /* FIXME: What are the a.out magic numbers for the i860? */
4018 internal_a
.magic
= 0;
4019 #define __A_MAGIC_SET__
4022 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
4023 #define __A_MAGIC_SET__
4026 #define __A_MAGIC_SET__
4027 internal_a
.magic
= PAGEMAGICBCS
;
4031 #define __A_MAGIC_SET__
4032 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
4035 #if defined(M68) || defined(WE32K) || defined(M68K)
4036 #define __A_MAGIC_SET__
4038 internal_a
.magic
= LYNXCOFFMAGIC
;
4040 #if defined(TARG_AUX)
4041 internal_a
.magic
= (abfd
->flags
& D_PAGED
? PAGEMAGICPEXECPAGED
:
4042 abfd
->flags
& WP_TEXT
? PAGEMAGICPEXECSWAPPED
:
4043 PAGEMAGICEXECSWAPPED
);
4045 #if defined (PAGEMAGICPEXECPAGED)
4046 internal_a
.magic
= PAGEMAGICPEXECPAGED
;
4048 #endif /* TARG_AUX */
4050 #endif /* M68 || WE32K || M68K */
4053 #define __A_MAGIC_SET__
4054 internal_a
.magic
= ZMAGIC
;
4058 #define __A_MAGIC_SET__
4059 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
4062 #if defined MCORE_PE
4063 #define __A_MAGIC_SET__
4064 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
4068 #define __A_MAGIC_SET__
4070 internal_a
.magic
= LYNXCOFFMAGIC
;
4072 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR64_MAGIC
;
4074 internal_a
.magic
= ZMAGIC
;
4079 #define __A_MAGIC_SET__
4080 internal_a
.magic
= PE32PMAGIC
;
4084 #define __A_MAGIC_SET__
4086 internal_a
.magic
= LYNXCOFFMAGIC
;
4091 #define __A_MAGIC_SET__
4092 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
4093 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
4094 RS6K_AOUTHDR_OMAGIC
;
4097 #if defined(SH) && defined(COFF_WITH_PE)
4098 #define __A_MAGIC_SET__
4099 internal_a
.magic
= SH_PE_MAGIC
;
4102 #if defined(MIPS) && defined(COFF_WITH_PE)
4103 #define __A_MAGIC_SET__
4104 internal_a
.magic
= MIPS_PE_MAGIC
;
4108 #define __A_MAGIC_SET__
4109 internal_a
.magic
= NMAGIC
; /* Assume separate i/d. */
4113 #define __A_MAGIC_SET__
4114 internal_a
.magic
= MAXQ20MAGIC
;
4117 #ifndef __A_MAGIC_SET__
4118 #include "Your aouthdr magic number is not being set!"
4120 #undef __A_MAGIC_SET__
4124 /* FIXME: Does anybody ever set this to another value? */
4125 internal_a
.vstamp
= 0;
4127 /* Now should write relocs, strings, syms. */
4128 obj_sym_filepos (abfd
) = sym_base
;
4130 if (bfd_get_symcount (abfd
) != 0)
4134 if (!coff_renumber_symbols (abfd
, &firstundef
))
4136 coff_mangle_symbols (abfd
);
4137 if (! coff_write_symbols (abfd
))
4139 if (! coff_write_linenumbers (abfd
))
4141 if (! coff_write_relocs (abfd
, firstundef
))
4144 #ifdef COFF_LONG_SECTION_NAMES
4145 else if (long_section_names
&& ! obj_coff_strings_written (abfd
))
4147 /* If we have long section names we have to write out the string
4148 table even if there are no symbols. */
4149 if (! coff_write_symbols (abfd
))
4153 #ifdef COFF_IMAGE_WITH_PE
4155 else if ((abfd
->flags
& EXEC_P
) != 0)
4159 /* PowerPC PE appears to require that all executable files be
4160 rounded up to the page size. */
4163 (file_ptr
) BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
4165 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
4171 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
4172 backend linker, and obj_raw_syment_count is not valid until after
4173 coff_write_symbols is called. */
4174 if (obj_raw_syment_count (abfd
) != 0)
4176 internal_f
.f_symptr
= sym_base
;
4178 /* AIX appears to require that F_RELFLG not be set if there are
4179 local symbols but no relocations. */
4180 internal_f
.f_flags
&=~ F_RELFLG
;
4185 if (long_section_names
)
4186 internal_f
.f_symptr
= sym_base
;
4188 internal_f
.f_symptr
= 0;
4189 internal_f
.f_flags
|= F_LSYMS
;
4194 internal_a
.tsize
= text_sec
->size
;
4195 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
4199 internal_a
.dsize
= data_sec
->size
;
4200 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
4204 internal_a
.bsize
= bss_sec
->size
;
4205 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
4206 internal_a
.data_start
= bss_sec
->vma
;
4209 internal_a
.entry
= bfd_get_start_address (abfd
);
4210 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
4213 if (xcoff_data (abfd
)->full_aouthdr
)
4216 asection
*loader_sec
;
4218 internal_a
.vstamp
= 1;
4220 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
4221 if (internal_a
.o_snentry
== 0)
4222 internal_a
.entry
= (bfd_vma
) -1;
4224 if (text_sec
!= NULL
)
4226 internal_a
.o_sntext
= text_sec
->target_index
;
4227 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
4231 internal_a
.o_sntext
= 0;
4232 internal_a
.o_algntext
= 0;
4234 if (data_sec
!= NULL
)
4236 internal_a
.o_sndata
= data_sec
->target_index
;
4237 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
4241 internal_a
.o_sndata
= 0;
4242 internal_a
.o_algndata
= 0;
4244 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
4245 if (loader_sec
!= NULL
)
4246 internal_a
.o_snloader
= loader_sec
->target_index
;
4248 internal_a
.o_snloader
= 0;
4249 if (bss_sec
!= NULL
)
4250 internal_a
.o_snbss
= bss_sec
->target_index
;
4252 internal_a
.o_snbss
= 0;
4254 toc
= xcoff_data (abfd
)->toc
;
4255 internal_a
.o_toc
= toc
;
4256 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
4258 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
4259 if (xcoff_data (abfd
)->cputype
!= -1)
4260 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
4263 switch (bfd_get_arch (abfd
))
4265 case bfd_arch_rs6000
:
4266 internal_a
.o_cputype
= 4;
4268 case bfd_arch_powerpc
:
4269 if (bfd_get_mach (abfd
) == bfd_mach_ppc
)
4270 internal_a
.o_cputype
= 3;
4272 internal_a
.o_cputype
= 1;
4278 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
4279 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
4283 /* Now write them. */
4284 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
4289 bfd_size_type amount
= bfd_coff_filhsz (abfd
);
4291 buff
= (char *) bfd_malloc (amount
);
4295 bfd_coff_swap_filehdr_out (abfd
, & internal_f
, buff
);
4296 amount
= bfd_bwrite (buff
, amount
, abfd
);
4300 if (amount
!= bfd_coff_filhsz (abfd
))
4304 if (abfd
->flags
& EXEC_P
)
4306 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4307 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4309 bfd_size_type amount
= bfd_coff_aoutsz (abfd
);
4311 buff
= (char *) bfd_malloc (amount
);
4315 coff_swap_aouthdr_out (abfd
, & internal_a
, buff
);
4316 amount
= bfd_bwrite (buff
, amount
, abfd
);
4320 if (amount
!= bfd_coff_aoutsz (abfd
))
4323 #ifdef COFF_IMAGE_WITH_PE
4324 if (! coff_apply_checksum (abfd
))
4334 /* XCOFF seems to always write at least a small a.out header. */
4335 coff_swap_aouthdr_out (abfd
, & internal_a
, & buff
);
4336 if (xcoff_data (abfd
)->full_aouthdr
)
4337 size
= bfd_coff_aoutsz (abfd
);
4339 size
= SMALL_AOUTSZ
;
4340 if (bfd_bwrite (& buff
, (bfd_size_type
) size
, abfd
) != size
)
4349 coff_set_section_contents (bfd
* abfd
,
4351 const void * location
,
4353 bfd_size_type count
)
4355 if (! abfd
->output_has_begun
) /* Set by bfd.c handler. */
4357 if (! coff_compute_section_file_positions (abfd
))
4361 #if defined(_LIB) && !defined(TARG_AUX)
4362 /* The physical address field of a .lib section is used to hold the
4363 number of shared libraries in the section. This code counts the
4364 number of sections being written, and increments the lma field
4367 I have found no documentation on the contents of this section.
4368 Experimentation indicates that the section contains zero or more
4369 records, each of which has the following structure:
4371 - a (four byte) word holding the length of this record, in words,
4372 - a word that always seems to be set to "2",
4373 - the path to a shared library, null-terminated and then padded
4374 to a whole word boundary.
4376 bfd_assert calls have been added to alert if an attempt is made
4377 to write a section which doesn't follow these assumptions. The
4378 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4379 <robertl@arnet.com> (Thanks!).
4381 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4382 if (strcmp (section
->name
, _LIB
) == 0)
4384 bfd_byte
*rec
, *recend
;
4386 rec
= (bfd_byte
*) location
;
4387 recend
= rec
+ count
;
4388 while (rec
< recend
)
4391 rec
+= bfd_get_32 (abfd
, rec
) * 4;
4394 BFD_ASSERT (rec
== recend
);
4398 /* Don't write out bss sections - one way to do this is to
4399 see if the filepos has not been set. */
4400 if (section
->filepos
== 0)
4403 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0)
4409 return bfd_bwrite (location
, count
, abfd
) == count
;
4413 buy_and_read (bfd
*abfd
, file_ptr where
, bfd_size_type size
)
4415 void * area
= bfd_alloc (abfd
, size
);
4419 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0
4420 || bfd_bread (area
, size
, abfd
) != size
)
4429 Creating the linenumber table is done by reading in the entire
4430 coff linenumber table, and creating another table for internal use.
4432 A coff linenumber table is structured so that each function
4433 is marked as having a line number of 0. Each line within the
4434 function is an offset from the first line in the function. The
4435 base of the line number information for the table is stored in
4436 the symbol associated with the function.
4438 Note: The PE format uses line number 0 for a flag indicating a
4441 The information is copied from the external to the internal
4442 table, and each symbol which marks a function is marked by
4445 How does this work ?
4449 coff_sort_func_alent (const void * arg1
, const void * arg2
)
4451 const alent
*al1
= *(const alent
**) arg1
;
4452 const alent
*al2
= *(const alent
**) arg2
;
4453 const coff_symbol_type
*s1
= (const coff_symbol_type
*) (al1
->u
.sym
);
4454 const coff_symbol_type
*s2
= (const coff_symbol_type
*) (al2
->u
.sym
);
4456 if (s1
->symbol
.value
< s2
->symbol
.value
)
4458 else if (s1
->symbol
.value
> s2
->symbol
.value
)
4465 coff_slurp_line_table (bfd
*abfd
, asection
*asect
)
4467 LINENO
*native_lineno
;
4468 alent
*lineno_cache
;
4470 unsigned int counter
;
4472 bfd_vma prev_offset
= 0;
4474 unsigned int nbr_func
;
4477 BFD_ASSERT (asect
->lineno
== NULL
);
4479 amt
= ((bfd_size_type
) asect
->lineno_count
+ 1) * sizeof (alent
);
4480 lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
);
4481 if (lineno_cache
== NULL
)
4484 amt
= (bfd_size_type
) bfd_coff_linesz (abfd
) * asect
->lineno_count
;
4485 native_lineno
= (LINENO
*) buy_and_read (abfd
, asect
->line_filepos
, amt
);
4486 if (native_lineno
== NULL
)
4488 (*_bfd_error_handler
)
4489 (_("%B: warning: line number table read failed"), abfd
);
4490 bfd_release (abfd
, lineno_cache
);
4494 cache_ptr
= lineno_cache
;
4495 asect
->lineno
= lineno_cache
;
4496 src
= native_lineno
;
4499 for (counter
= 0; counter
< asect
->lineno_count
; counter
++)
4501 struct internal_lineno dst
;
4503 bfd_coff_swap_lineno_in (abfd
, src
, &dst
);
4504 cache_ptr
->line_number
= dst
.l_lnno
;
4506 if (cache_ptr
->line_number
== 0)
4509 bfd_signed_vma symndx
;
4510 coff_symbol_type
*sym
;
4514 symndx
= dst
.l_addr
.l_symndx
;
4516 || (bfd_vma
) symndx
>= obj_raw_syment_count (abfd
))
4518 (*_bfd_error_handler
)
4519 (_("%B: warning: illegal symbol index %ld in line numbers"),
4520 abfd
, dst
.l_addr
.l_symndx
);
4525 /* FIXME: We should not be casting between ints and
4526 pointers like this. */
4527 sym
= ((coff_symbol_type
*)
4528 ((symndx
+ obj_raw_syments (abfd
))
4529 ->u
.syment
._n
._n_n
._n_zeroes
));
4530 cache_ptr
->u
.sym
= (asymbol
*) sym
;
4531 if (sym
->lineno
!= NULL
&& ! warned
)
4532 (*_bfd_error_handler
)
4533 (_("%B: warning: duplicate line number information for `%s'"),
4534 abfd
, bfd_asymbol_name (&sym
->symbol
));
4536 sym
->lineno
= cache_ptr
;
4537 if (sym
->symbol
.value
< prev_offset
)
4539 prev_offset
= sym
->symbol
.value
;
4542 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
4543 - bfd_section_vma (abfd
, asect
);
4548 cache_ptr
->line_number
= 0;
4549 bfd_release (abfd
, native_lineno
);
4551 /* On some systems (eg AIX5.3) the lineno table may not be sorted. */
4554 /* Sort the table. */
4556 alent
*n_lineno_cache
;
4558 /* Create a table of functions. */
4559 func_table
= (alent
**) bfd_alloc (abfd
, nbr_func
* sizeof (alent
*));
4560 if (func_table
!= NULL
)
4562 alent
**p
= func_table
;
4565 for (i
= 0; i
< counter
; i
++)
4566 if (lineno_cache
[i
].line_number
== 0)
4567 *p
++ = &lineno_cache
[i
];
4569 /* Sort by functions. */
4570 qsort (func_table
, nbr_func
, sizeof (alent
*), coff_sort_func_alent
);
4572 /* Create the new sorted table. */
4573 amt
= ((bfd_size_type
) asect
->lineno_count
+ 1) * sizeof (alent
);
4574 n_lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
);
4575 if (n_lineno_cache
!= NULL
)
4577 alent
*n_cache_ptr
= n_lineno_cache
;
4579 for (i
= 0; i
< nbr_func
; i
++)
4581 coff_symbol_type
*sym
;
4582 alent
*old_ptr
= func_table
[i
];
4584 /* Copy the function entry and update it. */
4585 *n_cache_ptr
= *old_ptr
;
4586 sym
= (coff_symbol_type
*)n_cache_ptr
->u
.sym
;
4587 sym
->lineno
= n_cache_ptr
;
4591 /* Copy the line number entries. */
4592 while (old_ptr
->line_number
!= 0)
4593 *n_cache_ptr
++ = *old_ptr
++;
4595 n_cache_ptr
->line_number
= 0;
4596 memcpy (lineno_cache
, n_lineno_cache
, amt
);
4598 bfd_release (abfd
, func_table
);
4605 /* Slurp in the symbol table, converting it to generic form. Note
4606 that if coff_relocate_section is defined, the linker will read
4607 symbols via coff_link_add_symbols, rather than via this routine. */
4610 coff_slurp_symbol_table (bfd
* abfd
)
4612 combined_entry_type
*native_symbols
;
4613 coff_symbol_type
*cached_area
;
4614 unsigned int *table_ptr
;
4616 unsigned int number_of_symbols
= 0;
4618 if (obj_symbols (abfd
))
4621 /* Read in the symbol table. */
4622 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4625 /* Allocate enough room for all the symbols in cached form. */
4626 amt
= obj_raw_syment_count (abfd
);
4627 amt
*= sizeof (coff_symbol_type
);
4628 cached_area
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
4629 if (cached_area
== NULL
)
4632 amt
= obj_raw_syment_count (abfd
);
4633 amt
*= sizeof (unsigned int);
4634 table_ptr
= (unsigned int *) bfd_alloc (abfd
, amt
);
4636 if (table_ptr
== NULL
)
4640 coff_symbol_type
*dst
= cached_area
;
4641 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4642 unsigned int this_index
= 0;
4644 while (this_index
< last_native_index
)
4646 combined_entry_type
*src
= native_symbols
+ this_index
;
4647 table_ptr
[this_index
] = number_of_symbols
;
4648 dst
->symbol
.the_bfd
= abfd
;
4650 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4651 /* We use the native name field to point to the cached field. */
4652 src
->u
.syment
._n
._n_n
._n_zeroes
= (bfd_hostptr_t
) dst
;
4653 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4654 src
->u
.syment
.n_scnum
);
4655 dst
->symbol
.flags
= 0;
4656 dst
->done_lineno
= FALSE
;
4658 switch (src
->u
.syment
.n_sclass
)
4662 /* Fall through to next case. */
4669 case C_THUMBEXTFUNC
:
4675 case C_SYSTEM
: /* System Wide variable. */
4678 /* In PE, 0x68 (104) denotes a section symbol. */
4680 /* In PE, 0x69 (105) denotes a weak external symbol. */
4683 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4685 case COFF_SYMBOL_GLOBAL
:
4686 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4687 #if defined COFF_WITH_PE
4688 /* PE sets the symbol to a value relative to the
4689 start of the section. */
4690 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4692 dst
->symbol
.value
= (src
->u
.syment
.n_value
4693 - dst
->symbol
.section
->vma
);
4695 if (ISFCN ((src
->u
.syment
.n_type
)))
4696 /* A function ext does not go at the end of a
4698 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4701 case COFF_SYMBOL_COMMON
:
4702 dst
->symbol
.section
= bfd_com_section_ptr
;
4703 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4706 case COFF_SYMBOL_UNDEFINED
:
4707 dst
->symbol
.section
= bfd_und_section_ptr
;
4708 dst
->symbol
.value
= 0;
4711 case COFF_SYMBOL_PE_SECTION
:
4712 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4713 dst
->symbol
.value
= 0;
4716 case COFF_SYMBOL_LOCAL
:
4717 dst
->symbol
.flags
= BSF_LOCAL
;
4718 #if defined COFF_WITH_PE
4719 /* PE sets the symbol to a value relative to the
4720 start of the section. */
4721 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4723 dst
->symbol
.value
= (src
->u
.syment
.n_value
4724 - dst
->symbol
.section
->vma
);
4726 if (ISFCN ((src
->u
.syment
.n_type
)))
4727 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4732 /* A symbol with a csect entry should not go at the end. */
4733 if (src
->u
.syment
.n_numaux
> 0)
4734 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4738 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4739 dst
->symbol
.flags
|= BSF_WEAK
;
4741 if (src
->u
.syment
.n_sclass
== C_SECTION
4742 && src
->u
.syment
.n_scnum
> 0)
4743 dst
->symbol
.flags
= BSF_LOCAL
;
4745 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
)
4746 dst
->symbol
.flags
|= BSF_WEAK
;
4750 case C_STAT
: /* Static. */
4752 case C_LEAFSTAT
: /* Static leaf procedure. */
4755 case C_THUMBSTAT
: /* Thumb static. */
4756 case C_THUMBLABEL
: /* Thumb label. */
4757 case C_THUMBSTATFUNC
:/* Thumb static function. */
4759 case C_LABEL
: /* Label. */
4760 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4761 dst
->symbol
.flags
= BSF_DEBUGGING
;
4763 dst
->symbol
.flags
= BSF_LOCAL
;
4765 /* Base the value as an index from the base of the
4766 section, if there is one. */
4767 if (dst
->symbol
.section
)
4769 #if defined COFF_WITH_PE
4770 /* PE sets the symbol to a value relative to the
4771 start of the section. */
4772 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4774 dst
->symbol
.value
= (src
->u
.syment
.n_value
4775 - dst
->symbol
.section
->vma
);
4779 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4782 case C_MOS
: /* Member of structure. */
4783 case C_EOS
: /* End of structure. */
4784 case C_REGPARM
: /* Register parameter. */
4785 case C_REG
: /* register variable. */
4786 /* C_AUTOARG conflicts with TI COFF C_UEXT. */
4787 #if !defined (TIC80COFF) && !defined (TICOFF)
4789 case C_AUTOARG
: /* 960-specific storage class. */
4792 case C_TPDEF
: /* Type definition. */
4794 case C_AUTO
: /* Automatic variable. */
4795 case C_FIELD
: /* Bit field. */
4796 case C_ENTAG
: /* Enumeration tag. */
4797 case C_MOE
: /* Member of enumeration. */
4798 case C_MOU
: /* Member of union. */
4799 case C_UNTAG
: /* Union tag. */
4800 dst
->symbol
.flags
= BSF_DEBUGGING
;
4801 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4804 case C_FILE
: /* File name. */
4805 case C_STRTAG
: /* Structure tag. */
4822 dst
->symbol
.flags
= BSF_DEBUGGING
;
4823 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4827 case C_BINCL
: /* Beginning of include file. */
4828 case C_EINCL
: /* Ending of include file. */
4829 /* The value is actually a pointer into the line numbers
4830 of the file. We locate the line number entry, and
4831 set the section to the section which contains it, and
4832 the value to the index in that section. */
4836 dst
->symbol
.flags
= BSF_DEBUGGING
;
4837 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4838 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4839 && ((file_ptr
) (sec
->line_filepos
4840 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4841 > (file_ptr
) src
->u
.syment
.n_value
))
4844 dst
->symbol
.value
= 0;
4847 dst
->symbol
.section
= sec
;
4848 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4849 - sec
->line_filepos
)
4850 / bfd_coff_linesz (abfd
));
4857 dst
->symbol
.flags
= BSF_DEBUGGING
;
4859 /* The value is actually a symbol index. Save a pointer
4860 to the symbol instead of the index. FIXME: This
4861 should use a union. */
4862 src
->u
.syment
.n_value
=
4863 (long) (native_symbols
+ src
->u
.syment
.n_value
);
4864 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4869 case C_BLOCK
: /* ".bb" or ".eb". */
4870 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf"). */
4871 case C_EFCN
: /* Physical end of function. */
4872 #if defined COFF_WITH_PE
4873 /* PE sets the symbol to a value relative to the start
4875 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4876 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4878 /* PE uses funny values for .ef and .lf; don't
4880 dst
->symbol
.flags
= BSF_DEBUGGING
;
4883 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4885 /* Base the value as an index from the base of the
4887 dst
->symbol
.flags
= BSF_LOCAL
;
4888 dst
->symbol
.value
= (src
->u
.syment
.n_value
4889 - dst
->symbol
.section
->vma
);
4893 case C_STATLAB
: /* Static load time label. */
4894 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4895 dst
->symbol
.flags
= BSF_GLOBAL
;
4899 /* PE DLLs sometimes have zeroed out symbols for some
4900 reason. Just ignore them without a warning. */
4901 if (src
->u
.syment
.n_type
== 0
4902 && src
->u
.syment
.n_value
== 0
4903 && src
->u
.syment
.n_scnum
== 0)
4906 case C_EXTDEF
: /* External definition. */
4907 case C_ULABEL
: /* Undefined label. */
4908 case C_USTATIC
: /* Undefined static. */
4909 #ifndef COFF_WITH_PE
4910 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4911 class to represent a section symbol. */
4912 case C_LINE
: /* line # reformatted as symbol table entry. */
4913 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4914 case C_ALIAS
: /* Duplicate tag. */
4916 /* New storage classes for TI COFF. */
4917 #if defined(TIC80COFF) || defined(TICOFF)
4918 case C_UEXT
: /* Tentative external definition. */
4920 case C_EXTLAB
: /* External load time label. */
4921 case C_HIDDEN
: /* Ext symbol in dmert public lib. */
4923 (*_bfd_error_handler
)
4924 (_("%B: Unrecognized storage class %d for %s symbol `%s'"),
4925 abfd
, src
->u
.syment
.n_sclass
,
4926 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4927 dst
->symbol
.flags
= BSF_DEBUGGING
;
4928 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4934 dst
->symbol
.udata
.i
= 0;
4936 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
4938 number_of_symbols
++;
4942 obj_symbols (abfd
) = cached_area
;
4943 obj_raw_syments (abfd
) = native_symbols
;
4945 bfd_get_symcount (abfd
) = number_of_symbols
;
4946 obj_convert (abfd
) = table_ptr
;
4947 /* Slurp the line tables for each section too. */
4954 coff_slurp_line_table (abfd
, p
);
4962 /* Classify a COFF symbol. A couple of targets have globally visible
4963 symbols which are not class C_EXT, and this handles those. It also
4964 recognizes some special PE cases. */
4966 static enum coff_symbol_classification
4967 coff_classify_symbol (bfd
*abfd
,
4968 struct internal_syment
*syment
)
4970 /* FIXME: This partially duplicates the switch in
4971 coff_slurp_symbol_table. */
4972 switch (syment
->n_sclass
)
4981 case C_THUMBEXTFUNC
:
4989 if (syment
->n_scnum
== 0)
4991 if (syment
->n_value
== 0)
4992 return COFF_SYMBOL_UNDEFINED
;
4994 return COFF_SYMBOL_COMMON
;
4996 return COFF_SYMBOL_GLOBAL
;
5003 if (syment
->n_sclass
== C_STAT
)
5005 if (syment
->n_scnum
== 0)
5006 /* The Microsoft compiler sometimes generates these if a
5007 small static function is inlined every time it is used.
5008 The function is discarded, but the symbol table entry
5010 return COFF_SYMBOL_LOCAL
;
5012 #ifdef STRICT_PE_FORMAT
5013 /* This is correct for Microsoft generated objects, but it
5014 breaks gas generated objects. */
5015 if (syment
->n_value
== 0)
5018 char buf
[SYMNMLEN
+ 1];
5020 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
5022 && (strcmp (bfd_get_section_name (abfd
, sec
),
5023 _bfd_coff_internal_syment_name (abfd
, syment
, buf
))
5025 return COFF_SYMBOL_PE_SECTION
;
5029 return COFF_SYMBOL_LOCAL
;
5032 if (syment
->n_sclass
== C_SECTION
)
5034 /* In some cases in a DLL generated by the Microsoft linker, the
5035 n_value field will contain garbage. FIXME: This should
5036 probably be handled by the swapping function instead. */
5037 syment
->n_value
= 0;
5038 if (syment
->n_scnum
== 0)
5039 return COFF_SYMBOL_UNDEFINED
;
5040 return COFF_SYMBOL_PE_SECTION
;
5042 #endif /* COFF_WITH_PE */
5044 /* If it is not a global symbol, we presume it is a local symbol. */
5045 if (syment
->n_scnum
== 0)
5047 char buf
[SYMNMLEN
+ 1];
5049 (*_bfd_error_handler
)
5050 (_("warning: %B: local symbol `%s' has no section"),
5051 abfd
, _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
5054 return COFF_SYMBOL_LOCAL
;
5061 Coff relocations are easily transformed into the internal BFD form
5064 Reading a coff relocation table is done in the following stages:
5066 o Read the entire coff relocation table into memory.
5068 o Process each relocation in turn; first swap it from the
5069 external to the internal form.
5071 o Turn the symbol referenced in the relocation's symbol index
5072 into a pointer into the canonical symbol table.
5073 This table is the same as the one returned by a call to
5074 @code{bfd_canonicalize_symtab}. The back end will call that
5075 routine and save the result if a canonicalization hasn't been done.
5077 o The reloc index is turned into a pointer to a howto
5078 structure, in a back end specific way. For instance, the 386
5079 and 960 use the @code{r_type} to directly produce an index
5080 into a howto table vector; the 88k subtracts a number from the
5081 @code{r_type} field and creates an addend field.
5085 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
5087 coff_symbol_type *coffsym = NULL; \
5089 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
5090 coffsym = (obj_symbols (abfd) \
5091 + (cache_ptr->sym_ptr_ptr - symbols)); \
5093 coffsym = coff_symbol_from (abfd, ptr); \
5094 if (coffsym != NULL \
5095 && coffsym->native->u.syment.n_scnum == 0) \
5096 cache_ptr->addend = 0; \
5097 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
5098 && ptr->section != NULL) \
5099 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
5101 cache_ptr->addend = 0; \
5106 coff_slurp_reloc_table (bfd
* abfd
, sec_ptr asect
, asymbol
** symbols
)
5108 RELOC
*native_relocs
;
5109 arelent
*reloc_cache
;
5114 if (asect
->relocation
)
5116 if (asect
->reloc_count
== 0)
5118 if (asect
->flags
& SEC_CONSTRUCTOR
)
5120 if (!coff_slurp_symbol_table (abfd
))
5123 amt
= (bfd_size_type
) bfd_coff_relsz (abfd
) * asect
->reloc_count
;
5124 native_relocs
= (RELOC
*) buy_and_read (abfd
, asect
->rel_filepos
, amt
);
5125 amt
= (bfd_size_type
) asect
->reloc_count
* sizeof (arelent
);
5126 reloc_cache
= (arelent
*) bfd_alloc (abfd
, amt
);
5128 if (reloc_cache
== NULL
|| native_relocs
== NULL
)
5131 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
5133 struct internal_reloc dst
;
5134 struct external_reloc
*src
;
5135 #ifndef RELOC_PROCESSING
5139 cache_ptr
= reloc_cache
+ idx
;
5140 src
= native_relocs
+ idx
;
5143 coff_swap_reloc_in (abfd
, src
, &dst
);
5145 #ifdef RELOC_PROCESSING
5146 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
5148 cache_ptr
->address
= dst
.r_vaddr
;
5150 if (dst
.r_symndx
!= -1)
5152 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
5154 (*_bfd_error_handler
)
5155 (_("%B: warning: illegal symbol index %ld in relocs"),
5156 abfd
, dst
.r_symndx
);
5157 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5162 cache_ptr
->sym_ptr_ptr
= (symbols
5163 + obj_convert (abfd
)[dst
.r_symndx
]);
5164 ptr
= *(cache_ptr
->sym_ptr_ptr
);
5169 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5173 /* The symbols definitions that we have read in have been
5174 relocated as if their sections started at 0. But the offsets
5175 refering to the symbols in the raw data have not been
5176 modified, so we have to have a negative addend to compensate.
5178 Note that symbols which used to be common must be left alone. */
5180 /* Calculate any reloc addend by looking at the symbol. */
5181 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
5183 cache_ptr
->address
-= asect
->vma
;
5184 /* !! cache_ptr->section = NULL;*/
5186 /* Fill in the cache_ptr->howto field from dst.r_type. */
5187 RTYPE2HOWTO (cache_ptr
, &dst
);
5188 #endif /* RELOC_PROCESSING */
5190 if (cache_ptr
->howto
== NULL
)
5192 (*_bfd_error_handler
)
5193 (_("%B: illegal relocation type %d at address 0x%lx"),
5194 abfd
, dst
.r_type
, (long) dst
.r_vaddr
);
5195 bfd_set_error (bfd_error_bad_value
);
5200 asect
->relocation
= reloc_cache
;
5204 #ifndef coff_rtype_to_howto
5207 /* Get the howto structure for a reloc. This is only used if the file
5208 including this one defines coff_relocate_section to be
5209 _bfd_coff_generic_relocate_section, so it is OK if it does not
5210 always work. It is the responsibility of the including file to
5211 make sure it is reasonable if it is needed. */
5213 static reloc_howto_type
*
5214 coff_rtype_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
5215 asection
*sec ATTRIBUTE_UNUSED
,
5216 struct internal_reloc
*rel
,
5217 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
,
5218 struct internal_syment
*sym ATTRIBUTE_UNUSED
,
5219 bfd_vma
*addendp ATTRIBUTE_UNUSED
)
5223 genrel
.howto
= NULL
;
5224 RTYPE2HOWTO (&genrel
, rel
);
5225 return genrel
.howto
;
5228 #else /* ! defined (RTYPE2HOWTO) */
5230 #define coff_rtype_to_howto NULL
5232 #endif /* ! defined (RTYPE2HOWTO) */
5233 #endif /* ! defined (coff_rtype_to_howto) */
5235 /* This is stupid. This function should be a boolean predicate. */
5238 coff_canonicalize_reloc (bfd
* abfd
,
5243 arelent
*tblptr
= section
->relocation
;
5244 unsigned int count
= 0;
5246 if (section
->flags
& SEC_CONSTRUCTOR
)
5248 /* This section has relocs made up by us, they are not in the
5249 file, so take them out of their chain and place them into
5250 the data area provided. */
5251 arelent_chain
*chain
= section
->constructor_chain
;
5253 for (count
= 0; count
< section
->reloc_count
; count
++)
5255 *relptr
++ = &chain
->relent
;
5256 chain
= chain
->next
;
5261 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
5264 tblptr
= section
->relocation
;
5266 for (; count
++ < section
->reloc_count
;)
5267 *relptr
++ = tblptr
++;
5270 return section
->reloc_count
;
5273 #ifndef coff_reloc16_estimate
5274 #define coff_reloc16_estimate dummy_reloc16_estimate
5277 dummy_reloc16_estimate (bfd
*abfd ATTRIBUTE_UNUSED
,
5278 asection
*input_section ATTRIBUTE_UNUSED
,
5279 arelent
*reloc ATTRIBUTE_UNUSED
,
5280 unsigned int shrink ATTRIBUTE_UNUSED
,
5281 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
)
5289 #ifndef coff_reloc16_extra_cases
5291 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5293 /* This works even if abort is not declared in any header file. */
5296 dummy_reloc16_extra_cases (bfd
*abfd ATTRIBUTE_UNUSED
,
5297 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
5298 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
,
5299 arelent
*reloc ATTRIBUTE_UNUSED
,
5300 bfd_byte
*data ATTRIBUTE_UNUSED
,
5301 unsigned int *src_ptr ATTRIBUTE_UNUSED
,
5302 unsigned int *dst_ptr ATTRIBUTE_UNUSED
)
5308 #ifndef coff_bfd_link_hash_table_free
5309 #define coff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
5312 /* If coff_relocate_section is defined, we can use the optimized COFF
5313 backend linker. Otherwise we must continue to use the old linker. */
5315 #ifdef coff_relocate_section
5317 #ifndef coff_bfd_link_hash_table_create
5318 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5320 #ifndef coff_bfd_link_add_symbols
5321 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5323 #ifndef coff_bfd_final_link
5324 #define coff_bfd_final_link _bfd_coff_final_link
5327 #else /* ! defined (coff_relocate_section) */
5329 #define coff_relocate_section NULL
5330 #ifndef coff_bfd_link_hash_table_create
5331 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5333 #ifndef coff_bfd_link_add_symbols
5334 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5336 #define coff_bfd_final_link _bfd_generic_final_link
5338 #endif /* ! defined (coff_relocate_section) */
5340 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5341 #define coff_bfd_copy_link_hash_symbol_type \
5342 _bfd_generic_copy_link_hash_symbol_type
5343 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5345 #ifndef coff_start_final_link
5346 #define coff_start_final_link NULL
5349 #ifndef coff_adjust_symndx
5350 #define coff_adjust_symndx NULL
5353 #ifndef coff_link_add_one_symbol
5354 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5357 #ifndef coff_link_output_has_begun
5360 coff_link_output_has_begun (bfd
* abfd
,
5361 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
)
5363 return abfd
->output_has_begun
;
5367 #ifndef coff_final_link_postscript
5370 coff_final_link_postscript (bfd
* abfd ATTRIBUTE_UNUSED
,
5371 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
)
5377 #ifndef coff_SWAP_aux_in
5378 #define coff_SWAP_aux_in coff_swap_aux_in
5380 #ifndef coff_SWAP_sym_in
5381 #define coff_SWAP_sym_in coff_swap_sym_in
5383 #ifndef coff_SWAP_lineno_in
5384 #define coff_SWAP_lineno_in coff_swap_lineno_in
5386 #ifndef coff_SWAP_aux_out
5387 #define coff_SWAP_aux_out coff_swap_aux_out
5389 #ifndef coff_SWAP_sym_out
5390 #define coff_SWAP_sym_out coff_swap_sym_out
5392 #ifndef coff_SWAP_lineno_out
5393 #define coff_SWAP_lineno_out coff_swap_lineno_out
5395 #ifndef coff_SWAP_reloc_out
5396 #define coff_SWAP_reloc_out coff_swap_reloc_out
5398 #ifndef coff_SWAP_filehdr_out
5399 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5401 #ifndef coff_SWAP_aouthdr_out
5402 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5404 #ifndef coff_SWAP_scnhdr_out
5405 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5407 #ifndef coff_SWAP_reloc_in
5408 #define coff_SWAP_reloc_in coff_swap_reloc_in
5410 #ifndef coff_SWAP_filehdr_in
5411 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5413 #ifndef coff_SWAP_aouthdr_in
5414 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5416 #ifndef coff_SWAP_scnhdr_in
5417 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5420 static bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED
=
5422 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5423 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5424 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5425 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5426 coff_SWAP_scnhdr_out
,
5427 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5428 #ifdef COFF_LONG_FILENAMES
5433 COFF_DEFAULT_LONG_SECTION_NAMES
,
5434 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5435 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5440 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5445 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5446 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5447 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5448 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5449 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5450 coff_classify_symbol
, coff_compute_section_file_positions
,
5451 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5452 coff_adjust_symndx
, coff_link_add_one_symbol
,
5453 coff_link_output_has_begun
, coff_final_link_postscript
,
5458 /* COFF0 differs in file/section header size and relocation entry size. */
5460 static bfd_coff_backend_data ticoff0_swap_table
=
5462 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5463 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5464 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5465 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5466 coff_SWAP_scnhdr_out
,
5467 FILHSZ_V0
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ_V0
, LINESZ
, FILNMLEN
,
5468 #ifdef COFF_LONG_FILENAMES
5473 COFF_DEFAULT_LONG_SECTION_NAMES
,
5474 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5475 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5480 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5485 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5486 coff_SWAP_reloc_in
, ticoff0_bad_format_hook
, coff_set_arch_mach_hook
,
5487 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5488 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5489 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5490 coff_classify_symbol
, coff_compute_section_file_positions
,
5491 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5492 coff_adjust_symndx
, coff_link_add_one_symbol
,
5493 coff_link_output_has_begun
, coff_final_link_postscript
,
5499 /* COFF1 differs in section header size. */
5501 static bfd_coff_backend_data ticoff1_swap_table
=
5503 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5504 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5505 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5506 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5507 coff_SWAP_scnhdr_out
,
5508 FILHSZ
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5509 #ifdef COFF_LONG_FILENAMES
5514 COFF_DEFAULT_LONG_SECTION_NAMES
,
5515 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5516 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5521 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5526 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5527 coff_SWAP_reloc_in
, ticoff1_bad_format_hook
, coff_set_arch_mach_hook
,
5528 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5529 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5530 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5531 coff_classify_symbol
, coff_compute_section_file_positions
,
5532 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5533 coff_adjust_symndx
, coff_link_add_one_symbol
,
5534 coff_link_output_has_begun
, coff_final_link_postscript
,
5535 bfd_pe_print_pdata
/* huh */
5539 #ifndef coff_close_and_cleanup
5540 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5543 #ifndef coff_bfd_free_cached_info
5544 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5547 #ifndef coff_get_section_contents
5548 #define coff_get_section_contents _bfd_generic_get_section_contents
5551 #ifndef coff_bfd_copy_private_symbol_data
5552 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5555 #ifndef coff_bfd_copy_private_header_data
5556 #define coff_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
5559 #ifndef coff_bfd_copy_private_section_data
5560 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5563 #ifndef coff_bfd_copy_private_bfd_data
5564 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5567 #ifndef coff_bfd_merge_private_bfd_data
5568 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5571 #ifndef coff_bfd_set_private_flags
5572 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5575 #ifndef coff_bfd_print_private_bfd_data
5576 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5579 #ifndef coff_bfd_is_local_label_name
5580 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5583 #ifndef coff_bfd_is_target_special_symbol
5584 #define coff_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
5587 #ifndef coff_read_minisymbols
5588 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5591 #ifndef coff_minisymbol_to_symbol
5592 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5595 /* The reloc lookup routine must be supplied by each individual COFF
5597 #ifndef coff_bfd_reloc_type_lookup
5598 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5600 #ifndef coff_bfd_reloc_name_lookup
5601 #define coff_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5604 #ifndef coff_bfd_get_relocated_section_contents
5605 #define coff_bfd_get_relocated_section_contents \
5606 bfd_generic_get_relocated_section_contents
5609 #ifndef coff_bfd_relax_section
5610 #define coff_bfd_relax_section bfd_generic_relax_section
5613 #ifndef coff_bfd_gc_sections
5614 #define coff_bfd_gc_sections bfd_generic_gc_sections
5617 #ifndef coff_bfd_merge_sections
5618 #define coff_bfd_merge_sections bfd_generic_merge_sections
5621 #ifndef coff_bfd_is_group_section
5622 #define coff_bfd_is_group_section bfd_generic_is_group_section
5625 #ifndef coff_bfd_discard_group
5626 #define coff_bfd_discard_group bfd_generic_discard_group
5629 #ifndef coff_section_already_linked
5630 #define coff_section_already_linked \
5631 _bfd_generic_section_already_linked
5634 #ifndef coff_bfd_define_common_symbol
5635 #define coff_bfd_define_common_symbol bfd_generic_define_common_symbol
5638 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5639 const bfd_target VAR = \
5642 bfd_target_coff_flavour, \
5643 BFD_ENDIAN_BIG, /* Data byte order is big. */ \
5644 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5645 /* object flags */ \
5646 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5647 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5648 /* section flags */ \
5649 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5650 UNDER, /* Leading symbol underscore. */ \
5651 '/', /* AR_pad_char. */ \
5652 15, /* AR_max_namelen. */ \
5654 /* Data conversion functions. */ \
5655 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5656 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5657 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5659 /* Header conversion functions. */ \
5660 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5661 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5662 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5664 /* bfd_check_format. */ \
5665 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5666 _bfd_dummy_target }, \
5667 /* bfd_set_format. */ \
5668 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5669 /* bfd_write_contents. */ \
5670 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5673 BFD_JUMP_TABLE_GENERIC (coff), \
5674 BFD_JUMP_TABLE_COPY (coff), \
5675 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5676 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5677 BFD_JUMP_TABLE_SYMBOLS (coff), \
5678 BFD_JUMP_TABLE_RELOCS (coff), \
5679 BFD_JUMP_TABLE_WRITE (coff), \
5680 BFD_JUMP_TABLE_LINK (coff), \
5681 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5688 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5689 const bfd_target VAR = \
5692 bfd_target_coff_flavour, \
5693 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5694 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5695 /* object flags */ \
5696 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5697 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5698 /* section flags */ \
5699 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5700 UNDER, /* Leading symbol underscore. */ \
5701 '/', /* AR_pad_char. */ \
5702 15, /* AR_max_namelen. */ \
5704 /* Data conversion functions. */ \
5705 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5706 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5707 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5709 /* Header conversion functions. */ \
5710 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5711 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5712 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5714 /* bfd_check_format. */ \
5715 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5716 _bfd_dummy_target }, \
5717 /* bfd_set_format. */ \
5718 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5719 /* bfd_write_contents. */ \
5720 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5723 BFD_JUMP_TABLE_GENERIC (coff), \
5724 BFD_JUMP_TABLE_COPY (coff), \
5725 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5726 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5727 BFD_JUMP_TABLE_SYMBOLS (coff), \
5728 BFD_JUMP_TABLE_RELOCS (coff), \
5729 BFD_JUMP_TABLE_WRITE (coff), \
5730 BFD_JUMP_TABLE_LINK (coff), \
5731 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5738 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5739 const bfd_target VAR = \
5742 bfd_target_coff_flavour, \
5743 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5744 BFD_ENDIAN_LITTLE, /* Header byte order is little. */ \
5745 /* object flags */ \
5746 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5747 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5748 /* section flags */ \
5749 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5750 UNDER, /* Leading symbol underscore. */ \
5751 '/', /* AR_pad_char. */ \
5752 15, /* AR_max_namelen. */ \
5754 /* Data conversion functions. */ \
5755 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5756 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5757 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5758 /* Header conversion functions. */ \
5759 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5760 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5761 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5762 /* bfd_check_format. */ \
5763 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5764 _bfd_dummy_target }, \
5765 /* bfd_set_format. */ \
5766 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5767 /* bfd_write_contents. */ \
5768 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5771 BFD_JUMP_TABLE_GENERIC (coff), \
5772 BFD_JUMP_TABLE_COPY (coff), \
5773 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5774 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5775 BFD_JUMP_TABLE_SYMBOLS (coff), \
5776 BFD_JUMP_TABLE_RELOCS (coff), \
5777 BFD_JUMP_TABLE_WRITE (coff), \
5778 BFD_JUMP_TABLE_LINK (coff), \
5779 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \