1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
5 Written by Cygnus Support.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
24 /* Most of this hacked by Steve Chamberlain,
30 BFD supports a number of different flavours of coff format.
31 The major differences between formats are the sizes and
32 alignments of fields in structures on disk, and the occasional
35 Coff in all its varieties is implemented with a few common
36 files and a number of implementation specific files. For
37 example, The 88k bcs coff format is implemented in the file
38 @file{coff-m88k.c}. This file @code{#include}s
39 @file{coff/m88k.h} which defines the external structure of the
40 coff format for the 88k, and @file{coff/internal.h} which
41 defines the internal structure. @file{coff-m88k.c} also
42 defines the relocations used by the 88k format
45 The Intel i960 processor version of coff is implemented in
46 @file{coff-i960.c}. This file has the same structure as
47 @file{coff-m88k.c}, except that it includes @file{coff/i960.h}
48 rather than @file{coff-m88k.h}.
51 Porting to a new version of coff
53 The recommended method is to select from the existing
54 implementations the version of coff which is most like the one
55 you want to use. For example, we'll say that i386 coff is
56 the one you select, and that your coff flavour is called foo.
57 Copy @file{i386coff.c} to @file{foocoff.c}, copy
58 @file{../include/coff/i386.h} to @file{../include/coff/foo.h},
59 and add the lines to @file{targets.c} and @file{Makefile.in}
60 so that your new back end is used. Alter the shapes of the
61 structures in @file{../include/coff/foo.h} so that they match
62 what you need. You will probably also have to add
63 @code{#ifdef}s to the code in @file{coff/internal.h} and
64 @file{coffcode.h} if your version of coff is too wild.
66 You can verify that your new BFD backend works quite simply by
67 building @file{objdump} from the @file{binutils} directory,
68 and making sure that its version of what's going on and your
69 host system's idea (assuming it has the pretty standard coff
70 dump utility, usually called @code{att-dump} or just
71 @code{dump}) are the same. Then clean up your code, and send
72 what you've done to Cygnus. Then your stuff will be in the
73 next release, and you won't have to keep integrating it.
76 How the coff backend works
81 The Coff backend is split into generic routines that are
82 applicable to any Coff target and routines that are specific
83 to a particular target. The target-specific routines are
84 further split into ones which are basically the same for all
85 Coff targets except that they use the external symbol format
86 or use different values for certain constants.
88 The generic routines are in @file{coffgen.c}. These routines
89 work for any Coff target. They use some hooks into the target
90 specific code; the hooks are in a @code{bfd_coff_backend_data}
91 structure, one of which exists for each target.
93 The essentially similar target-specific routines are in
94 @file{coffcode.h}. This header file includes executable C code.
95 The various Coff targets first include the appropriate Coff
96 header file, make any special defines that are needed, and
97 then include @file{coffcode.h}.
99 Some of the Coff targets then also have additional routines in
100 the target source file itself.
102 For example, @file{coff-i960.c} includes
103 @file{coff/internal.h} and @file{coff/i960.h}. It then
104 defines a few constants, such as @code{I960}, and includes
105 @file{coffcode.h}. Since the i960 has complex relocation
106 types, @file{coff-i960.c} also includes some code to
107 manipulate the i960 relocs. This code is not in
108 @file{coffcode.h} because it would not be used by any other
112 Coff long section names
114 In the standard Coff object format, section names are limited to
115 the eight bytes available in the @code{s_name} field of the
116 @code{SCNHDR} section header structure. The format requires the
117 field to be NUL-padded, but not necessarily NUL-terminated, so
118 the longest section names permitted are a full eight characters.
120 The Microsoft PE variants of the Coff object file format add
121 an extension to support the use of long section names. This
122 extension is defined in section 4 of the Microsoft PE/COFF
123 specification (rev 8.1). If a section name is too long to fit
124 into the section header's @code{s_name} field, it is instead
125 placed into the string table, and the @code{s_name} field is
126 filled with a slash ("/") followed by the ASCII decimal
127 representation of the offset of the full name relative to the
130 Note that this implies that the extension can only be used in object
131 files, as executables do not contain a string table. The standard
132 specifies that long section names from objects emitted into executable
133 images are to be truncated.
135 However, as a GNU extension, BFD can generate executable images
136 that contain a string table and long section names. This
137 would appear to be technically valid, as the standard only says
138 that Coff debugging information is deprecated, not forbidden,
139 and in practice it works, although some tools that parse PE files
140 expecting the MS standard format may become confused; @file{PEview} is
143 The functionality is supported in BFD by code implemented under
144 the control of the macro @code{COFF_LONG_SECTION_NAMES}. If not
145 defined, the format does not support long section names in any way.
146 If defined, it is used to initialise a flag,
147 @code{_bfd_coff_long_section_names}, and a hook function pointer,
148 @code{_bfd_coff_set_long_section_names}, in the Coff backend data
149 structure. The flag controls the generation of long section names
150 in output BFDs at runtime; if it is false, as it will be by default
151 when generating an executable image, long section names are truncated;
152 if true, the long section names extension is employed. The hook
153 points to a function that allows the value of the flag to be altered
154 at runtime, on formats that support long section names at all; on
155 other formats it points to a stub that returns an error indication.
157 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;
367 #include "coffswap.h"
370 #define STRING_SIZE_SIZE 4
372 #define DOT_DEBUG ".debug"
373 #define GNU_LINKONCE_WI ".gnu.linkonce.wi."
374 #define DOT_RELOC ".reloc"
376 #if defined (COFF_LONG_SECTION_NAMES)
377 /* Needed to expand the inputs to BLANKOR1TOODD. */
378 #define COFFLONGSECTIONCATHELPER(x,y) x ## y
379 /* If the input macro Y is blank or '1', return an odd number; if it is
380 '0', return an even number. Result undefined in all other cases. */
381 #define BLANKOR1TOODD(y) COFFLONGSECTIONCATHELPER(1,y)
382 /* Defined to numerical 0 or 1 according to whether generation of long
383 section names is disabled or enabled by default. */
384 #define COFF_ENABLE_LONG_SECTION_NAMES (BLANKOR1TOODD(COFF_LONG_SECTION_NAMES) & 1)
385 /* Where long section names are supported, we allow them to be enabled
386 and disabled at runtime, so select an appropriate hook function for
387 _bfd_coff_set_long_section_names. */
388 #define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_allowed
389 #else /* !defined (COFF_LONG_SECTION_NAMES) */
390 /* If long section names are not supported, this stub disallows any
391 attempt to enable them at run-time. */
392 #define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_disallowed
393 #endif /* defined (COFF_LONG_SECTION_NAMES) */
395 /* Define a macro that can be used to initialise both the fields relating
396 to long section names in the backend data struct simultaneously. */
397 #if COFF_ENABLE_LONG_SECTION_NAMES
398 #define COFF_DEFAULT_LONG_SECTION_NAMES (TRUE), COFF_LONG_SECTION_NAMES_SETTER
399 #else /* !COFF_ENABLE_LONG_SECTION_NAMES */
400 #define COFF_DEFAULT_LONG_SECTION_NAMES (FALSE), COFF_LONG_SECTION_NAMES_SETTER
401 #endif /* COFF_ENABLE_LONG_SECTION_NAMES */
403 #if defined (COFF_LONG_SECTION_NAMES)
404 static bfd_boolean bfd_coff_set_long_section_names_allowed
406 #else /* !defined (COFF_LONG_SECTION_NAMES) */
407 static bfd_boolean bfd_coff_set_long_section_names_disallowed
409 #endif /* defined (COFF_LONG_SECTION_NAMES) */
410 static long sec_to_styp_flags
411 (const char *, flagword
);
412 static bfd_boolean styp_to_sec_flags
413 (bfd
*, void *, const char *, asection
*, flagword
*);
414 static bfd_boolean coff_bad_format_hook
416 static void coff_set_custom_section_alignment
417 (bfd
*, asection
*, const struct coff_section_alignment_entry
*,
419 static bfd_boolean coff_new_section_hook
421 static bfd_boolean coff_set_arch_mach_hook
423 static bfd_boolean coff_write_relocs
425 static bfd_boolean coff_set_flags
426 (bfd
*, unsigned int *, unsigned short *);
427 static bfd_boolean coff_set_arch_mach
428 (bfd
*, enum bfd_architecture
, unsigned long) ATTRIBUTE_UNUSED
;
429 static bfd_boolean coff_compute_section_file_positions
431 static bfd_boolean coff_write_object_contents
432 (bfd
*) ATTRIBUTE_UNUSED
;
433 static bfd_boolean coff_set_section_contents
434 (bfd
*, asection
*, const void *, file_ptr
, bfd_size_type
);
435 static void * buy_and_read
436 (bfd
*, file_ptr
, bfd_size_type
);
437 static bfd_boolean coff_slurp_line_table
439 static bfd_boolean coff_slurp_symbol_table
441 static enum coff_symbol_classification coff_classify_symbol
442 (bfd
*, struct internal_syment
*);
443 static bfd_boolean coff_slurp_reloc_table
444 (bfd
*, asection
*, asymbol
**);
445 static long coff_canonicalize_reloc
446 (bfd
*, asection
*, arelent
**, asymbol
**);
447 #ifndef coff_mkobject_hook
448 static void * coff_mkobject_hook
449 (bfd
*, void *, void *);
452 static flagword handle_COMDAT
453 (bfd
*, flagword
, void *, const char *, asection
*);
455 #ifdef COFF_IMAGE_WITH_PE
456 static bfd_boolean coff_read_word
457 (bfd
*, unsigned int *);
458 static unsigned int coff_compute_checksum
460 static bfd_boolean coff_apply_checksum
464 static bfd_boolean ticoff0_bad_format_hook
466 static bfd_boolean ticoff1_bad_format_hook
470 /* void warning(); */
472 #if defined (COFF_LONG_SECTION_NAMES)
474 bfd_coff_set_long_section_names_allowed (bfd
*abfd
, int enable
)
476 coff_backend_info (abfd
)->_bfd_coff_long_section_names
= enable
;
479 #else /* !defined (COFF_LONG_SECTION_NAMES) */
481 bfd_coff_set_long_section_names_disallowed (bfd
*abfd
, int enable
)
487 #endif /* defined (COFF_LONG_SECTION_NAMES) */
489 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
490 the incoming SEC_* flags. The inverse of this function is
491 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
492 should probably mirror the changes in styp_to_sec_flags(). */
496 /* Macros for setting debugging flags. */
499 #define STYP_XCOFF_DEBUG STYP_DEBUG
501 #define STYP_XCOFF_DEBUG STYP_INFO
504 #ifdef COFF_ALIGN_IN_S_FLAGS
505 #define STYP_DEBUG_INFO STYP_DSECT
507 #define STYP_DEBUG_INFO STYP_INFO
511 sec_to_styp_flags (const char *sec_name
, flagword sec_flags
)
515 if (!strcmp (sec_name
, _TEXT
))
517 styp_flags
= STYP_TEXT
;
519 else if (!strcmp (sec_name
, _DATA
))
521 styp_flags
= STYP_DATA
;
523 else if (!strcmp (sec_name
, _BSS
))
525 styp_flags
= STYP_BSS
;
528 else if (!strcmp (sec_name
, _COMMENT
))
530 styp_flags
= STYP_INFO
;
531 #endif /* _COMMENT */
534 else if (!strcmp (sec_name
, _LIB
))
536 styp_flags
= STYP_LIB
;
540 else if (!strcmp (sec_name
, _LIT
))
542 styp_flags
= STYP_LIT
;
545 else if (CONST_STRNEQ (sec_name
, DOT_DEBUG
))
547 /* Handle the XCOFF debug section and DWARF2 debug sections. */
549 styp_flags
= STYP_XCOFF_DEBUG
;
551 styp_flags
= STYP_DEBUG_INFO
;
553 else if (CONST_STRNEQ (sec_name
, ".stab"))
555 styp_flags
= STYP_DEBUG_INFO
;
557 #ifdef COFF_LONG_SECTION_NAMES
558 else if (CONST_STRNEQ (sec_name
, GNU_LINKONCE_WI
))
560 styp_flags
= STYP_DEBUG_INFO
;
564 else if (!strcmp (sec_name
, _PAD
))
566 styp_flags
= STYP_PAD
;
568 else if (!strcmp (sec_name
, _LOADER
))
570 styp_flags
= STYP_LOADER
;
572 else if (!strcmp (sec_name
, _EXCEPT
))
574 styp_flags
= STYP_EXCEPT
;
576 else if (!strcmp (sec_name
, _TYPCHK
))
578 styp_flags
= STYP_TYPCHK
;
581 /* Try and figure out what it should be */
582 else if (sec_flags
& SEC_CODE
)
584 styp_flags
= STYP_TEXT
;
586 else if (sec_flags
& SEC_DATA
)
588 styp_flags
= STYP_DATA
;
590 else if (sec_flags
& SEC_READONLY
)
592 #ifdef STYP_LIT /* 29k readonly text/data section */
593 styp_flags
= STYP_LIT
;
595 styp_flags
= STYP_TEXT
;
596 #endif /* STYP_LIT */
598 else if (sec_flags
& SEC_LOAD
)
600 styp_flags
= STYP_TEXT
;
602 else if (sec_flags
& SEC_ALLOC
)
604 styp_flags
= STYP_BSS
;
608 if (sec_flags
& SEC_TIC54X_CLINK
)
609 styp_flags
|= STYP_CLINK
;
613 if (sec_flags
& SEC_TIC54X_BLOCK
)
614 styp_flags
|= STYP_BLOCK
;
618 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
619 styp_flags
|= STYP_NOLOAD
;
625 #else /* COFF_WITH_PE */
627 /* The PE version; see above for the general comments. The non-PE
628 case seems to be more guessing, and breaks PE format; specifically,
629 .rdata is readonly, but it sure ain't text. Really, all this
630 should be set up properly in gas (or whatever assembler is in use),
631 and honor whatever objcopy/strip, etc. sent us as input. */
634 sec_to_styp_flags (const char *sec_name
, flagword sec_flags
)
638 /* caution: there are at least three groups of symbols that have
639 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
640 SEC_* are the BFD internal flags, used for generic BFD
641 information. STYP_* are the COFF section flags which appear in
642 COFF files. IMAGE_SCN_* are the PE section flags which appear in
643 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
644 but there are more IMAGE_SCN_* flags. */
646 /* FIXME: There is no gas syntax to specify the debug section flag. */
647 if (CONST_STRNEQ (sec_name
, DOT_DEBUG
)
648 || CONST_STRNEQ (sec_name
, GNU_LINKONCE_WI
))
649 sec_flags
= SEC_DEBUGGING
| SEC_READONLY
;
654 if ((sec_flags
& SEC_CODE
) != 0)
655 styp_flags
|= IMAGE_SCN_CNT_CODE
;
656 if ((sec_flags
& SEC_DATA
) != 0)
657 styp_flags
|= IMAGE_SCN_CNT_INITIALIZED_DATA
;
658 if ((sec_flags
& SEC_ALLOC
) != 0 && (sec_flags
& SEC_LOAD
) == 0)
659 styp_flags
|= IMAGE_SCN_CNT_UNINITIALIZED_DATA
; /* ==STYP_BSS */
661 /* skip constRUCTOR */
663 if ((sec_flags
& SEC_IS_COMMON
) != 0)
664 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
665 if ((sec_flags
& SEC_DEBUGGING
) != 0)
666 styp_flags
|= IMAGE_SCN_MEM_DISCARDABLE
;
667 if ((sec_flags
& SEC_EXCLUDE
) != 0)
668 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
669 if ((sec_flags
& SEC_NEVER_LOAD
) != 0)
670 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
673 if (sec_flags
& SEC_LINK_ONCE
)
674 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
675 /* skip LINK_DUPLICATES */
676 /* skip LINKER_CREATED */
678 if ((sec_flags
& SEC_COFF_NOREAD
) == 0)
679 styp_flags
|= IMAGE_SCN_MEM_READ
; /* Invert NOREAD for read. */
680 if ((sec_flags
& SEC_READONLY
) == 0)
681 styp_flags
|= IMAGE_SCN_MEM_WRITE
; /* Invert READONLY for write. */
682 if (sec_flags
& SEC_CODE
)
683 styp_flags
|= IMAGE_SCN_MEM_EXECUTE
; /* CODE->EXECUTE. */
684 if (sec_flags
& SEC_COFF_SHARED
)
685 styp_flags
|= IMAGE_SCN_MEM_SHARED
; /* Shared remains meaningful. */
690 #endif /* COFF_WITH_PE */
692 /* Return a word with SEC_* flags set to represent the incoming STYP_*
693 flags (from scnhdr.s_flags). The inverse of this function is
694 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
695 should probably mirror the changes in sec_to_styp_flags(). */
700 styp_to_sec_flags (bfd
*abfd ATTRIBUTE_UNUSED
,
703 asection
*section ATTRIBUTE_UNUSED
,
706 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
707 long styp_flags
= internal_s
->s_flags
;
708 flagword sec_flags
= 0;
711 if (styp_flags
& STYP_BLOCK
)
712 sec_flags
|= SEC_TIC54X_BLOCK
;
716 if (styp_flags
& STYP_CLINK
)
717 sec_flags
|= SEC_TIC54X_CLINK
;
721 if (styp_flags
& STYP_NOLOAD
)
722 sec_flags
|= SEC_NEVER_LOAD
;
723 #endif /* STYP_NOLOAD */
725 /* For 386 COFF, at least, an unloadable text or data section is
726 actually a shared library section. */
727 if (styp_flags
& STYP_TEXT
)
729 if (sec_flags
& SEC_NEVER_LOAD
)
730 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
732 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
734 else if (styp_flags
& STYP_DATA
)
736 if (sec_flags
& SEC_NEVER_LOAD
)
737 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
739 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
741 else if (styp_flags
& STYP_BSS
)
743 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
744 if (sec_flags
& SEC_NEVER_LOAD
)
745 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
748 sec_flags
|= SEC_ALLOC
;
750 else if (styp_flags
& STYP_INFO
)
752 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
753 defined. coff_compute_section_file_positions uses
754 COFF_PAGE_SIZE to ensure that the low order bits of the
755 section VMA and the file offset match. If we don't know
756 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
757 and demand page loading of the file will fail. */
758 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
759 sec_flags
|= SEC_DEBUGGING
;
762 else if (styp_flags
& STYP_PAD
)
764 else if (strcmp (name
, _TEXT
) == 0)
766 if (sec_flags
& SEC_NEVER_LOAD
)
767 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
769 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
771 else if (strcmp (name
, _DATA
) == 0)
773 if (sec_flags
& SEC_NEVER_LOAD
)
774 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
776 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
778 else if (strcmp (name
, _BSS
) == 0)
780 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
781 if (sec_flags
& SEC_NEVER_LOAD
)
782 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
785 sec_flags
|= SEC_ALLOC
;
787 else if (CONST_STRNEQ (name
, DOT_DEBUG
)
789 || strcmp (name
, _COMMENT
) == 0
791 #ifdef COFF_LONG_SECTION_NAMES
792 || CONST_STRNEQ (name
, GNU_LINKONCE_WI
)
794 || CONST_STRNEQ (name
, ".stab"))
796 #ifdef COFF_PAGE_SIZE
797 sec_flags
|= SEC_DEBUGGING
;
801 else if (strcmp (name
, _LIB
) == 0)
805 else if (strcmp (name
, _LIT
) == 0)
806 sec_flags
= SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
809 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
811 #ifdef STYP_LIT /* A29k readonly text/data section type. */
812 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
813 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
814 #endif /* STYP_LIT */
816 #ifdef STYP_OTHER_LOAD /* Other loaded sections. */
817 if (styp_flags
& STYP_OTHER_LOAD
)
818 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
819 #endif /* STYP_SDATA */
821 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
822 /* As a GNU extension, if the name begins with .gnu.linkonce, we
823 only link a single copy of the section. This is used to support
824 g++. g++ will emit each template expansion in its own section.
825 The symbols will be defined as weak, so that multiple definitions
826 are permitted. The GNU linker extension is to actually discard
827 all but one of the sections. */
828 if (CONST_STRNEQ (name
, ".gnu.linkonce"))
829 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
832 if (flags_ptr
== NULL
)
835 * flags_ptr
= sec_flags
;
839 #else /* COFF_WITH_PE */
842 handle_COMDAT (bfd
* abfd
,
848 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
849 bfd_byte
*esymstart
, *esym
, *esymend
;
851 char *target_name
= NULL
;
853 sec_flags
|= SEC_LINK_ONCE
;
855 /* Unfortunately, the PE format stores essential information in
856 the symbol table, of all places. We need to extract that
857 information now, so that objdump and the linker will know how
858 to handle the section without worrying about the symbols. We
859 can't call slurp_symtab, because the linker doesn't want the
862 /* COMDAT sections are special. The first symbol is the section
863 symbol, which tells what kind of COMDAT section it is. The
864 second symbol is the "comdat symbol" - the one with the
865 unique name. GNU uses the section symbol for the unique
866 name; MS uses ".text" for every comdat section. Sigh. - DJ */
868 /* This is not mirrored in sec_to_styp_flags(), but there
869 doesn't seem to be a need to, either, and it would at best be
872 if (! _bfd_coff_get_external_symbols (abfd
))
875 esymstart
= esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
876 esymend
= esym
+ obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
878 while (esym
< esymend
)
880 struct internal_syment isym
;
881 char buf
[SYMNMLEN
+ 1];
884 bfd_coff_swap_sym_in (abfd
, esym
, & isym
);
886 if (sizeof (internal_s
->s_name
) > SYMNMLEN
)
888 /* This case implies that the matching
889 symbol name will be in the string table. */
893 if (isym
.n_scnum
== section
->target_index
)
895 /* According to the MSVC documentation, the first
896 TWO entries with the section # are both of
897 interest to us. The first one is the "section
898 symbol" (section name). The second is the comdat
899 symbol name. Here, we've found the first
900 qualifying entry; we distinguish it from the
901 second with a state flag.
903 In the case of gas-generated (at least until that
904 is fixed) .o files, it isn't necessarily the
905 second one. It may be some other later symbol.
907 Since gas also doesn't follow MS conventions and
908 emits the section similar to .text$<name>, where
909 <something> is the name we're looking for, we
910 distinguish the two as follows:
912 If the section name is simply a section name (no
913 $) we presume it's MS-generated, and look at
914 precisely the second symbol for the comdat name.
915 If the section name has a $, we assume it's
916 gas-generated, and look for <something> (whatever
917 follows the $) as the comdat symbol. */
919 /* All 3 branches use this. */
920 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
, buf
);
929 /* The first time we've seen the symbol. */
930 union internal_auxent aux
;
932 /* If it isn't the stuff we're expecting, die;
933 The MS documentation is vague, but it
934 appears that the second entry serves BOTH
935 as the comdat symbol and the defining
936 symbol record (either C_STAT or C_EXT,
937 possibly with an aux entry with debug
938 information if it's a function.) It
939 appears the only way to find the second one
940 is to count. (On Intel, they appear to be
941 adjacent, but on Alpha, they have been
944 Here, we think we've found the first one,
945 but there's some checking we can do to be
948 if (! ((isym
.n_sclass
== C_STAT
949 || isym
.n_sclass
== C_EXT
)
950 && isym
.n_type
== T_NULL
951 && isym
.n_value
== 0))
954 /* FIXME LATER: MSVC generates section names
955 like .text for comdats. Gas generates
956 names like .text$foo__Fv (in the case of a
957 function). See comment above for more. */
959 if (isym
.n_sclass
== C_STAT
&& strcmp (name
, symname
) != 0)
960 _bfd_error_handler (_("%B: warning: COMDAT symbol '%s' does not match section name '%s'"),
961 abfd
, symname
, name
);
965 /* This is the section symbol. */
966 bfd_coff_swap_aux_in (abfd
, (esym
+ bfd_coff_symesz (abfd
)),
967 isym
.n_type
, isym
.n_sclass
,
968 0, isym
.n_numaux
, & aux
);
970 target_name
= strchr (name
, '$');
971 if (target_name
!= NULL
)
979 /* FIXME: Microsoft uses NODUPLICATES and
980 ASSOCIATIVE, but gnu uses ANY and
981 SAME_SIZE. Unfortunately, gnu doesn't do
982 the comdat symbols right. So, until we can
983 fix it to do the right thing, we are
984 temporarily disabling comdats for the MS
985 types (they're used in DLLs and C++, but we
986 don't support *their* C++ libraries anyway
989 /* Cygwin does not follow the MS style, and
990 uses ANY and SAME_SIZE where NODUPLICATES
991 and ASSOCIATIVE should be used. For
992 Interix, we just do the right thing up
995 switch (aux
.x_scn
.x_comdat
)
997 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
998 #ifdef STRICT_PE_FORMAT
999 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
1001 sec_flags
&= ~SEC_LINK_ONCE
;
1005 case IMAGE_COMDAT_SELECT_ANY
:
1006 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1009 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
1010 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
1013 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
1014 /* Not yet fully implemented ??? */
1015 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
1018 /* debug$S gets this case; other
1021 /* There may be no symbol... we'll search
1022 the whole table... Is this the right
1023 place to play this game? Or should we do
1024 it when reading it in. */
1025 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
1026 #ifdef STRICT_PE_FORMAT
1027 /* FIXME: This is not currently implemented. */
1028 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1030 sec_flags
&= ~SEC_LINK_ONCE
;
1034 default: /* 0 means "no symbol" */
1035 /* debug$F gets this case; other
1037 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1044 /* Gas mode: the first matching on partial name. */
1046 #ifndef TARGET_UNDERSCORE
1047 #define TARGET_UNDERSCORE 0
1049 /* Is this the name we're looking for ? */
1050 if (strcmp (target_name
,
1051 symname
+ (TARGET_UNDERSCORE
? 1 : 0)) != 0)
1053 /* Not the name we're looking for */
1054 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1059 /* MSVC mode: the lexically second symbol (or
1060 drop through from the above). */
1065 /* This must the second symbol with the
1066 section #. It is the actual symbol name.
1067 Intel puts the two adjacent, but Alpha (at
1068 least) spreads them out. */
1070 amt
= sizeof (struct coff_comdat_info
);
1071 coff_section_data (abfd
, section
)->comdat
1072 = bfd_alloc (abfd
, amt
);
1073 if (coff_section_data (abfd
, section
)->comdat
== NULL
)
1076 coff_section_data (abfd
, section
)->comdat
->symbol
=
1077 (esym
- esymstart
) / bfd_coff_symesz (abfd
);
1079 amt
= strlen (symname
) + 1;
1080 newname
= bfd_alloc (abfd
, amt
);
1081 if (newname
== NULL
)
1084 strcpy (newname
, symname
);
1085 coff_section_data (abfd
, section
)->comdat
->name
1093 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1101 /* The PE version; see above for the general comments.
1103 Since to set the SEC_LINK_ONCE and associated flags, we have to
1104 look at the symbol table anyway, we return the symbol table index
1105 of the symbol being used as the COMDAT symbol. This is admittedly
1106 ugly, but there's really nowhere else that we have access to the
1107 required information. FIXME: Is the COMDAT symbol index used for
1108 any purpose other than objdump? */
1111 styp_to_sec_flags (bfd
*abfd
,
1115 flagword
*flags_ptr
)
1117 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
1118 long styp_flags
= internal_s
->s_flags
;
1120 bfd_boolean result
= TRUE
;
1122 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
1123 sec_flags
= SEC_READONLY
;
1125 /* If section disallows read, then set the NOREAD flag. */
1126 if ((styp_flags
& IMAGE_SCN_MEM_READ
) == 0)
1127 sec_flags
|= SEC_COFF_NOREAD
;
1129 /* Process each flag bit in styp_flags in turn. */
1132 long flag
= styp_flags
& - styp_flags
;
1133 char * unhandled
= NULL
;
1135 styp_flags
&= ~ flag
;
1137 /* We infer from the distinct read/write/execute bits the settings
1138 of some of the bfd flags; the actual values, should we need them,
1139 are also in pei_section_data (abfd, section)->pe_flags. */
1144 unhandled
= "STYP_DSECT";
1147 unhandled
= "STYP_GROUP";
1150 unhandled
= "STYP_COPY";
1153 unhandled
= "STYP_OVER";
1155 #ifdef SEC_NEVER_LOAD
1157 sec_flags
|= SEC_NEVER_LOAD
;
1160 case IMAGE_SCN_MEM_READ
:
1161 sec_flags
&= ~SEC_COFF_NOREAD
;
1163 case IMAGE_SCN_TYPE_NO_PAD
:
1166 case IMAGE_SCN_LNK_OTHER
:
1167 unhandled
= "IMAGE_SCN_LNK_OTHER";
1169 case IMAGE_SCN_MEM_NOT_CACHED
:
1170 unhandled
= "IMAGE_SCN_MEM_NOT_CACHED";
1172 case IMAGE_SCN_MEM_NOT_PAGED
:
1173 /* Generate a warning message rather using the 'unhandled'
1174 variable as this will allow some .sys files generate by
1175 other toolchains to be processed. See bugzilla issue 196. */
1176 _bfd_error_handler (_("%B: Warning: Ignoring section flag IMAGE_SCN_MEM_NOT_PAGED in section %s"),
1179 case IMAGE_SCN_MEM_EXECUTE
:
1180 sec_flags
|= SEC_CODE
;
1182 case IMAGE_SCN_MEM_WRITE
:
1183 sec_flags
&= ~ SEC_READONLY
;
1185 case IMAGE_SCN_MEM_DISCARDABLE
:
1186 /* The MS PE spec says that debug sections are DISCARDABLE,
1187 but the presence of a DISCARDABLE flag does not necessarily
1188 mean that a given section contains debug information. Thus
1189 we only set the SEC_DEBUGGING flag on sections that we
1190 recognise as containing debug information. */
1191 if (CONST_STRNEQ (name
, DOT_DEBUG
)
1193 || strcmp (name
, _COMMENT
) == 0
1195 #ifdef COFF_LONG_SECTION_NAMES
1196 || CONST_STRNEQ (name
, GNU_LINKONCE_WI
)
1198 || CONST_STRNEQ (name
, ".stab"))
1199 sec_flags
|= SEC_DEBUGGING
;
1201 case IMAGE_SCN_MEM_SHARED
:
1202 sec_flags
|= SEC_COFF_SHARED
;
1204 case IMAGE_SCN_LNK_REMOVE
:
1205 sec_flags
|= SEC_EXCLUDE
;
1207 case IMAGE_SCN_CNT_CODE
:
1208 sec_flags
|= SEC_CODE
| SEC_ALLOC
| SEC_LOAD
;
1210 case IMAGE_SCN_CNT_INITIALIZED_DATA
:
1211 sec_flags
|= SEC_DATA
| SEC_ALLOC
| SEC_LOAD
;
1213 case IMAGE_SCN_CNT_UNINITIALIZED_DATA
:
1214 sec_flags
|= SEC_ALLOC
;
1216 case IMAGE_SCN_LNK_INFO
:
1217 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1218 defined. coff_compute_section_file_positions uses
1219 COFF_PAGE_SIZE to ensure that the low order bits of the
1220 section VMA and the file offset match. If we don't know
1221 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1222 and demand page loading of the file will fail. */
1223 #ifdef COFF_PAGE_SIZE
1224 sec_flags
|= SEC_DEBUGGING
;
1227 case IMAGE_SCN_LNK_COMDAT
:
1228 /* COMDAT gets very special treatment. */
1229 sec_flags
= handle_COMDAT (abfd
, sec_flags
, hdr
, name
, section
);
1232 /* Silently ignore for now. */
1236 /* If the section flag was not handled, report it here. */
1237 if (unhandled
!= NULL
)
1239 (*_bfd_error_handler
)
1240 (_("%B (%s): Section flag %s (0x%x) ignored"),
1241 abfd
, name
, unhandled
, flag
);
1246 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1247 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1248 only link a single copy of the section. This is used to support
1249 g++. g++ will emit each template expansion in its own section.
1250 The symbols will be defined as weak, so that multiple definitions
1251 are permitted. The GNU linker extension is to actually discard
1252 all but one of the sections. */
1253 if (CONST_STRNEQ (name
, ".gnu.linkonce"))
1254 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1258 * flags_ptr
= sec_flags
;
1263 #endif /* COFF_WITH_PE */
1265 #define get_index(symbol) ((symbol)->udata.i)
1269 bfd_coff_backend_data
1273 .{* COFF symbol classifications. *}
1275 .enum coff_symbol_classification
1277 . {* Global symbol. *}
1278 . COFF_SYMBOL_GLOBAL,
1279 . {* Common symbol. *}
1280 . COFF_SYMBOL_COMMON,
1281 . {* Undefined symbol. *}
1282 . COFF_SYMBOL_UNDEFINED,
1283 . {* Local symbol. *}
1284 . COFF_SYMBOL_LOCAL,
1285 . {* PE section symbol. *}
1286 . COFF_SYMBOL_PE_SECTION
1289 Special entry points for gdb to swap in coff symbol table parts:
1292 . void (*_bfd_coff_swap_aux_in)
1293 . (bfd *, void *, int, int, int, int, void *);
1295 . void (*_bfd_coff_swap_sym_in)
1296 . (bfd *, void *, void *);
1298 . void (*_bfd_coff_swap_lineno_in)
1299 . (bfd *, void *, void *);
1301 . unsigned int (*_bfd_coff_swap_aux_out)
1302 . (bfd *, void *, int, int, int, int, void *);
1304 . unsigned int (*_bfd_coff_swap_sym_out)
1305 . (bfd *, void *, void *);
1307 . unsigned int (*_bfd_coff_swap_lineno_out)
1308 . (bfd *, void *, void *);
1310 . unsigned int (*_bfd_coff_swap_reloc_out)
1311 . (bfd *, void *, void *);
1313 . unsigned int (*_bfd_coff_swap_filehdr_out)
1314 . (bfd *, void *, void *);
1316 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1317 . (bfd *, void *, void *);
1319 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1320 . (bfd *, void *, void *);
1322 . unsigned int _bfd_filhsz;
1323 . unsigned int _bfd_aoutsz;
1324 . unsigned int _bfd_scnhsz;
1325 . unsigned int _bfd_symesz;
1326 . unsigned int _bfd_auxesz;
1327 . unsigned int _bfd_relsz;
1328 . unsigned int _bfd_linesz;
1329 . unsigned int _bfd_filnmlen;
1330 . bfd_boolean _bfd_coff_long_filenames;
1332 . bfd_boolean _bfd_coff_long_section_names;
1333 . bfd_boolean (*_bfd_coff_set_long_section_names)
1336 . unsigned int _bfd_coff_default_section_alignment_power;
1337 . bfd_boolean _bfd_coff_force_symnames_in_strings;
1338 . unsigned int _bfd_coff_debug_string_prefix_length;
1340 . void (*_bfd_coff_swap_filehdr_in)
1341 . (bfd *, void *, void *);
1343 . void (*_bfd_coff_swap_aouthdr_in)
1344 . (bfd *, void *, void *);
1346 . void (*_bfd_coff_swap_scnhdr_in)
1347 . (bfd *, void *, void *);
1349 . void (*_bfd_coff_swap_reloc_in)
1350 . (bfd *abfd, void *, void *);
1352 . bfd_boolean (*_bfd_coff_bad_format_hook)
1355 . bfd_boolean (*_bfd_coff_set_arch_mach_hook)
1358 . void * (*_bfd_coff_mkobject_hook)
1359 . (bfd *, void *, void *);
1361 . bfd_boolean (*_bfd_styp_to_sec_flags_hook)
1362 . (bfd *, void *, const char *, asection *, flagword *);
1364 . void (*_bfd_set_alignment_hook)
1365 . (bfd *, asection *, void *);
1367 . bfd_boolean (*_bfd_coff_slurp_symbol_table)
1370 . bfd_boolean (*_bfd_coff_symname_in_debug)
1371 . (bfd *, struct internal_syment *);
1373 . bfd_boolean (*_bfd_coff_pointerize_aux_hook)
1374 . (bfd *, combined_entry_type *, combined_entry_type *,
1375 . unsigned int, combined_entry_type *);
1377 . bfd_boolean (*_bfd_coff_print_aux)
1378 . (bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1379 . combined_entry_type *, unsigned int);
1381 . void (*_bfd_coff_reloc16_extra_cases)
1382 . (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1383 . bfd_byte *, unsigned int *, unsigned int *);
1385 . int (*_bfd_coff_reloc16_estimate)
1386 . (bfd *, asection *, arelent *, unsigned int,
1387 . struct bfd_link_info *);
1389 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1390 . (bfd *, struct internal_syment *);
1392 . bfd_boolean (*_bfd_coff_compute_section_file_positions)
1395 . bfd_boolean (*_bfd_coff_start_final_link)
1396 . (bfd *, struct bfd_link_info *);
1398 . bfd_boolean (*_bfd_coff_relocate_section)
1399 . (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1400 . struct internal_reloc *, struct internal_syment *, asection **);
1402 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1403 . (bfd *, asection *, struct internal_reloc *,
1404 . struct coff_link_hash_entry *, struct internal_syment *,
1407 . bfd_boolean (*_bfd_coff_adjust_symndx)
1408 . (bfd *, struct bfd_link_info *, bfd *, asection *,
1409 . struct internal_reloc *, bfd_boolean *);
1411 . bfd_boolean (*_bfd_coff_link_add_one_symbol)
1412 . (struct bfd_link_info *, bfd *, const char *, flagword,
1413 . asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
1414 . struct bfd_link_hash_entry **);
1416 . bfd_boolean (*_bfd_coff_link_output_has_begun)
1417 . (bfd *, struct coff_final_link_info *);
1419 . bfd_boolean (*_bfd_coff_final_link_postscript)
1420 . (bfd *, struct coff_final_link_info *);
1422 . bfd_boolean (*_bfd_coff_print_pdata)
1425 .} bfd_coff_backend_data;
1427 .#define coff_backend_info(abfd) \
1428 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1430 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1431 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1433 .#define bfd_coff_swap_sym_in(a,e,i) \
1434 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1436 .#define bfd_coff_swap_lineno_in(a,e,i) \
1437 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1439 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1440 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1442 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1443 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1445 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1446 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1448 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1449 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1451 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1452 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1454 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1455 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1457 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1458 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1460 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1461 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1462 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1463 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1464 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1465 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1466 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1467 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1468 .#define bfd_coff_long_filenames(abfd) \
1469 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1470 .#define bfd_coff_long_section_names(abfd) \
1471 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1472 .#define bfd_coff_set_long_section_names(abfd, enable) \
1473 . ((coff_backend_info (abfd)->_bfd_coff_set_long_section_names) (abfd, enable))
1474 .#define bfd_coff_default_section_alignment_power(abfd) \
1475 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1476 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1477 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1479 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1480 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1482 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1483 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1485 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1486 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1488 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1489 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1491 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1492 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1493 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1494 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1495 . (abfd, filehdr, aouthdr))
1497 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1498 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1499 . (abfd, scnhdr, name, section, flags_ptr))
1501 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1502 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1504 .#define bfd_coff_slurp_symbol_table(abfd)\
1505 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1507 .#define bfd_coff_symname_in_debug(abfd, sym)\
1508 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1510 .#define bfd_coff_force_symnames_in_strings(abfd)\
1511 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1513 .#define bfd_coff_debug_string_prefix_length(abfd)\
1514 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1516 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1517 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1518 . (abfd, file, base, symbol, aux, indaux))
1520 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1521 . reloc, data, src_ptr, dst_ptr)\
1522 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1523 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1525 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1526 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1527 . (abfd, section, reloc, shrink, link_info))
1529 .#define bfd_coff_classify_symbol(abfd, sym)\
1530 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1533 .#define bfd_coff_compute_section_file_positions(abfd)\
1534 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1537 .#define bfd_coff_start_final_link(obfd, info)\
1538 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1540 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1541 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1542 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1543 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1544 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1545 . (abfd, sec, rel, h, sym, addendp))
1546 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1547 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1548 . (obfd, info, ibfd, sec, rel, adjustedp))
1549 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1550 . value, string, cp, coll, hashp)\
1551 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1552 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1554 .#define bfd_coff_link_output_has_begun(a,p) \
1555 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p))
1556 .#define bfd_coff_final_link_postscript(a,p) \
1557 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p))
1559 .#define bfd_coff_have_print_pdata(a) \
1560 . (coff_backend_info (a)->_bfd_coff_print_pdata)
1561 .#define bfd_coff_print_pdata(a,p) \
1562 . ((coff_backend_info (a)->_bfd_coff_print_pdata) (a, p))
1564 .{* Macro: Returns true if the bfd is a PE executable as opposed to a
1565 . PE object file. *}
1566 .#define bfd_pei_p(abfd) \
1567 . (CONST_STRNEQ ((abfd)->xvec->name, "pei-"))
1570 /* See whether the magic number matches. */
1573 coff_bad_format_hook (bfd
* abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1575 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1577 if (BADMAG (*internal_f
))
1580 /* If the optional header is NULL or not the correct size then
1581 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1582 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1583 optional header is of a different size.
1585 But the mips keeps extra stuff in it's opthdr, so dont check
1588 #if defined(M88) || defined(I960)
1589 if (internal_f
->f_opthdr
!= 0 && bfd_coff_aoutsz (abfd
) != internal_f
->f_opthdr
)
1598 ticoff0_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1600 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1602 if (COFF0_BADMAG (*internal_f
))
1611 ticoff1_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1613 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1615 if (COFF1_BADMAG (*internal_f
))
1622 /* Check whether this section uses an alignment other than the
1626 coff_set_custom_section_alignment (bfd
*abfd ATTRIBUTE_UNUSED
,
1628 const struct coff_section_alignment_entry
*alignment_table
,
1629 const unsigned int table_size
)
1631 const unsigned int default_alignment
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1634 for (i
= 0; i
< table_size
; ++i
)
1636 const char *secname
= bfd_get_section_name (abfd
, section
);
1638 if (alignment_table
[i
].comparison_length
== (unsigned int) -1
1639 ? strcmp (alignment_table
[i
].name
, secname
) == 0
1640 : strncmp (alignment_table
[i
].name
, secname
,
1641 alignment_table
[i
].comparison_length
) == 0)
1644 if (i
>= table_size
)
1647 if (alignment_table
[i
].default_alignment_min
!= COFF_ALIGNMENT_FIELD_EMPTY
1648 && default_alignment
< alignment_table
[i
].default_alignment_min
)
1651 if (alignment_table
[i
].default_alignment_max
!= COFF_ALIGNMENT_FIELD_EMPTY
1652 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1653 && default_alignment
> alignment_table
[i
].default_alignment_max
1658 section
->alignment_power
= alignment_table
[i
].alignment_power
;
1661 /* Custom section alignment records. */
1663 static const struct coff_section_alignment_entry
1664 coff_section_alignment_table
[] =
1666 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1667 COFF_SECTION_ALIGNMENT_ENTRIES
,
1669 /* There must not be any gaps between .stabstr sections. */
1670 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1671 1, COFF_ALIGNMENT_FIELD_EMPTY
, 0 },
1672 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1673 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1674 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1675 /* Similarly for the .ctors and .dtors sections. */
1676 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1677 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1678 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1679 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 }
1682 static const unsigned int coff_section_alignment_table_size
=
1683 sizeof coff_section_alignment_table
/ sizeof coff_section_alignment_table
[0];
1685 /* Initialize a section structure with information peculiar to this
1686 particular implementation of COFF. */
1689 coff_new_section_hook (bfd
* abfd
, asection
* section
)
1691 combined_entry_type
*native
;
1694 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1697 if (bfd_xcoff_text_align_power (abfd
) != 0
1698 && strcmp (bfd_get_section_name (abfd
, section
), ".text") == 0)
1699 section
->alignment_power
= bfd_xcoff_text_align_power (abfd
);
1700 if (bfd_xcoff_data_align_power (abfd
) != 0
1701 && strcmp (bfd_get_section_name (abfd
, section
), ".data") == 0)
1702 section
->alignment_power
= bfd_xcoff_data_align_power (abfd
);
1705 /* Set up the section symbol. */
1706 if (!_bfd_generic_new_section_hook (abfd
, section
))
1709 /* Allocate aux records for section symbols, to store size and
1712 @@ The 10 is a guess at a plausible maximum number of aux entries
1713 (but shouldn't be a constant). */
1714 amt
= sizeof (combined_entry_type
) * 10;
1715 native
= bfd_zalloc (abfd
, amt
);
1719 /* We don't need to set up n_name, n_value, or n_scnum in the native
1720 symbol information, since they'll be overridden by the BFD symbol
1721 anyhow. However, we do need to set the type and storage class,
1722 in case this symbol winds up getting written out. The value 0
1723 for n_numaux is already correct. */
1725 native
->u
.syment
.n_type
= T_NULL
;
1726 native
->u
.syment
.n_sclass
= C_STAT
;
1728 coffsymbol (section
->symbol
)->native
= native
;
1730 coff_set_custom_section_alignment (abfd
, section
,
1731 coff_section_alignment_table
,
1732 coff_section_alignment_table_size
);
1737 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1739 /* Set the alignment of a BFD section. */
1742 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1746 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1750 /* Extract ALIGN from 2**ALIGN stored in section header. */
1751 for (i
= 0; i
< 32; i
++)
1752 if ((1 << i
) >= hdr
->s_align
)
1756 /* TI tools puts the alignment power in bits 8-11. */
1757 i
= (hdr
->s_flags
>> 8) & 0xF ;
1759 #ifdef COFF_DECODE_ALIGNMENT
1760 i
= COFF_DECODE_ALIGNMENT(hdr
->s_flags
);
1762 section
->alignment_power
= i
;
1764 #ifdef coff_set_section_load_page
1765 coff_set_section_load_page (section
, hdr
->s_page
);
1769 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1773 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1777 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1779 unsigned int alignment_power_const
1780 = hdr
->s_flags
& IMAGE_SCN_ALIGN_POWER_BIT_MASK
;
1782 switch (alignment_power_const
)
1784 case IMAGE_SCN_ALIGN_8192BYTES
:
1785 case IMAGE_SCN_ALIGN_4096BYTES
:
1786 case IMAGE_SCN_ALIGN_2048BYTES
:
1787 case IMAGE_SCN_ALIGN_1024BYTES
:
1788 case IMAGE_SCN_ALIGN_512BYTES
:
1789 case IMAGE_SCN_ALIGN_256BYTES
:
1790 case IMAGE_SCN_ALIGN_128BYTES
:
1791 case IMAGE_SCN_ALIGN_64BYTES
:
1792 case IMAGE_SCN_ALIGN_32BYTES
:
1793 case IMAGE_SCN_ALIGN_16BYTES
:
1794 case IMAGE_SCN_ALIGN_8BYTES
:
1795 case IMAGE_SCN_ALIGN_4BYTES
:
1796 case IMAGE_SCN_ALIGN_2BYTES
:
1797 case IMAGE_SCN_ALIGN_1BYTES
:
1798 section
->alignment_power
1799 = IMAGE_SCN_ALIGN_POWER_NUM (alignment_power_const
);
1805 /* In a PE image file, the s_paddr field holds the virtual size of a
1806 section, while the s_size field holds the raw size. We also keep
1807 the original section flag value, since not every bit can be
1808 mapped onto a generic BFD section bit. */
1809 if (coff_section_data (abfd
, section
) == NULL
)
1811 amt
= sizeof (struct coff_section_tdata
);
1812 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
1813 if (section
->used_by_bfd
== NULL
)
1814 /* FIXME: Return error. */
1818 if (pei_section_data (abfd
, section
) == NULL
)
1820 amt
= sizeof (struct pei_section_tdata
);
1821 coff_section_data (abfd
, section
)->tdata
= bfd_zalloc (abfd
, amt
);
1822 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1823 /* FIXME: Return error. */
1826 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1827 pei_section_data (abfd
, section
)->pe_flags
= hdr
->s_flags
;
1829 section
->lma
= hdr
->s_vaddr
;
1831 /* Check for extended relocs. */
1832 if (hdr
->s_flags
& IMAGE_SCN_LNK_NRELOC_OVFL
)
1834 struct external_reloc dst
;
1835 struct internal_reloc n
;
1836 file_ptr oldpos
= bfd_tell (abfd
);
1837 bfd_size_type relsz
= bfd_coff_relsz (abfd
);
1839 bfd_seek (abfd
, (file_ptr
) hdr
->s_relptr
, 0);
1840 if (bfd_bread (& dst
, relsz
, abfd
) != relsz
)
1843 coff_swap_reloc_in (abfd
, &dst
, &n
);
1844 bfd_seek (abfd
, oldpos
, 0);
1845 section
->reloc_count
= hdr
->s_nreloc
= n
.r_vaddr
- 1;
1846 section
->rel_filepos
+= relsz
;
1848 else if (hdr
->s_nreloc
== 0xffff)
1849 (*_bfd_error_handler
)
1850 ("%s: warning: claims to have 0xffff relocs, without overflow",
1851 bfd_get_filename (abfd
));
1854 #undef ELIFALIGN_SET
1856 #else /* ! COFF_WITH_PE */
1859 /* We grossly abuse this function to handle XCOFF overflow headers.
1860 When we see one, we correct the reloc and line number counts in the
1861 real header, and remove the section we just created. */
1864 coff_set_alignment_hook (bfd
*abfd
, asection
*section
, void * scnhdr
)
1866 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1869 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1872 real_sec
= coff_section_from_bfd_index (abfd
, (int) hdr
->s_nreloc
);
1873 if (real_sec
== NULL
)
1876 real_sec
->reloc_count
= hdr
->s_paddr
;
1877 real_sec
->lineno_count
= hdr
->s_vaddr
;
1879 if (!bfd_section_removed_from_list (abfd
, section
))
1881 bfd_section_list_remove (abfd
, section
);
1882 --abfd
->section_count
;
1886 #else /* ! RS6000COFF_C */
1888 #define coff_set_alignment_hook \
1889 ((void (*) (bfd *, asection *, void *)) bfd_void)
1891 #endif /* ! RS6000COFF_C */
1892 #endif /* ! COFF_WITH_PE */
1893 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1895 #ifndef coff_mkobject
1898 coff_mkobject (bfd
* abfd
)
1900 coff_data_type
*coff
;
1901 bfd_size_type amt
= sizeof (coff_data_type
);
1903 abfd
->tdata
.coff_obj_data
= bfd_zalloc (abfd
, amt
);
1904 if (abfd
->tdata
.coff_obj_data
== NULL
)
1906 coff
= coff_data (abfd
);
1907 coff
->symbols
= NULL
;
1908 coff
->conversion_table
= NULL
;
1909 coff
->raw_syments
= NULL
;
1910 coff
->relocbase
= 0;
1911 coff
->local_toc_sym_map
= 0;
1913 /* make_abs_section(abfd);*/
1919 /* Create the COFF backend specific information. */
1921 #ifndef coff_mkobject_hook
1923 coff_mkobject_hook (bfd
* abfd
,
1925 void * aouthdr ATTRIBUTE_UNUSED
)
1927 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1928 coff_data_type
*coff
;
1930 if (! coff_mkobject (abfd
))
1933 coff
= coff_data (abfd
);
1935 coff
->sym_filepos
= internal_f
->f_symptr
;
1937 /* These members communicate important constants about the symbol
1938 table to GDB's symbol-reading code. These `constants'
1939 unfortunately vary among coff implementations... */
1940 coff
->local_n_btmask
= N_BTMASK
;
1941 coff
->local_n_btshft
= N_BTSHFT
;
1942 coff
->local_n_tmask
= N_TMASK
;
1943 coff
->local_n_tshift
= N_TSHIFT
;
1944 coff
->local_symesz
= bfd_coff_symesz (abfd
);
1945 coff
->local_auxesz
= bfd_coff_auxesz (abfd
);
1946 coff
->local_linesz
= bfd_coff_linesz (abfd
);
1948 coff
->timestamp
= internal_f
->f_timdat
;
1950 obj_raw_syment_count (abfd
) =
1951 obj_conv_table_size (abfd
) =
1952 internal_f
->f_nsyms
;
1955 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
1956 abfd
->flags
|= DYNAMIC
;
1957 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= bfd_coff_aoutsz (abfd
))
1959 struct internal_aouthdr
*internal_a
=
1960 (struct internal_aouthdr
*) aouthdr
;
1961 struct xcoff_tdata
*xcoff
;
1963 xcoff
= xcoff_data (abfd
);
1964 # ifdef U803XTOCMAGIC
1965 xcoff
->xcoff64
= internal_f
->f_magic
== U803XTOCMAGIC
;
1969 xcoff
->full_aouthdr
= TRUE
;
1970 xcoff
->toc
= internal_a
->o_toc
;
1971 xcoff
->sntoc
= internal_a
->o_sntoc
;
1972 xcoff
->snentry
= internal_a
->o_snentry
;
1973 bfd_xcoff_text_align_power (abfd
) = internal_a
->o_algntext
;
1974 bfd_xcoff_data_align_power (abfd
) = internal_a
->o_algndata
;
1975 xcoff
->modtype
= internal_a
->o_modtype
;
1976 xcoff
->cputype
= internal_a
->o_cputype
;
1977 xcoff
->maxdata
= internal_a
->o_maxdata
;
1978 xcoff
->maxstack
= internal_a
->o_maxstack
;
1983 /* Set the flags field from the COFF header read in. */
1984 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
1989 /* FIXME: I'm not sure this is ever executed, since peicode.h
1990 defines coff_mkobject_hook. */
1991 if ((internal_f
->f_flags
& IMAGE_FILE_DEBUG_STRIPPED
) == 0)
1992 abfd
->flags
|= HAS_DEBUG
;
1999 /* Determine the machine architecture and type. FIXME: This is target
2000 dependent because the magic numbers are defined in the target
2001 dependent header files. But there is no particular need for this.
2002 If the magic numbers were moved to a separate file, this function
2003 would be target independent and would also be much more successful
2004 at linking together COFF files for different architectures. */
2007 coff_set_arch_mach_hook (bfd
*abfd
, void * filehdr
)
2009 unsigned long machine
;
2010 enum bfd_architecture arch
;
2011 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
2013 /* Zero selects the default machine for an arch. */
2015 switch (internal_f
->f_magic
)
2017 #ifdef OR32_MAGIC_BIG
2018 case OR32_MAGIC_BIG
:
2019 case OR32_MAGIC_LITTLE
:
2020 arch
= bfd_arch_or32
;
2025 arch
= bfd_arch_powerpc
;
2031 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler. */
2032 case LYNXCOFFMAGIC
: /* Shadows the m68k Lynx number below, sigh. */
2033 arch
= bfd_arch_i386
;
2038 arch
= bfd_arch_i386
;
2039 machine
= bfd_mach_x86_64
;
2044 arch
= bfd_arch_ia64
;
2051 arch
= bfd_arch_arm
;
2052 machine
= bfd_arm_get_mach_from_notes (abfd
, ARM_NOTE_SECTION
);
2053 if (machine
== bfd_mach_arm_unknown
)
2055 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
2057 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
2058 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
2059 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
2061 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
2062 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
2063 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
2064 /* The COFF header does not have enough bits available
2065 to cover all the different ARM architectures. So
2066 we interpret F_ARM_5, the highest flag value to mean
2067 "the highest ARM architecture known to BFD" which is
2068 currently the XScale. */
2069 case F_ARM_5
: machine
= bfd_mach_arm_XScale
; break;
2077 #ifdef MC68KBCSMAGIC
2080 #ifdef APOLLOM68KMAGIC
2081 case APOLLOM68KMAGIC
:
2083 #ifdef LYNXCOFFMAGIC
2086 arch
= bfd_arch_m68k
;
2087 machine
= bfd_mach_m68020
;
2092 arch
= bfd_arch_maxq
;
2093 switch (internal_f
->f_flags
& F_MACHMASK
)
2096 machine
= bfd_mach_maxq10
;
2099 machine
= bfd_mach_maxq20
;
2110 arch
= bfd_arch_m88k
;
2116 arch
= bfd_arch_z80
;
2117 switch (internal_f
->f_flags
& F_MACHMASK
)
2120 case bfd_mach_z80strict
<< 12:
2121 case bfd_mach_z80
<< 12:
2122 case bfd_mach_z80full
<< 12:
2123 case bfd_mach_r800
<< 12:
2124 machine
= ((unsigned)internal_f
->f_flags
& F_MACHMASK
) >> 12;
2133 arch
= bfd_arch_z8k
;
2134 switch (internal_f
->f_flags
& F_MACHMASK
)
2137 machine
= bfd_mach_z8001
;
2140 machine
= bfd_mach_z8002
;
2149 arch
= bfd_arch_i860
;
2156 arch
= bfd_arch_i960
;
2157 switch (F_I960TYPE
& internal_f
->f_flags
)
2161 machine
= bfd_mach_i960_core
;
2164 machine
= bfd_mach_i960_kb_sb
;
2167 machine
= bfd_mach_i960_mc
;
2170 machine
= bfd_mach_i960_xa
;
2173 machine
= bfd_mach_i960_ca
;
2176 machine
= bfd_mach_i960_ka_sa
;
2179 machine
= bfd_mach_i960_jx
;
2182 machine
= bfd_mach_i960_hx
;
2201 if (xcoff_data (abfd
)->cputype
!= -1)
2202 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
2205 /* We did not get a value from the a.out header. If the
2206 file has not been stripped, we may be able to get the
2207 architecture information from the first symbol, if it
2208 is a .file symbol. */
2209 if (obj_raw_syment_count (abfd
) == 0)
2214 struct internal_syment sym
;
2215 bfd_size_type amt
= bfd_coff_symesz (abfd
);
2217 buf
= bfd_malloc (amt
);
2218 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
2219 || bfd_bread (buf
, amt
, abfd
) != amt
)
2224 bfd_coff_swap_sym_in (abfd
, buf
, & sym
);
2225 if (sym
.n_sclass
== C_FILE
)
2226 cputype
= sym
.n_type
& 0xff;
2233 /* FIXME: We don't handle all cases here. */
2238 arch
= bfd_xcoff_architecture (abfd
);
2239 machine
= bfd_xcoff_machine (abfd
);
2243 arch
= bfd_arch_powerpc
;
2244 machine
= bfd_mach_ppc_601
;
2246 case 2: /* 64 bit PowerPC */
2247 arch
= bfd_arch_powerpc
;
2248 machine
= bfd_mach_ppc_620
;
2251 arch
= bfd_arch_powerpc
;
2252 machine
= bfd_mach_ppc
;
2255 arch
= bfd_arch_rs6000
;
2256 machine
= bfd_mach_rs6k
;
2265 arch
= bfd_arch_we32k
;
2271 arch
= bfd_arch_h8300
;
2272 machine
= bfd_mach_h8300
;
2273 /* !! FIXME this probably isn't the right place for this. */
2274 abfd
->flags
|= BFD_IS_RELAXABLE
;
2280 arch
= bfd_arch_h8300
;
2281 machine
= bfd_mach_h8300h
;
2282 /* !! FIXME this probably isn't the right place for this. */
2283 abfd
->flags
|= BFD_IS_RELAXABLE
;
2289 arch
= bfd_arch_h8300
;
2290 machine
= bfd_mach_h8300s
;
2291 /* !! FIXME this probably isn't the right place for this. */
2292 abfd
->flags
|= BFD_IS_RELAXABLE
;
2298 arch
= bfd_arch_h8300
;
2299 machine
= bfd_mach_h8300hn
;
2300 /* !! FIXME this probably isn't the right place for this. */
2301 abfd
->flags
|= BFD_IS_RELAXABLE
;
2307 arch
= bfd_arch_h8300
;
2308 machine
= bfd_mach_h8300sn
;
2309 /* !! FIXME this probably isn't the right place for this. */
2310 abfd
->flags
|= BFD_IS_RELAXABLE
;
2314 #ifdef SH_ARCH_MAGIC_BIG
2315 case SH_ARCH_MAGIC_BIG
:
2316 case SH_ARCH_MAGIC_LITTLE
:
2318 case SH_ARCH_MAGIC_WINCE
:
2324 #ifdef MIPS_ARCH_MAGIC_WINCE
2325 case MIPS_ARCH_MAGIC_WINCE
:
2326 arch
= bfd_arch_mips
;
2332 arch
= bfd_arch_h8500
;
2338 #ifdef LYNXCOFFMAGIC
2341 arch
= bfd_arch_sparc
;
2347 arch
= bfd_arch_tic30
;
2352 #ifdef TICOFF_TARGET_ARCH
2353 /* This TI COFF section should be used by all new TI COFF v0 targets. */
2355 arch
= TICOFF_TARGET_ARCH
;
2356 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2362 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */
2363 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */
2366 switch (internal_f
->f_target_id
)
2370 arch
= TICOFF_TARGET_ARCH
;
2371 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2375 arch
= bfd_arch_obscure
;
2376 (*_bfd_error_handler
)
2377 (_("Unrecognized TI COFF target id '0x%x'"),
2378 internal_f
->f_target_id
);
2384 #ifdef TIC80_ARCH_MAGIC
2385 case TIC80_ARCH_MAGIC
:
2386 arch
= bfd_arch_tic80
;
2392 arch
= bfd_arch_mcore
;
2398 arch
= bfd_arch_w65
;
2402 default: /* Unreadable input file type. */
2403 arch
= bfd_arch_obscure
;
2407 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2411 #ifdef SYMNAME_IN_DEBUG
2414 symname_in_debug_hook (bfd
* abfd ATTRIBUTE_UNUSED
, struct internal_syment
*sym
)
2416 return SYMNAME_IN_DEBUG (sym
) != 0;
2421 #define symname_in_debug_hook \
2422 (bfd_boolean (*) (bfd *, struct internal_syment *)) bfd_false
2429 #define FORCE_SYMNAMES_IN_STRINGS
2432 /* Handle the csect auxent of a C_EXT, C_AIX_WEAKEXT or C_HIDEXT symbol. */
2435 coff_pointerize_aux_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2436 combined_entry_type
*table_base
,
2437 combined_entry_type
*symbol
,
2438 unsigned int indaux
,
2439 combined_entry_type
*aux
)
2441 int class = symbol
->u
.syment
.n_sclass
;
2443 if (CSECT_SYM_P (class)
2444 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2446 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2448 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2449 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2450 aux
->fix_scnlen
= 1;
2453 /* Return TRUE to indicate that the caller should not do any
2454 further work on this auxent. */
2458 /* Return FALSE to indicate that this auxent should be handled by
2466 /* We don't want to pointerize bal entries. */
2469 coff_pointerize_aux_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2470 combined_entry_type
*table_base ATTRIBUTE_UNUSED
,
2471 combined_entry_type
*symbol
,
2472 unsigned int indaux
,
2473 combined_entry_type
*aux ATTRIBUTE_UNUSED
)
2475 /* Return TRUE if we don't want to pointerize this aux entry, which
2476 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2478 && (symbol
->u
.syment
.n_sclass
== C_LEAFPROC
2479 || symbol
->u
.syment
.n_sclass
== C_LEAFSTAT
2480 || symbol
->u
.syment
.n_sclass
== C_LEAFEXT
));
2485 #define coff_pointerize_aux_hook 0
2488 #endif /* ! RS6000COFF_C */
2490 /* Print an aux entry. This returns TRUE if it has printed it. */
2493 coff_print_aux (bfd
*abfd ATTRIBUTE_UNUSED
,
2494 FILE *file ATTRIBUTE_UNUSED
,
2495 combined_entry_type
*table_base ATTRIBUTE_UNUSED
,
2496 combined_entry_type
*symbol ATTRIBUTE_UNUSED
,
2497 combined_entry_type
*aux ATTRIBUTE_UNUSED
,
2498 unsigned int indaux ATTRIBUTE_UNUSED
)
2501 if (CSECT_SYM_P (symbol
->u
.syment
.n_sclass
)
2502 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2504 /* This is a csect entry. */
2505 fprintf (file
, "AUX ");
2506 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2508 BFD_ASSERT (! aux
->fix_scnlen
);
2510 fprintf (file
, "val %5lld",
2511 (long long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2513 fprintf (file
, "val %5ld", (long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2518 fprintf (file
, "indx ");
2519 if (! aux
->fix_scnlen
)
2521 fprintf (file
, "%4lld",
2522 (long long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2524 fprintf (file
, "%4ld", (long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2527 fprintf (file
, "%4ld",
2528 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2531 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2532 aux
->u
.auxent
.x_csect
.x_parmhash
,
2533 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2534 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2535 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2536 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2537 aux
->u
.auxent
.x_csect
.x_stab
,
2538 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2543 /* Return FALSE to indicate that no special action was taken. */
2551 To write relocations, the back end steps though the
2552 canonical relocation table and create an
2553 @code{internal_reloc}. The symbol index to use is removed from
2554 the @code{offset} field in the symbol table supplied. The
2555 address comes directly from the sum of the section base
2556 address and the relocation offset; the type is dug directly
2557 from the howto field. Then the @code{internal_reloc} is
2558 swapped into the shape of an @code{external_reloc} and written
2566 /* AUX's ld wants relocations to be sorted. */
2568 compare_arelent_ptr (const void * x
, const void * y
)
2570 const arelent
**a
= (const arelent
**) x
;
2571 const arelent
**b
= (const arelent
**) y
;
2572 bfd_size_type aadr
= (*a
)->address
;
2573 bfd_size_type badr
= (*b
)->address
;
2575 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2578 #endif /* TARG_AUX */
2581 coff_write_relocs (bfd
* abfd
, int first_undef
)
2585 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2588 struct external_reloc dst
;
2595 /* Sort relocations before we write them out. */
2598 amt
= s
->reloc_count
;
2599 amt
*= sizeof (arelent
*);
2600 p
= bfd_malloc (amt
);
2601 if (p
== NULL
&& s
->reloc_count
> 0)
2603 memcpy (p
, s
->orelocation
, (size_t) amt
);
2604 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2608 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2612 if (obj_pe (abfd
) && s
->reloc_count
>= 0xffff)
2614 /* Encode real count here as first reloc. */
2615 struct internal_reloc n
;
2617 memset (& n
, 0, sizeof (n
));
2618 /* Add one to count *this* reloc (grr). */
2619 n
.r_vaddr
= s
->reloc_count
+ 1;
2620 coff_swap_reloc_out (abfd
, &n
, &dst
);
2621 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2622 abfd
) != bfd_coff_relsz (abfd
))
2627 for (i
= 0; i
< s
->reloc_count
; i
++)
2629 struct internal_reloc n
;
2632 memset (& n
, 0, sizeof (n
));
2634 /* Now we've renumbered the symbols we know where the
2635 undefined symbols live in the table. Check the reloc
2636 entries for symbols who's output bfd isn't the right one.
2637 This is because the symbol was undefined (which means
2638 that all the pointers are never made to point to the same
2639 place). This is a bad thing,'cause the symbols attached
2640 to the output bfd are indexed, so that the relocation
2641 entries know which symbol index they point to. So we
2642 have to look up the output symbol here. */
2644 if (q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2647 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2648 asymbol
**outsyms
= abfd
->outsymbols
;
2650 for (j
= first_undef
; outsyms
[j
]; j
++)
2652 const char *intable
= outsyms
[j
]->name
;
2654 if (strcmp (intable
, sname
) == 0)
2656 /* Got a hit, so repoint the reloc. */
2657 q
->sym_ptr_ptr
= outsyms
+ j
;
2663 n
.r_vaddr
= q
->address
+ s
->vma
;
2666 /* The 29k const/consth reloc pair is a real kludge. The consth
2667 part doesn't have a symbol; it has an offset. So rebuilt
2669 if (q
->howto
->type
== R_IHCONST
)
2670 n
.r_symndx
= q
->addend
;
2675 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2676 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
, s
))
2678 if ((*q
->sym_ptr_ptr
)->section
== bfd_abs_section_ptr
2679 && ((*q
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) != 0)
2681 /* This is a relocation relative to the absolute symbol. */
2685 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2686 /* Check to see if the symbol reloc points to a symbol
2687 we don't have in our symbol table. */
2688 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2690 bfd_set_error (bfd_error_bad_value
);
2691 _bfd_error_handler (_("%B: reloc against a non-existant symbol index: %ld"),
2698 #ifdef SWAP_OUT_RELOC_OFFSET
2699 n
.r_offset
= q
->addend
;
2703 /* Work out reloc type from what is required. */
2704 SELECT_RELOC (n
, q
->howto
);
2706 n
.r_type
= q
->howto
->type
;
2708 coff_swap_reloc_out (abfd
, &n
, &dst
);
2710 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2711 abfd
) != bfd_coff_relsz (abfd
))
2724 /* Set flags and magic number of a coff file from architecture and machine
2725 type. Result is TRUE if we can represent the arch&type, FALSE if not. */
2728 coff_set_flags (bfd
* abfd
,
2729 unsigned int *magicp ATTRIBUTE_UNUSED
,
2730 unsigned short *flagsp ATTRIBUTE_UNUSED
)
2732 switch (bfd_get_arch (abfd
))
2737 switch (bfd_get_mach (abfd
))
2740 case bfd_mach_z80strict
:
2742 case bfd_mach_z80full
:
2744 *flagsp
= bfd_get_mach (abfd
) << 12;
2756 switch (bfd_get_mach (abfd
))
2758 case bfd_mach_z8001
: *flagsp
= F_Z8001
; break;
2759 case bfd_mach_z8002
: *flagsp
= F_Z8002
; break;
2760 default: return FALSE
;
2771 *magicp
= I960ROMAGIC
;
2773 switch (bfd_get_mach (abfd
))
2775 case bfd_mach_i960_core
: flags
= F_I960CORE
; break;
2776 case bfd_mach_i960_kb_sb
: flags
= F_I960KB
; break;
2777 case bfd_mach_i960_mc
: flags
= F_I960MC
; break;
2778 case bfd_mach_i960_xa
: flags
= F_I960XA
; break;
2779 case bfd_mach_i960_ca
: flags
= F_I960CA
; break;
2780 case bfd_mach_i960_ka_sa
: flags
= F_I960KA
; break;
2781 case bfd_mach_i960_jx
: flags
= F_I960JX
; break;
2782 case bfd_mach_i960_hx
: flags
= F_I960HX
; break;
2783 default: return FALSE
;
2792 case bfd_arch_tic30
:
2793 *magicp
= TIC30MAGIC
;
2797 #ifdef TICOFF_DEFAULT_MAGIC
2798 case TICOFF_TARGET_ARCH
:
2799 /* If there's no indication of which version we want, use the default. */
2801 *magicp
= TICOFF_DEFAULT_MAGIC
;
2804 /* We may want to output in a different COFF version. */
2805 switch (abfd
->xvec
->name
[4])
2808 *magicp
= TICOFF0MAGIC
;
2811 *magicp
= TICOFF1MAGIC
;
2814 *magicp
= TICOFF2MAGIC
;
2820 TICOFF_TARGET_MACHINE_SET (flagsp
, bfd_get_mach (abfd
));
2824 #ifdef TIC80_ARCH_MAGIC
2825 case bfd_arch_tic80
:
2826 *magicp
= TIC80_ARCH_MAGIC
;
2833 * magicp
= ARMPEMAGIC
;
2835 * magicp
= ARMMAGIC
;
2838 if (APCS_SET (abfd
))
2840 if (APCS_26_FLAG (abfd
))
2841 * flagsp
|= F_APCS26
;
2843 if (APCS_FLOAT_FLAG (abfd
))
2844 * flagsp
|= F_APCS_FLOAT
;
2846 if (PIC_FLAG (abfd
))
2849 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2850 * flagsp
|= F_INTERWORK
;
2851 switch (bfd_get_mach (abfd
))
2853 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2854 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2855 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2856 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2857 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2858 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2859 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2860 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2861 See also the comment in coff_set_arch_mach_hook(). */
2862 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break;
2863 case bfd_mach_arm_5TE
: * flagsp
|= F_ARM_5
; break;
2864 case bfd_mach_arm_XScale
: * flagsp
|= F_ARM_5
; break;
2870 case bfd_arch_powerpc
:
2875 #if defined(I386MAGIC) || defined(AMD64MAGIC)
2877 #if defined(I386MAGIC)
2878 *magicp
= I386MAGIC
;
2881 /* Just overwrite the usual value if we're doing Lynx. */
2882 *magicp
= LYNXCOFFMAGIC
;
2884 #if defined AMD64MAGIC
2885 *magicp
= AMD64MAGIC
;
2892 *magicp
= I860MAGIC
;
2898 *magicp
= IA64MAGIC
;
2904 #ifdef APOLLOM68KMAGIC
2905 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
2907 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2908 #ifdef NAMES_HAVE_UNDERSCORE
2909 *magicp
= MC68KBCSMAGIC
;
2911 *magicp
= MC68MAGIC
;
2915 /* Just overwrite the usual value if we're doing Lynx. */
2916 *magicp
= LYNXCOFFMAGIC
;
2923 *magicp
= MC88OMAGIC
;
2928 case bfd_arch_h8300
:
2929 switch (bfd_get_mach (abfd
))
2931 case bfd_mach_h8300
: *magicp
= H8300MAGIC
; return TRUE
;
2932 case bfd_mach_h8300h
: *magicp
= H8300HMAGIC
; return TRUE
;
2933 case bfd_mach_h8300s
: *magicp
= H8300SMAGIC
; return TRUE
;
2934 case bfd_mach_h8300hn
: *magicp
= H8300HNMAGIC
; return TRUE
;
2935 case bfd_mach_h8300sn
: *magicp
= H8300SNMAGIC
; return TRUE
;
2941 #ifdef SH_ARCH_MAGIC_BIG
2943 #ifdef COFF_IMAGE_WITH_PE
2944 *magicp
= SH_ARCH_MAGIC_WINCE
;
2946 if (bfd_big_endian (abfd
))
2947 *magicp
= SH_ARCH_MAGIC_BIG
;
2949 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2954 #ifdef MIPS_ARCH_MAGIC_WINCE
2956 *magicp
= MIPS_ARCH_MAGIC_WINCE
;
2961 case bfd_arch_sparc
:
2962 *magicp
= SPARCMAGIC
;
2964 /* Just overwrite the usual value if we're doing Lynx. */
2965 *magicp
= LYNXCOFFMAGIC
;
2971 case bfd_arch_h8500
:
2972 *magicp
= H8500MAGIC
;
2978 case bfd_arch_we32k
:
2979 *magicp
= WE32KMAGIC
;
2984 case bfd_arch_rs6000
:
2986 case bfd_arch_powerpc
:
2988 BFD_ASSERT (bfd_get_flavour (abfd
) == bfd_target_xcoff_flavour
);
2989 *magicp
= bfd_xcoff_magic_number (abfd
);
2994 case bfd_arch_mcore
:
2995 * magicp
= MCOREMAGIC
;
3005 #ifdef OR32_MAGIC_BIG
3007 if (bfd_big_endian (abfd
))
3008 * magicp
= OR32_MAGIC_BIG
;
3010 * magicp
= OR32_MAGIC_LITTLE
;
3016 * magicp
= MAXQ20MAGIC
;
3017 switch (bfd_get_mach (abfd
))
3019 case bfd_mach_maxq10
: * flagsp
= F_MAXQ10
; return TRUE
;
3020 case bfd_mach_maxq20
: * flagsp
= F_MAXQ20
; return TRUE
;
3021 default: return FALSE
;
3025 default: /* Unknown architecture. */
3026 /* Fall through to "return FALSE" below, to avoid
3027 "statement never reached" errors on the one below. */
3035 coff_set_arch_mach (bfd
* abfd
,
3036 enum bfd_architecture arch
,
3037 unsigned long machine
)
3040 unsigned short dummy2
;
3042 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
3045 if (arch
!= bfd_arch_unknown
3046 && ! coff_set_flags (abfd
, &dummy1
, &dummy2
))
3047 return FALSE
; /* We can't represent this type. */
3049 return TRUE
; /* We're easy... */
3052 #ifdef COFF_IMAGE_WITH_PE
3054 /* This is used to sort sections by VMA, as required by PE image
3058 sort_by_secaddr (const void * arg1
, const void * arg2
)
3060 const asection
*a
= *(const asection
**) arg1
;
3061 const asection
*b
= *(const asection
**) arg2
;
3063 if (a
->vma
< b
->vma
)
3065 else if (a
->vma
> b
->vma
)
3071 #endif /* COFF_IMAGE_WITH_PE */
3073 /* Calculate the file position for each section. */
3076 #define ALIGN_SECTIONS_IN_FILE
3078 #if defined(TIC80COFF) || defined(TICOFF)
3079 #undef ALIGN_SECTIONS_IN_FILE
3083 coff_compute_section_file_positions (bfd
* abfd
)
3086 asection
*previous
= NULL
;
3087 file_ptr sofar
= bfd_coff_filhsz (abfd
);
3088 bfd_boolean align_adjust
;
3089 #ifdef ALIGN_SECTIONS_IN_FILE
3094 /* On XCOFF, if we have symbols, set up the .debug section. */
3095 if (bfd_get_symcount (abfd
) > 0)
3098 bfd_size_type i
, symcount
;
3102 symcount
= bfd_get_symcount (abfd
);
3103 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
3105 coff_symbol_type
*cf
;
3107 cf
= coff_symbol_from (abfd
, *symp
);
3109 && cf
->native
!= NULL
3110 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
3114 len
= strlen (bfd_asymbol_name (*symp
));
3115 if (len
> SYMNMLEN
|| bfd_coff_force_symnames_in_strings (abfd
))
3116 sz
+= len
+ 1 + bfd_coff_debug_string_prefix_length (abfd
);
3123 dsec
= bfd_make_section_old_way (abfd
, DOT_DEBUG
);
3127 dsec
->flags
|= SEC_HAS_CONTENTS
;
3132 #ifdef COFF_IMAGE_WITH_PE
3135 if (coff_data (abfd
)->link_info
)
3137 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
3139 /* If no file alignment has been set, default to one.
3140 This repairs 'ld -r' for arm-wince-pe target. */
3145 page_size
= PE_DEF_FILE_ALIGNMENT
;
3147 #ifdef COFF_PAGE_SIZE
3148 int page_size
= COFF_PAGE_SIZE
;
3152 if (bfd_get_start_address (abfd
))
3153 /* A start address may have been added to the original file. In this
3154 case it will need an optional header to record it. */
3155 abfd
->flags
|= EXEC_P
;
3157 if (abfd
->flags
& EXEC_P
)
3158 sofar
+= bfd_coff_aoutsz (abfd
);
3160 else if (xcoff_data (abfd
)->full_aouthdr
)
3161 sofar
+= bfd_coff_aoutsz (abfd
);
3163 sofar
+= SMALL_AOUTSZ
;
3166 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
3169 /* XCOFF handles overflows in the reloc and line number count fields
3170 by allocating a new section header to hold the correct counts. */
3171 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3172 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3173 sofar
+= bfd_coff_scnhsz (abfd
);
3176 #ifdef COFF_IMAGE_WITH_PE
3178 /* PE requires the sections to be in memory order when listed in
3179 the section headers. It also does not like empty loadable
3180 sections. The sections apparently do not have to be in the
3181 right order in the image file itself, but we do need to get the
3182 target_index values right. */
3185 asection
**section_list
;
3190 #ifdef COFF_PAGE_SIZE
3191 /* Clear D_PAGED if section alignment is smaller than
3193 if (pe_data (abfd
)->pe_opthdr
.SectionAlignment
< COFF_PAGE_SIZE
)
3194 abfd
->flags
&= ~D_PAGED
;
3198 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3201 /* We allocate an extra cell to simplify the final loop. */
3202 amt
= sizeof (struct asection
*) * (count
+ 1);
3203 section_list
= bfd_malloc (amt
);
3204 if (section_list
== NULL
)
3208 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3210 section_list
[i
] = current
;
3213 section_list
[i
] = NULL
;
3215 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
3217 /* Rethread the linked list into sorted order; at the same time,
3218 assign target_index values. */
3220 abfd
->sections
= NULL
;
3221 abfd
->section_last
= NULL
;
3222 for (i
= 0; i
< count
; i
++)
3224 current
= section_list
[i
];
3225 bfd_section_list_append (abfd
, current
);
3227 /* Later, if the section has zero size, we'll be throwing it
3228 away, so we don't want to number it now. Note that having
3229 a zero size and having real contents are different
3230 concepts: .bss has no contents, but (usually) non-zero
3232 if (current
->size
== 0)
3234 /* Discard. However, it still might have (valid) symbols
3235 in it, so arbitrarily set it to section 1 (indexing is
3236 1-based here; usually .text). __end__ and other
3237 contents of .endsection really have this happen.
3238 FIXME: This seems somewhat dubious. */
3239 current
->target_index
= 1;
3242 current
->target_index
= target_index
++;
3245 free (section_list
);
3247 #else /* ! COFF_IMAGE_WITH_PE */
3249 /* Set the target_index field. */
3253 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3254 current
->target_index
= target_index
++;
3256 #endif /* ! COFF_IMAGE_WITH_PE */
3258 align_adjust
= FALSE
;
3259 for (current
= abfd
->sections
;
3261 current
= current
->next
)
3263 #ifdef COFF_IMAGE_WITH_PE
3264 /* With PE we have to pad each section to be a multiple of its
3265 page size too, and remember both sizes. */
3266 if (coff_section_data (abfd
, current
) == NULL
)
3268 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
3270 current
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
3271 if (current
->used_by_bfd
== NULL
)
3274 if (pei_section_data (abfd
, current
) == NULL
)
3276 bfd_size_type amt
= sizeof (struct pei_section_tdata
);
3278 coff_section_data (abfd
, current
)->tdata
= bfd_zalloc (abfd
, amt
);
3279 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
3282 if (pei_section_data (abfd
, current
)->virt_size
== 0)
3283 pei_section_data (abfd
, current
)->virt_size
= current
->size
;
3286 /* Only deal with sections which have contents. */
3287 if (!(current
->flags
& SEC_HAS_CONTENTS
))
3290 #ifdef COFF_IMAGE_WITH_PE
3291 /* Make sure we skip empty sections in a PE image. */
3292 if (current
->size
== 0)
3296 /* Align the sections in the file to the same boundary on
3297 which they are aligned in virtual memory. I960 doesn't
3298 do this (FIXME) so we can stay in sync with Intel. 960
3299 doesn't yet page from files... */
3300 #ifdef ALIGN_SECTIONS_IN_FILE
3301 if ((abfd
->flags
& EXEC_P
) != 0)
3303 /* Make sure this section is aligned on the right boundary - by
3304 padding the previous section up if necessary. */
3308 /* AIX loader checks the text section alignment of (vma - filepos)
3309 So even though the filepos may be aligned wrt the o_algntext, for
3310 AIX executables, this check fails. This shows up when a native
3311 AIX executable is stripped with gnu strip because the default vma
3312 of native is 0x10000150 but default for gnu is 0x10000140. Gnu
3313 stripped gnu excutable passes this check because the filepos is
3314 0x0140. This problem also show up with 64 bit shared objects. The
3315 data section must also be aligned. */
3316 if (!strcmp (current
->name
, _TEXT
)
3317 || !strcmp (current
->name
, _DATA
))
3322 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3324 align
= 1 << current
->alignment_power
;
3325 pad
= abs (current
->vma
- sofar
) % align
;
3336 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3339 if (previous
!= NULL
)
3340 previous
->size
+= sofar
- old_sofar
;
3345 /* In demand paged files the low order bits of the file offset
3346 must match the low order bits of the virtual address. */
3347 #ifdef COFF_PAGE_SIZE
3348 if ((abfd
->flags
& D_PAGED
) != 0
3349 && (current
->flags
& SEC_ALLOC
) != 0)
3350 sofar
+= (current
->vma
- (bfd_vma
) sofar
) % page_size
;
3352 current
->filepos
= sofar
;
3354 #ifdef COFF_IMAGE_WITH_PE
3355 /* Set the padded size. */
3356 current
->size
= (current
->size
+ page_size
-1) & -page_size
;
3359 sofar
+= current
->size
;
3361 #ifdef ALIGN_SECTIONS_IN_FILE
3362 /* Make sure that this section is of the right size too. */
3363 if ((abfd
->flags
& EXEC_P
) == 0)
3365 bfd_size_type old_size
;
3367 old_size
= current
->size
;
3368 current
->size
= BFD_ALIGN (current
->size
,
3369 1 << current
->alignment_power
);
3370 align_adjust
= current
->size
!= old_size
;
3371 sofar
+= current
->size
- old_size
;
3376 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3377 align_adjust
= sofar
!= old_sofar
;
3378 current
->size
+= sofar
- old_sofar
;
3382 #ifdef COFF_IMAGE_WITH_PE
3383 /* For PE we need to make sure we pad out to the aligned
3384 size, in case the caller only writes out data to the
3386 if (pei_section_data (abfd
, current
)->virt_size
< current
->size
)
3387 align_adjust
= TRUE
;
3391 /* Force .lib sections to start at zero. The vma is then
3392 incremented in coff_set_section_contents. This is right for
3394 if (strcmp (current
->name
, _LIB
) == 0)
3395 bfd_set_section_vma (abfd
, current
, 0);
3401 /* It is now safe to write to the output file. If we needed an
3402 alignment adjustment for the last section, then make sure that
3403 there is a byte at offset sofar. If there are no symbols and no
3404 relocs, then nothing follows the last section. If we don't force
3405 the last byte out, then the file may appear to be truncated. */
3411 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
3412 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3416 /* Make sure the relocations are aligned. We don't need to make
3417 sure that this byte exists, because it will only matter if there
3418 really are relocs. */
3419 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
3421 obj_relocbase (abfd
) = sofar
;
3422 abfd
->output_has_begun
= TRUE
;
3427 #ifdef COFF_IMAGE_WITH_PE
3429 static unsigned int pelength
;
3430 static unsigned int peheader
;
3433 coff_read_word (bfd
*abfd
, unsigned int *value
)
3438 status
= bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3446 *value
= (unsigned int) b
[0];
3448 *value
= (unsigned int) (b
[0] + (b
[1] << 8));
3450 pelength
+= (unsigned int) status
;
3456 coff_compute_checksum (bfd
*abfd
)
3458 bfd_boolean more_data
;
3465 filepos
= (file_ptr
) 0;
3469 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
3472 more_data
= coff_read_word (abfd
, &value
);
3474 total
= 0xffff & (total
+ (total
>> 0x10));
3479 return (0xffff & (total
+ (total
>> 0x10)));
3483 coff_apply_checksum (bfd
*abfd
)
3485 unsigned int computed
;
3486 unsigned int checksum
= 0;
3488 if (bfd_seek (abfd
, 0x3c, SEEK_SET
) != 0)
3491 if (!coff_read_word (abfd
, &peheader
))
3494 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3498 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3500 if (bfd_seek (abfd
, peheader
, SEEK_SET
) != 0)
3503 computed
= coff_compute_checksum (abfd
);
3505 checksum
= computed
+ pelength
;
3507 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3510 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3515 #endif /* COFF_IMAGE_WITH_PE */
3518 coff_write_object_contents (bfd
* abfd
)
3521 bfd_boolean hasrelocs
= FALSE
;
3522 bfd_boolean haslinno
= FALSE
;
3523 bfd_boolean hasdebug
= FALSE
;
3525 file_ptr reloc_base
;
3526 file_ptr lineno_base
;
3528 unsigned long reloc_size
= 0, reloc_count
= 0;
3529 unsigned long lnno_size
= 0;
3530 bfd_boolean long_section_names
;
3531 asection
*text_sec
= NULL
;
3532 asection
*data_sec
= NULL
;
3533 asection
*bss_sec
= NULL
;
3534 struct internal_filehdr internal_f
;
3535 struct internal_aouthdr internal_a
;
3536 #ifdef COFF_LONG_SECTION_NAMES
3537 size_t string_size
= STRING_SIZE_SIZE
;
3540 bfd_set_error (bfd_error_system_call
);
3542 /* Make a pass through the symbol table to count line number entries and
3543 put them into the correct asections. */
3544 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3546 if (! abfd
->output_has_begun
)
3548 if (! coff_compute_section_file_positions (abfd
))
3552 reloc_base
= obj_relocbase (abfd
);
3554 /* Work out the size of the reloc and linno areas. */
3556 for (current
= abfd
->sections
; current
!= NULL
; current
=
3560 /* We store the actual reloc count in the first reloc's addr. */
3561 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3564 reloc_count
+= current
->reloc_count
;
3567 reloc_size
= reloc_count
* bfd_coff_relsz (abfd
);
3569 lineno_base
= reloc_base
+ reloc_size
;
3570 sym_base
= lineno_base
+ lnno_size
;
3572 /* Indicate in each section->line_filepos its actual file address. */
3573 for (current
= abfd
->sections
; current
!= NULL
; current
=
3576 if (current
->lineno_count
)
3578 current
->line_filepos
= lineno_base
;
3579 current
->moving_line_filepos
= lineno_base
;
3580 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3583 current
->line_filepos
= 0;
3585 if (current
->reloc_count
)
3587 current
->rel_filepos
= reloc_base
;
3588 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3590 /* Extra reloc to hold real count. */
3591 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3592 reloc_base
+= bfd_coff_relsz (abfd
);
3596 current
->rel_filepos
= 0;
3599 /* Write section headers to the file. */
3600 internal_f
.f_nscns
= 0;
3602 if ((abfd
->flags
& EXEC_P
) != 0)
3603 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3606 scn_base
= bfd_coff_filhsz (abfd
);
3609 if (xcoff_data (abfd
)->full_aouthdr
)
3610 scn_base
+= bfd_coff_aoutsz (abfd
);
3612 scn_base
+= SMALL_AOUTSZ
;
3617 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3620 long_section_names
= FALSE
;
3621 for (current
= abfd
->sections
;
3623 current
= current
->next
)
3625 struct internal_scnhdr section
;
3626 bfd_boolean is_reloc_section
= FALSE
;
3628 #ifdef COFF_IMAGE_WITH_PE
3629 if (strcmp (current
->name
, DOT_RELOC
) == 0)
3631 is_reloc_section
= TRUE
;
3633 pe_data (abfd
)->has_reloc_section
= 1;
3637 internal_f
.f_nscns
++;
3639 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3641 #ifdef COFF_LONG_SECTION_NAMES
3642 /* Handle long section names as in PE. This must be compatible
3643 with the code in coff_write_symbols and _bfd_coff_final_link. */
3644 if (bfd_coff_long_section_names (abfd
))
3648 len
= strlen (current
->name
);
3651 /* The s_name field is defined to be NUL-padded but need not be
3652 NUL-terminated. We use a temporary buffer so that we can still
3653 sprintf all eight chars without splatting a terminating NUL
3654 over the first byte of the following member (s_paddr). */
3655 char s_name_buf
[SCNNMLEN
+ 1];
3657 /* An inherent limitation of the /nnnnnnn notation used to indicate
3658 the offset of the long name in the string table is that we
3659 cannot address entries beyone the ten million byte boundary. */
3660 if (string_size
>= 10000000)
3662 bfd_set_error (bfd_error_file_too_big
);
3663 (*_bfd_error_handler
)
3664 (_("%B: section %s: string table overflow at offset %ld"),
3665 abfd
, current
->name
, string_size
);
3669 /* snprintf not strictly necessary now we've verified the value
3670 has less than eight ASCII digits, but never mind. */
3671 snprintf (s_name_buf
, SCNNMLEN
+ 1, "/%lu", (unsigned long) string_size
);
3672 /* Then strncpy takes care of any padding for us. */
3673 strncpy (section
.s_name
, s_name_buf
, SCNNMLEN
);
3674 string_size
+= len
+ 1;
3675 long_section_names
= TRUE
;
3681 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3682 Ian Taylor <ian@cygnus.com>. */
3683 if (strcmp (current
->name
, _LIB
) == 0)
3684 section
.s_vaddr
= 0;
3687 section
.s_vaddr
= current
->vma
;
3688 section
.s_paddr
= current
->lma
;
3689 section
.s_size
= current
->size
;
3690 #ifdef coff_get_section_load_page
3691 section
.s_page
= coff_get_section_load_page (current
);
3697 section
.s_paddr
= 0;
3699 #ifdef COFF_IMAGE_WITH_PE
3700 /* Reminder: s_paddr holds the virtual size of the section. */
3701 if (coff_section_data (abfd
, current
) != NULL
3702 && pei_section_data (abfd
, current
) != NULL
)
3703 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3705 section
.s_paddr
= 0;
3708 /* If this section has no size or is unloadable then the scnptr
3710 if (current
->size
== 0
3711 || (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3712 section
.s_scnptr
= 0;
3714 section
.s_scnptr
= current
->filepos
;
3716 section
.s_relptr
= current
->rel_filepos
;
3717 section
.s_lnnoptr
= current
->line_filepos
;
3718 section
.s_nreloc
= current
->reloc_count
;
3719 section
.s_nlnno
= current
->lineno_count
;
3720 #ifndef COFF_IMAGE_WITH_PE
3721 /* In PEI, relocs come in the .reloc section. */
3722 if (current
->reloc_count
!= 0)
3725 if (current
->lineno_count
!= 0)
3727 if ((current
->flags
& SEC_DEBUGGING
) != 0
3728 && ! is_reloc_section
)
3733 /* Indicate the use of an XCOFF overflow section header. */
3734 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3736 section
.s_nreloc
= 0xffff;
3737 section
.s_nlnno
= 0xffff;
3742 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3744 if (!strcmp (current
->name
, _TEXT
))
3746 else if (!strcmp (current
->name
, _DATA
))
3748 else if (!strcmp (current
->name
, _BSS
))
3752 section
.s_align
= (current
->alignment_power
3753 ? 1 << current
->alignment_power
3757 /* TI COFF puts the alignment power in bits 8-11 of the flags. */
3758 section
.s_flags
|= (current
->alignment_power
& 0xF) << 8;
3760 #ifdef COFF_ENCODE_ALIGNMENT
3761 COFF_ENCODE_ALIGNMENT(section
, current
->alignment_power
);
3764 #ifdef COFF_IMAGE_WITH_PE
3765 /* Suppress output of the sections if they are null. ld
3766 includes the bss and data sections even if there is no size
3767 assigned to them. NT loader doesn't like it if these section
3768 headers are included if the sections themselves are not
3769 needed. See also coff_compute_section_file_positions. */
3770 if (section
.s_size
== 0)
3771 internal_f
.f_nscns
--;
3776 bfd_size_type amt
= bfd_coff_scnhsz (abfd
);
3778 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3779 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3784 /* PE stores COMDAT section information in the symbol table. If
3785 this section is supposed to have some COMDAT info, track down
3786 the symbol in the symbol table and modify it. */
3787 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3789 unsigned int i
, count
;
3791 coff_symbol_type
*csym
= NULL
;
3795 count
= bfd_get_symcount (abfd
);
3796 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3798 if ((*psym
)->section
!= current
)
3801 /* Remember the location of the first symbol in this
3803 if (psymsec
== NULL
)
3806 /* See if this is the section symbol. */
3807 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3809 csym
= coff_symbol_from (abfd
, *psym
);
3811 || csym
->native
== NULL
3812 || csym
->native
->u
.syment
.n_numaux
< 1
3813 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3814 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3817 /* Here *PSYM is the section symbol for CURRENT. */
3824 Note that we might not if we're converting the file from
3825 some other object file format. */
3828 combined_entry_type
*aux
;
3830 /* We don't touch the x_checksum field. The
3831 x_associated field is not currently supported. */
3833 aux
= csym
->native
+ 1;
3834 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3836 case SEC_LINK_DUPLICATES_DISCARD
:
3837 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3840 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3841 aux
->u
.auxent
.x_scn
.x_comdat
=
3842 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3845 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3846 aux
->u
.auxent
.x_scn
.x_comdat
=
3847 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3850 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3851 aux
->u
.auxent
.x_scn
.x_comdat
=
3852 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3856 /* The COMDAT symbol must be the first symbol from this
3857 section in the symbol table. In order to make this
3858 work, we move the COMDAT symbol before the first
3859 symbol we found in the search above. It's OK to
3860 rearrange the symbol table at this point, because
3861 coff_renumber_symbols is going to rearrange it
3862 further and fix up all the aux entries. */
3863 if (psym
!= psymsec
)
3869 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3870 pcopy
[0] = pcopy
[-1];
3875 #endif /* COFF_WITH_PE */
3880 /* XCOFF handles overflows in the reloc and line number count fields
3881 by creating a new section header to hold the correct values. */
3882 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3884 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3886 struct internal_scnhdr scnhdr
;
3890 internal_f
.f_nscns
++;
3891 strncpy (&(scnhdr
.s_name
[0]), current
->name
, 8);
3892 scnhdr
.s_paddr
= current
->reloc_count
;
3893 scnhdr
.s_vaddr
= current
->lineno_count
;
3895 scnhdr
.s_scnptr
= 0;
3896 scnhdr
.s_relptr
= current
->rel_filepos
;
3897 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3898 scnhdr
.s_nreloc
= current
->target_index
;
3899 scnhdr
.s_nlnno
= current
->target_index
;
3900 scnhdr
.s_flags
= STYP_OVRFLO
;
3901 amt
= bfd_coff_scnhsz (abfd
);
3902 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3903 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3910 /* OK, now set up the filehdr... */
3912 /* Don't include the internal abs section in the section count */
3914 /* We will NOT put a fucking timestamp in the header here. Every time you
3915 put it back, I will come in and take it out again. I'm sorry. This
3916 field does not belong here. We fill it with a 0 so it compares the
3917 same but is not a reasonable time. -- gnu@cygnus.com */
3918 internal_f
.f_timdat
= 0;
3919 internal_f
.f_flags
= 0;
3921 if (abfd
->flags
& EXEC_P
)
3922 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3925 internal_f
.f_opthdr
= 0;
3928 if (xcoff_data (abfd
)->full_aouthdr
)
3929 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3931 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
3937 internal_f
.f_flags
|= F_RELFLG
;
3939 internal_f
.f_flags
|= F_LNNO
;
3940 if (abfd
->flags
& EXEC_P
)
3941 internal_f
.f_flags
|= F_EXEC
;
3942 #ifdef COFF_IMAGE_WITH_PE
3944 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
3945 if (pe_data (abfd
)->real_flags
& IMAGE_FILE_LARGE_ADDRESS_AWARE
)
3946 internal_f
.f_flags
|= IMAGE_FILE_LARGE_ADDRESS_AWARE
;
3949 #ifndef COFF_WITH_pex64
3951 internal_f
.f_flags
|= IMAGE_FILE_32BIT_MACHINE
;
3953 if (bfd_little_endian (abfd
))
3954 internal_f
.f_flags
|= F_AR32WR
;
3956 internal_f
.f_flags
|= F_AR32W
;
3961 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
3962 but it doesn't hurt to set it internally. */
3963 internal_f
.f_target_id
= TI_TARGET_ID
;
3965 #ifdef TIC80_TARGET_ID
3966 internal_f
.f_target_id
= TIC80_TARGET_ID
;
3969 /* FIXME, should do something about the other byte orders and
3973 if ((abfd
->flags
& DYNAMIC
) != 0)
3974 internal_f
.f_flags
|= F_SHROBJ
;
3975 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
3976 internal_f
.f_flags
|= F_DYNLOAD
;
3979 memset (&internal_a
, 0, sizeof internal_a
);
3981 /* Set up architecture-dependent stuff. */
3983 unsigned int magic
= 0;
3984 unsigned short flags
= 0;
3986 coff_set_flags (abfd
, &magic
, &flags
);
3987 internal_f
.f_magic
= magic
;
3988 internal_f
.f_flags
|= flags
;
3989 /* ...and the "opt"hdr... */
3991 #ifdef TICOFF_AOUT_MAGIC
3992 internal_a
.magic
= TICOFF_AOUT_MAGIC
;
3993 #define __A_MAGIC_SET__
3996 internal_a
.magic
= TIC80_ARCH_MAGIC
;
3997 #define __A_MAGIC_SET__
4000 /* FIXME: What are the a.out magic numbers for the i860? */
4001 internal_a
.magic
= 0;
4002 #define __A_MAGIC_SET__
4005 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
4006 #define __A_MAGIC_SET__
4009 #define __A_MAGIC_SET__
4010 internal_a
.magic
= PAGEMAGICBCS
;
4014 #define __A_MAGIC_SET__
4015 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
4018 #if defined(M68) || defined(WE32K) || defined(M68K)
4019 #define __A_MAGIC_SET__
4021 internal_a
.magic
= LYNXCOFFMAGIC
;
4023 #if defined(TARG_AUX)
4024 internal_a
.magic
= (abfd
->flags
& D_PAGED
? PAGEMAGICPEXECPAGED
:
4025 abfd
->flags
& WP_TEXT
? PAGEMAGICPEXECSWAPPED
:
4026 PAGEMAGICEXECSWAPPED
);
4028 #if defined (PAGEMAGICPEXECPAGED)
4029 internal_a
.magic
= PAGEMAGICPEXECPAGED
;
4031 #endif /* TARG_AUX */
4033 #endif /* M68 || WE32K || M68K */
4036 #define __A_MAGIC_SET__
4037 internal_a
.magic
= ZMAGIC
;
4041 #define __A_MAGIC_SET__
4042 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
4045 #if defined MCORE_PE
4046 #define __A_MAGIC_SET__
4047 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
4051 #define __A_MAGIC_SET__
4053 internal_a
.magic
= LYNXCOFFMAGIC
;
4055 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR64_MAGIC
;
4057 internal_a
.magic
= ZMAGIC
;
4062 #define __A_MAGIC_SET__
4063 internal_a
.magic
= PE32PMAGIC
;
4067 #define __A_MAGIC_SET__
4069 internal_a
.magic
= LYNXCOFFMAGIC
;
4074 #define __A_MAGIC_SET__
4075 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
4076 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
4077 RS6K_AOUTHDR_OMAGIC
;
4080 #if defined(SH) && defined(COFF_WITH_PE)
4081 #define __A_MAGIC_SET__
4082 internal_a
.magic
= SH_PE_MAGIC
;
4085 #if defined(MIPS) && defined(COFF_WITH_PE)
4086 #define __A_MAGIC_SET__
4087 internal_a
.magic
= MIPS_PE_MAGIC
;
4091 #define __A_MAGIC_SET__
4092 internal_a
.magic
= NMAGIC
; /* Assume separate i/d. */
4096 #define __A_MAGIC_SET__
4097 internal_a
.magic
= MAXQ20MAGIC
;
4100 #ifndef __A_MAGIC_SET__
4101 #include "Your aouthdr magic number is not being set!"
4103 #undef __A_MAGIC_SET__
4107 /* FIXME: Does anybody ever set this to another value? */
4108 internal_a
.vstamp
= 0;
4110 /* Now should write relocs, strings, syms. */
4111 obj_sym_filepos (abfd
) = sym_base
;
4113 if (bfd_get_symcount (abfd
) != 0)
4117 if (!coff_renumber_symbols (abfd
, &firstundef
))
4119 coff_mangle_symbols (abfd
);
4120 if (! coff_write_symbols (abfd
))
4122 if (! coff_write_linenumbers (abfd
))
4124 if (! coff_write_relocs (abfd
, firstundef
))
4127 #ifdef COFF_LONG_SECTION_NAMES
4128 else if (long_section_names
&& ! obj_coff_strings_written (abfd
))
4130 /* If we have long section names we have to write out the string
4131 table even if there are no symbols. */
4132 if (! coff_write_symbols (abfd
))
4136 #ifdef COFF_IMAGE_WITH_PE
4138 else if ((abfd
->flags
& EXEC_P
) != 0)
4142 /* PowerPC PE appears to require that all executable files be
4143 rounded up to the page size. */
4146 (file_ptr
) BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
4148 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
4154 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
4155 backend linker, and obj_raw_syment_count is not valid until after
4156 coff_write_symbols is called. */
4157 if (obj_raw_syment_count (abfd
) != 0)
4159 internal_f
.f_symptr
= sym_base
;
4161 /* AIX appears to require that F_RELFLG not be set if there are
4162 local symbols but no relocations. */
4163 internal_f
.f_flags
&=~ F_RELFLG
;
4168 if (long_section_names
)
4169 internal_f
.f_symptr
= sym_base
;
4171 internal_f
.f_symptr
= 0;
4172 internal_f
.f_flags
|= F_LSYMS
;
4177 internal_a
.tsize
= text_sec
->size
;
4178 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
4182 internal_a
.dsize
= data_sec
->size
;
4183 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
4187 internal_a
.bsize
= bss_sec
->size
;
4188 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
4189 internal_a
.data_start
= bss_sec
->vma
;
4192 internal_a
.entry
= bfd_get_start_address (abfd
);
4193 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
4196 if (xcoff_data (abfd
)->full_aouthdr
)
4199 asection
*loader_sec
;
4201 internal_a
.vstamp
= 1;
4203 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
4204 if (internal_a
.o_snentry
== 0)
4205 internal_a
.entry
= (bfd_vma
) -1;
4207 if (text_sec
!= NULL
)
4209 internal_a
.o_sntext
= text_sec
->target_index
;
4210 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
4214 internal_a
.o_sntext
= 0;
4215 internal_a
.o_algntext
= 0;
4217 if (data_sec
!= NULL
)
4219 internal_a
.o_sndata
= data_sec
->target_index
;
4220 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
4224 internal_a
.o_sndata
= 0;
4225 internal_a
.o_algndata
= 0;
4227 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
4228 if (loader_sec
!= NULL
)
4229 internal_a
.o_snloader
= loader_sec
->target_index
;
4231 internal_a
.o_snloader
= 0;
4232 if (bss_sec
!= NULL
)
4233 internal_a
.o_snbss
= bss_sec
->target_index
;
4235 internal_a
.o_snbss
= 0;
4237 toc
= xcoff_data (abfd
)->toc
;
4238 internal_a
.o_toc
= toc
;
4239 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
4241 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
4242 if (xcoff_data (abfd
)->cputype
!= -1)
4243 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
4246 switch (bfd_get_arch (abfd
))
4248 case bfd_arch_rs6000
:
4249 internal_a
.o_cputype
= 4;
4251 case bfd_arch_powerpc
:
4252 if (bfd_get_mach (abfd
) == bfd_mach_ppc
)
4253 internal_a
.o_cputype
= 3;
4255 internal_a
.o_cputype
= 1;
4261 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
4262 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
4266 /* Now write them. */
4267 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
4272 bfd_size_type amount
= bfd_coff_filhsz (abfd
);
4274 buff
= bfd_malloc (amount
);
4278 bfd_coff_swap_filehdr_out (abfd
, & internal_f
, buff
);
4279 amount
= bfd_bwrite (buff
, amount
, abfd
);
4283 if (amount
!= bfd_coff_filhsz (abfd
))
4287 if (abfd
->flags
& EXEC_P
)
4289 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4290 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4292 bfd_size_type amount
= bfd_coff_aoutsz (abfd
);
4294 buff
= bfd_malloc (amount
);
4298 coff_swap_aouthdr_out (abfd
, & internal_a
, buff
);
4299 amount
= bfd_bwrite (buff
, amount
, abfd
);
4303 if (amount
!= bfd_coff_aoutsz (abfd
))
4306 #ifdef COFF_IMAGE_WITH_PE
4307 if (! coff_apply_checksum (abfd
))
4317 /* XCOFF seems to always write at least a small a.out header. */
4318 coff_swap_aouthdr_out (abfd
, & internal_a
, & buff
);
4319 if (xcoff_data (abfd
)->full_aouthdr
)
4320 size
= bfd_coff_aoutsz (abfd
);
4322 size
= SMALL_AOUTSZ
;
4323 if (bfd_bwrite (& buff
, (bfd_size_type
) size
, abfd
) != size
)
4332 coff_set_section_contents (bfd
* abfd
,
4334 const void * location
,
4336 bfd_size_type count
)
4338 if (! abfd
->output_has_begun
) /* Set by bfd.c handler. */
4340 if (! coff_compute_section_file_positions (abfd
))
4344 #if defined(_LIB) && !defined(TARG_AUX)
4345 /* The physical address field of a .lib section is used to hold the
4346 number of shared libraries in the section. This code counts the
4347 number of sections being written, and increments the lma field
4350 I have found no documentation on the contents of this section.
4351 Experimentation indicates that the section contains zero or more
4352 records, each of which has the following structure:
4354 - a (four byte) word holding the length of this record, in words,
4355 - a word that always seems to be set to "2",
4356 - the path to a shared library, null-terminated and then padded
4357 to a whole word boundary.
4359 bfd_assert calls have been added to alert if an attempt is made
4360 to write a section which doesn't follow these assumptions. The
4361 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4362 <robertl@arnet.com> (Thanks!).
4364 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4365 if (strcmp (section
->name
, _LIB
) == 0)
4367 bfd_byte
*rec
, *recend
;
4369 rec
= (bfd_byte
*) location
;
4370 recend
= rec
+ count
;
4371 while (rec
< recend
)
4374 rec
+= bfd_get_32 (abfd
, rec
) * 4;
4377 BFD_ASSERT (rec
== recend
);
4381 /* Don't write out bss sections - one way to do this is to
4382 see if the filepos has not been set. */
4383 if (section
->filepos
== 0)
4386 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0)
4392 return bfd_bwrite (location
, count
, abfd
) == count
;
4396 buy_and_read (bfd
*abfd
, file_ptr where
, bfd_size_type size
)
4398 void * area
= bfd_alloc (abfd
, size
);
4402 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0
4403 || bfd_bread (area
, size
, abfd
) != size
)
4412 Creating the linenumber table is done by reading in the entire
4413 coff linenumber table, and creating another table for internal use.
4415 A coff linenumber table is structured so that each function
4416 is marked as having a line number of 0. Each line within the
4417 function is an offset from the first line in the function. The
4418 base of the line number information for the table is stored in
4419 the symbol associated with the function.
4421 Note: The PE format uses line number 0 for a flag indicating a
4424 The information is copied from the external to the internal
4425 table, and each symbol which marks a function is marked by
4428 How does this work ?
4432 coff_sort_func_alent (const void * arg1
, const void * arg2
)
4434 const alent
*al1
= *(const alent
**) arg1
;
4435 const alent
*al2
= *(const alent
**) arg2
;
4436 const coff_symbol_type
*s1
= (const coff_symbol_type
*) (al1
->u
.sym
);
4437 const coff_symbol_type
*s2
= (const coff_symbol_type
*) (al2
->u
.sym
);
4439 if (s1
->symbol
.value
< s2
->symbol
.value
)
4441 else if (s1
->symbol
.value
> s2
->symbol
.value
)
4448 coff_slurp_line_table (bfd
*abfd
, asection
*asect
)
4450 LINENO
*native_lineno
;
4451 alent
*lineno_cache
;
4453 unsigned int counter
;
4455 bfd_vma prev_offset
= 0;
4457 unsigned int nbr_func
;
4460 BFD_ASSERT (asect
->lineno
== NULL
);
4462 amt
= ((bfd_size_type
) asect
->lineno_count
+ 1) * sizeof (alent
);
4463 lineno_cache
= bfd_alloc (abfd
, amt
);
4464 if (lineno_cache
== NULL
)
4467 amt
= (bfd_size_type
) bfd_coff_linesz (abfd
) * asect
->lineno_count
;
4468 native_lineno
= (LINENO
*) buy_and_read (abfd
, asect
->line_filepos
, amt
);
4469 if (native_lineno
== NULL
)
4471 (*_bfd_error_handler
)
4472 (_("%B: warning: line number table read failed"), abfd
);
4473 bfd_release (abfd
, lineno_cache
);
4477 cache_ptr
= lineno_cache
;
4478 asect
->lineno
= lineno_cache
;
4479 src
= native_lineno
;
4482 for (counter
= 0; counter
< asect
->lineno_count
; counter
++)
4484 struct internal_lineno dst
;
4486 bfd_coff_swap_lineno_in (abfd
, src
, &dst
);
4487 cache_ptr
->line_number
= dst
.l_lnno
;
4489 if (cache_ptr
->line_number
== 0)
4492 bfd_signed_vma symndx
;
4493 coff_symbol_type
*sym
;
4497 symndx
= dst
.l_addr
.l_symndx
;
4499 || (bfd_vma
) symndx
>= obj_raw_syment_count (abfd
))
4501 (*_bfd_error_handler
)
4502 (_("%B: warning: illegal symbol index %ld in line numbers"),
4503 abfd
, dst
.l_addr
.l_symndx
);
4508 /* FIXME: We should not be casting between ints and
4509 pointers like this. */
4510 sym
= ((coff_symbol_type
*)
4511 ((symndx
+ obj_raw_syments (abfd
))
4512 ->u
.syment
._n
._n_n
._n_zeroes
));
4513 cache_ptr
->u
.sym
= (asymbol
*) sym
;
4514 if (sym
->lineno
!= NULL
&& ! warned
)
4515 (*_bfd_error_handler
)
4516 (_("%B: warning: duplicate line number information for `%s'"),
4517 abfd
, bfd_asymbol_name (&sym
->symbol
));
4519 sym
->lineno
= cache_ptr
;
4520 if (sym
->symbol
.value
< prev_offset
)
4522 prev_offset
= sym
->symbol
.value
;
4525 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
4526 - bfd_section_vma (abfd
, asect
);
4531 cache_ptr
->line_number
= 0;
4532 bfd_release (abfd
, native_lineno
);
4534 /* On some systems (eg AIX5.3) the lineno table may not be sorted. */
4537 /* Sort the table. */
4539 alent
*n_lineno_cache
;
4541 /* Create a table of functions. */
4542 func_table
= bfd_alloc (abfd
, nbr_func
* sizeof (alent
*));
4543 if (func_table
!= NULL
)
4545 alent
**p
= func_table
;
4548 for (i
= 0; i
< counter
; i
++)
4549 if (lineno_cache
[i
].line_number
== 0)
4550 *p
++ = &lineno_cache
[i
];
4552 /* Sort by functions. */
4553 qsort (func_table
, nbr_func
, sizeof (alent
*), coff_sort_func_alent
);
4555 /* Create the new sorted table. */
4556 amt
= ((bfd_size_type
) asect
->lineno_count
+ 1) * sizeof (alent
);
4557 n_lineno_cache
= bfd_alloc (abfd
, amt
);
4558 if (n_lineno_cache
!= NULL
)
4560 alent
*n_cache_ptr
= n_lineno_cache
;
4562 for (i
= 0; i
< nbr_func
; i
++)
4564 coff_symbol_type
*sym
;
4565 alent
*old_ptr
= func_table
[i
];
4567 /* Copy the function entry and update it. */
4568 *n_cache_ptr
= *old_ptr
;
4569 sym
= (coff_symbol_type
*)n_cache_ptr
->u
.sym
;
4570 sym
->lineno
= n_cache_ptr
;
4574 /* Copy the line number entries. */
4575 while (old_ptr
->line_number
!= 0)
4576 *n_cache_ptr
++ = *old_ptr
++;
4578 n_cache_ptr
->line_number
= 0;
4579 memcpy (lineno_cache
, n_lineno_cache
, amt
);
4581 bfd_release (abfd
, func_table
);
4588 /* Slurp in the symbol table, converting it to generic form. Note
4589 that if coff_relocate_section is defined, the linker will read
4590 symbols via coff_link_add_symbols, rather than via this routine. */
4593 coff_slurp_symbol_table (bfd
* abfd
)
4595 combined_entry_type
*native_symbols
;
4596 coff_symbol_type
*cached_area
;
4597 unsigned int *table_ptr
;
4599 unsigned int number_of_symbols
= 0;
4601 if (obj_symbols (abfd
))
4604 /* Read in the symbol table. */
4605 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4608 /* Allocate enough room for all the symbols in cached form. */
4609 amt
= obj_raw_syment_count (abfd
);
4610 amt
*= sizeof (coff_symbol_type
);
4611 cached_area
= bfd_alloc (abfd
, amt
);
4612 if (cached_area
== NULL
)
4615 amt
= obj_raw_syment_count (abfd
);
4616 amt
*= sizeof (unsigned int);
4617 table_ptr
= bfd_alloc (abfd
, amt
);
4619 if (table_ptr
== NULL
)
4623 coff_symbol_type
*dst
= cached_area
;
4624 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4625 unsigned int this_index
= 0;
4627 while (this_index
< last_native_index
)
4629 combined_entry_type
*src
= native_symbols
+ this_index
;
4630 table_ptr
[this_index
] = number_of_symbols
;
4631 dst
->symbol
.the_bfd
= abfd
;
4633 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4634 /* We use the native name field to point to the cached field. */
4635 src
->u
.syment
._n
._n_n
._n_zeroes
= (bfd_hostptr_t
) dst
;
4636 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4637 src
->u
.syment
.n_scnum
);
4638 dst
->symbol
.flags
= 0;
4639 dst
->done_lineno
= FALSE
;
4641 switch (src
->u
.syment
.n_sclass
)
4645 /* Fall through to next case. */
4652 case C_THUMBEXTFUNC
:
4658 case C_SYSTEM
: /* System Wide variable. */
4661 /* In PE, 0x68 (104) denotes a section symbol. */
4663 /* In PE, 0x69 (105) denotes a weak external symbol. */
4666 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4668 case COFF_SYMBOL_GLOBAL
:
4669 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4670 #if defined COFF_WITH_PE
4671 /* PE sets the symbol to a value relative to the
4672 start of the section. */
4673 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4675 dst
->symbol
.value
= (src
->u
.syment
.n_value
4676 - dst
->symbol
.section
->vma
);
4678 if (ISFCN ((src
->u
.syment
.n_type
)))
4679 /* A function ext does not go at the end of a
4681 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4684 case COFF_SYMBOL_COMMON
:
4685 dst
->symbol
.section
= bfd_com_section_ptr
;
4686 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4689 case COFF_SYMBOL_UNDEFINED
:
4690 dst
->symbol
.section
= bfd_und_section_ptr
;
4691 dst
->symbol
.value
= 0;
4694 case COFF_SYMBOL_PE_SECTION
:
4695 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4696 dst
->symbol
.value
= 0;
4699 case COFF_SYMBOL_LOCAL
:
4700 dst
->symbol
.flags
= BSF_LOCAL
;
4701 #if defined COFF_WITH_PE
4702 /* PE sets the symbol to a value relative to the
4703 start of the section. */
4704 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4706 dst
->symbol
.value
= (src
->u
.syment
.n_value
4707 - dst
->symbol
.section
->vma
);
4709 if (ISFCN ((src
->u
.syment
.n_type
)))
4710 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4715 /* A symbol with a csect entry should not go at the end. */
4716 if (src
->u
.syment
.n_numaux
> 0)
4717 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4721 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4722 dst
->symbol
.flags
|= BSF_WEAK
;
4724 if (src
->u
.syment
.n_sclass
== C_SECTION
4725 && src
->u
.syment
.n_scnum
> 0)
4726 dst
->symbol
.flags
= BSF_LOCAL
;
4728 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
)
4729 dst
->symbol
.flags
|= BSF_WEAK
;
4733 case C_STAT
: /* Static. */
4735 case C_LEAFSTAT
: /* Static leaf procedure. */
4738 case C_THUMBSTAT
: /* Thumb static. */
4739 case C_THUMBLABEL
: /* Thumb label. */
4740 case C_THUMBSTATFUNC
:/* Thumb static function. */
4742 case C_LABEL
: /* Label. */
4743 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4744 dst
->symbol
.flags
= BSF_DEBUGGING
;
4746 dst
->symbol
.flags
= BSF_LOCAL
;
4748 /* Base the value as an index from the base of the
4749 section, if there is one. */
4750 if (dst
->symbol
.section
)
4752 #if defined COFF_WITH_PE
4753 /* PE sets the symbol to a value relative to the
4754 start of the section. */
4755 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4757 dst
->symbol
.value
= (src
->u
.syment
.n_value
4758 - dst
->symbol
.section
->vma
);
4762 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4765 case C_MOS
: /* Member of structure. */
4766 case C_EOS
: /* End of structure. */
4767 case C_REGPARM
: /* Register parameter. */
4768 case C_REG
: /* register variable. */
4769 /* C_AUTOARG conflicts with TI COFF C_UEXT. */
4770 #if !defined (TIC80COFF) && !defined (TICOFF)
4772 case C_AUTOARG
: /* 960-specific storage class. */
4775 case C_TPDEF
: /* Type definition. */
4777 case C_AUTO
: /* Automatic variable. */
4778 case C_FIELD
: /* Bit field. */
4779 case C_ENTAG
: /* Enumeration tag. */
4780 case C_MOE
: /* Member of enumeration. */
4781 case C_MOU
: /* Member of union. */
4782 case C_UNTAG
: /* Union tag. */
4783 dst
->symbol
.flags
= BSF_DEBUGGING
;
4784 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4787 case C_FILE
: /* File name. */
4788 case C_STRTAG
: /* Structure tag. */
4805 dst
->symbol
.flags
= BSF_DEBUGGING
;
4806 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4810 case C_BINCL
: /* Beginning of include file. */
4811 case C_EINCL
: /* Ending of include file. */
4812 /* The value is actually a pointer into the line numbers
4813 of the file. We locate the line number entry, and
4814 set the section to the section which contains it, and
4815 the value to the index in that section. */
4819 dst
->symbol
.flags
= BSF_DEBUGGING
;
4820 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4821 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4822 && ((file_ptr
) (sec
->line_filepos
4823 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4824 > (file_ptr
) src
->u
.syment
.n_value
))
4827 dst
->symbol
.value
= 0;
4830 dst
->symbol
.section
= sec
;
4831 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4832 - sec
->line_filepos
)
4833 / bfd_coff_linesz (abfd
));
4840 dst
->symbol
.flags
= BSF_DEBUGGING
;
4842 /* The value is actually a symbol index. Save a pointer
4843 to the symbol instead of the index. FIXME: This
4844 should use a union. */
4845 src
->u
.syment
.n_value
=
4846 (long) (native_symbols
+ src
->u
.syment
.n_value
);
4847 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4852 case C_BLOCK
: /* ".bb" or ".eb". */
4853 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf"). */
4854 case C_EFCN
: /* Physical end of function. */
4855 #if defined COFF_WITH_PE
4856 /* PE sets the symbol to a value relative to the start
4858 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4859 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4861 /* PE uses funny values for .ef and .lf; don't
4863 dst
->symbol
.flags
= BSF_DEBUGGING
;
4866 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4868 /* Base the value as an index from the base of the
4870 dst
->symbol
.flags
= BSF_LOCAL
;
4871 dst
->symbol
.value
= (src
->u
.syment
.n_value
4872 - dst
->symbol
.section
->vma
);
4876 case C_STATLAB
: /* Static load time label. */
4877 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4878 dst
->symbol
.flags
= BSF_GLOBAL
;
4882 /* PE DLLs sometimes have zeroed out symbols for some
4883 reason. Just ignore them without a warning. */
4884 if (src
->u
.syment
.n_type
== 0
4885 && src
->u
.syment
.n_value
== 0
4886 && src
->u
.syment
.n_scnum
== 0)
4889 case C_EXTDEF
: /* External definition. */
4890 case C_ULABEL
: /* Undefined label. */
4891 case C_USTATIC
: /* Undefined static. */
4892 #ifndef COFF_WITH_PE
4893 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4894 class to represent a section symbol. */
4895 case C_LINE
: /* line # reformatted as symbol table entry. */
4896 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4897 case C_ALIAS
: /* Duplicate tag. */
4899 /* New storage classes for TI COFF. */
4900 #if defined(TIC80COFF) || defined(TICOFF)
4901 case C_UEXT
: /* Tentative external definition. */
4903 case C_EXTLAB
: /* External load time label. */
4904 case C_HIDDEN
: /* Ext symbol in dmert public lib. */
4906 (*_bfd_error_handler
)
4907 (_("%B: Unrecognized storage class %d for %s symbol `%s'"),
4908 abfd
, src
->u
.syment
.n_sclass
,
4909 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4910 dst
->symbol
.flags
= BSF_DEBUGGING
;
4911 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4917 dst
->symbol
.udata
.i
= 0;
4919 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
4921 number_of_symbols
++;
4925 obj_symbols (abfd
) = cached_area
;
4926 obj_raw_syments (abfd
) = native_symbols
;
4928 bfd_get_symcount (abfd
) = number_of_symbols
;
4929 obj_convert (abfd
) = table_ptr
;
4930 /* Slurp the line tables for each section too. */
4937 coff_slurp_line_table (abfd
, p
);
4945 /* Classify a COFF symbol. A couple of targets have globally visible
4946 symbols which are not class C_EXT, and this handles those. It also
4947 recognizes some special PE cases. */
4949 static enum coff_symbol_classification
4950 coff_classify_symbol (bfd
*abfd
,
4951 struct internal_syment
*syment
)
4953 /* FIXME: This partially duplicates the switch in
4954 coff_slurp_symbol_table. */
4955 switch (syment
->n_sclass
)
4964 case C_THUMBEXTFUNC
:
4972 if (syment
->n_scnum
== 0)
4974 if (syment
->n_value
== 0)
4975 return COFF_SYMBOL_UNDEFINED
;
4977 return COFF_SYMBOL_COMMON
;
4979 return COFF_SYMBOL_GLOBAL
;
4986 if (syment
->n_sclass
== C_STAT
)
4988 if (syment
->n_scnum
== 0)
4989 /* The Microsoft compiler sometimes generates these if a
4990 small static function is inlined every time it is used.
4991 The function is discarded, but the symbol table entry
4993 return COFF_SYMBOL_LOCAL
;
4995 #ifdef STRICT_PE_FORMAT
4996 /* This is correct for Microsoft generated objects, but it
4997 breaks gas generated objects. */
4998 if (syment
->n_value
== 0)
5001 char buf
[SYMNMLEN
+ 1];
5003 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
5005 && (strcmp (bfd_get_section_name (abfd
, sec
),
5006 _bfd_coff_internal_syment_name (abfd
, syment
, buf
))
5008 return COFF_SYMBOL_PE_SECTION
;
5012 return COFF_SYMBOL_LOCAL
;
5015 if (syment
->n_sclass
== C_SECTION
)
5017 /* In some cases in a DLL generated by the Microsoft linker, the
5018 n_value field will contain garbage. FIXME: This should
5019 probably be handled by the swapping function instead. */
5020 syment
->n_value
= 0;
5021 if (syment
->n_scnum
== 0)
5022 return COFF_SYMBOL_UNDEFINED
;
5023 return COFF_SYMBOL_PE_SECTION
;
5025 #endif /* COFF_WITH_PE */
5027 /* If it is not a global symbol, we presume it is a local symbol. */
5028 if (syment
->n_scnum
== 0)
5030 char buf
[SYMNMLEN
+ 1];
5032 (*_bfd_error_handler
)
5033 (_("warning: %B: local symbol `%s' has no section"),
5034 abfd
, _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
5037 return COFF_SYMBOL_LOCAL
;
5044 Coff relocations are easily transformed into the internal BFD form
5047 Reading a coff relocation table is done in the following stages:
5049 o Read the entire coff relocation table into memory.
5051 o Process each relocation in turn; first swap it from the
5052 external to the internal form.
5054 o Turn the symbol referenced in the relocation's symbol index
5055 into a pointer into the canonical symbol table.
5056 This table is the same as the one returned by a call to
5057 @code{bfd_canonicalize_symtab}. The back end will call that
5058 routine and save the result if a canonicalization hasn't been done.
5060 o The reloc index is turned into a pointer to a howto
5061 structure, in a back end specific way. For instance, the 386
5062 and 960 use the @code{r_type} to directly produce an index
5063 into a howto table vector; the 88k subtracts a number from the
5064 @code{r_type} field and creates an addend field.
5068 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
5070 coff_symbol_type *coffsym = NULL; \
5072 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
5073 coffsym = (obj_symbols (abfd) \
5074 + (cache_ptr->sym_ptr_ptr - symbols)); \
5076 coffsym = coff_symbol_from (abfd, ptr); \
5077 if (coffsym != NULL \
5078 && coffsym->native->u.syment.n_scnum == 0) \
5079 cache_ptr->addend = 0; \
5080 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
5081 && ptr->section != NULL) \
5082 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
5084 cache_ptr->addend = 0; \
5089 coff_slurp_reloc_table (bfd
* abfd
, sec_ptr asect
, asymbol
** symbols
)
5091 RELOC
*native_relocs
;
5092 arelent
*reloc_cache
;
5097 if (asect
->relocation
)
5099 if (asect
->reloc_count
== 0)
5101 if (asect
->flags
& SEC_CONSTRUCTOR
)
5103 if (!coff_slurp_symbol_table (abfd
))
5106 amt
= (bfd_size_type
) bfd_coff_relsz (abfd
) * asect
->reloc_count
;
5107 native_relocs
= (RELOC
*) buy_and_read (abfd
, asect
->rel_filepos
, amt
);
5108 amt
= (bfd_size_type
) asect
->reloc_count
* sizeof (arelent
);
5109 reloc_cache
= bfd_alloc (abfd
, amt
);
5111 if (reloc_cache
== NULL
|| native_relocs
== NULL
)
5114 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
5116 struct internal_reloc dst
;
5117 struct external_reloc
*src
;
5118 #ifndef RELOC_PROCESSING
5122 cache_ptr
= reloc_cache
+ idx
;
5123 src
= native_relocs
+ idx
;
5126 coff_swap_reloc_in (abfd
, src
, &dst
);
5128 #ifdef RELOC_PROCESSING
5129 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
5131 cache_ptr
->address
= dst
.r_vaddr
;
5133 if (dst
.r_symndx
!= -1)
5135 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
5137 (*_bfd_error_handler
)
5138 (_("%B: warning: illegal symbol index %ld in relocs"),
5139 abfd
, dst
.r_symndx
);
5140 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5145 cache_ptr
->sym_ptr_ptr
= (symbols
5146 + obj_convert (abfd
)[dst
.r_symndx
]);
5147 ptr
= *(cache_ptr
->sym_ptr_ptr
);
5152 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5156 /* The symbols definitions that we have read in have been
5157 relocated as if their sections started at 0. But the offsets
5158 refering to the symbols in the raw data have not been
5159 modified, so we have to have a negative addend to compensate.
5161 Note that symbols which used to be common must be left alone. */
5163 /* Calculate any reloc addend by looking at the symbol. */
5164 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
5166 cache_ptr
->address
-= asect
->vma
;
5167 /* !! cache_ptr->section = NULL;*/
5169 /* Fill in the cache_ptr->howto field from dst.r_type. */
5170 RTYPE2HOWTO (cache_ptr
, &dst
);
5171 #endif /* RELOC_PROCESSING */
5173 if (cache_ptr
->howto
== NULL
)
5175 (*_bfd_error_handler
)
5176 (_("%B: illegal relocation type %d at address 0x%lx"),
5177 abfd
, dst
.r_type
, (long) dst
.r_vaddr
);
5178 bfd_set_error (bfd_error_bad_value
);
5183 asect
->relocation
= reloc_cache
;
5187 #ifndef coff_rtype_to_howto
5190 /* Get the howto structure for a reloc. This is only used if the file
5191 including this one defines coff_relocate_section to be
5192 _bfd_coff_generic_relocate_section, so it is OK if it does not
5193 always work. It is the responsibility of the including file to
5194 make sure it is reasonable if it is needed. */
5196 static reloc_howto_type
*
5197 coff_rtype_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
5198 asection
*sec ATTRIBUTE_UNUSED
,
5199 struct internal_reloc
*rel
,
5200 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
,
5201 struct internal_syment
*sym ATTRIBUTE_UNUSED
,
5202 bfd_vma
*addendp ATTRIBUTE_UNUSED
)
5206 genrel
.howto
= NULL
;
5207 RTYPE2HOWTO (&genrel
, rel
);
5208 return genrel
.howto
;
5211 #else /* ! defined (RTYPE2HOWTO) */
5213 #define coff_rtype_to_howto NULL
5215 #endif /* ! defined (RTYPE2HOWTO) */
5216 #endif /* ! defined (coff_rtype_to_howto) */
5218 /* This is stupid. This function should be a boolean predicate. */
5221 coff_canonicalize_reloc (bfd
* abfd
,
5226 arelent
*tblptr
= section
->relocation
;
5227 unsigned int count
= 0;
5229 if (section
->flags
& SEC_CONSTRUCTOR
)
5231 /* This section has relocs made up by us, they are not in the
5232 file, so take them out of their chain and place them into
5233 the data area provided. */
5234 arelent_chain
*chain
= section
->constructor_chain
;
5236 for (count
= 0; count
< section
->reloc_count
; count
++)
5238 *relptr
++ = &chain
->relent
;
5239 chain
= chain
->next
;
5244 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
5247 tblptr
= section
->relocation
;
5249 for (; count
++ < section
->reloc_count
;)
5250 *relptr
++ = tblptr
++;
5253 return section
->reloc_count
;
5256 #ifndef coff_reloc16_estimate
5257 #define coff_reloc16_estimate dummy_reloc16_estimate
5260 dummy_reloc16_estimate (bfd
*abfd ATTRIBUTE_UNUSED
,
5261 asection
*input_section ATTRIBUTE_UNUSED
,
5262 arelent
*reloc ATTRIBUTE_UNUSED
,
5263 unsigned int shrink ATTRIBUTE_UNUSED
,
5264 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
)
5272 #ifndef coff_reloc16_extra_cases
5274 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5276 /* This works even if abort is not declared in any header file. */
5279 dummy_reloc16_extra_cases (bfd
*abfd ATTRIBUTE_UNUSED
,
5280 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
5281 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
,
5282 arelent
*reloc ATTRIBUTE_UNUSED
,
5283 bfd_byte
*data ATTRIBUTE_UNUSED
,
5284 unsigned int *src_ptr ATTRIBUTE_UNUSED
,
5285 unsigned int *dst_ptr ATTRIBUTE_UNUSED
)
5291 #ifndef coff_bfd_link_hash_table_free
5292 #define coff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
5295 /* If coff_relocate_section is defined, we can use the optimized COFF
5296 backend linker. Otherwise we must continue to use the old linker. */
5298 #ifdef coff_relocate_section
5300 #ifndef coff_bfd_link_hash_table_create
5301 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5303 #ifndef coff_bfd_link_add_symbols
5304 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5306 #ifndef coff_bfd_final_link
5307 #define coff_bfd_final_link _bfd_coff_final_link
5310 #else /* ! defined (coff_relocate_section) */
5312 #define coff_relocate_section NULL
5313 #ifndef coff_bfd_link_hash_table_create
5314 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5316 #ifndef coff_bfd_link_add_symbols
5317 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5319 #define coff_bfd_final_link _bfd_generic_final_link
5321 #endif /* ! defined (coff_relocate_section) */
5323 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5324 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5326 #ifndef coff_start_final_link
5327 #define coff_start_final_link NULL
5330 #ifndef coff_adjust_symndx
5331 #define coff_adjust_symndx NULL
5334 #ifndef coff_link_add_one_symbol
5335 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5338 #ifndef coff_link_output_has_begun
5341 coff_link_output_has_begun (bfd
* abfd
,
5342 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
)
5344 return abfd
->output_has_begun
;
5348 #ifndef coff_final_link_postscript
5351 coff_final_link_postscript (bfd
* abfd ATTRIBUTE_UNUSED
,
5352 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
)
5358 #ifndef coff_SWAP_aux_in
5359 #define coff_SWAP_aux_in coff_swap_aux_in
5361 #ifndef coff_SWAP_sym_in
5362 #define coff_SWAP_sym_in coff_swap_sym_in
5364 #ifndef coff_SWAP_lineno_in
5365 #define coff_SWAP_lineno_in coff_swap_lineno_in
5367 #ifndef coff_SWAP_aux_out
5368 #define coff_SWAP_aux_out coff_swap_aux_out
5370 #ifndef coff_SWAP_sym_out
5371 #define coff_SWAP_sym_out coff_swap_sym_out
5373 #ifndef coff_SWAP_lineno_out
5374 #define coff_SWAP_lineno_out coff_swap_lineno_out
5376 #ifndef coff_SWAP_reloc_out
5377 #define coff_SWAP_reloc_out coff_swap_reloc_out
5379 #ifndef coff_SWAP_filehdr_out
5380 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5382 #ifndef coff_SWAP_aouthdr_out
5383 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5385 #ifndef coff_SWAP_scnhdr_out
5386 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5388 #ifndef coff_SWAP_reloc_in
5389 #define coff_SWAP_reloc_in coff_swap_reloc_in
5391 #ifndef coff_SWAP_filehdr_in
5392 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5394 #ifndef coff_SWAP_aouthdr_in
5395 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5397 #ifndef coff_SWAP_scnhdr_in
5398 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5401 static bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED
=
5403 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5404 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5405 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5406 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5407 coff_SWAP_scnhdr_out
,
5408 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5409 #ifdef COFF_LONG_FILENAMES
5414 COFF_DEFAULT_LONG_SECTION_NAMES
,
5415 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5416 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5421 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5426 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5427 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5428 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5429 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5430 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5431 coff_classify_symbol
, coff_compute_section_file_positions
,
5432 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5433 coff_adjust_symndx
, coff_link_add_one_symbol
,
5434 coff_link_output_has_begun
, coff_final_link_postscript
,
5439 /* COFF0 differs in file/section header size and relocation entry size. */
5441 static bfd_coff_backend_data ticoff0_swap_table
=
5443 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5444 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5445 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5446 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5447 coff_SWAP_scnhdr_out
,
5448 FILHSZ_V0
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ_V0
, LINESZ
, FILNMLEN
,
5449 #ifdef COFF_LONG_FILENAMES
5454 COFF_DEFAULT_LONG_SECTION_NAMES
,
5455 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5456 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5461 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5466 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5467 coff_SWAP_reloc_in
, ticoff0_bad_format_hook
, coff_set_arch_mach_hook
,
5468 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5469 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5470 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5471 coff_classify_symbol
, coff_compute_section_file_positions
,
5472 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5473 coff_adjust_symndx
, coff_link_add_one_symbol
,
5474 coff_link_output_has_begun
, coff_final_link_postscript
,
5480 /* COFF1 differs in section header size. */
5482 static bfd_coff_backend_data ticoff1_swap_table
=
5484 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5485 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5486 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5487 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5488 coff_SWAP_scnhdr_out
,
5489 FILHSZ
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5490 #ifdef COFF_LONG_FILENAMES
5495 COFF_DEFAULT_LONG_SECTION_NAMES
,
5496 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5497 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5502 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5507 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5508 coff_SWAP_reloc_in
, ticoff1_bad_format_hook
, coff_set_arch_mach_hook
,
5509 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5510 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5511 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5512 coff_classify_symbol
, coff_compute_section_file_positions
,
5513 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5514 coff_adjust_symndx
, coff_link_add_one_symbol
,
5515 coff_link_output_has_begun
, coff_final_link_postscript
,
5516 bfd_pe_print_pdata
/* huh */
5520 #ifndef coff_close_and_cleanup
5521 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5524 #ifndef coff_bfd_free_cached_info
5525 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5528 #ifndef coff_get_section_contents
5529 #define coff_get_section_contents _bfd_generic_get_section_contents
5532 #ifndef coff_bfd_copy_private_symbol_data
5533 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5536 #ifndef coff_bfd_copy_private_header_data
5537 #define coff_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
5540 #ifndef coff_bfd_copy_private_section_data
5541 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5544 #ifndef coff_bfd_copy_private_bfd_data
5545 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5548 #ifndef coff_bfd_merge_private_bfd_data
5549 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5552 #ifndef coff_bfd_set_private_flags
5553 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5556 #ifndef coff_bfd_print_private_bfd_data
5557 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5560 #ifndef coff_bfd_is_local_label_name
5561 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5564 #ifndef coff_bfd_is_target_special_symbol
5565 #define coff_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
5568 #ifndef coff_read_minisymbols
5569 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5572 #ifndef coff_minisymbol_to_symbol
5573 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5576 /* The reloc lookup routine must be supplied by each individual COFF
5578 #ifndef coff_bfd_reloc_type_lookup
5579 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5581 #ifndef coff_bfd_reloc_name_lookup
5582 #define coff_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5585 #ifndef coff_bfd_get_relocated_section_contents
5586 #define coff_bfd_get_relocated_section_contents \
5587 bfd_generic_get_relocated_section_contents
5590 #ifndef coff_bfd_relax_section
5591 #define coff_bfd_relax_section bfd_generic_relax_section
5594 #ifndef coff_bfd_gc_sections
5595 #define coff_bfd_gc_sections bfd_generic_gc_sections
5598 #ifndef coff_bfd_merge_sections
5599 #define coff_bfd_merge_sections bfd_generic_merge_sections
5602 #ifndef coff_bfd_is_group_section
5603 #define coff_bfd_is_group_section bfd_generic_is_group_section
5606 #ifndef coff_bfd_discard_group
5607 #define coff_bfd_discard_group bfd_generic_discard_group
5610 #ifndef coff_section_already_linked
5611 #define coff_section_already_linked \
5612 _bfd_generic_section_already_linked
5615 #ifndef coff_bfd_define_common_symbol
5616 #define coff_bfd_define_common_symbol bfd_generic_define_common_symbol
5619 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5620 const bfd_target VAR = \
5623 bfd_target_coff_flavour, \
5624 BFD_ENDIAN_BIG, /* Data byte order is big. */ \
5625 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5626 /* object flags */ \
5627 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5628 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5629 /* section flags */ \
5630 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5631 UNDER, /* Leading symbol underscore. */ \
5632 '/', /* AR_pad_char. */ \
5633 15, /* AR_max_namelen. */ \
5635 /* Data conversion functions. */ \
5636 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5637 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5638 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5640 /* Header conversion functions. */ \
5641 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5642 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5643 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5645 /* bfd_check_format. */ \
5646 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5647 _bfd_dummy_target }, \
5648 /* bfd_set_format. */ \
5649 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5650 /* bfd_write_contents. */ \
5651 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5654 BFD_JUMP_TABLE_GENERIC (coff), \
5655 BFD_JUMP_TABLE_COPY (coff), \
5656 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5657 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5658 BFD_JUMP_TABLE_SYMBOLS (coff), \
5659 BFD_JUMP_TABLE_RELOCS (coff), \
5660 BFD_JUMP_TABLE_WRITE (coff), \
5661 BFD_JUMP_TABLE_LINK (coff), \
5662 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5669 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5670 const bfd_target VAR = \
5673 bfd_target_coff_flavour, \
5674 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5675 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5676 /* object flags */ \
5677 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5678 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5679 /* section flags */ \
5680 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5681 UNDER, /* Leading symbol underscore. */ \
5682 '/', /* AR_pad_char. */ \
5683 15, /* AR_max_namelen. */ \
5685 /* Data conversion functions. */ \
5686 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5687 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5688 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5690 /* Header conversion functions. */ \
5691 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5692 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5693 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5695 /* bfd_check_format. */ \
5696 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5697 _bfd_dummy_target }, \
5698 /* bfd_set_format. */ \
5699 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5700 /* bfd_write_contents. */ \
5701 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5704 BFD_JUMP_TABLE_GENERIC (coff), \
5705 BFD_JUMP_TABLE_COPY (coff), \
5706 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5707 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5708 BFD_JUMP_TABLE_SYMBOLS (coff), \
5709 BFD_JUMP_TABLE_RELOCS (coff), \
5710 BFD_JUMP_TABLE_WRITE (coff), \
5711 BFD_JUMP_TABLE_LINK (coff), \
5712 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5719 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5720 const bfd_target VAR = \
5723 bfd_target_coff_flavour, \
5724 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5725 BFD_ENDIAN_LITTLE, /* Header byte order is little. */ \
5726 /* object flags */ \
5727 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5728 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5729 /* section flags */ \
5730 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5731 UNDER, /* Leading symbol underscore. */ \
5732 '/', /* AR_pad_char. */ \
5733 15, /* AR_max_namelen. */ \
5735 /* Data conversion functions. */ \
5736 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5737 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5738 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5739 /* Header conversion functions. */ \
5740 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5741 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5742 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5743 /* bfd_check_format. */ \
5744 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5745 _bfd_dummy_target }, \
5746 /* bfd_set_format. */ \
5747 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5748 /* bfd_write_contents. */ \
5749 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5752 BFD_JUMP_TABLE_GENERIC (coff), \
5753 BFD_JUMP_TABLE_COPY (coff), \
5754 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5755 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5756 BFD_JUMP_TABLE_SYMBOLS (coff), \
5757 BFD_JUMP_TABLE_RELOCS (coff), \
5758 BFD_JUMP_TABLE_WRITE (coff), \
5759 BFD_JUMP_TABLE_LINK (coff), \
5760 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \