1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright 1990-2013 Free Software Foundation, Inc.
3 Written by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
22 /* Most of this hacked by Steve Chamberlain,
28 BFD supports a number of different flavours of coff format.
29 The major differences between formats are the sizes and
30 alignments of fields in structures on disk, and the occasional
33 Coff in all its varieties is implemented with a few common
34 files and a number of implementation specific files. For
35 example, The 88k bcs coff format is implemented in the file
36 @file{coff-m88k.c}. This file @code{#include}s
37 @file{coff/m88k.h} which defines the external structure of the
38 coff format for the 88k, and @file{coff/internal.h} which
39 defines the internal structure. @file{coff-m88k.c} also
40 defines the relocations used by the 88k format
43 The Intel i960 processor version of coff is implemented in
44 @file{coff-i960.c}. This file has the same structure as
45 @file{coff-m88k.c}, except that it includes @file{coff/i960.h}
46 rather than @file{coff-m88k.h}.
49 Porting to a new version of coff
51 The recommended method is to select from the existing
52 implementations the version of coff which is most like the one
53 you want to use. For example, we'll say that i386 coff is
54 the one you select, and that your coff flavour is called foo.
55 Copy @file{i386coff.c} to @file{foocoff.c}, copy
56 @file{../include/coff/i386.h} to @file{../include/coff/foo.h},
57 and add the lines to @file{targets.c} and @file{Makefile.in}
58 so that your new back end is used. Alter the shapes of the
59 structures in @file{../include/coff/foo.h} so that they match
60 what you need. You will probably also have to add
61 @code{#ifdef}s to the code in @file{coff/internal.h} and
62 @file{coffcode.h} if your version of coff is too wild.
64 You can verify that your new BFD backend works quite simply by
65 building @file{objdump} from the @file{binutils} directory,
66 and making sure that its version of what's going on and your
67 host system's idea (assuming it has the pretty standard coff
68 dump utility, usually called @code{att-dump} or just
69 @code{dump}) are the same. Then clean up your code, and send
70 what you've done to Cygnus. Then your stuff will be in the
71 next release, and you won't have to keep integrating it.
74 How the coff backend works
79 The Coff backend is split into generic routines that are
80 applicable to any Coff target and routines that are specific
81 to a particular target. The target-specific routines are
82 further split into ones which are basically the same for all
83 Coff targets except that they use the external symbol format
84 or use different values for certain constants.
86 The generic routines are in @file{coffgen.c}. These routines
87 work for any Coff target. They use some hooks into the target
88 specific code; the hooks are in a @code{bfd_coff_backend_data}
89 structure, one of which exists for each target.
91 The essentially similar target-specific routines are in
92 @file{coffcode.h}. This header file includes executable C code.
93 The various Coff targets first include the appropriate Coff
94 header file, make any special defines that are needed, and
95 then include @file{coffcode.h}.
97 Some of the Coff targets then also have additional routines in
98 the target source file itself.
100 For example, @file{coff-i960.c} includes
101 @file{coff/internal.h} and @file{coff/i960.h}. It then
102 defines a few constants, such as @code{I960}, and includes
103 @file{coffcode.h}. Since the i960 has complex relocation
104 types, @file{coff-i960.c} also includes some code to
105 manipulate the i960 relocs. This code is not in
106 @file{coffcode.h} because it would not be used by any other
110 Coff long section names
112 In the standard Coff object format, section names are limited to
113 the eight bytes available in the @code{s_name} field of the
114 @code{SCNHDR} section header structure. The format requires the
115 field to be NUL-padded, but not necessarily NUL-terminated, so
116 the longest section names permitted are a full eight characters.
118 The Microsoft PE variants of the Coff object file format add
119 an extension to support the use of long section names. This
120 extension is defined in section 4 of the Microsoft PE/COFF
121 specification (rev 8.1). If a section name is too long to fit
122 into the section header's @code{s_name} field, it is instead
123 placed into the string table, and the @code{s_name} field is
124 filled with a slash ("/") followed by the ASCII decimal
125 representation of the offset of the full name relative to the
128 Note that this implies that the extension can only be used in object
129 files, as executables do not contain a string table. The standard
130 specifies that long section names from objects emitted into executable
131 images are to be truncated.
133 However, as a GNU extension, BFD can generate executable images
134 that contain a string table and long section names. This
135 would appear to be technically valid, as the standard only says
136 that Coff debugging information is deprecated, not forbidden,
137 and in practice it works, although some tools that parse PE files
138 expecting the MS standard format may become confused; @file{PEview} is
141 The functionality is supported in BFD by code implemented under
142 the control of the macro @code{COFF_LONG_SECTION_NAMES}. If not
143 defined, the format does not support long section names in any way.
144 If defined, it is used to initialise a flag,
145 @code{_bfd_coff_long_section_names}, and a hook function pointer,
146 @code{_bfd_coff_set_long_section_names}, in the Coff backend data
147 structure. The flag controls the generation of long section names
148 in output BFDs at runtime; if it is false, as it will be by default
149 when generating an executable image, long section names are truncated;
150 if true, the long section names extension is employed. The hook
151 points to a function that allows the value of the flag to be altered
152 at runtime, on formats that support long section names at all; on
153 other formats it points to a stub that returns an error indication.
155 With input BFDs, the flag is set according to whether any long section
156 names are detected while reading the section headers. For a completely
157 new BFD, the flag is set to the default for the target format. This
158 information can be used by a client of the BFD library when deciding
159 what output format to generate, and means that a BFD that is opened
160 for read and subsequently converted to a writeable BFD and modified
161 in-place will retain whatever format it had on input.
163 If @code{COFF_LONG_SECTION_NAMES} is simply defined (blank), or is
164 defined to the value "1", then long section names are enabled by
165 default; if it is defined to the value zero, they are disabled by
166 default (but still accepted in input BFDs). The header @file{coffcode.h}
167 defines a macro, @code{COFF_DEFAULT_LONG_SECTION_NAMES}, which is
168 used in the backends to initialise the backend data structure fields
169 appropriately; see the comments for further detail.
174 Each flavour of coff supported in BFD has its own header file
175 describing the external layout of the structures. There is also
176 an internal description of the coff layout, in
177 @file{coff/internal.h}. A major function of the
178 coff backend is swapping the bytes and twiddling the bits to
179 translate the external form of the structures into the normal
180 internal form. This is all performed in the
181 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
182 elements are different sizes between different versions of
183 coff; it is the duty of the coff version specific include file
184 to override the definitions of various packing routines in
185 @file{coffcode.h}. E.g., the size of line number entry in coff is
186 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
187 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
188 correct one. No doubt, some day someone will find a version of
189 coff which has a varying field size not catered to at the
190 moment. To port BFD, that person will have to add more @code{#defines}.
191 Three of the bit twiddling routines are exported to
192 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
193 and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol
194 table on its own, but uses BFD to fix things up. More of the
195 bit twiddlers are exported for @code{gas};
196 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
197 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
198 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
199 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
200 of all the symbol table and reloc drudgery itself, thereby
201 saving the internal BFD overhead, but uses BFD to swap things
202 on the way out, making cross ports much safer. Doing so also
203 allows BFD (and thus the linker) to use the same header files
204 as @code{gas}, which makes one avenue to disaster disappear.
209 The simple canonical form for symbols used by BFD is not rich
210 enough to keep all the information available in a coff symbol
211 table. The back end gets around this problem by keeping the original
212 symbol table around, "behind the scenes".
214 When a symbol table is requested (through a call to
215 @code{bfd_canonicalize_symtab}), a request gets through to
216 @code{coff_get_normalized_symtab}. This reads the symbol table from
217 the coff file and swaps all the structures inside into the
218 internal form. It also fixes up all the pointers in the table
219 (represented in the file by offsets from the first symbol in
220 the table) into physical pointers to elements in the new
221 internal table. This involves some work since the meanings of
222 fields change depending upon context: a field that is a
223 pointer to another structure in the symbol table at one moment
224 may be the size in bytes of a structure at the next. Another
225 pass is made over the table. All symbols which mark file names
226 (<<C_FILE>> symbols) are modified so that the internal
227 string points to the value in the auxent (the real filename)
228 rather than the normal text associated with the symbol
231 At this time the symbol names are moved around. Coff stores
232 all symbols less than nine characters long physically
233 within the symbol table; longer strings are kept at the end of
234 the file in the string table. This pass moves all strings
235 into memory and replaces them with pointers to the strings.
237 The symbol table is massaged once again, this time to create
238 the canonical table used by the BFD application. Each symbol
239 is inspected in turn, and a decision made (using the
240 @code{sclass} field) about the various flags to set in the
241 @code{asymbol}. @xref{Symbols}. The generated canonical table
242 shares strings with the hidden internal symbol table.
244 Any linenumbers are read from the coff file too, and attached
245 to the symbols which own the functions the linenumbers belong to.
250 Writing a symbol to a coff file which didn't come from a coff
251 file will lose any debugging information. The @code{asymbol}
252 structure remembers the BFD from which the symbol was taken, and on
253 output the back end makes sure that the same destination target as
254 source target is present.
256 When the symbols have come from a coff file then all the
257 debugging information is preserved.
259 Symbol tables are provided for writing to the back end in a
260 vector of pointers to pointers. This allows applications like
261 the linker to accumulate and output large symbol tables
262 without having to do too much byte copying.
264 This function runs through the provided symbol table and
265 patches each symbol marked as a file place holder
266 (@code{C_FILE}) to point to the next file place holder in the
267 list. It also marks each @code{offset} field in the list with
268 the offset from the first symbol of the current symbol.
270 Another function of this procedure is to turn the canonical
271 value form of BFD into the form used by coff. Internally, BFD
272 expects symbol values to be offsets from a section base; so a
273 symbol physically at 0x120, but in a section starting at
274 0x100, would have the value 0x20. Coff expects symbols to
275 contain their final value, so symbols have their values
276 changed at this point to reflect their sum with their owning
277 section. This transformation uses the
278 <<output_section>> field of the @code{asymbol}'s
279 @code{asection} @xref{Sections}.
281 o <<coff_mangle_symbols>>
283 This routine runs though the provided symbol table and uses
284 the offsets generated by the previous pass and the pointers
285 generated when the symbol table was read in to create the
286 structured hierarchy required by coff. It changes each pointer
287 to a symbol into the index into the symbol table of the asymbol.
289 o <<coff_write_symbols>>
291 This routine runs through the symbol table and patches up the
292 symbols from their internal form into the coff way, calls the
293 bit twiddlers, and writes out the table to the file.
302 The hidden information for an <<asymbol>> is described in a
303 <<combined_entry_type>>:
307 .typedef struct coff_ptr_struct
309 . {* Remembers the offset from the first symbol in the file for
310 . this symbol. Generated by coff_renumber_symbols. *}
311 . unsigned int offset;
313 . {* Should the value of this symbol be renumbered. Used for
314 . XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
315 . unsigned int fix_value : 1;
317 . {* Should the tag field of this symbol be renumbered.
318 . Created by coff_pointerize_aux. *}
319 . unsigned int fix_tag : 1;
321 . {* Should the endidx field of this symbol be renumbered.
322 . Created by coff_pointerize_aux. *}
323 . unsigned int fix_end : 1;
325 . {* Should the x_csect.x_scnlen field be renumbered.
326 . Created by coff_pointerize_aux. *}
327 . unsigned int fix_scnlen : 1;
329 . {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
330 . index into the line number entries. Set by coff_slurp_symbol_table. *}
331 . unsigned int fix_line : 1;
333 . {* The container for the symbol structure as read and translated
337 . union internal_auxent auxent;
338 . struct internal_syment syment;
340 .} combined_entry_type;
343 .{* Each canonical asymbol really looks like this: *}
345 .typedef struct coff_symbol_struct
347 . {* The actual symbol which the rest of BFD works with *}
350 . {* A pointer to the hidden information for this symbol *}
351 . combined_entry_type *native;
353 . {* A pointer to the linenumber information for this symbol *}
354 . struct lineno_cache_entry *lineno;
356 . {* Have the line numbers been relocated yet ? *}
357 . bfd_boolean done_lineno;
362 #include "libiberty.h"
367 #include "coffswap.h"
370 #define STRING_SIZE_SIZE 4
372 #define DOT_DEBUG ".debug"
373 #define DOT_ZDEBUG ".zdebug"
374 #define GNU_LINKONCE_WI ".gnu.linkonce.wi."
375 #define GNU_LINKONCE_WT ".gnu.linkonce.wt."
376 #define DOT_RELOC ".reloc"
378 #if defined (COFF_LONG_SECTION_NAMES)
379 /* Needed to expand the inputs to BLANKOR1TOODD. */
380 #define COFFLONGSECTIONCATHELPER(x,y) x ## y
381 /* If the input macro Y is blank or '1', return an odd number; if it is
382 '0', return an even number. Result undefined in all other cases. */
383 #define BLANKOR1TOODD(y) COFFLONGSECTIONCATHELPER(1,y)
384 /* Defined to numerical 0 or 1 according to whether generation of long
385 section names is disabled or enabled by default. */
386 #define COFF_ENABLE_LONG_SECTION_NAMES (BLANKOR1TOODD(COFF_LONG_SECTION_NAMES) & 1)
387 /* Where long section names are supported, we allow them to be enabled
388 and disabled at runtime, so select an appropriate hook function for
389 _bfd_coff_set_long_section_names. */
390 #define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_allowed
391 #else /* !defined (COFF_LONG_SECTION_NAMES) */
392 /* If long section names are not supported, this stub disallows any
393 attempt to enable them at run-time. */
394 #define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_disallowed
395 #endif /* defined (COFF_LONG_SECTION_NAMES) */
397 /* Define a macro that can be used to initialise both the fields relating
398 to long section names in the backend data struct simultaneously. */
399 #if COFF_ENABLE_LONG_SECTION_NAMES
400 #define COFF_DEFAULT_LONG_SECTION_NAMES (TRUE), COFF_LONG_SECTION_NAMES_SETTER
401 #else /* !COFF_ENABLE_LONG_SECTION_NAMES */
402 #define COFF_DEFAULT_LONG_SECTION_NAMES (FALSE), COFF_LONG_SECTION_NAMES_SETTER
403 #endif /* COFF_ENABLE_LONG_SECTION_NAMES */
405 #if defined (COFF_LONG_SECTION_NAMES)
406 static bfd_boolean bfd_coff_set_long_section_names_allowed
408 #else /* !defined (COFF_LONG_SECTION_NAMES) */
409 static bfd_boolean bfd_coff_set_long_section_names_disallowed
411 #endif /* defined (COFF_LONG_SECTION_NAMES) */
412 static long sec_to_styp_flags
413 (const char *, flagword);
414 static bfd_boolean styp_to_sec_flags
415 (bfd *, void *, const char *, asection *, flagword *);
416 static bfd_boolean coff_bad_format_hook
418 static void coff_set_custom_section_alignment
419 (bfd *, asection *, const struct coff_section_alignment_entry *,
421 static bfd_boolean coff_new_section_hook
423 static bfd_boolean coff_set_arch_mach_hook
425 static bfd_boolean coff_write_relocs
427 static bfd_boolean coff_set_flags
428 (bfd *, unsigned int *, unsigned short *);
429 static bfd_boolean coff_set_arch_mach
430 (bfd *, enum bfd_architecture, unsigned long) ATTRIBUTE_UNUSED;
431 static bfd_boolean coff_compute_section_file_positions
433 static bfd_boolean coff_write_object_contents
434 (bfd *) ATTRIBUTE_UNUSED;
435 static bfd_boolean coff_set_section_contents
436 (bfd *, asection *, const void *, file_ptr, bfd_size_type);
437 static void * buy_and_read
438 (bfd *, file_ptr, bfd_size_type);
439 static bfd_boolean coff_slurp_line_table
441 static bfd_boolean coff_slurp_symbol_table
443 static enum coff_symbol_classification coff_classify_symbol
444 (bfd *, struct internal_syment *);
445 static bfd_boolean coff_slurp_reloc_table
446 (bfd *, asection *, asymbol **);
447 static long coff_canonicalize_reloc
448 (bfd *, asection *, arelent **, asymbol **);
449 #ifndef coff_mkobject_hook
450 static void * coff_mkobject_hook
451 (bfd *, void *, void *);
454 static flagword handle_COMDAT
455 (bfd *, flagword, void *, const char *, asection *);
457 #ifdef COFF_IMAGE_WITH_PE
458 static bfd_boolean coff_read_word
459 (bfd *, unsigned int *);
460 static unsigned int coff_compute_checksum
462 static bfd_boolean coff_apply_checksum
466 static bfd_boolean ticoff0_bad_format_hook
468 static bfd_boolean ticoff1_bad_format_hook
472 /* void warning(); */
474 #if defined (COFF_LONG_SECTION_NAMES)
476 bfd_coff_set_long_section_names_allowed (bfd *abfd, int enable)
478 coff_backend_info (abfd)->_bfd_coff_long_section_names = enable;
481 #else /* !defined (COFF_LONG_SECTION_NAMES) */
483 bfd_coff_set_long_section_names_disallowed (bfd *abfd, int enable)
489 #endif /* defined (COFF_LONG_SECTION_NAMES) */
491 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
492 the incoming SEC_* flags. The inverse of this function is
493 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
494 should probably mirror the changes in styp_to_sec_flags(). */
498 /* Macros for setting debugging flags. */
501 #define STYP_XCOFF_DEBUG STYP_DEBUG
503 #define STYP_XCOFF_DEBUG STYP_INFO
506 #ifdef COFF_ALIGN_IN_S_FLAGS
507 #define STYP_DEBUG_INFO STYP_DSECT
509 #define STYP_DEBUG_INFO STYP_INFO
513 sec_to_styp_flags (const char *sec_name, flagword sec_flags)
517 if (!strcmp (sec_name, _TEXT))
519 styp_flags = STYP_TEXT;
521 else if (!strcmp (sec_name, _DATA))
523 styp_flags = STYP_DATA;
525 else if (!strcmp (sec_name, _BSS))
527 styp_flags = STYP_BSS;
530 else if (!strcmp (sec_name, _COMMENT))
532 styp_flags = STYP_INFO;
533 #endif /* _COMMENT */
536 else if (!strcmp (sec_name, _LIB))
538 styp_flags = STYP_LIB;
542 else if (!strcmp (sec_name, _LIT))
544 styp_flags = STYP_LIT;
547 else if (CONST_STRNEQ (sec_name, DOT_DEBUG)
548 || CONST_STRNEQ (sec_name, DOT_ZDEBUG))
550 /* Handle the XCOFF debug section and DWARF2 debug sections. */
552 styp_flags = STYP_XCOFF_DEBUG;
554 styp_flags = STYP_DEBUG_INFO;
556 else if (CONST_STRNEQ (sec_name, ".stab"))
558 styp_flags = STYP_DEBUG_INFO;
560 #ifdef COFF_LONG_SECTION_NAMES
561 else if (CONST_STRNEQ (sec_name, GNU_LINKONCE_WI)
562 || CONST_STRNEQ (sec_name, GNU_LINKONCE_WT))
564 styp_flags = STYP_DEBUG_INFO;
568 else if (!strcmp (sec_name, _PAD))
570 styp_flags = STYP_PAD;
572 else if (!strcmp (sec_name, _LOADER))
574 styp_flags = STYP_LOADER;
576 else if (!strcmp (sec_name, _EXCEPT))
578 styp_flags = STYP_EXCEPT;
580 else if (!strcmp (sec_name, _TYPCHK))
582 styp_flags = STYP_TYPCHK;
584 else if (sec_flags & SEC_DEBUGGING)
588 for (i = 0; i < XCOFF_DWSECT_NBR_NAMES; i++)
589 if (!strcmp (sec_name, xcoff_dwsect_names[i].name))
591 styp_flags = STYP_DWARF | xcoff_dwsect_names[i].flag;
596 /* Try and figure out what it should be */
597 else if (sec_flags & SEC_CODE)
599 styp_flags = STYP_TEXT;
601 else if (sec_flags & SEC_DATA)
603 styp_flags = STYP_DATA;
605 else if (sec_flags & SEC_READONLY)
607 #ifdef STYP_LIT /* 29k readonly text/data section */
608 styp_flags = STYP_LIT;
610 styp_flags = STYP_TEXT;
611 #endif /* STYP_LIT */
613 else if (sec_flags & SEC_LOAD)
615 styp_flags = STYP_TEXT;
617 else if (sec_flags & SEC_ALLOC)
619 styp_flags = STYP_BSS;
623 if (sec_flags & SEC_TIC54X_CLINK)
624 styp_flags |= STYP_CLINK;
628 if (sec_flags & SEC_TIC54X_BLOCK)
629 styp_flags |= STYP_BLOCK;
633 if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
634 styp_flags |= STYP_NOLOAD;
640 #else /* COFF_WITH_PE */
642 /* The PE version; see above for the general comments. The non-PE
643 case seems to be more guessing, and breaks PE format; specifically,
644 .rdata is readonly, but it sure ain't text. Really, all this
645 should be set up properly in gas (or whatever assembler is in use),
646 and honor whatever objcopy/strip, etc. sent us as input. */
649 sec_to_styp_flags (const char *sec_name, flagword sec_flags)
652 bfd_boolean is_dbg = FALSE;
654 if (CONST_STRNEQ (sec_name, DOT_DEBUG)
655 || CONST_STRNEQ (sec_name, DOT_ZDEBUG)
656 #ifdef COFF_LONG_SECTION_NAMES
657 || CONST_STRNEQ (sec_name, GNU_LINKONCE_WI)
658 || CONST_STRNEQ (sec_name, GNU_LINKONCE_WT)
660 || CONST_STRNEQ (sec_name, ".stab"))
663 /* caution: there are at least three groups of symbols that have
664 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
665 SEC_* are the BFD internal flags, used for generic BFD
666 information. STYP_* are the COFF section flags which appear in
667 COFF files. IMAGE_SCN_* are the PE section flags which appear in
668 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
669 but there are more IMAGE_SCN_* flags. */
671 /* FIXME: There is no gas syntax to specify the debug section flag. */
674 sec_flags &= (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD
675 | SEC_LINK_DUPLICATES_SAME_CONTENTS
676 | SEC_LINK_DUPLICATES_SAME_SIZE);
677 sec_flags |= SEC_DEBUGGING | SEC_READONLY;
683 if ((sec_flags & SEC_CODE) != 0)
684 styp_flags |= IMAGE_SCN_CNT_CODE;
685 if ((sec_flags & (SEC_DATA | SEC_DEBUGGING)) != 0)
686 styp_flags |= IMAGE_SCN_CNT_INITIALIZED_DATA;
687 if ((sec_flags & SEC_ALLOC) != 0 && (sec_flags & SEC_LOAD) == 0)
688 styp_flags |= IMAGE_SCN_CNT_UNINITIALIZED_DATA; /* ==STYP_BSS */
690 /* skip constRUCTOR */
692 if ((sec_flags & SEC_IS_COMMON) != 0)
693 styp_flags |= IMAGE_SCN_LNK_COMDAT;
694 if ((sec_flags & SEC_DEBUGGING) != 0)
695 styp_flags |= IMAGE_SCN_MEM_DISCARDABLE;
696 if ((sec_flags & SEC_EXCLUDE) != 0 && !is_dbg)
697 styp_flags |= IMAGE_SCN_LNK_REMOVE;
698 if ((sec_flags & SEC_NEVER_LOAD) != 0 && !is_dbg)
699 styp_flags |= IMAGE_SCN_LNK_REMOVE;
702 if (sec_flags & SEC_LINK_ONCE)
703 styp_flags |= IMAGE_SCN_LNK_COMDAT;
705 & (SEC_LINK_DUPLICATES_DISCARD | SEC_LINK_DUPLICATES_SAME_CONTENTS
706 | SEC_LINK_DUPLICATES_SAME_SIZE)) != 0)
707 styp_flags |= IMAGE_SCN_LNK_COMDAT;
709 /* skip LINKER_CREATED */
711 if ((sec_flags & SEC_COFF_NOREAD) == 0)
712 styp_flags |= IMAGE_SCN_MEM_READ; /* Invert NOREAD for read. */
713 if ((sec_flags & SEC_READONLY) == 0)
714 styp_flags |= IMAGE_SCN_MEM_WRITE; /* Invert READONLY for write. */
715 if (sec_flags & SEC_CODE)
716 styp_flags |= IMAGE_SCN_MEM_EXECUTE; /* CODE->EXECUTE. */
717 if (sec_flags & SEC_COFF_SHARED)
718 styp_flags |= IMAGE_SCN_MEM_SHARED; /* Shared remains meaningful. */
723 #endif /* COFF_WITH_PE */
725 /* Return a word with SEC_* flags set to represent the incoming STYP_*
726 flags (from scnhdr.s_flags). The inverse of this function is
727 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
728 should probably mirror the changes in sec_to_styp_flags(). */
733 styp_to_sec_flags (bfd *abfd ATTRIBUTE_UNUSED,
736 asection *section ATTRIBUTE_UNUSED,
739 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
740 long styp_flags = internal_s->s_flags;
741 flagword sec_flags = 0;
744 if (styp_flags & STYP_BLOCK)
745 sec_flags |= SEC_TIC54X_BLOCK;
749 if (styp_flags & STYP_CLINK)
750 sec_flags |= SEC_TIC54X_CLINK;
754 if (styp_flags & STYP_NOLOAD)
755 sec_flags |= SEC_NEVER_LOAD;
756 #endif /* STYP_NOLOAD */
758 /* For 386 COFF, at least, an unloadable text or data section is
759 actually a shared library section. */
760 if (styp_flags & STYP_TEXT)
762 if (sec_flags & SEC_NEVER_LOAD)
763 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
765 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
767 else if (styp_flags & STYP_DATA)
769 if (sec_flags & SEC_NEVER_LOAD)
770 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
772 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
774 else if (styp_flags & STYP_BSS)
776 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
777 if (sec_flags & SEC_NEVER_LOAD)
778 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
781 sec_flags |= SEC_ALLOC;
783 else if (styp_flags & STYP_INFO)
785 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
786 defined. coff_compute_section_file_positions uses
787 COFF_PAGE_SIZE to ensure that the low order bits of the
788 section VMA and the file offset match. If we don't know
789 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
790 and demand page loading of the file will fail. */
791 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
792 sec_flags |= SEC_DEBUGGING;
795 else if (styp_flags & STYP_PAD)
798 else if (styp_flags & STYP_DWARF)
799 sec_flags |= SEC_DEBUGGING;
801 else if (strcmp (name, _TEXT) == 0)
803 if (sec_flags & SEC_NEVER_LOAD)
804 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
806 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
808 else if (strcmp (name, _DATA) == 0)
810 if (sec_flags & SEC_NEVER_LOAD)
811 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
813 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
815 else if (strcmp (name, _BSS) == 0)
817 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
818 if (sec_flags & SEC_NEVER_LOAD)
819 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
822 sec_flags |= SEC_ALLOC;
824 else if (CONST_STRNEQ (name, DOT_DEBUG)
825 || CONST_STRNEQ (name, DOT_ZDEBUG)
827 || strcmp (name, _COMMENT) == 0
829 #ifdef COFF_LONG_SECTION_NAMES
830 || CONST_STRNEQ (name, GNU_LINKONCE_WI)
831 || CONST_STRNEQ (name, GNU_LINKONCE_WT)
833 || CONST_STRNEQ (name, ".stab"))
835 #ifdef COFF_PAGE_SIZE
836 sec_flags |= SEC_DEBUGGING;
840 else if (strcmp (name, _LIB) == 0)
844 else if (strcmp (name, _LIT) == 0)
845 sec_flags = SEC_LOAD | SEC_ALLOC | SEC_READONLY;
848 sec_flags |= SEC_ALLOC | SEC_LOAD;
850 #ifdef STYP_LIT /* A29k readonly text/data section type. */
851 if ((styp_flags & STYP_LIT) == STYP_LIT)
852 sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
853 #endif /* STYP_LIT */
855 #ifdef STYP_OTHER_LOAD /* Other loaded sections. */
856 if (styp_flags & STYP_OTHER_LOAD)
857 sec_flags = (SEC_LOAD | SEC_ALLOC);
858 #endif /* STYP_SDATA */
860 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
861 /* As a GNU extension, if the name begins with .gnu.linkonce, we
862 only link a single copy of the section. This is used to support
863 g++. g++ will emit each template expansion in its own section.
864 The symbols will be defined as weak, so that multiple definitions
865 are permitted. The GNU linker extension is to actually discard
866 all but one of the sections. */
867 if (CONST_STRNEQ (name, ".gnu.linkonce"))
868 sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
871 if (flags_ptr == NULL)
874 * flags_ptr = sec_flags;
878 #else /* COFF_WITH_PE */
881 handle_COMDAT (bfd * abfd,
887 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
888 bfd_byte *esymstart, *esym, *esymend;
890 char *target_name = NULL;
892 sec_flags |= SEC_LINK_ONCE;
894 /* Unfortunately, the PE format stores essential information in
895 the symbol table, of all places. We need to extract that
896 information now, so that objdump and the linker will know how
897 to handle the section without worrying about the symbols. We
898 can't call slurp_symtab, because the linker doesn't want the
901 /* COMDAT sections are special. The first symbol is the section
902 symbol, which tells what kind of COMDAT section it is. The
903 second symbol is the "comdat symbol" - the one with the
904 unique name. GNU uses the section symbol for the unique
905 name; MS uses ".text" for every comdat section. Sigh. - DJ */
907 /* This is not mirrored in sec_to_styp_flags(), but there
908 doesn't seem to be a need to, either, and it would at best be
911 if (! _bfd_coff_get_external_symbols (abfd))
914 esymstart = esym = (bfd_byte *) obj_coff_external_syms (abfd);
915 esymend = esym + obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd);
917 while (esym < esymend)
919 struct internal_syment isym;
920 char buf[SYMNMLEN + 1];
923 bfd_coff_swap_sym_in (abfd, esym, & isym);
925 if (sizeof (internal_s->s_name) > SYMNMLEN)
927 /* This case implies that the matching
928 symbol name will be in the string table. */
932 if (isym.n_scnum == section->target_index)
934 /* According to the MSVC documentation, the first
935 TWO entries with the section # are both of
936 interest to us. The first one is the "section
937 symbol" (section name). The second is the comdat
938 symbol name. Here, we've found the first
939 qualifying entry; we distinguish it from the
940 second with a state flag.
942 In the case of gas-generated (at least until that
943 is fixed) .o files, it isn't necessarily the
944 second one. It may be some other later symbol.
946 Since gas also doesn't follow MS conventions and
947 emits the section similar to .text$<name>, where
948 <something> is the name we're looking for, we
949 distinguish the two as follows:
951 If the section name is simply a section name (no
952 $) we presume it's MS-generated, and look at
953 precisely the second symbol for the comdat name.
954 If the section name has a $, we assume it's
955 gas-generated, and look for <something> (whatever
956 follows the $) as the comdat symbol. */
958 /* All 3 branches use this. */
959 symname = _bfd_coff_internal_syment_name (abfd, &isym, buf);
968 /* The first time we've seen the symbol. */
969 union internal_auxent aux;
971 /* If it isn't the stuff we're expecting, die;
972 The MS documentation is vague, but it
973 appears that the second entry serves BOTH
974 as the comdat symbol and the defining
975 symbol record (either C_STAT or C_EXT,
976 possibly with an aux entry with debug
977 information if it's a function.) It
978 appears the only way to find the second one
979 is to count. (On Intel, they appear to be
980 adjacent, but on Alpha, they have been
983 Here, we think we've found the first one,
984 but there's some checking we can do to be
987 if (! ((isym.n_sclass == C_STAT
988 || isym.n_sclass == C_EXT)
989 && BTYPE (isym.n_type) == T_NULL
990 && isym.n_value == 0))
993 /* FIXME LATER: MSVC generates section names
994 like .text for comdats. Gas generates
995 names like .text$foo__Fv (in the case of a
996 function). See comment above for more. */
998 if (isym.n_sclass == C_STAT && strcmp (name, symname) != 0)
999 _bfd_error_handler (_("%B: warning: COMDAT symbol '%s' does not match section name '%s'"),
1000 abfd, symname, name);
1004 /* This is the section symbol. */
1005 bfd_coff_swap_aux_in (abfd, (esym + bfd_coff_symesz (abfd)),
1006 isym.n_type, isym.n_sclass,
1007 0, isym.n_numaux, & aux);
1009 target_name = strchr (name, '$');
1010 if (target_name != NULL)
1018 /* FIXME: Microsoft uses NODUPLICATES and
1019 ASSOCIATIVE, but gnu uses ANY and
1020 SAME_SIZE. Unfortunately, gnu doesn't do
1021 the comdat symbols right. So, until we can
1022 fix it to do the right thing, we are
1023 temporarily disabling comdats for the MS
1024 types (they're used in DLLs and C++, but we
1025 don't support *their* C++ libraries anyway
1028 /* Cygwin does not follow the MS style, and
1029 uses ANY and SAME_SIZE where NODUPLICATES
1030 and ASSOCIATIVE should be used. For
1031 Interix, we just do the right thing up
1034 switch (aux.x_scn.x_comdat)
1036 case IMAGE_COMDAT_SELECT_NODUPLICATES:
1037 #ifdef STRICT_PE_FORMAT
1038 sec_flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
1040 sec_flags &= ~SEC_LINK_ONCE;
1044 case IMAGE_COMDAT_SELECT_ANY:
1045 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
1048 case IMAGE_COMDAT_SELECT_SAME_SIZE:
1049 sec_flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
1052 case IMAGE_COMDAT_SELECT_EXACT_MATCH:
1053 /* Not yet fully implemented ??? */
1054 sec_flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
1057 /* debug$S gets this case; other
1060 /* There may be no symbol... we'll search
1061 the whole table... Is this the right
1062 place to play this game? Or should we do
1063 it when reading it in. */
1064 case IMAGE_COMDAT_SELECT_ASSOCIATIVE:
1065 #ifdef STRICT_PE_FORMAT
1066 /* FIXME: This is not currently implemented. */
1067 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
1069 sec_flags &= ~SEC_LINK_ONCE;
1073 default: /* 0 means "no symbol" */
1074 /* debug$F gets this case; other
1076 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
1083 /* Gas mode: the first matching on partial name. */
1085 #ifndef TARGET_UNDERSCORE
1086 #define TARGET_UNDERSCORE 0
1088 /* Is this the name we're looking for ? */
1089 if (strcmp (target_name,
1090 symname + (TARGET_UNDERSCORE ? 1 : 0)) != 0)
1092 /* Not the name we're looking for */
1093 esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd);
1098 /* MSVC mode: the lexically second symbol (or
1099 drop through from the above). */
1104 /* This must the second symbol with the
1105 section #. It is the actual symbol name.
1106 Intel puts the two adjacent, but Alpha (at
1107 least) spreads them out. */
1109 amt = sizeof (struct coff_comdat_info);
1110 coff_section_data (abfd, section)->comdat
1111 = (struct coff_comdat_info *) bfd_alloc (abfd, amt);
1112 if (coff_section_data (abfd, section)->comdat == NULL)
1115 coff_section_data (abfd, section)->comdat->symbol =
1116 (esym - esymstart) / bfd_coff_symesz (abfd);
1118 amt = strlen (symname) + 1;
1119 newname = (char *) bfd_alloc (abfd, amt);
1120 if (newname == NULL)
1123 strcpy (newname, symname);
1124 coff_section_data (abfd, section)->comdat->name
1132 esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd);
1140 /* The PE version; see above for the general comments.
1142 Since to set the SEC_LINK_ONCE and associated flags, we have to
1143 look at the symbol table anyway, we return the symbol table index
1144 of the symbol being used as the COMDAT symbol. This is admittedly
1145 ugly, but there's really nowhere else that we have access to the
1146 required information. FIXME: Is the COMDAT symbol index used for
1147 any purpose other than objdump? */
1150 styp_to_sec_flags (bfd *abfd,
1154 flagword *flags_ptr)
1156 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
1157 long styp_flags = internal_s->s_flags;
1159 bfd_boolean result = TRUE;
1160 bfd_boolean is_dbg = FALSE;
1162 if (CONST_STRNEQ (name, DOT_DEBUG)
1163 || CONST_STRNEQ (name, DOT_ZDEBUG)
1164 #ifdef COFF_LONG_SECTION_NAMES
1165 || CONST_STRNEQ (name, GNU_LINKONCE_WI)
1166 || CONST_STRNEQ (name, GNU_LINKONCE_WT)
1168 || CONST_STRNEQ (name, ".stab"))
1170 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
1171 sec_flags = SEC_READONLY;
1173 /* If section disallows read, then set the NOREAD flag. */
1174 if ((styp_flags & IMAGE_SCN_MEM_READ) == 0)
1175 sec_flags |= SEC_COFF_NOREAD;
1177 /* Process each flag bit in styp_flags in turn. */
1180 long flag = styp_flags & - styp_flags;
1181 char * unhandled = NULL;
1183 styp_flags &= ~ flag;
1185 /* We infer from the distinct read/write/execute bits the settings
1186 of some of the bfd flags; the actual values, should we need them,
1187 are also in pei_section_data (abfd, section)->pe_flags. */
1192 unhandled = "STYP_DSECT";
1195 unhandled = "STYP_GROUP";
1198 unhandled = "STYP_COPY";
1201 unhandled = "STYP_OVER";
1203 #ifdef SEC_NEVER_LOAD
1205 sec_flags |= SEC_NEVER_LOAD;
1208 case IMAGE_SCN_MEM_READ:
1209 sec_flags &= ~SEC_COFF_NOREAD;
1211 case IMAGE_SCN_TYPE_NO_PAD:
1214 case IMAGE_SCN_LNK_OTHER:
1215 unhandled = "IMAGE_SCN_LNK_OTHER";
1217 case IMAGE_SCN_MEM_NOT_CACHED:
1218 unhandled = "IMAGE_SCN_MEM_NOT_CACHED";
1220 case IMAGE_SCN_MEM_NOT_PAGED:
1221 /* Generate a warning message rather using the 'unhandled'
1222 variable as this will allow some .sys files generate by
1223 other toolchains to be processed. See bugzilla issue 196. */
1224 _bfd_error_handler (_("%B: Warning: Ignoring section flag IMAGE_SCN_MEM_NOT_PAGED in section %s"),
1227 case IMAGE_SCN_MEM_EXECUTE:
1228 sec_flags |= SEC_CODE;
1230 case IMAGE_SCN_MEM_WRITE:
1231 sec_flags &= ~ SEC_READONLY;
1233 case IMAGE_SCN_MEM_DISCARDABLE:
1234 /* The MS PE spec says that debug sections are DISCARDABLE,
1235 but the presence of a DISCARDABLE flag does not necessarily
1236 mean that a given section contains debug information. Thus
1237 we only set the SEC_DEBUGGING flag on sections that we
1238 recognise as containing debug information. */
1241 || strcmp (name, _COMMENT) == 0
1245 sec_flags |= SEC_DEBUGGING | SEC_READONLY;
1248 case IMAGE_SCN_MEM_SHARED:
1249 sec_flags |= SEC_COFF_SHARED;
1251 case IMAGE_SCN_LNK_REMOVE:
1253 sec_flags |= SEC_EXCLUDE;
1255 case IMAGE_SCN_CNT_CODE:
1256 sec_flags |= SEC_CODE | SEC_ALLOC | SEC_LOAD;
1258 case IMAGE_SCN_CNT_INITIALIZED_DATA:
1260 sec_flags |= SEC_DEBUGGING;
1262 sec_flags |= SEC_DATA | SEC_ALLOC | SEC_LOAD;
1264 case IMAGE_SCN_CNT_UNINITIALIZED_DATA:
1265 sec_flags |= SEC_ALLOC;
1267 case IMAGE_SCN_LNK_INFO:
1268 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1269 defined. coff_compute_section_file_positions uses
1270 COFF_PAGE_SIZE to ensure that the low order bits of the
1271 section VMA and the file offset match. If we don't know
1272 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1273 and demand page loading of the file will fail. */
1274 #ifdef COFF_PAGE_SIZE
1275 sec_flags |= SEC_DEBUGGING;
1278 case IMAGE_SCN_LNK_COMDAT:
1279 /* COMDAT gets very special treatment. */
1280 sec_flags = handle_COMDAT (abfd, sec_flags, hdr, name, section);
1283 /* Silently ignore for now. */
1287 /* If the section flag was not handled, report it here. */
1288 if (unhandled != NULL)
1290 (*_bfd_error_handler)
1291 (_("%B (%s): Section flag %s (0x%x) ignored"),
1292 abfd, name, unhandled, flag);
1297 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1298 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1299 only link a single copy of the section. This is used to support
1300 g++. g++ will emit each template expansion in its own section.
1301 The symbols will be defined as weak, so that multiple definitions
1302 are permitted. The GNU linker extension is to actually discard
1303 all but one of the sections. */
1304 if (CONST_STRNEQ (name, ".gnu.linkonce"))
1305 sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1309 * flags_ptr = sec_flags;
1314 #endif /* COFF_WITH_PE */
1316 #define get_index(symbol) ((symbol)->udata.i)
1320 bfd_coff_backend_data
1324 .{* COFF symbol classifications. *}
1326 .enum coff_symbol_classification
1328 . {* Global symbol. *}
1329 . COFF_SYMBOL_GLOBAL,
1330 . {* Common symbol. *}
1331 . COFF_SYMBOL_COMMON,
1332 . {* Undefined symbol. *}
1333 . COFF_SYMBOL_UNDEFINED,
1334 . {* Local symbol. *}
1335 . COFF_SYMBOL_LOCAL,
1336 . {* PE section symbol. *}
1337 . COFF_SYMBOL_PE_SECTION
1340 Special entry points for gdb to swap in coff symbol table parts:
1343 . void (*_bfd_coff_swap_aux_in)
1344 . (bfd *, void *, int, int, int, int, void *);
1346 . void (*_bfd_coff_swap_sym_in)
1347 . (bfd *, void *, void *);
1349 . void (*_bfd_coff_swap_lineno_in)
1350 . (bfd *, void *, void *);
1352 . unsigned int (*_bfd_coff_swap_aux_out)
1353 . (bfd *, void *, int, int, int, int, void *);
1355 . unsigned int (*_bfd_coff_swap_sym_out)
1356 . (bfd *, void *, void *);
1358 . unsigned int (*_bfd_coff_swap_lineno_out)
1359 . (bfd *, void *, void *);
1361 . unsigned int (*_bfd_coff_swap_reloc_out)
1362 . (bfd *, void *, void *);
1364 . unsigned int (*_bfd_coff_swap_filehdr_out)
1365 . (bfd *, void *, void *);
1367 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1368 . (bfd *, void *, void *);
1370 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1371 . (bfd *, void *, void *);
1373 . unsigned int _bfd_filhsz;
1374 . unsigned int _bfd_aoutsz;
1375 . unsigned int _bfd_scnhsz;
1376 . unsigned int _bfd_symesz;
1377 . unsigned int _bfd_auxesz;
1378 . unsigned int _bfd_relsz;
1379 . unsigned int _bfd_linesz;
1380 . unsigned int _bfd_filnmlen;
1381 . bfd_boolean _bfd_coff_long_filenames;
1383 . bfd_boolean _bfd_coff_long_section_names;
1384 . bfd_boolean (*_bfd_coff_set_long_section_names)
1387 . unsigned int _bfd_coff_default_section_alignment_power;
1388 . bfd_boolean _bfd_coff_force_symnames_in_strings;
1389 . unsigned int _bfd_coff_debug_string_prefix_length;
1391 . void (*_bfd_coff_swap_filehdr_in)
1392 . (bfd *, void *, void *);
1394 . void (*_bfd_coff_swap_aouthdr_in)
1395 . (bfd *, void *, void *);
1397 . void (*_bfd_coff_swap_scnhdr_in)
1398 . (bfd *, void *, void *);
1400 . void (*_bfd_coff_swap_reloc_in)
1401 . (bfd *abfd, void *, void *);
1403 . bfd_boolean (*_bfd_coff_bad_format_hook)
1406 . bfd_boolean (*_bfd_coff_set_arch_mach_hook)
1409 . void * (*_bfd_coff_mkobject_hook)
1410 . (bfd *, void *, void *);
1412 . bfd_boolean (*_bfd_styp_to_sec_flags_hook)
1413 . (bfd *, void *, const char *, asection *, flagword *);
1415 . void (*_bfd_set_alignment_hook)
1416 . (bfd *, asection *, void *);
1418 . bfd_boolean (*_bfd_coff_slurp_symbol_table)
1421 . bfd_boolean (*_bfd_coff_symname_in_debug)
1422 . (bfd *, struct internal_syment *);
1424 . bfd_boolean (*_bfd_coff_pointerize_aux_hook)
1425 . (bfd *, combined_entry_type *, combined_entry_type *,
1426 . unsigned int, combined_entry_type *);
1428 . bfd_boolean (*_bfd_coff_print_aux)
1429 . (bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1430 . combined_entry_type *, unsigned int);
1432 . void (*_bfd_coff_reloc16_extra_cases)
1433 . (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1434 . bfd_byte *, unsigned int *, unsigned int *);
1436 . int (*_bfd_coff_reloc16_estimate)
1437 . (bfd *, asection *, arelent *, unsigned int,
1438 . struct bfd_link_info *);
1440 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1441 . (bfd *, struct internal_syment *);
1443 . bfd_boolean (*_bfd_coff_compute_section_file_positions)
1446 . bfd_boolean (*_bfd_coff_start_final_link)
1447 . (bfd *, struct bfd_link_info *);
1449 . bfd_boolean (*_bfd_coff_relocate_section)
1450 . (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1451 . struct internal_reloc *, struct internal_syment *, asection **);
1453 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1454 . (bfd *, asection *, struct internal_reloc *,
1455 . struct coff_link_hash_entry *, struct internal_syment *,
1458 . bfd_boolean (*_bfd_coff_adjust_symndx)
1459 . (bfd *, struct bfd_link_info *, bfd *, asection *,
1460 . struct internal_reloc *, bfd_boolean *);
1462 . bfd_boolean (*_bfd_coff_link_add_one_symbol)
1463 . (struct bfd_link_info *, bfd *, const char *, flagword,
1464 . asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
1465 . struct bfd_link_hash_entry **);
1467 . bfd_boolean (*_bfd_coff_link_output_has_begun)
1468 . (bfd *, struct coff_final_link_info *);
1470 . bfd_boolean (*_bfd_coff_final_link_postscript)
1471 . (bfd *, struct coff_final_link_info *);
1473 . bfd_boolean (*_bfd_coff_print_pdata)
1476 .} bfd_coff_backend_data;
1478 .#define coff_backend_info(abfd) \
1479 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1481 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1482 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1484 .#define bfd_coff_swap_sym_in(a,e,i) \
1485 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1487 .#define bfd_coff_swap_lineno_in(a,e,i) \
1488 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1490 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1491 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1493 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1494 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1496 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1497 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1499 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1500 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1502 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1503 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1505 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1506 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1508 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1509 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1511 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1512 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1513 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1514 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1515 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1516 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1517 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1518 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1519 .#define bfd_coff_long_filenames(abfd) \
1520 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1521 .#define bfd_coff_long_section_names(abfd) \
1522 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1523 .#define bfd_coff_set_long_section_names(abfd, enable) \
1524 . ((coff_backend_info (abfd)->_bfd_coff_set_long_section_names) (abfd, enable))
1525 .#define bfd_coff_default_section_alignment_power(abfd) \
1526 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1527 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1528 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1530 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1531 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1533 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1534 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1536 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1537 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1539 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1540 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1542 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1543 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1544 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1545 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1546 . (abfd, filehdr, aouthdr))
1548 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1549 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1550 . (abfd, scnhdr, name, section, flags_ptr))
1552 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1553 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1555 .#define bfd_coff_slurp_symbol_table(abfd)\
1556 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1558 .#define bfd_coff_symname_in_debug(abfd, sym)\
1559 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1561 .#define bfd_coff_force_symnames_in_strings(abfd)\
1562 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1564 .#define bfd_coff_debug_string_prefix_length(abfd)\
1565 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1567 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1568 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1569 . (abfd, file, base, symbol, aux, indaux))
1571 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1572 . reloc, data, src_ptr, dst_ptr)\
1573 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1574 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1576 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1577 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1578 . (abfd, section, reloc, shrink, link_info))
1580 .#define bfd_coff_classify_symbol(abfd, sym)\
1581 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1584 .#define bfd_coff_compute_section_file_positions(abfd)\
1585 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1588 .#define bfd_coff_start_final_link(obfd, info)\
1589 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1591 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1592 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1593 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1594 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1595 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1596 . (abfd, sec, rel, h, sym, addendp))
1597 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1598 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1599 . (obfd, info, ibfd, sec, rel, adjustedp))
1600 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1601 . value, string, cp, coll, hashp)\
1602 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1603 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1605 .#define bfd_coff_link_output_has_begun(a,p) \
1606 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p))
1607 .#define bfd_coff_final_link_postscript(a,p) \
1608 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p))
1610 .#define bfd_coff_have_print_pdata(a) \
1611 . (coff_backend_info (a)->_bfd_coff_print_pdata)
1612 .#define bfd_coff_print_pdata(a,p) \
1613 . ((coff_backend_info (a)->_bfd_coff_print_pdata) (a, p))
1615 .{* Macro: Returns true if the bfd is a PE executable as opposed to a
1616 . PE object file. *}
1617 .#define bfd_pei_p(abfd) \
1618 . (CONST_STRNEQ ((abfd)->xvec->name, "pei-"))
1621 /* See whether the magic number matches. */
1624 coff_bad_format_hook (bfd * abfd ATTRIBUTE_UNUSED, void * filehdr)
1626 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1628 if (BADMAG (*internal_f))
1631 /* If the optional header is NULL or not the correct size then
1632 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1633 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1634 optional header is of a different size.
1636 But the mips keeps extra stuff in it's opthdr, so dont check
1639 #if defined(M88) || defined(I960)
1640 if (internal_f->f_opthdr != 0 && bfd_coff_aoutsz (abfd) != internal_f->f_opthdr)
1649 ticoff0_bad_format_hook (bfd *abfd ATTRIBUTE_UNUSED, void * filehdr)
1651 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1653 if (COFF0_BADMAG (*internal_f))
1662 ticoff1_bad_format_hook (bfd *abfd ATTRIBUTE_UNUSED, void * filehdr)
1664 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1666 if (COFF1_BADMAG (*internal_f))
1673 /* Check whether this section uses an alignment other than the
1677 coff_set_custom_section_alignment (bfd *abfd ATTRIBUTE_UNUSED,
1679 const struct coff_section_alignment_entry *alignment_table,
1680 const unsigned int table_size)
1682 const unsigned int default_alignment = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1685 for (i = 0; i < table_size; ++i)
1687 const char *secname = bfd_get_section_name (abfd, section);
1689 if (alignment_table[i].comparison_length == (unsigned int) -1
1690 ? strcmp (alignment_table[i].name, secname) == 0
1691 : strncmp (alignment_table[i].name, secname,
1692 alignment_table[i].comparison_length) == 0)
1695 if (i >= table_size)
1698 if (alignment_table[i].default_alignment_min != COFF_ALIGNMENT_FIELD_EMPTY
1699 && default_alignment < alignment_table[i].default_alignment_min)
1702 if (alignment_table[i].default_alignment_max != COFF_ALIGNMENT_FIELD_EMPTY
1703 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1704 && default_alignment > alignment_table[i].default_alignment_max
1709 section->alignment_power = alignment_table[i].alignment_power;
1712 /* Custom section alignment records. */
1714 static const struct coff_section_alignment_entry
1715 coff_section_alignment_table[] =
1717 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1718 COFF_SECTION_ALIGNMENT_ENTRIES,
1720 /* There must not be any gaps between .stabstr sections. */
1721 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1722 1, COFF_ALIGNMENT_FIELD_EMPTY, 0 },
1723 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1724 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1725 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1726 /* Similarly for the .ctors and .dtors sections. */
1727 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1728 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1729 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1730 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 }
1733 static const unsigned int coff_section_alignment_table_size =
1734 sizeof coff_section_alignment_table / sizeof coff_section_alignment_table[0];
1736 /* Initialize a section structure with information peculiar to this
1737 particular implementation of COFF. */
1740 coff_new_section_hook (bfd * abfd, asection * section)
1742 combined_entry_type *native;
1744 unsigned char sclass = C_STAT;
1746 section->alignment_power = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1749 if (bfd_xcoff_text_align_power (abfd) != 0
1750 && strcmp (bfd_get_section_name (abfd, section), ".text") == 0)
1751 section->alignment_power = bfd_xcoff_text_align_power (abfd);
1752 else if (bfd_xcoff_data_align_power (abfd) != 0
1753 && strcmp (bfd_get_section_name (abfd, section), ".data") == 0)
1754 section->alignment_power = bfd_xcoff_data_align_power (abfd);
1759 for (i = 0; i < XCOFF_DWSECT_NBR_NAMES; i++)
1760 if (strcmp (bfd_get_section_name (abfd, section),
1761 xcoff_dwsect_names[i].name) == 0)
1763 section->alignment_power = 0;
1770 /* Set up the section symbol. */
1771 if (!_bfd_generic_new_section_hook (abfd, section))
1774 /* Allocate aux records for section symbols, to store size and
1777 @@ The 10 is a guess at a plausible maximum number of aux entries
1778 (but shouldn't be a constant). */
1779 amt = sizeof (combined_entry_type) * 10;
1780 native = (combined_entry_type *) bfd_zalloc (abfd, amt);
1784 /* We don't need to set up n_name, n_value, or n_scnum in the native
1785 symbol information, since they'll be overridden by the BFD symbol
1786 anyhow. However, we do need to set the type and storage class,
1787 in case this symbol winds up getting written out. The value 0
1788 for n_numaux is already correct. */
1790 native->u.syment.n_type = T_NULL;
1791 native->u.syment.n_sclass = sclass;
1793 coffsymbol (section->symbol)->native = native;
1795 coff_set_custom_section_alignment (abfd, section,
1796 coff_section_alignment_table,
1797 coff_section_alignment_table_size);
1802 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1804 /* Set the alignment of a BFD section. */
1807 coff_set_alignment_hook (bfd * abfd ATTRIBUTE_UNUSED,
1811 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1815 /* Extract ALIGN from 2**ALIGN stored in section header. */
1816 for (i = 0; i < 32; i++)
1817 if ((1 << i) >= hdr->s_align)
1821 /* TI tools puts the alignment power in bits 8-11. */
1822 i = (hdr->s_flags >> 8) & 0xF ;
1824 #ifdef COFF_DECODE_ALIGNMENT
1825 i = COFF_DECODE_ALIGNMENT(hdr->s_flags);
1827 section->alignment_power = i;
1829 #ifdef coff_set_section_load_page
1830 coff_set_section_load_page (section, hdr->s_page);
1834 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1838 coff_set_alignment_hook (bfd * abfd ATTRIBUTE_UNUSED,
1842 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1844 unsigned int alignment_power_const
1845 = hdr->s_flags & IMAGE_SCN_ALIGN_POWER_BIT_MASK;
1847 switch (alignment_power_const)
1849 case IMAGE_SCN_ALIGN_8192BYTES:
1850 case IMAGE_SCN_ALIGN_4096BYTES:
1851 case IMAGE_SCN_ALIGN_2048BYTES:
1852 case IMAGE_SCN_ALIGN_1024BYTES:
1853 case IMAGE_SCN_ALIGN_512BYTES:
1854 case IMAGE_SCN_ALIGN_256BYTES:
1855 case IMAGE_SCN_ALIGN_128BYTES:
1856 case IMAGE_SCN_ALIGN_64BYTES:
1857 case IMAGE_SCN_ALIGN_32BYTES:
1858 case IMAGE_SCN_ALIGN_16BYTES:
1859 case IMAGE_SCN_ALIGN_8BYTES:
1860 case IMAGE_SCN_ALIGN_4BYTES:
1861 case IMAGE_SCN_ALIGN_2BYTES:
1862 case IMAGE_SCN_ALIGN_1BYTES:
1863 section->alignment_power
1864 = IMAGE_SCN_ALIGN_POWER_NUM (alignment_power_const);
1870 /* In a PE image file, the s_paddr field holds the virtual size of a
1871 section, while the s_size field holds the raw size. We also keep
1872 the original section flag value, since not every bit can be
1873 mapped onto a generic BFD section bit. */
1874 if (coff_section_data (abfd, section) == NULL)
1876 amt = sizeof (struct coff_section_tdata);
1877 section->used_by_bfd = bfd_zalloc (abfd, amt);
1878 if (section->used_by_bfd == NULL)
1879 /* FIXME: Return error. */
1883 if (pei_section_data (abfd, section) == NULL)
1885 amt = sizeof (struct pei_section_tdata);
1886 coff_section_data (abfd, section)->tdata = bfd_zalloc (abfd, amt);
1887 if (coff_section_data (abfd, section)->tdata == NULL)
1888 /* FIXME: Return error. */
1891 pei_section_data (abfd, section)->virt_size = hdr->s_paddr;
1892 pei_section_data (abfd, section)->pe_flags = hdr->s_flags;
1894 section->lma = hdr->s_vaddr;
1896 /* Check for extended relocs. */
1897 if (hdr->s_flags & IMAGE_SCN_LNK_NRELOC_OVFL)
1899 struct external_reloc dst;
1900 struct internal_reloc n;
1901 file_ptr oldpos = bfd_tell (abfd);
1902 bfd_size_type relsz = bfd_coff_relsz (abfd);
1904 if (bfd_seek (abfd, (file_ptr) hdr->s_relptr, 0) != 0)
1906 if (bfd_bread (& dst, relsz, abfd) != relsz)
1909 coff_swap_reloc_in (abfd, &dst, &n);
1910 if (bfd_seek (abfd, oldpos, 0) != 0)
1912 section->reloc_count = hdr->s_nreloc = n.r_vaddr - 1;
1913 section->rel_filepos += relsz;
1915 else if (hdr->s_nreloc == 0xffff)
1916 (*_bfd_error_handler)
1917 ("%s: warning: claims to have 0xffff relocs, without overflow",
1918 bfd_get_filename (abfd));
1921 #undef ELIFALIGN_SET
1923 #else /* ! COFF_WITH_PE */
1926 /* We grossly abuse this function to handle XCOFF overflow headers.
1927 When we see one, we correct the reloc and line number counts in the
1928 real header, and remove the section we just created. */
1931 coff_set_alignment_hook (bfd *abfd, asection *section, void * scnhdr)
1933 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1936 if ((hdr->s_flags & STYP_OVRFLO) == 0)
1939 real_sec = coff_section_from_bfd_index (abfd, (int) hdr->s_nreloc);
1940 if (real_sec == NULL)
1943 real_sec->reloc_count = hdr->s_paddr;
1944 real_sec->lineno_count = hdr->s_vaddr;
1946 if (!bfd_section_removed_from_list (abfd, section))
1948 bfd_section_list_remove (abfd, section);
1949 --abfd->section_count;
1953 #else /* ! RS6000COFF_C */
1955 #define coff_set_alignment_hook \
1956 ((void (*) (bfd *, asection *, void *)) bfd_void)
1958 #endif /* ! RS6000COFF_C */
1959 #endif /* ! COFF_WITH_PE */
1960 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1962 #ifndef coff_mkobject
1965 coff_mkobject (bfd * abfd)
1967 coff_data_type *coff;
1968 bfd_size_type amt = sizeof (coff_data_type);
1970 abfd->tdata.coff_obj_data = bfd_zalloc (abfd, amt);
1971 if (abfd->tdata.coff_obj_data == NULL)
1973 coff = coff_data (abfd);
1974 coff->symbols = NULL;
1975 coff->conversion_table = NULL;
1976 coff->raw_syments = NULL;
1977 coff->relocbase = 0;
1978 coff->local_toc_sym_map = 0;
1980 /* make_abs_section(abfd);*/
1986 /* Create the COFF backend specific information. */
1988 #ifndef coff_mkobject_hook
1990 coff_mkobject_hook (bfd * abfd,
1992 void * aouthdr ATTRIBUTE_UNUSED)
1994 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1995 coff_data_type *coff;
1997 if (! coff_mkobject (abfd))
2000 coff = coff_data (abfd);
2002 coff->sym_filepos = internal_f->f_symptr;
2004 /* These members communicate important constants about the symbol
2005 table to GDB's symbol-reading code. These `constants'
2006 unfortunately vary among coff implementations... */
2007 coff->local_n_btmask = N_BTMASK;
2008 coff->local_n_btshft = N_BTSHFT;
2009 coff->local_n_tmask = N_TMASK;
2010 coff->local_n_tshift = N_TSHIFT;
2011 coff->local_symesz = bfd_coff_symesz (abfd);
2012 coff->local_auxesz = bfd_coff_auxesz (abfd);
2013 coff->local_linesz = bfd_coff_linesz (abfd);
2015 coff->timestamp = internal_f->f_timdat;
2017 obj_raw_syment_count (abfd) =
2018 obj_conv_table_size (abfd) =
2019 internal_f->f_nsyms;
2022 if ((internal_f->f_flags & F_SHROBJ) != 0)
2023 abfd->flags |= DYNAMIC;
2024 if (aouthdr != NULL && internal_f->f_opthdr >= bfd_coff_aoutsz (abfd))
2026 struct internal_aouthdr *internal_a =
2027 (struct internal_aouthdr *) aouthdr;
2028 struct xcoff_tdata *xcoff;
2030 xcoff = xcoff_data (abfd);
2031 # ifdef U803XTOCMAGIC
2032 xcoff->xcoff64 = internal_f->f_magic == U803XTOCMAGIC;
2036 xcoff->full_aouthdr = TRUE;
2037 xcoff->toc = internal_a->o_toc;
2038 xcoff->sntoc = internal_a->o_sntoc;
2039 xcoff->snentry = internal_a->o_snentry;
2040 bfd_xcoff_text_align_power (abfd) = internal_a->o_algntext;
2041 bfd_xcoff_data_align_power (abfd) = internal_a->o_algndata;
2042 xcoff->modtype = internal_a->o_modtype;
2043 xcoff->cputype = internal_a->o_cputype;
2044 xcoff->maxdata = internal_a->o_maxdata;
2045 xcoff->maxstack = internal_a->o_maxstack;
2050 /* Set the flags field from the COFF header read in. */
2051 if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags))
2056 /* FIXME: I'm not sure this is ever executed, since peicode.h
2057 defines coff_mkobject_hook. */
2058 if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0)
2059 abfd->flags |= HAS_DEBUG;
2062 if ((internal_f->f_flags & F_GO32STUB) != 0)
2063 coff->go32stub = (char *) bfd_alloc (abfd, (bfd_size_type) GO32_STUBSIZE);
2064 if (coff->go32stub != NULL)
2065 memcpy (coff->go32stub, internal_f->go32stub, GO32_STUBSIZE);
2071 /* Determine the machine architecture and type. FIXME: This is target
2072 dependent because the magic numbers are defined in the target
2073 dependent header files. But there is no particular need for this.
2074 If the magic numbers were moved to a separate file, this function
2075 would be target independent and would also be much more successful
2076 at linking together COFF files for different architectures. */
2079 coff_set_arch_mach_hook (bfd *abfd, void * filehdr)
2081 unsigned long machine;
2082 enum bfd_architecture arch;
2083 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
2085 /* Zero selects the default machine for an arch. */
2087 switch (internal_f->f_magic)
2089 #ifdef OR32_MAGIC_BIG
2090 case OR32_MAGIC_BIG:
2091 case OR32_MAGIC_LITTLE:
2092 arch = bfd_arch_or32;
2097 arch = bfd_arch_powerpc;
2103 case I386AIXMAGIC: /* Danbury PS/2 AIX C Compiler. */
2104 case LYNXCOFFMAGIC: /* Shadows the m68k Lynx number below, sigh. */
2105 arch = bfd_arch_i386;
2110 arch = bfd_arch_i386;
2111 machine = bfd_mach_x86_64;
2116 arch = bfd_arch_ia64;
2123 arch = bfd_arch_arm;
2124 machine = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
2125 if (machine == bfd_mach_arm_unknown)
2127 switch (internal_f->f_flags & F_ARM_ARCHITECTURE_MASK)
2129 case F_ARM_2: machine = bfd_mach_arm_2; break;
2130 case F_ARM_2a: machine = bfd_mach_arm_2a; break;
2131 case F_ARM_3: machine = bfd_mach_arm_3; break;
2133 case F_ARM_3M: machine = bfd_mach_arm_3M; break;
2134 case F_ARM_4: machine = bfd_mach_arm_4; break;
2135 case F_ARM_4T: machine = bfd_mach_arm_4T; break;
2136 /* The COFF header does not have enough bits available
2137 to cover all the different ARM architectures. So
2138 we interpret F_ARM_5, the highest flag value to mean
2139 "the highest ARM architecture known to BFD" which is
2140 currently the XScale. */
2141 case F_ARM_5: machine = bfd_mach_arm_XScale; break;
2149 #ifdef MC68KBCSMAGIC
2152 #ifdef APOLLOM68KMAGIC
2153 case APOLLOM68KMAGIC:
2155 #ifdef LYNXCOFFMAGIC
2158 arch = bfd_arch_m68k;
2159 machine = bfd_mach_m68020;
2166 arch = bfd_arch_m88k;
2172 arch = bfd_arch_z80;
2173 switch (internal_f->f_flags & F_MACHMASK)
2176 case bfd_mach_z80strict << 12:
2177 case bfd_mach_z80 << 12:
2178 case bfd_mach_z80full << 12:
2179 case bfd_mach_r800 << 12:
2180 machine = ((unsigned)internal_f->f_flags & F_MACHMASK) >> 12;
2189 arch = bfd_arch_z8k;
2190 switch (internal_f->f_flags & F_MACHMASK)
2193 machine = bfd_mach_z8001;
2196 machine = bfd_mach_z8002;
2205 arch = bfd_arch_i860;
2212 arch = bfd_arch_i960;
2213 switch (F_I960TYPE & internal_f->f_flags)
2217 machine = bfd_mach_i960_core;
2220 machine = bfd_mach_i960_kb_sb;
2223 machine = bfd_mach_i960_mc;
2226 machine = bfd_mach_i960_xa;
2229 machine = bfd_mach_i960_ca;
2232 machine = bfd_mach_i960_ka_sa;
2235 machine = bfd_mach_i960_jx;
2238 machine = bfd_mach_i960_hx;
2257 if (xcoff_data (abfd)->cputype != -1)
2258 cputype = xcoff_data (abfd)->cputype & 0xff;
2261 /* We did not get a value from the a.out header. If the
2262 file has not been stripped, we may be able to get the
2263 architecture information from the first symbol, if it
2264 is a .file symbol. */
2265 if (obj_raw_syment_count (abfd) == 0)
2270 struct internal_syment sym;
2271 bfd_size_type amt = bfd_coff_symesz (abfd);
2273 buf = bfd_malloc (amt);
2274 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
2275 || bfd_bread (buf, amt, abfd) != amt)
2280 bfd_coff_swap_sym_in (abfd, buf, & sym);
2281 if (sym.n_sclass == C_FILE)
2282 cputype = sym.n_type & 0xff;
2289 /* FIXME: We don't handle all cases here. */
2294 arch = bfd_xcoff_architecture (abfd);
2295 machine = bfd_xcoff_machine (abfd);
2299 arch = bfd_arch_powerpc;
2300 machine = bfd_mach_ppc_601;
2302 case 2: /* 64 bit PowerPC */
2303 arch = bfd_arch_powerpc;
2304 machine = bfd_mach_ppc_620;
2307 arch = bfd_arch_powerpc;
2308 machine = bfd_mach_ppc;
2311 arch = bfd_arch_rs6000;
2312 machine = bfd_mach_rs6k;
2321 arch = bfd_arch_we32k;
2327 arch = bfd_arch_h8300;
2328 machine = bfd_mach_h8300;
2329 /* !! FIXME this probably isn't the right place for this. */
2330 abfd->flags |= BFD_IS_RELAXABLE;
2336 arch = bfd_arch_h8300;
2337 machine = bfd_mach_h8300h;
2338 /* !! FIXME this probably isn't the right place for this. */
2339 abfd->flags |= BFD_IS_RELAXABLE;
2345 arch = bfd_arch_h8300;
2346 machine = bfd_mach_h8300s;
2347 /* !! FIXME this probably isn't the right place for this. */
2348 abfd->flags |= BFD_IS_RELAXABLE;
2354 arch = bfd_arch_h8300;
2355 machine = bfd_mach_h8300hn;
2356 /* !! FIXME this probably isn't the right place for this. */
2357 abfd->flags |= BFD_IS_RELAXABLE;
2363 arch = bfd_arch_h8300;
2364 machine = bfd_mach_h8300sn;
2365 /* !! FIXME this probably isn't the right place for this. */
2366 abfd->flags |= BFD_IS_RELAXABLE;
2370 #ifdef SH_ARCH_MAGIC_BIG
2371 case SH_ARCH_MAGIC_BIG:
2372 case SH_ARCH_MAGIC_LITTLE:
2374 case SH_ARCH_MAGIC_WINCE:
2380 #ifdef MIPS_ARCH_MAGIC_WINCE
2381 case MIPS_ARCH_MAGIC_WINCE:
2382 arch = bfd_arch_mips;
2388 arch = bfd_arch_h8500;
2394 #ifdef LYNXCOFFMAGIC
2397 arch = bfd_arch_sparc;
2403 arch = bfd_arch_tic30;
2408 #ifdef TICOFF_TARGET_ARCH
2409 /* This TI COFF section should be used by all new TI COFF v0 targets. */
2411 arch = TICOFF_TARGET_ARCH;
2412 machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags);
2418 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */
2419 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */
2422 switch (internal_f->f_target_id)
2426 arch = TICOFF_TARGET_ARCH;
2427 machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags);
2431 arch = bfd_arch_obscure;
2432 (*_bfd_error_handler)
2433 (_("Unrecognized TI COFF target id '0x%x'"),
2434 internal_f->f_target_id);
2440 #ifdef TIC80_ARCH_MAGIC
2441 case TIC80_ARCH_MAGIC:
2442 arch = bfd_arch_tic80;
2448 arch = bfd_arch_mcore;
2454 arch = bfd_arch_w65;
2458 default: /* Unreadable input file type. */
2459 arch = bfd_arch_obscure;
2463 bfd_default_set_arch_mach (abfd, arch, machine);
2467 #ifdef SYMNAME_IN_DEBUG
2470 symname_in_debug_hook (bfd * abfd ATTRIBUTE_UNUSED, struct internal_syment *sym)
2472 return SYMNAME_IN_DEBUG (sym) != 0;
2477 #define symname_in_debug_hook \
2478 (bfd_boolean (*) (bfd *, struct internal_syment *)) bfd_false
2485 #define FORCE_SYMNAMES_IN_STRINGS
2488 /* Handle the csect auxent of a C_EXT, C_AIX_WEAKEXT or C_HIDEXT symbol. */
2491 coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED,
2492 combined_entry_type *table_base,
2493 combined_entry_type *symbol,
2494 unsigned int indaux,
2495 combined_entry_type *aux)
2497 int n_sclass = symbol->u.syment.n_sclass;
2499 if (CSECT_SYM_P (n_sclass)
2500 && indaux + 1 == symbol->u.syment.n_numaux)
2502 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
2504 aux->u.auxent.x_csect.x_scnlen.p =
2505 table_base + aux->u.auxent.x_csect.x_scnlen.l;
2506 aux->fix_scnlen = 1;
2509 /* Return TRUE to indicate that the caller should not do any
2510 further work on this auxent. */
2514 /* Return FALSE to indicate that this auxent should be handled by
2522 /* We don't want to pointerize bal entries. */
2525 coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED,
2526 combined_entry_type *table_base ATTRIBUTE_UNUSED,
2527 combined_entry_type *symbol,
2528 unsigned int indaux,
2529 combined_entry_type *aux ATTRIBUTE_UNUSED)
2531 /* Return TRUE if we don't want to pointerize this aux entry, which
2532 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2534 && (symbol->u.syment.n_sclass == C_LEAFPROC
2535 || symbol->u.syment.n_sclass == C_LEAFSTAT
2536 || symbol->u.syment.n_sclass == C_LEAFEXT));
2541 #define coff_pointerize_aux_hook 0
2544 #endif /* ! RS6000COFF_C */
2546 /* Print an aux entry. This returns TRUE if it has printed it. */
2549 coff_print_aux (bfd *abfd ATTRIBUTE_UNUSED,
2550 FILE *file ATTRIBUTE_UNUSED,
2551 combined_entry_type *table_base ATTRIBUTE_UNUSED,
2552 combined_entry_type *symbol ATTRIBUTE_UNUSED,
2553 combined_entry_type *aux ATTRIBUTE_UNUSED,
2554 unsigned int indaux ATTRIBUTE_UNUSED)
2557 if (CSECT_SYM_P (symbol->u.syment.n_sclass)
2558 && indaux + 1 == symbol->u.syment.n_numaux)
2560 /* This is a csect entry. */
2561 fprintf (file, "AUX ");
2562 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
2564 BFD_ASSERT (! aux->fix_scnlen);
2566 fprintf (file, "val %5lld",
2567 (long long) aux->u.auxent.x_csect.x_scnlen.l);
2569 fprintf (file, "val %5ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
2574 fprintf (file, "indx ");
2575 if (! aux->fix_scnlen)
2577 fprintf (file, "%4lld",
2578 (long long) aux->u.auxent.x_csect.x_scnlen.l);
2580 fprintf (file, "%4ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
2583 fprintf (file, "%4ld",
2584 (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base));
2587 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2588 aux->u.auxent.x_csect.x_parmhash,
2589 (unsigned int) aux->u.auxent.x_csect.x_snhash,
2590 SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp),
2591 SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp),
2592 (unsigned int) aux->u.auxent.x_csect.x_smclas,
2593 aux->u.auxent.x_csect.x_stab,
2594 (unsigned int) aux->u.auxent.x_csect.x_snstab);
2599 /* Return FALSE to indicate that no special action was taken. */
2607 To write relocations, the back end steps though the
2608 canonical relocation table and create an
2609 @code{internal_reloc}. The symbol index to use is removed from
2610 the @code{offset} field in the symbol table supplied. The
2611 address comes directly from the sum of the section base
2612 address and the relocation offset; the type is dug directly
2613 from the howto field. Then the @code{internal_reloc} is
2614 swapped into the shape of an @code{external_reloc} and written
2622 /* AUX's ld wants relocations to be sorted. */
2624 compare_arelent_ptr (const void * x, const void * y)
2626 const arelent **a = (const arelent **) x;
2627 const arelent **b = (const arelent **) y;
2628 bfd_size_type aadr = (*a)->address;
2629 bfd_size_type badr = (*b)->address;
2631 return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
2634 #endif /* TARG_AUX */
2637 coff_write_relocs (bfd * abfd, int first_undef)
2641 for (s = abfd->sections; s != NULL; s = s->next)
2644 struct external_reloc dst;
2651 /* Sort relocations before we write them out. */
2654 amt = s->reloc_count;
2655 amt *= sizeof (arelent *);
2656 p = bfd_malloc (amt);
2657 if (p == NULL && s->reloc_count > 0)
2659 memcpy (p, s->orelocation, (size_t) amt);
2660 qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr);
2664 if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
2668 if (obj_pe (abfd) && s->reloc_count >= 0xffff)
2670 /* Encode real count here as first reloc. */
2671 struct internal_reloc n;
2673 memset (& n, 0, sizeof (n));
2674 /* Add one to count *this* reloc (grr). */
2675 n.r_vaddr = s->reloc_count + 1;
2676 coff_swap_reloc_out (abfd, &n, &dst);
2677 if (bfd_bwrite (& dst, (bfd_size_type) bfd_coff_relsz (abfd),
2678 abfd) != bfd_coff_relsz (abfd))
2683 for (i = 0; i < s->reloc_count; i++)
2685 struct internal_reloc n;
2688 memset (& n, 0, sizeof (n));
2690 /* Now we've renumbered the symbols we know where the
2691 undefined symbols live in the table. Check the reloc
2692 entries for symbols who's output bfd isn't the right one.
2693 This is because the symbol was undefined (which means
2694 that all the pointers are never made to point to the same
2695 place). This is a bad thing,'cause the symbols attached
2696 to the output bfd are indexed, so that the relocation
2697 entries know which symbol index they point to. So we
2698 have to look up the output symbol here. */
2700 if (q->sym_ptr_ptr[0] != NULL && q->sym_ptr_ptr[0]->the_bfd != abfd)
2703 const char *sname = q->sym_ptr_ptr[0]->name;
2704 asymbol **outsyms = abfd->outsymbols;
2706 for (j = first_undef; outsyms[j]; j++)
2708 const char *intable = outsyms[j]->name;
2710 if (strcmp (intable, sname) == 0)
2712 /* Got a hit, so repoint the reloc. */
2713 q->sym_ptr_ptr = outsyms + j;
2719 n.r_vaddr = q->address + s->vma;
2722 /* The 29k const/consth reloc pair is a real kludge. The consth
2723 part doesn't have a symbol; it has an offset. So rebuilt
2725 if (q->howto->type == R_IHCONST)
2726 n.r_symndx = q->addend;
2729 if (q->sym_ptr_ptr && q->sym_ptr_ptr[0] != NULL)
2731 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2732 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q, s))
2734 if ((*q->sym_ptr_ptr)->section == bfd_abs_section_ptr
2735 && ((*q->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0)
2737 /* This is a relocation relative to the absolute symbol. */
2741 n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
2742 /* Check to see if the symbol reloc points to a symbol
2743 we don't have in our symbol table. */
2744 if (n.r_symndx > obj_conv_table_size (abfd))
2746 bfd_set_error (bfd_error_bad_value);
2747 _bfd_error_handler (_("%B: reloc against a non-existant symbol index: %ld"),
2754 #ifdef SWAP_OUT_RELOC_OFFSET
2755 n.r_offset = q->addend;
2759 /* Work out reloc type from what is required. */
2760 SELECT_RELOC (n, q->howto);
2762 n.r_type = q->howto->type;
2764 coff_swap_reloc_out (abfd, &n, &dst);
2766 if (bfd_bwrite (& dst, (bfd_size_type) bfd_coff_relsz (abfd),
2767 abfd) != bfd_coff_relsz (abfd))
2780 /* Set flags and magic number of a coff file from architecture and machine
2781 type. Result is TRUE if we can represent the arch&type, FALSE if not. */
2784 coff_set_flags (bfd * abfd,
2785 unsigned int *magicp ATTRIBUTE_UNUSED,
2786 unsigned short *flagsp ATTRIBUTE_UNUSED)
2788 switch (bfd_get_arch (abfd))
2793 switch (bfd_get_mach (abfd))
2796 case bfd_mach_z80strict:
2798 case bfd_mach_z80full:
2800 *flagsp = bfd_get_mach (abfd) << 12;
2812 switch (bfd_get_mach (abfd))
2814 case bfd_mach_z8001: *flagsp = F_Z8001; break;
2815 case bfd_mach_z8002: *flagsp = F_Z8002; break;
2816 default: return FALSE;
2827 *magicp = I960ROMAGIC;
2829 switch (bfd_get_mach (abfd))
2831 case bfd_mach_i960_core: flags = F_I960CORE; break;
2832 case bfd_mach_i960_kb_sb: flags = F_I960KB; break;
2833 case bfd_mach_i960_mc: flags = F_I960MC; break;
2834 case bfd_mach_i960_xa: flags = F_I960XA; break;
2835 case bfd_mach_i960_ca: flags = F_I960CA; break;
2836 case bfd_mach_i960_ka_sa: flags = F_I960KA; break;
2837 case bfd_mach_i960_jx: flags = F_I960JX; break;
2838 case bfd_mach_i960_hx: flags = F_I960HX; break;
2839 default: return FALSE;
2848 case bfd_arch_tic30:
2849 *magicp = TIC30MAGIC;
2853 #ifdef TICOFF_DEFAULT_MAGIC
2854 case TICOFF_TARGET_ARCH:
2855 /* If there's no indication of which version we want, use the default. */
2857 *magicp = TICOFF_DEFAULT_MAGIC;
2860 /* We may want to output in a different COFF version. */
2861 switch (abfd->xvec->name[4])
2864 *magicp = TICOFF0MAGIC;
2867 *magicp = TICOFF1MAGIC;
2870 *magicp = TICOFF2MAGIC;
2876 TICOFF_TARGET_MACHINE_SET (flagsp, bfd_get_mach (abfd));
2880 #ifdef TIC80_ARCH_MAGIC
2881 case bfd_arch_tic80:
2882 *magicp = TIC80_ARCH_MAGIC;
2889 * magicp = ARMPEMAGIC;
2891 * magicp = ARMMAGIC;
2894 if (APCS_SET (abfd))
2896 if (APCS_26_FLAG (abfd))
2897 * flagsp |= F_APCS26;
2899 if (APCS_FLOAT_FLAG (abfd))
2900 * flagsp |= F_APCS_FLOAT;
2902 if (PIC_FLAG (abfd))
2905 if (INTERWORK_SET (abfd) && INTERWORK_FLAG (abfd))
2906 * flagsp |= F_INTERWORK;
2907 switch (bfd_get_mach (abfd))
2909 case bfd_mach_arm_2: * flagsp |= F_ARM_2; break;
2910 case bfd_mach_arm_2a: * flagsp |= F_ARM_2a; break;
2911 case bfd_mach_arm_3: * flagsp |= F_ARM_3; break;
2912 case bfd_mach_arm_3M: * flagsp |= F_ARM_3M; break;
2913 case bfd_mach_arm_4: * flagsp |= F_ARM_4; break;
2914 case bfd_mach_arm_4T: * flagsp |= F_ARM_4T; break;
2915 case bfd_mach_arm_5: * flagsp |= F_ARM_5; break;
2916 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2917 See also the comment in coff_set_arch_mach_hook(). */
2918 case bfd_mach_arm_5T: * flagsp |= F_ARM_5; break;
2919 case bfd_mach_arm_5TE: * flagsp |= F_ARM_5; break;
2920 case bfd_mach_arm_XScale: * flagsp |= F_ARM_5; break;
2926 case bfd_arch_powerpc:
2931 #if defined(I386MAGIC) || defined(AMD64MAGIC)
2933 #if defined(I386MAGIC)
2934 *magicp = I386MAGIC;
2937 /* Just overwrite the usual value if we're doing Lynx. */
2938 *magicp = LYNXCOFFMAGIC;
2940 #if defined AMD64MAGIC
2941 *magicp = AMD64MAGIC;
2948 *magicp = I860MAGIC;
2954 *magicp = IA64MAGIC;
2960 #ifdef APOLLOM68KMAGIC
2961 *magicp = APOLLO_COFF_VERSION_NUMBER;
2963 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2964 #ifdef NAMES_HAVE_UNDERSCORE
2965 *magicp = MC68KBCSMAGIC;
2967 *magicp = MC68MAGIC;
2971 /* Just overwrite the usual value if we're doing Lynx. */
2972 *magicp = LYNXCOFFMAGIC;
2979 *magicp = MC88OMAGIC;
2984 case bfd_arch_h8300:
2985 switch (bfd_get_mach (abfd))
2987 case bfd_mach_h8300: *magicp = H8300MAGIC; return TRUE;
2988 case bfd_mach_h8300h: *magicp = H8300HMAGIC; return TRUE;
2989 case bfd_mach_h8300s: *magicp = H8300SMAGIC; return TRUE;
2990 case bfd_mach_h8300hn: *magicp = H8300HNMAGIC; return TRUE;
2991 case bfd_mach_h8300sn: *magicp = H8300SNMAGIC; return TRUE;
2997 #ifdef SH_ARCH_MAGIC_BIG
2999 #ifdef COFF_IMAGE_WITH_PE
3000 *magicp = SH_ARCH_MAGIC_WINCE;
3002 if (bfd_big_endian (abfd))
3003 *magicp = SH_ARCH_MAGIC_BIG;
3005 *magicp = SH_ARCH_MAGIC_LITTLE;
3010 #ifdef MIPS_ARCH_MAGIC_WINCE
3012 *magicp = MIPS_ARCH_MAGIC_WINCE;
3017 case bfd_arch_sparc:
3018 *magicp = SPARCMAGIC;
3020 /* Just overwrite the usual value if we're doing Lynx. */
3021 *magicp = LYNXCOFFMAGIC;
3027 case bfd_arch_h8500:
3028 *magicp = H8500MAGIC;
3034 case bfd_arch_we32k:
3035 *magicp = WE32KMAGIC;
3040 case bfd_arch_rs6000:
3042 case bfd_arch_powerpc:
3044 BFD_ASSERT (bfd_get_flavour (abfd) == bfd_target_xcoff_flavour);
3045 *magicp = bfd_xcoff_magic_number (abfd);
3050 case bfd_arch_mcore:
3051 * magicp = MCOREMAGIC;
3061 #ifdef OR32_MAGIC_BIG
3063 if (bfd_big_endian (abfd))
3064 * magicp = OR32_MAGIC_BIG;
3066 * magicp = OR32_MAGIC_LITTLE;
3070 default: /* Unknown architecture. */
3071 /* Fall through to "return FALSE" below, to avoid
3072 "statement never reached" errors on the one below. */
3080 coff_set_arch_mach (bfd * abfd,
3081 enum bfd_architecture arch,
3082 unsigned long machine)
3085 unsigned short dummy2;
3087 if (! bfd_default_set_arch_mach (abfd, arch, machine))
3090 if (arch != bfd_arch_unknown
3091 && ! coff_set_flags (abfd, &dummy1, &dummy2))
3092 return FALSE; /* We can't represent this type. */
3094 return TRUE; /* We're easy... */
3097 #ifdef COFF_IMAGE_WITH_PE
3099 /* This is used to sort sections by VMA, as required by PE image
3103 sort_by_secaddr (const void * arg1, const void * arg2)
3105 const asection *a = *(const asection **) arg1;
3106 const asection *b = *(const asection **) arg2;
3108 if (a->vma < b->vma)
3110 else if (a->vma > b->vma)
3116 #endif /* COFF_IMAGE_WITH_PE */
3118 /* Calculate the file position for each section. */
3121 #define ALIGN_SECTIONS_IN_FILE
3123 #if defined(TIC80COFF) || defined(TICOFF)
3124 #undef ALIGN_SECTIONS_IN_FILE
3128 coff_compute_section_file_positions (bfd * abfd)
3131 file_ptr sofar = bfd_coff_filhsz (abfd);
3132 bfd_boolean align_adjust;
3134 #ifdef ALIGN_SECTIONS_IN_FILE
3135 asection *previous = NULL;
3139 #ifdef COFF_IMAGE_WITH_PE
3142 if (coff_data (abfd)->link_info)
3144 page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
3146 /* If no file alignment has been set, default to one.
3147 This repairs 'ld -r' for arm-wince-pe target. */
3152 page_size = PE_DEF_FILE_ALIGNMENT;
3154 #ifdef COFF_PAGE_SIZE
3155 int page_size = COFF_PAGE_SIZE;
3160 /* On XCOFF, if we have symbols, set up the .debug section. */
3161 if (bfd_get_symcount (abfd) > 0)
3164 bfd_size_type i, symcount;
3168 symcount = bfd_get_symcount (abfd);
3169 for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++)
3171 coff_symbol_type *cf;
3173 cf = coff_symbol_from (abfd, *symp);
3175 && cf->native != NULL
3176 && SYMNAME_IN_DEBUG (&cf->native->u.syment))
3180 len = strlen (bfd_asymbol_name (*symp));
3181 if (len > SYMNMLEN || bfd_coff_force_symnames_in_strings (abfd))
3182 sz += len + 1 + bfd_coff_debug_string_prefix_length (abfd);
3189 dsec = bfd_make_section_old_way (abfd, DOT_DEBUG);
3193 dsec->flags |= SEC_HAS_CONTENTS;
3198 if (bfd_get_start_address (abfd))
3199 /* A start address may have been added to the original file. In this
3200 case it will need an optional header to record it. */
3201 abfd->flags |= EXEC_P;
3203 if (abfd->flags & EXEC_P)
3204 sofar += bfd_coff_aoutsz (abfd);
3206 else if (xcoff_data (abfd)->full_aouthdr)
3207 sofar += bfd_coff_aoutsz (abfd);
3209 sofar += SMALL_AOUTSZ;
3212 sofar += abfd->section_count * bfd_coff_scnhsz (abfd);
3215 /* XCOFF handles overflows in the reloc and line number count fields
3216 by allocating a new section header to hold the correct counts. */
3217 for (current = abfd->sections; current != NULL; current = current->next)
3218 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3219 sofar += bfd_coff_scnhsz (abfd);
3222 #ifdef COFF_IMAGE_WITH_PE
3224 /* PE requires the sections to be in memory order when listed in
3225 the section headers. It also does not like empty loadable
3226 sections. The sections apparently do not have to be in the
3227 right order in the image file itself, but we do need to get the
3228 target_index values right. */
3231 asection **section_list;
3235 #ifdef COFF_PAGE_SIZE
3236 /* Clear D_PAGED if section alignment is smaller than
3238 if (pe_data (abfd)->pe_opthdr.SectionAlignment < COFF_PAGE_SIZE)
3239 abfd->flags &= ~D_PAGED;
3243 for (current = abfd->sections; current != NULL; current = current->next)
3246 /* We allocate an extra cell to simplify the final loop. */
3247 amt = sizeof (struct asection *) * (count + 1);
3248 section_list = (asection **) bfd_malloc (amt);
3249 if (section_list == NULL)
3253 for (current = abfd->sections; current != NULL; current = current->next)
3255 section_list[i] = current;
3258 section_list[i] = NULL;
3260 qsort (section_list, count, sizeof (asection *), sort_by_secaddr);
3262 /* Rethread the linked list into sorted order; at the same time,
3263 assign target_index values. */
3265 abfd->sections = NULL;
3266 abfd->section_last = NULL;
3267 for (i = 0; i < count; i++)
3269 current = section_list[i];
3270 bfd_section_list_append (abfd, current);
3272 /* Later, if the section has zero size, we'll be throwing it
3273 away, so we don't want to number it now. Note that having
3274 a zero size and having real contents are different
3275 concepts: .bss has no contents, but (usually) non-zero
3277 if (current->size == 0)
3279 /* Discard. However, it still might have (valid) symbols
3280 in it, so arbitrarily set it to section 1 (indexing is
3281 1-based here; usually .text). __end__ and other
3282 contents of .endsection really have this happen.
3283 FIXME: This seems somewhat dubious. */
3284 current->target_index = 1;
3287 current->target_index = target_index++;
3290 free (section_list);
3292 #else /* ! COFF_IMAGE_WITH_PE */
3294 /* Set the target_index field. */
3296 for (current = abfd->sections; current != NULL; current = current->next)
3297 current->target_index = target_index++;
3299 #endif /* ! COFF_IMAGE_WITH_PE */
3301 if (target_index >= 32768)
3303 bfd_set_error (bfd_error_file_too_big);
3304 (*_bfd_error_handler)
3305 (_("%B: too many sections (%d)"), abfd, target_index);
3309 align_adjust = FALSE;
3310 for (current = abfd->sections;
3312 current = current->next)
3314 #ifdef COFF_IMAGE_WITH_PE
3315 /* With PE we have to pad each section to be a multiple of its
3316 page size too, and remember both sizes. */
3317 if (coff_section_data (abfd, current) == NULL)
3319 bfd_size_type amt = sizeof (struct coff_section_tdata);
3321 current->used_by_bfd = bfd_zalloc (abfd, amt);
3322 if (current->used_by_bfd == NULL)
3325 if (pei_section_data (abfd, current) == NULL)
3327 bfd_size_type amt = sizeof (struct pei_section_tdata);
3329 coff_section_data (abfd, current)->tdata = bfd_zalloc (abfd, amt);
3330 if (coff_section_data (abfd, current)->tdata == NULL)
3333 if (pei_section_data (abfd, current)->virt_size == 0)
3334 pei_section_data (abfd, current)->virt_size = current->size;
3337 /* Only deal with sections which have contents. */
3338 if (!(current->flags & SEC_HAS_CONTENTS))
3341 current->rawsize = current->size;
3343 #ifdef COFF_IMAGE_WITH_PE
3344 /* Make sure we skip empty sections in a PE image. */
3345 if (current->size == 0)
3349 /* Align the sections in the file to the same boundary on
3350 which they are aligned in virtual memory. I960 doesn't
3351 do this (FIXME) so we can stay in sync with Intel. 960
3352 doesn't yet page from files... */
3353 #ifdef ALIGN_SECTIONS_IN_FILE
3354 if ((abfd->flags & EXEC_P) != 0)
3356 /* Make sure this section is aligned on the right boundary - by
3357 padding the previous section up if necessary. */
3361 /* AIX loader checks the text section alignment of (vma - filepos)
3362 So even though the filepos may be aligned wrt the o_algntext, for
3363 AIX executables, this check fails. This shows up when a native
3364 AIX executable is stripped with gnu strip because the default vma
3365 of native is 0x10000150 but default for gnu is 0x10000140. Gnu
3366 stripped gnu excutable passes this check because the filepos is
3367 0x0140. This problem also show up with 64 bit shared objects. The
3368 data section must also be aligned. */
3369 if (!strcmp (current->name, _TEXT)
3370 || !strcmp (current->name, _DATA))
3375 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3377 align = 1 << current->alignment_power;
3378 pad = abs (current->vma - sofar) % align;
3389 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3392 if (previous != NULL)
3393 previous->size += sofar - old_sofar;
3398 /* In demand paged files the low order bits of the file offset
3399 must match the low order bits of the virtual address. */
3400 #ifdef COFF_PAGE_SIZE
3401 if ((abfd->flags & D_PAGED) != 0
3402 && (current->flags & SEC_ALLOC) != 0)
3403 sofar += (current->vma - (bfd_vma) sofar) % page_size;
3405 current->filepos = sofar;
3407 #ifdef COFF_IMAGE_WITH_PE
3408 /* Set the padded size. */
3409 current->size = (current->size + page_size - 1) & -page_size;
3412 sofar += current->size;
3414 #ifdef ALIGN_SECTIONS_IN_FILE
3415 /* Make sure that this section is of the right size too. */
3416 if ((abfd->flags & EXEC_P) == 0)
3418 bfd_size_type old_size;
3420 old_size = current->size;
3421 current->size = BFD_ALIGN (current->size,
3422 1 << current->alignment_power);
3423 align_adjust = current->size != old_size;
3424 sofar += current->size - old_size;
3429 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3430 align_adjust = sofar != old_sofar;
3431 current->size += sofar - old_sofar;
3435 #ifdef COFF_IMAGE_WITH_PE
3436 /* For PE we need to make sure we pad out to the aligned
3437 size, in case the caller only writes out data to the
3439 if (pei_section_data (abfd, current)->virt_size < current->size)
3440 align_adjust = TRUE;
3444 /* Force .lib sections to start at zero. The vma is then
3445 incremented in coff_set_section_contents. This is right for
3447 if (strcmp (current->name, _LIB) == 0)
3448 (void) bfd_set_section_vma (abfd, current, 0);
3451 #ifdef ALIGN_SECTIONS_IN_FILE
3456 /* It is now safe to write to the output file. If we needed an
3457 alignment adjustment for the last section, then make sure that
3458 there is a byte at offset sofar. If there are no symbols and no
3459 relocs, then nothing follows the last section. If we don't force
3460 the last byte out, then the file may appear to be truncated. */
3466 if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0
3467 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
3471 /* Make sure the relocations are aligned. We don't need to make
3472 sure that this byte exists, because it will only matter if there
3473 really are relocs. */
3474 sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER);
3476 obj_relocbase (abfd) = sofar;
3477 abfd->output_has_begun = TRUE;
3482 #ifdef COFF_IMAGE_WITH_PE
3484 static unsigned int pelength;
3485 static unsigned int peheader;
3488 coff_read_word (bfd *abfd, unsigned int *value)
3493 status = bfd_bread (b, (bfd_size_type) 2, abfd);
3501 *value = (unsigned int) b[0];
3503 *value = (unsigned int) (b[0] + (b[1] << 8));
3505 pelength += (unsigned int) status;
3511 coff_compute_checksum (bfd *abfd)
3513 bfd_boolean more_data;
3520 filepos = (file_ptr) 0;
3524 if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
3527 more_data = coff_read_word (abfd, &value);
3529 total = 0xffff & (total + (total >> 0x10));
3534 return (0xffff & (total + (total >> 0x10)));
3538 coff_apply_checksum (bfd *abfd)
3540 unsigned int computed;
3541 unsigned int checksum = 0;
3543 if (bfd_seek (abfd, 0x3c, SEEK_SET) != 0)
3546 if (!coff_read_word (abfd, &peheader))
3549 if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
3553 bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
3555 if (bfd_seek (abfd, peheader, SEEK_SET) != 0)
3558 computed = coff_compute_checksum (abfd);
3560 checksum = computed + pelength;
3562 if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
3565 bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
3570 #endif /* COFF_IMAGE_WITH_PE */
3573 coff_write_object_contents (bfd * abfd)
3576 bfd_boolean hasrelocs = FALSE;
3577 bfd_boolean haslinno = FALSE;
3578 #ifdef COFF_IMAGE_WITH_PE
3579 bfd_boolean hasdebug = FALSE;
3582 file_ptr reloc_base;
3583 file_ptr lineno_base;
3585 unsigned long reloc_size = 0, reloc_count = 0;
3586 unsigned long lnno_size = 0;
3587 bfd_boolean long_section_names;
3588 asection *text_sec = NULL;
3589 asection *data_sec = NULL;
3590 asection *bss_sec = NULL;
3591 struct internal_filehdr internal_f;
3592 struct internal_aouthdr internal_a;
3593 #ifdef COFF_LONG_SECTION_NAMES
3594 size_t string_size = STRING_SIZE_SIZE;
3597 bfd_set_error (bfd_error_system_call);
3599 /* Make a pass through the symbol table to count line number entries and
3600 put them into the correct asections. */
3601 lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd);
3603 if (! abfd->output_has_begun)
3605 if (! coff_compute_section_file_positions (abfd))
3609 reloc_base = obj_relocbase (abfd);
3611 /* Work out the size of the reloc and linno areas. */
3613 for (current = abfd->sections; current != NULL; current =
3617 /* We store the actual reloc count in the first reloc's addr. */
3618 if (obj_pe (abfd) && current->reloc_count >= 0xffff)
3621 reloc_count += current->reloc_count;
3624 reloc_size = reloc_count * bfd_coff_relsz (abfd);
3626 lineno_base = reloc_base + reloc_size;
3627 sym_base = lineno_base + lnno_size;
3629 /* Indicate in each section->line_filepos its actual file address. */
3630 for (current = abfd->sections; current != NULL; current =
3633 if (current->lineno_count)
3635 current->line_filepos = lineno_base;
3636 current->moving_line_filepos = lineno_base;
3637 lineno_base += current->lineno_count * bfd_coff_linesz (abfd);
3640 current->line_filepos = 0;
3642 if (current->reloc_count)
3644 current->rel_filepos = reloc_base;
3645 reloc_base += current->reloc_count * bfd_coff_relsz (abfd);
3647 /* Extra reloc to hold real count. */
3648 if (obj_pe (abfd) && current->reloc_count >= 0xffff)
3649 reloc_base += bfd_coff_relsz (abfd);
3653 current->rel_filepos = 0;
3656 /* Write section headers to the file. */
3657 internal_f.f_nscns = 0;
3659 if ((abfd->flags & EXEC_P) != 0)
3660 scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
3663 scn_base = bfd_coff_filhsz (abfd);
3666 if (xcoff_data (abfd)->full_aouthdr)
3667 scn_base += bfd_coff_aoutsz (abfd);
3669 scn_base += SMALL_AOUTSZ;
3674 if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
3677 long_section_names = FALSE;
3678 for (current = abfd->sections;
3680 current = current->next)
3682 struct internal_scnhdr section;
3683 #ifdef COFF_IMAGE_WITH_PE
3684 bfd_boolean is_reloc_section = FALSE;
3686 if (strcmp (current->name, DOT_RELOC) == 0)
3688 is_reloc_section = TRUE;
3690 pe_data (abfd)->has_reloc_section = 1;
3694 internal_f.f_nscns++;
3696 strncpy (section.s_name, current->name, SCNNMLEN);
3698 #ifdef COFF_LONG_SECTION_NAMES
3699 /* Handle long section names as in PE. This must be compatible
3700 with the code in coff_write_symbols and _bfd_coff_final_link. */
3701 if (bfd_coff_long_section_names (abfd))
3705 len = strlen (current->name);
3708 /* The s_name field is defined to be NUL-padded but need not be
3709 NUL-terminated. We use a temporary buffer so that we can still
3710 sprintf all eight chars without splatting a terminating NUL
3711 over the first byte of the following member (s_paddr). */
3712 char s_name_buf[SCNNMLEN + 1];
3714 /* An inherent limitation of the /nnnnnnn notation used to indicate
3715 the offset of the long name in the string table is that we
3716 cannot address entries beyone the ten million byte boundary. */
3717 if (string_size >= 10000000)
3719 bfd_set_error (bfd_error_file_too_big);
3720 (*_bfd_error_handler)
3721 (_("%B: section %s: string table overflow at offset %ld"),
3722 abfd, current->name, string_size);
3726 /* snprintf not strictly necessary now we've verified the value
3727 has less than eight ASCII digits, but never mind. */
3728 snprintf (s_name_buf, SCNNMLEN + 1, "/%lu", (unsigned long) string_size);
3729 /* Then strncpy takes care of any padding for us. */
3730 strncpy (section.s_name, s_name_buf, SCNNMLEN);
3731 string_size += len + 1;
3732 long_section_names = TRUE;
3738 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3739 Ian Taylor <ian@cygnus.com>. */
3740 if (strcmp (current->name, _LIB) == 0)
3741 section.s_vaddr = 0;
3744 section.s_vaddr = current->vma;
3745 section.s_paddr = current->lma;
3746 section.s_size = current->size;
3747 #ifdef coff_get_section_load_page
3748 section.s_page = coff_get_section_load_page (current);
3754 section.s_paddr = 0;
3756 #ifdef COFF_IMAGE_WITH_PE
3757 /* Reminder: s_paddr holds the virtual size of the section. */
3758 if (coff_section_data (abfd, current) != NULL
3759 && pei_section_data (abfd, current) != NULL)
3760 section.s_paddr = pei_section_data (abfd, current)->virt_size;
3762 section.s_paddr = 0;
3765 /* If this section has no size or is unloadable then the scnptr
3767 if (current->size == 0
3768 || (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
3769 section.s_scnptr = 0;
3771 section.s_scnptr = current->filepos;
3773 section.s_relptr = current->rel_filepos;
3774 section.s_lnnoptr = current->line_filepos;
3775 section.s_nreloc = current->reloc_count;
3776 section.s_nlnno = current->lineno_count;
3777 #ifndef COFF_IMAGE_WITH_PE
3778 /* In PEI, relocs come in the .reloc section. */
3779 if (current->reloc_count != 0)
3782 if (current->lineno_count != 0)
3784 #ifdef COFF_IMAGE_WITH_PE
3785 if ((current->flags & SEC_DEBUGGING) != 0
3786 && ! is_reloc_section)
3792 /* Indicate the use of an XCOFF overflow section header. */
3793 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3795 section.s_nreloc = 0xffff;
3796 section.s_nlnno = 0xffff;
3801 section.s_flags = sec_to_styp_flags (current->name, current->flags);
3803 if (!strcmp (current->name, _TEXT))
3805 else if (!strcmp (current->name, _DATA))
3807 else if (!strcmp (current->name, _BSS))
3811 section.s_align = (current->alignment_power
3812 ? 1 << current->alignment_power
3816 /* TI COFF puts the alignment power in bits 8-11 of the flags. */
3817 section.s_flags |= (current->alignment_power & 0xF) << 8;
3819 #ifdef COFF_ENCODE_ALIGNMENT
3820 COFF_ENCODE_ALIGNMENT(section, current->alignment_power);
3823 #ifdef COFF_IMAGE_WITH_PE
3824 /* Suppress output of the sections if they are null. ld
3825 includes the bss and data sections even if there is no size
3826 assigned to them. NT loader doesn't like it if these section
3827 headers are included if the sections themselves are not
3828 needed. See also coff_compute_section_file_positions. */
3829 if (section.s_size == 0)
3830 internal_f.f_nscns--;
3835 bfd_size_type amt = bfd_coff_scnhsz (abfd);
3837 if (coff_swap_scnhdr_out (abfd, §ion, &buff) == 0
3838 || bfd_bwrite (& buff, amt, abfd) != amt)
3843 /* PE stores COMDAT section information in the symbol table. If
3844 this section is supposed to have some COMDAT info, track down
3845 the symbol in the symbol table and modify it. */
3846 if ((current->flags & SEC_LINK_ONCE) != 0)
3848 unsigned int i, count;
3850 coff_symbol_type *csym = NULL;
3854 count = bfd_get_symcount (abfd);
3855 for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++)
3857 if ((*psym)->section != current)
3860 /* Remember the location of the first symbol in this
3862 if (psymsec == NULL)
3865 /* See if this is the section symbol. */
3866 if (strcmp ((*psym)->name, current->name) == 0)
3868 csym = coff_symbol_from (abfd, *psym);
3870 || csym->native == NULL
3871 || csym->native->u.syment.n_numaux < 1
3872 || csym->native->u.syment.n_sclass != C_STAT
3873 || csym->native->u.syment.n_type != T_NULL)
3876 /* Here *PSYM is the section symbol for CURRENT. */
3883 Note that we might not if we're converting the file from
3884 some other object file format. */
3887 combined_entry_type *aux;
3889 /* We don't touch the x_checksum field. The
3890 x_associated field is not currently supported. */
3892 aux = csym->native + 1;
3893 switch (current->flags & SEC_LINK_DUPLICATES)
3895 case SEC_LINK_DUPLICATES_DISCARD:
3896 aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY;
3899 case SEC_LINK_DUPLICATES_ONE_ONLY:
3900 aux->u.auxent.x_scn.x_comdat =
3901 IMAGE_COMDAT_SELECT_NODUPLICATES;
3904 case SEC_LINK_DUPLICATES_SAME_SIZE:
3905 aux->u.auxent.x_scn.x_comdat =
3906 IMAGE_COMDAT_SELECT_SAME_SIZE;
3909 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
3910 aux->u.auxent.x_scn.x_comdat =
3911 IMAGE_COMDAT_SELECT_EXACT_MATCH;
3915 /* The COMDAT symbol must be the first symbol from this
3916 section in the symbol table. In order to make this
3917 work, we move the COMDAT symbol before the first
3918 symbol we found in the search above. It's OK to
3919 rearrange the symbol table at this point, because
3920 coff_renumber_symbols is going to rearrange it
3921 further and fix up all the aux entries. */
3922 if (psym != psymsec)
3928 for (pcopy = psym; pcopy > psymsec; pcopy--)
3929 pcopy[0] = pcopy[-1];
3934 #endif /* COFF_WITH_PE */
3939 /* XCOFF handles overflows in the reloc and line number count fields
3940 by creating a new section header to hold the correct values. */
3941 for (current = abfd->sections; current != NULL; current = current->next)
3943 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3945 struct internal_scnhdr scnhdr;
3949 internal_f.f_nscns++;
3950 strncpy (&(scnhdr.s_name[0]), current->name, 8);
3951 scnhdr.s_paddr = current->reloc_count;
3952 scnhdr.s_vaddr = current->lineno_count;
3954 scnhdr.s_scnptr = 0;
3955 scnhdr.s_relptr = current->rel_filepos;
3956 scnhdr.s_lnnoptr = current->line_filepos;
3957 scnhdr.s_nreloc = current->target_index;
3958 scnhdr.s_nlnno = current->target_index;
3959 scnhdr.s_flags = STYP_OVRFLO;
3960 amt = bfd_coff_scnhsz (abfd);
3961 if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
3962 || bfd_bwrite (& buff, amt, abfd) != amt)
3969 /* OK, now set up the filehdr... */
3971 /* Don't include the internal abs section in the section count */
3973 /* We will NOT put a fucking timestamp in the header here. Every time you
3974 put it back, I will come in and take it out again. I'm sorry. This
3975 field does not belong here. We fill it with a 0 so it compares the
3976 same but is not a reasonable time. -- gnu@cygnus.com */
3977 internal_f.f_timdat = 0;
3978 internal_f.f_flags = 0;
3980 if (abfd->flags & EXEC_P)
3981 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3984 internal_f.f_opthdr = 0;
3987 if (xcoff_data (abfd)->full_aouthdr)
3988 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3990 internal_f.f_opthdr = SMALL_AOUTSZ;
3996 internal_f.f_flags |= F_RELFLG;
3998 internal_f.f_flags |= F_LNNO;
3999 if (abfd->flags & EXEC_P)
4000 internal_f.f_flags |= F_EXEC;
4001 #ifdef COFF_IMAGE_WITH_PE
4003 internal_f.f_flags |= IMAGE_FILE_DEBUG_STRIPPED;
4004 if (pe_data (abfd)->real_flags & IMAGE_FILE_LARGE_ADDRESS_AWARE)
4005 internal_f.f_flags |= IMAGE_FILE_LARGE_ADDRESS_AWARE;
4008 #ifndef COFF_WITH_pex64
4010 internal_f.f_flags |= IMAGE_FILE_32BIT_MACHINE;
4012 if (bfd_little_endian (abfd))
4013 internal_f.f_flags |= F_AR32WR;
4015 internal_f.f_flags |= F_AR32W;
4020 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
4021 but it doesn't hurt to set it internally. */
4022 internal_f.f_target_id = TI_TARGET_ID;
4024 #ifdef TIC80_TARGET_ID
4025 internal_f.f_target_id = TIC80_TARGET_ID;
4028 /* FIXME, should do something about the other byte orders and
4032 if ((abfd->flags & DYNAMIC) != 0)
4033 internal_f.f_flags |= F_SHROBJ;
4034 if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
4035 internal_f.f_flags |= F_DYNLOAD;
4038 memset (&internal_a, 0, sizeof internal_a);
4040 /* Set up architecture-dependent stuff. */
4042 unsigned int magic = 0;
4043 unsigned short flags = 0;
4045 coff_set_flags (abfd, &magic, &flags);
4046 internal_f.f_magic = magic;
4047 internal_f.f_flags |= flags;
4048 /* ...and the "opt"hdr... */
4050 #ifdef TICOFF_AOUT_MAGIC
4051 internal_a.magic = TICOFF_AOUT_MAGIC;
4052 #define __A_MAGIC_SET__
4055 internal_a.magic = TIC80_ARCH_MAGIC;
4056 #define __A_MAGIC_SET__
4059 /* FIXME: What are the a.out magic numbers for the i860? */
4060 internal_a.magic = 0;
4061 #define __A_MAGIC_SET__
4064 internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
4065 #define __A_MAGIC_SET__
4068 #define __A_MAGIC_SET__
4069 internal_a.magic = PAGEMAGICBCS;
4073 #define __A_MAGIC_SET__
4074 internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
4077 #if defined(M68) || defined(WE32K) || defined(M68K)
4078 #define __A_MAGIC_SET__
4080 internal_a.magic = LYNXCOFFMAGIC;
4082 #if defined(TARG_AUX)
4083 internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED :
4084 abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED :
4085 PAGEMAGICEXECSWAPPED);
4087 #if defined (PAGEMAGICPEXECPAGED)
4088 internal_a.magic = PAGEMAGICPEXECPAGED;
4090 #endif /* TARG_AUX */
4092 #endif /* M68 || WE32K || M68K */
4095 #define __A_MAGIC_SET__
4096 internal_a.magic = ZMAGIC;
4100 #define __A_MAGIC_SET__
4101 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
4104 #if defined MCORE_PE
4105 #define __A_MAGIC_SET__
4106 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
4110 #define __A_MAGIC_SET__
4112 internal_a.magic = LYNXCOFFMAGIC;
4114 internal_a.magic = IMAGE_NT_OPTIONAL_HDR64_MAGIC;
4116 internal_a.magic = ZMAGIC;
4121 #define __A_MAGIC_SET__
4122 internal_a.magic = PE32PMAGIC;
4126 #define __A_MAGIC_SET__
4128 internal_a.magic = LYNXCOFFMAGIC;
4133 #define __A_MAGIC_SET__
4134 internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
4135 (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
4136 RS6K_AOUTHDR_OMAGIC;
4139 #if defined(SH) && defined(COFF_WITH_PE)
4140 #define __A_MAGIC_SET__
4141 internal_a.magic = SH_PE_MAGIC;
4144 #if defined(MIPS) && defined(COFF_WITH_PE)
4145 #define __A_MAGIC_SET__
4146 internal_a.magic = MIPS_PE_MAGIC;
4150 #define __A_MAGIC_SET__
4151 internal_a.magic = NMAGIC; /* Assume separate i/d. */
4154 #ifndef __A_MAGIC_SET__
4155 #include "Your aouthdr magic number is not being set!"
4157 #undef __A_MAGIC_SET__
4161 /* FIXME: Does anybody ever set this to another value? */
4162 internal_a.vstamp = 0;
4164 /* Now should write relocs, strings, syms. */
4165 obj_sym_filepos (abfd) = sym_base;
4167 if (bfd_get_symcount (abfd) != 0)
4171 if (!coff_renumber_symbols (abfd, &firstundef))
4173 coff_mangle_symbols (abfd);
4174 if (! coff_write_symbols (abfd))
4176 if (! coff_write_linenumbers (abfd))
4178 if (! coff_write_relocs (abfd, firstundef))
4181 #ifdef COFF_LONG_SECTION_NAMES
4182 else if (long_section_names && ! obj_coff_strings_written (abfd))
4184 /* If we have long section names we have to write out the string
4185 table even if there are no symbols. */
4186 if (! coff_write_symbols (abfd))
4190 #ifdef COFF_IMAGE_WITH_PE
4192 else if ((abfd->flags & EXEC_P) != 0)
4196 /* PowerPC PE appears to require that all executable files be
4197 rounded up to the page size. */
4200 (file_ptr) BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1,
4202 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
4208 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
4209 backend linker, and obj_raw_syment_count is not valid until after
4210 coff_write_symbols is called. */
4211 if (obj_raw_syment_count (abfd) != 0)
4213 internal_f.f_symptr = sym_base;
4215 /* AIX appears to require that F_RELFLG not be set if there are
4216 local symbols but no relocations. */
4217 internal_f.f_flags &=~ F_RELFLG;
4222 if (long_section_names)
4223 internal_f.f_symptr = sym_base;
4225 internal_f.f_symptr = 0;
4226 internal_f.f_flags |= F_LSYMS;
4231 internal_a.tsize = text_sec->size;
4232 internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
4236 internal_a.dsize = data_sec->size;
4237 internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
4241 internal_a.bsize = bss_sec->size;
4242 if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
4243 internal_a.data_start = bss_sec->vma;
4246 internal_a.entry = bfd_get_start_address (abfd);
4247 internal_f.f_nsyms = obj_raw_syment_count (abfd);
4250 if (xcoff_data (abfd)->full_aouthdr)
4253 asection *loader_sec;
4255 internal_a.vstamp = 1;
4257 internal_a.o_snentry = xcoff_data (abfd)->snentry;
4258 if (internal_a.o_snentry == 0)
4259 internal_a.entry = (bfd_vma) -1;
4261 if (text_sec != NULL)
4263 internal_a.o_sntext = text_sec->target_index;
4264 internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
4268 internal_a.o_sntext = 0;
4269 internal_a.o_algntext = 0;
4271 if (data_sec != NULL)
4273 internal_a.o_sndata = data_sec->target_index;
4274 internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
4278 internal_a.o_sndata = 0;
4279 internal_a.o_algndata = 0;
4281 loader_sec = bfd_get_section_by_name (abfd, ".loader");
4282 if (loader_sec != NULL)
4283 internal_a.o_snloader = loader_sec->target_index;
4285 internal_a.o_snloader = 0;
4286 if (bss_sec != NULL)
4287 internal_a.o_snbss = bss_sec->target_index;
4289 internal_a.o_snbss = 0;
4291 toc = xcoff_data (abfd)->toc;
4292 internal_a.o_toc = toc;
4293 internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
4295 internal_a.o_modtype = xcoff_data (abfd)->modtype;
4296 if (xcoff_data (abfd)->cputype != -1)
4297 internal_a.o_cputype = xcoff_data (abfd)->cputype;
4300 switch (bfd_get_arch (abfd))
4302 case bfd_arch_rs6000:
4303 internal_a.o_cputype = 4;
4305 case bfd_arch_powerpc:
4306 if (bfd_get_mach (abfd) == bfd_mach_ppc)
4307 internal_a.o_cputype = 3;
4309 internal_a.o_cputype = 1;
4315 internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
4316 internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
4320 /* Now write them. */
4321 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
4326 bfd_size_type amount = bfd_coff_filhsz (abfd);
4328 buff = (char *) bfd_malloc (amount);
4332 bfd_coff_swap_filehdr_out (abfd, & internal_f, buff);
4333 amount = bfd_bwrite (buff, amount, abfd);
4337 if (amount != bfd_coff_filhsz (abfd))
4341 if (abfd->flags & EXEC_P)
4343 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4344 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4346 bfd_size_type amount = bfd_coff_aoutsz (abfd);
4348 buff = (char *) bfd_malloc (amount);
4352 coff_swap_aouthdr_out (abfd, & internal_a, buff);
4353 amount = bfd_bwrite (buff, amount, abfd);
4357 if (amount != bfd_coff_aoutsz (abfd))
4360 #ifdef COFF_IMAGE_WITH_PE
4361 if (! coff_apply_checksum (abfd))
4371 /* XCOFF seems to always write at least a small a.out header. */
4372 coff_swap_aouthdr_out (abfd, & internal_a, & buff);
4373 if (xcoff_data (abfd)->full_aouthdr)
4374 size = bfd_coff_aoutsz (abfd);
4376 size = SMALL_AOUTSZ;
4377 if (bfd_bwrite (& buff, (bfd_size_type) size, abfd) != size)
4386 coff_set_section_contents (bfd * abfd,
4388 const void * location,
4390 bfd_size_type count)
4392 if (! abfd->output_has_begun) /* Set by bfd.c handler. */
4394 if (! coff_compute_section_file_positions (abfd))
4398 #if defined(_LIB) && !defined(TARG_AUX)
4399 /* The physical address field of a .lib section is used to hold the
4400 number of shared libraries in the section. This code counts the
4401 number of sections being written, and increments the lma field
4404 I have found no documentation on the contents of this section.
4405 Experimentation indicates that the section contains zero or more
4406 records, each of which has the following structure:
4408 - a (four byte) word holding the length of this record, in words,
4409 - a word that always seems to be set to "2",
4410 - the path to a shared library, null-terminated and then padded
4411 to a whole word boundary.
4413 bfd_assert calls have been added to alert if an attempt is made
4414 to write a section which doesn't follow these assumptions. The
4415 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4416 <robertl@arnet.com> (Thanks!).
4418 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4419 if (strcmp (section->name, _LIB) == 0)
4421 bfd_byte *rec, *recend;
4423 rec = (bfd_byte *) location;
4424 recend = rec + count;
4425 while (rec < recend)
4428 rec += bfd_get_32 (abfd, rec) * 4;
4431 BFD_ASSERT (rec == recend);
4435 /* Don't write out bss sections - one way to do this is to
4436 see if the filepos has not been set. */
4437 if (section->filepos == 0)
4440 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
4446 return bfd_bwrite (location, count, abfd) == count;
4450 buy_and_read (bfd *abfd, file_ptr where, bfd_size_type size)
4452 void * area = bfd_alloc (abfd, size);
4456 if (bfd_seek (abfd, where, SEEK_SET) != 0
4457 || bfd_bread (area, size, abfd) != size)
4466 Creating the linenumber table is done by reading in the entire
4467 coff linenumber table, and creating another table for internal use.
4469 A coff linenumber table is structured so that each function
4470 is marked as having a line number of 0. Each line within the
4471 function is an offset from the first line in the function. The
4472 base of the line number information for the table is stored in
4473 the symbol associated with the function.
4475 Note: The PE format uses line number 0 for a flag indicating a
4478 The information is copied from the external to the internal
4479 table, and each symbol which marks a function is marked by
4482 How does this work ?
4486 coff_sort_func_alent (const void * arg1, const void * arg2)
4488 const alent *al1 = *(const alent **) arg1;
4489 const alent *al2 = *(const alent **) arg2;
4490 const coff_symbol_type *s1 = (const coff_symbol_type *) (al1->u.sym);
4491 const coff_symbol_type *s2 = (const coff_symbol_type *) (al2->u.sym);
4493 if (s1->symbol.value < s2->symbol.value)
4495 else if (s1->symbol.value > s2->symbol.value)
4502 coff_slurp_line_table (bfd *abfd, asection *asect)
4504 LINENO *native_lineno;
4505 alent *lineno_cache;
4507 unsigned int counter;
4509 bfd_vma prev_offset = 0;
4511 unsigned int nbr_func;
4514 BFD_ASSERT (asect->lineno == NULL);
4516 amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
4517 lineno_cache = (alent *) bfd_alloc (abfd, amt);
4518 if (lineno_cache == NULL)
4521 amt = (bfd_size_type) bfd_coff_linesz (abfd) * asect->lineno_count;
4522 native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos, amt);
4523 if (native_lineno == NULL)
4525 (*_bfd_error_handler)
4526 (_("%B: warning: line number table read failed"), abfd);
4527 bfd_release (abfd, lineno_cache);
4531 cache_ptr = lineno_cache;
4532 asect->lineno = lineno_cache;
4533 src = native_lineno;
4536 for (counter = 0; counter < asect->lineno_count; counter++)
4538 struct internal_lineno dst;
4540 bfd_coff_swap_lineno_in (abfd, src, &dst);
4541 cache_ptr->line_number = dst.l_lnno;
4543 if (cache_ptr->line_number == 0)
4546 bfd_signed_vma symndx;
4547 coff_symbol_type *sym;
4551 symndx = dst.l_addr.l_symndx;
4553 || (bfd_vma) symndx >= obj_raw_syment_count (abfd))
4555 (*_bfd_error_handler)
4556 (_("%B: warning: illegal symbol index %ld in line numbers"),
4557 abfd, (long) symndx);
4562 /* FIXME: We should not be casting between ints and
4563 pointers like this. */
4564 sym = ((coff_symbol_type *)
4565 ((symndx + obj_raw_syments (abfd))
4566 ->u.syment._n._n_n._n_zeroes));
4567 cache_ptr->u.sym = (asymbol *) sym;
4568 if (sym->lineno != NULL && ! warned)
4569 (*_bfd_error_handler)
4570 (_("%B: warning: duplicate line number information for `%s'"),
4571 abfd, bfd_asymbol_name (&sym->symbol));
4573 sym->lineno = cache_ptr;
4574 if (sym->symbol.value < prev_offset)
4576 prev_offset = sym->symbol.value;
4579 cache_ptr->u.offset = dst.l_addr.l_paddr
4580 - bfd_section_vma (abfd, asect);
4585 cache_ptr->line_number = 0;
4586 bfd_release (abfd, native_lineno);
4588 /* On some systems (eg AIX5.3) the lineno table may not be sorted. */
4591 /* Sort the table. */
4593 alent *n_lineno_cache;
4595 /* Create a table of functions. */
4596 func_table = (alent **) bfd_alloc (abfd, nbr_func * sizeof (alent *));
4597 if (func_table != NULL)
4599 alent **p = func_table;
4602 for (i = 0; i < counter; i++)
4603 if (lineno_cache[i].line_number == 0)
4604 *p++ = &lineno_cache[i];
4606 /* Sort by functions. */
4607 qsort (func_table, nbr_func, sizeof (alent *), coff_sort_func_alent);
4609 /* Create the new sorted table. */
4610 amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
4611 n_lineno_cache = (alent *) bfd_alloc (abfd, amt);
4612 if (n_lineno_cache != NULL)
4614 alent *n_cache_ptr = n_lineno_cache;
4616 for (i = 0; i < nbr_func; i++)
4618 coff_symbol_type *sym;
4619 alent *old_ptr = func_table[i];
4621 /* Copy the function entry and update it. */
4622 *n_cache_ptr = *old_ptr;
4623 sym = (coff_symbol_type *)n_cache_ptr->u.sym;
4624 sym->lineno = n_cache_ptr;
4628 /* Copy the line number entries. */
4629 while (old_ptr->line_number != 0)
4630 *n_cache_ptr++ = *old_ptr++;
4632 n_cache_ptr->line_number = 0;
4633 memcpy (lineno_cache, n_lineno_cache, amt);
4635 bfd_release (abfd, func_table);
4642 /* Slurp in the symbol table, converting it to generic form. Note
4643 that if coff_relocate_section is defined, the linker will read
4644 symbols via coff_link_add_symbols, rather than via this routine. */
4647 coff_slurp_symbol_table (bfd * abfd)
4649 combined_entry_type *native_symbols;
4650 coff_symbol_type *cached_area;
4651 unsigned int *table_ptr;
4653 unsigned int number_of_symbols = 0;
4655 if (obj_symbols (abfd))
4658 /* Read in the symbol table. */
4659 if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
4662 /* Allocate enough room for all the symbols in cached form. */
4663 amt = obj_raw_syment_count (abfd);
4664 amt *= sizeof (coff_symbol_type);
4665 cached_area = (coff_symbol_type *) bfd_alloc (abfd, amt);
4666 if (cached_area == NULL)
4669 amt = obj_raw_syment_count (abfd);
4670 amt *= sizeof (unsigned int);
4671 table_ptr = (unsigned int *) bfd_alloc (abfd, amt);
4673 if (table_ptr == NULL)
4677 coff_symbol_type *dst = cached_area;
4678 unsigned int last_native_index = obj_raw_syment_count (abfd);
4679 unsigned int this_index = 0;
4681 while (this_index < last_native_index)
4683 combined_entry_type *src = native_symbols + this_index;
4684 table_ptr[this_index] = number_of_symbols;
4685 dst->symbol.the_bfd = abfd;
4687 dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
4688 /* We use the native name field to point to the cached field. */
4689 src->u.syment._n._n_n._n_zeroes = (bfd_hostptr_t) dst;
4690 dst->symbol.section = coff_section_from_bfd_index (abfd,
4691 src->u.syment.n_scnum);
4692 dst->symbol.flags = 0;
4693 dst->done_lineno = FALSE;
4695 switch (src->u.syment.n_sclass)
4699 /* Fall through to next case. */
4706 case C_THUMBEXTFUNC:
4712 case C_SYSTEM: /* System Wide variable. */
4715 /* In PE, 0x68 (104) denotes a section symbol. */
4717 /* In PE, 0x69 (105) denotes a weak external symbol. */
4720 switch (coff_classify_symbol (abfd, &src->u.syment))
4722 case COFF_SYMBOL_GLOBAL:
4723 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
4724 #if defined COFF_WITH_PE
4725 /* PE sets the symbol to a value relative to the
4726 start of the section. */
4727 dst->symbol.value = src->u.syment.n_value;
4729 dst->symbol.value = (src->u.syment.n_value
4730 - dst->symbol.section->vma);
4732 if (ISFCN ((src->u.syment.n_type)))
4733 /* A function ext does not go at the end of a
4735 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4738 case COFF_SYMBOL_COMMON:
4739 dst->symbol.section = bfd_com_section_ptr;
4740 dst->symbol.value = src->u.syment.n_value;
4743 case COFF_SYMBOL_UNDEFINED:
4744 dst->symbol.section = bfd_und_section_ptr;
4745 dst->symbol.value = 0;
4748 case COFF_SYMBOL_PE_SECTION:
4749 dst->symbol.flags |= BSF_EXPORT | BSF_SECTION_SYM;
4750 dst->symbol.value = 0;
4753 case COFF_SYMBOL_LOCAL:
4754 dst->symbol.flags = BSF_LOCAL;
4755 #if defined COFF_WITH_PE
4756 /* PE sets the symbol to a value relative to the
4757 start of the section. */
4758 dst->symbol.value = src->u.syment.n_value;
4760 dst->symbol.value = (src->u.syment.n_value
4761 - dst->symbol.section->vma);
4763 if (ISFCN ((src->u.syment.n_type)))
4764 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4769 /* A symbol with a csect entry should not go at the end. */
4770 if (src->u.syment.n_numaux > 0)
4771 dst->symbol.flags |= BSF_NOT_AT_END;
4775 if (src->u.syment.n_sclass == C_NT_WEAK)
4776 dst->symbol.flags |= BSF_WEAK;
4778 if (src->u.syment.n_sclass == C_SECTION
4779 && src->u.syment.n_scnum > 0)
4780 dst->symbol.flags = BSF_LOCAL;
4782 if (src->u.syment.n_sclass == C_WEAKEXT)
4783 dst->symbol.flags |= BSF_WEAK;
4787 case C_STAT: /* Static. */
4789 case C_LEAFSTAT: /* Static leaf procedure. */
4792 case C_THUMBSTAT: /* Thumb static. */
4793 case C_THUMBLABEL: /* Thumb label. */
4794 case C_THUMBSTATFUNC:/* Thumb static function. */
4797 case C_DWARF: /* A label in a dwarf section. */
4798 case C_INFO: /* A label in a comment section. */
4800 case C_LABEL: /* Label. */
4801 if (src->u.syment.n_scnum == N_DEBUG)
4802 dst->symbol.flags = BSF_DEBUGGING;
4804 dst->symbol.flags = BSF_LOCAL;
4806 /* Base the value as an index from the base of the
4807 section, if there is one. */
4808 if (dst->symbol.section)
4810 #if defined COFF_WITH_PE
4811 /* PE sets the symbol to a value relative to the
4812 start of the section. */
4813 dst->symbol.value = src->u.syment.n_value;
4815 dst->symbol.value = (src->u.syment.n_value
4816 - dst->symbol.section->vma);
4820 dst->symbol.value = src->u.syment.n_value;
4823 case C_MOS: /* Member of structure. */
4824 case C_EOS: /* End of structure. */
4825 case C_REGPARM: /* Register parameter. */
4826 case C_REG: /* register variable. */
4827 /* C_AUTOARG conflicts with TI COFF C_UEXT. */
4828 #if !defined (TIC80COFF) && !defined (TICOFF)
4830 case C_AUTOARG: /* 960-specific storage class. */
4833 case C_TPDEF: /* Type definition. */
4835 case C_AUTO: /* Automatic variable. */
4836 case C_FIELD: /* Bit field. */
4837 case C_ENTAG: /* Enumeration tag. */
4838 case C_MOE: /* Member of enumeration. */
4839 case C_MOU: /* Member of union. */
4840 case C_UNTAG: /* Union tag. */
4841 dst->symbol.flags = BSF_DEBUGGING;
4842 dst->symbol.value = (src->u.syment.n_value);
4845 case C_FILE: /* File name. */
4846 case C_STRTAG: /* Structure tag. */
4863 dst->symbol.flags = BSF_DEBUGGING;
4864 dst->symbol.value = (src->u.syment.n_value);
4868 case C_BINCL: /* Beginning of include file. */
4869 case C_EINCL: /* Ending of include file. */
4870 /* The value is actually a pointer into the line numbers
4871 of the file. We locate the line number entry, and
4872 set the section to the section which contains it, and
4873 the value to the index in that section. */
4877 dst->symbol.flags = BSF_DEBUGGING;
4878 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4879 if (sec->line_filepos <= (file_ptr) src->u.syment.n_value
4880 && ((file_ptr) (sec->line_filepos
4881 + sec->lineno_count * bfd_coff_linesz (abfd))
4882 > (file_ptr) src->u.syment.n_value))
4885 dst->symbol.value = 0;
4888 dst->symbol.section = sec;
4889 dst->symbol.value = ((src->u.syment.n_value
4890 - sec->line_filepos)
4891 / bfd_coff_linesz (abfd));
4898 dst->symbol.flags = BSF_DEBUGGING;
4900 /* The value is actually a symbol index. Save a pointer
4901 to the symbol instead of the index. FIXME: This
4902 should use a union. */
4903 src->u.syment.n_value =
4904 (long) (intptr_t) (native_symbols + src->u.syment.n_value);
4905 dst->symbol.value = src->u.syment.n_value;
4910 case C_BLOCK: /* ".bb" or ".eb". */
4911 case C_FCN: /* ".bf" or ".ef" (or PE ".lf"). */
4912 case C_EFCN: /* Physical end of function. */
4913 #if defined COFF_WITH_PE
4914 /* PE sets the symbol to a value relative to the start
4916 dst->symbol.value = src->u.syment.n_value;
4917 if (strcmp (dst->symbol.name, ".bf") != 0)
4919 /* PE uses funny values for .ef and .lf; don't
4921 dst->symbol.flags = BSF_DEBUGGING;
4924 dst->symbol.flags = BSF_DEBUGGING | BSF_DEBUGGING_RELOC;
4926 /* Base the value as an index from the base of the
4928 dst->symbol.flags = BSF_LOCAL;
4929 dst->symbol.value = (src->u.syment.n_value
4930 - dst->symbol.section->vma);
4934 case C_STATLAB: /* Static load time label. */
4935 dst->symbol.value = src->u.syment.n_value;
4936 dst->symbol.flags = BSF_GLOBAL;
4940 /* PE DLLs sometimes have zeroed out symbols for some
4941 reason. Just ignore them without a warning. */
4942 if (src->u.syment.n_type == 0
4943 && src->u.syment.n_value == 0
4944 && src->u.syment.n_scnum == 0)
4947 /* XCOFF specific: deleted entry. */
4948 if (src->u.syment.n_value == C_NULL_VALUE)
4952 case C_EXTDEF: /* External definition. */
4953 case C_ULABEL: /* Undefined label. */
4954 case C_USTATIC: /* Undefined static. */
4955 #ifndef COFF_WITH_PE
4956 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4957 class to represent a section symbol. */
4958 case C_LINE: /* line # reformatted as symbol table entry. */
4959 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4960 case C_ALIAS: /* Duplicate tag. */
4962 /* New storage classes for TI COFF. */
4963 #if defined(TIC80COFF) || defined(TICOFF)
4964 case C_UEXT: /* Tentative external definition. */
4966 case C_EXTLAB: /* External load time label. */
4967 case C_HIDDEN: /* Ext symbol in dmert public lib. */
4969 (*_bfd_error_handler)
4970 (_("%B: Unrecognized storage class %d for %s symbol `%s'"),
4971 abfd, src->u.syment.n_sclass,
4972 dst->symbol.section->name, dst->symbol.name);
4973 dst->symbol.flags = BSF_DEBUGGING;
4974 dst->symbol.value = (src->u.syment.n_value);
4980 dst->symbol.udata.i = 0;
4982 this_index += (src->u.syment.n_numaux) + 1;
4984 number_of_symbols++;
4988 obj_symbols (abfd) = cached_area;
4989 obj_raw_syments (abfd) = native_symbols;
4991 bfd_get_symcount (abfd) = number_of_symbols;
4992 obj_convert (abfd) = table_ptr;
4993 /* Slurp the line tables for each section too. */
5000 coff_slurp_line_table (abfd, p);
5008 /* Classify a COFF symbol. A couple of targets have globally visible
5009 symbols which are not class C_EXT, and this handles those. It also
5010 recognizes some special PE cases. */
5012 static enum coff_symbol_classification
5013 coff_classify_symbol (bfd *abfd,
5014 struct internal_syment *syment)
5016 /* FIXME: This partially duplicates the switch in
5017 coff_slurp_symbol_table. */
5018 switch (syment->n_sclass)
5027 case C_THUMBEXTFUNC:
5035 if (syment->n_scnum == 0)
5037 if (syment->n_value == 0)
5038 return COFF_SYMBOL_UNDEFINED;
5040 return COFF_SYMBOL_COMMON;
5042 return COFF_SYMBOL_GLOBAL;
5049 if (syment->n_sclass == C_STAT)
5051 if (syment->n_scnum == 0)
5052 /* The Microsoft compiler sometimes generates these if a
5053 small static function is inlined every time it is used.
5054 The function is discarded, but the symbol table entry
5056 return COFF_SYMBOL_LOCAL;
5058 #ifdef STRICT_PE_FORMAT
5059 /* This is correct for Microsoft generated objects, but it
5060 breaks gas generated objects. */
5061 if (syment->n_value == 0)
5064 char buf[SYMNMLEN + 1];
5066 sec = coff_section_from_bfd_index (abfd, syment->n_scnum);
5068 && (strcmp (bfd_get_section_name (abfd, sec),
5069 _bfd_coff_internal_syment_name (abfd, syment, buf))
5071 return COFF_SYMBOL_PE_SECTION;
5075 return COFF_SYMBOL_LOCAL;
5078 if (syment->n_sclass == C_SECTION)
5080 /* In some cases in a DLL generated by the Microsoft linker, the
5081 n_value field will contain garbage. FIXME: This should
5082 probably be handled by the swapping function instead. */
5083 syment->n_value = 0;
5084 if (syment->n_scnum == 0)
5085 return COFF_SYMBOL_UNDEFINED;
5086 return COFF_SYMBOL_PE_SECTION;
5088 #endif /* COFF_WITH_PE */
5090 /* If it is not a global symbol, we presume it is a local symbol. */
5091 if (syment->n_scnum == 0)
5093 char buf[SYMNMLEN + 1];
5095 (*_bfd_error_handler)
5096 (_("warning: %B: local symbol `%s' has no section"),
5097 abfd, _bfd_coff_internal_syment_name (abfd, syment, buf));
5100 return COFF_SYMBOL_LOCAL;
5107 Coff relocations are easily transformed into the internal BFD form
5110 Reading a coff relocation table is done in the following stages:
5112 o Read the entire coff relocation table into memory.
5114 o Process each relocation in turn; first swap it from the
5115 external to the internal form.
5117 o Turn the symbol referenced in the relocation's symbol index
5118 into a pointer into the canonical symbol table.
5119 This table is the same as the one returned by a call to
5120 @code{bfd_canonicalize_symtab}. The back end will call that
5121 routine and save the result if a canonicalization hasn't been done.
5123 o The reloc index is turned into a pointer to a howto
5124 structure, in a back end specific way. For instance, the 386
5125 and 960 use the @code{r_type} to directly produce an index
5126 into a howto table vector; the 88k subtracts a number from the
5127 @code{r_type} field and creates an addend field.
5131 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
5133 coff_symbol_type *coffsym = NULL; \
5135 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
5136 coffsym = (obj_symbols (abfd) \
5137 + (cache_ptr->sym_ptr_ptr - symbols)); \
5139 coffsym = coff_symbol_from (abfd, ptr); \
5140 if (coffsym != NULL \
5141 && coffsym->native->u.syment.n_scnum == 0) \
5142 cache_ptr->addend = 0; \
5143 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
5144 && ptr->section != NULL) \
5145 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
5147 cache_ptr->addend = 0; \
5152 coff_slurp_reloc_table (bfd * abfd, sec_ptr asect, asymbol ** symbols)
5154 RELOC *native_relocs;
5155 arelent *reloc_cache;
5160 if (asect->relocation)
5162 if (asect->reloc_count == 0)
5164 if (asect->flags & SEC_CONSTRUCTOR)
5166 if (!coff_slurp_symbol_table (abfd))
5169 amt = (bfd_size_type) bfd_coff_relsz (abfd) * asect->reloc_count;
5170 native_relocs = (RELOC *) buy_and_read (abfd, asect->rel_filepos, amt);
5171 amt = (bfd_size_type) asect->reloc_count * sizeof (arelent);
5172 reloc_cache = (arelent *) bfd_alloc (abfd, amt);
5174 if (reloc_cache == NULL || native_relocs == NULL)
5177 for (idx = 0; idx < asect->reloc_count; idx++)
5179 struct internal_reloc dst;
5180 struct external_reloc *src;
5181 #ifndef RELOC_PROCESSING
5185 cache_ptr = reloc_cache + idx;
5186 src = native_relocs + idx;
5189 coff_swap_reloc_in (abfd, src, &dst);
5191 #ifdef RELOC_PROCESSING
5192 RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
5194 cache_ptr->address = dst.r_vaddr;
5196 if (dst.r_symndx != -1)
5198 if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd))
5200 (*_bfd_error_handler)
5201 (_("%B: warning: illegal symbol index %ld in relocs"),
5202 abfd, (long) dst.r_symndx);
5203 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
5208 cache_ptr->sym_ptr_ptr = (symbols
5209 + obj_convert (abfd)[dst.r_symndx]);
5210 ptr = *(cache_ptr->sym_ptr_ptr);
5215 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
5219 /* The symbols definitions that we have read in have been
5220 relocated as if their sections started at 0. But the offsets
5221 refering to the symbols in the raw data have not been
5222 modified, so we have to have a negative addend to compensate.
5224 Note that symbols which used to be common must be left alone. */
5226 /* Calculate any reloc addend by looking at the symbol. */
5227 CALC_ADDEND (abfd, ptr, dst, cache_ptr);
5230 cache_ptr->address -= asect->vma;
5231 /* !! cache_ptr->section = NULL;*/
5233 /* Fill in the cache_ptr->howto field from dst.r_type. */
5234 RTYPE2HOWTO (cache_ptr, &dst);
5235 #endif /* RELOC_PROCESSING */
5237 if (cache_ptr->howto == NULL)
5239 (*_bfd_error_handler)
5240 (_("%B: illegal relocation type %d at address 0x%lx"),
5241 abfd, dst.r_type, (long) dst.r_vaddr);
5242 bfd_set_error (bfd_error_bad_value);
5247 asect->relocation = reloc_cache;
5251 #ifndef coff_rtype_to_howto
5254 /* Get the howto structure for a reloc. This is only used if the file
5255 including this one defines coff_relocate_section to be
5256 _bfd_coff_generic_relocate_section, so it is OK if it does not
5257 always work. It is the responsibility of the including file to
5258 make sure it is reasonable if it is needed. */
5260 static reloc_howto_type *
5261 coff_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
5262 asection *sec ATTRIBUTE_UNUSED,
5263 struct internal_reloc *rel,
5264 struct coff_link_hash_entry *h ATTRIBUTE_UNUSED,
5265 struct internal_syment *sym ATTRIBUTE_UNUSED,
5266 bfd_vma *addendp ATTRIBUTE_UNUSED)
5270 genrel.howto = NULL;
5271 RTYPE2HOWTO (&genrel, rel);
5272 return genrel.howto;
5275 #else /* ! defined (RTYPE2HOWTO) */
5277 #define coff_rtype_to_howto NULL
5279 #endif /* ! defined (RTYPE2HOWTO) */
5280 #endif /* ! defined (coff_rtype_to_howto) */
5282 /* This is stupid. This function should be a boolean predicate. */
5285 coff_canonicalize_reloc (bfd * abfd,
5290 arelent *tblptr = section->relocation;
5291 unsigned int count = 0;
5293 if (section->flags & SEC_CONSTRUCTOR)
5295 /* This section has relocs made up by us, they are not in the
5296 file, so take them out of their chain and place them into
5297 the data area provided. */
5298 arelent_chain *chain = section->constructor_chain;
5300 for (count = 0; count < section->reloc_count; count++)
5302 *relptr++ = &chain->relent;
5303 chain = chain->next;
5308 if (! coff_slurp_reloc_table (abfd, section, symbols))
5311 tblptr = section->relocation;
5313 for (; count++ < section->reloc_count;)
5314 *relptr++ = tblptr++;
5317 return section->reloc_count;
5320 #ifndef coff_reloc16_estimate
5321 #define coff_reloc16_estimate dummy_reloc16_estimate
5324 dummy_reloc16_estimate (bfd *abfd ATTRIBUTE_UNUSED,
5325 asection *input_section ATTRIBUTE_UNUSED,
5326 arelent *reloc ATTRIBUTE_UNUSED,
5327 unsigned int shrink ATTRIBUTE_UNUSED,
5328 struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
5336 #ifndef coff_reloc16_extra_cases
5338 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5340 /* This works even if abort is not declared in any header file. */
5343 dummy_reloc16_extra_cases (bfd *abfd ATTRIBUTE_UNUSED,
5344 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
5345 struct bfd_link_order *link_order ATTRIBUTE_UNUSED,
5346 arelent *reloc ATTRIBUTE_UNUSED,
5347 bfd_byte *data ATTRIBUTE_UNUSED,
5348 unsigned int *src_ptr ATTRIBUTE_UNUSED,
5349 unsigned int *dst_ptr ATTRIBUTE_UNUSED)
5355 #ifndef coff_bfd_link_hash_table_free
5356 #define coff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
5359 /* If coff_relocate_section is defined, we can use the optimized COFF
5360 backend linker. Otherwise we must continue to use the old linker. */
5362 #ifdef coff_relocate_section
5364 #ifndef coff_bfd_link_hash_table_create
5365 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5367 #ifndef coff_bfd_link_add_symbols
5368 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5370 #ifndef coff_bfd_final_link
5371 #define coff_bfd_final_link _bfd_coff_final_link
5374 #else /* ! defined (coff_relocate_section) */
5376 #define coff_relocate_section NULL
5377 #ifndef coff_bfd_link_hash_table_create
5378 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5380 #ifndef coff_bfd_link_add_symbols
5381 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5383 #define coff_bfd_final_link _bfd_generic_final_link
5385 #endif /* ! defined (coff_relocate_section) */
5387 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5388 #define coff_bfd_copy_link_hash_symbol_type \
5389 _bfd_generic_copy_link_hash_symbol_type
5390 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5392 #ifndef coff_start_final_link
5393 #define coff_start_final_link NULL
5396 #ifndef coff_adjust_symndx
5397 #define coff_adjust_symndx NULL
5400 #ifndef coff_link_add_one_symbol
5401 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5404 #ifndef coff_link_output_has_begun
5407 coff_link_output_has_begun (bfd * abfd,
5408 struct coff_final_link_info * info ATTRIBUTE_UNUSED)
5410 return abfd->output_has_begun;
5414 #ifndef coff_final_link_postscript
5417 coff_final_link_postscript (bfd * abfd ATTRIBUTE_UNUSED,
5418 struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED)
5424 #ifndef coff_SWAP_aux_in
5425 #define coff_SWAP_aux_in coff_swap_aux_in
5427 #ifndef coff_SWAP_sym_in
5428 #define coff_SWAP_sym_in coff_swap_sym_in
5430 #ifndef coff_SWAP_lineno_in
5431 #define coff_SWAP_lineno_in coff_swap_lineno_in
5433 #ifndef coff_SWAP_aux_out
5434 #define coff_SWAP_aux_out coff_swap_aux_out
5436 #ifndef coff_SWAP_sym_out
5437 #define coff_SWAP_sym_out coff_swap_sym_out
5439 #ifndef coff_SWAP_lineno_out
5440 #define coff_SWAP_lineno_out coff_swap_lineno_out
5442 #ifndef coff_SWAP_reloc_out
5443 #define coff_SWAP_reloc_out coff_swap_reloc_out
5445 #ifndef coff_SWAP_filehdr_out
5446 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5448 #ifndef coff_SWAP_aouthdr_out
5449 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5451 #ifndef coff_SWAP_scnhdr_out
5452 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5454 #ifndef coff_SWAP_reloc_in
5455 #define coff_SWAP_reloc_in coff_swap_reloc_in
5457 #ifndef coff_SWAP_filehdr_in
5458 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5460 #ifndef coff_SWAP_aouthdr_in
5461 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5463 #ifndef coff_SWAP_scnhdr_in
5464 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5467 static bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED =
5469 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5470 coff_SWAP_aux_out, coff_SWAP_sym_out,
5471 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5472 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5473 coff_SWAP_scnhdr_out,
5474 FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
5475 #ifdef COFF_LONG_FILENAMES
5480 COFF_DEFAULT_LONG_SECTION_NAMES,
5481 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5482 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5487 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5492 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5493 coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
5494 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5495 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5496 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5497 coff_classify_symbol, coff_compute_section_file_positions,
5498 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5499 coff_adjust_symndx, coff_link_add_one_symbol,
5500 coff_link_output_has_begun, coff_final_link_postscript,
5505 /* COFF0 differs in file/section header size and relocation entry size. */
5507 static bfd_coff_backend_data ticoff0_swap_table =
5509 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5510 coff_SWAP_aux_out, coff_SWAP_sym_out,
5511 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5512 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5513 coff_SWAP_scnhdr_out,
5514 FILHSZ_V0, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ_V0, LINESZ, FILNMLEN,
5515 #ifdef COFF_LONG_FILENAMES
5520 COFF_DEFAULT_LONG_SECTION_NAMES,
5521 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5522 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5527 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5532 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5533 coff_SWAP_reloc_in, ticoff0_bad_format_hook, coff_set_arch_mach_hook,
5534 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5535 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5536 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5537 coff_classify_symbol, coff_compute_section_file_positions,
5538 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5539 coff_adjust_symndx, coff_link_add_one_symbol,
5540 coff_link_output_has_begun, coff_final_link_postscript,
5546 /* COFF1 differs in section header size. */
5548 static bfd_coff_backend_data ticoff1_swap_table =
5550 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5551 coff_SWAP_aux_out, coff_SWAP_sym_out,
5552 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5553 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5554 coff_SWAP_scnhdr_out,
5555 FILHSZ, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
5556 #ifdef COFF_LONG_FILENAMES
5561 COFF_DEFAULT_LONG_SECTION_NAMES,
5562 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5563 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5568 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5573 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5574 coff_SWAP_reloc_in, ticoff1_bad_format_hook, coff_set_arch_mach_hook,
5575 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5576 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5577 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5578 coff_classify_symbol, coff_compute_section_file_positions,
5579 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5580 coff_adjust_symndx, coff_link_add_one_symbol,
5581 coff_link_output_has_begun, coff_final_link_postscript,
5582 bfd_pe_print_pdata /* huh */
5586 #ifndef coff_close_and_cleanup
5587 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5590 #ifndef coff_bfd_free_cached_info
5591 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5594 #ifndef coff_get_section_contents
5595 #define coff_get_section_contents _bfd_generic_get_section_contents
5598 #ifndef coff_bfd_copy_private_symbol_data
5599 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5602 #ifndef coff_bfd_copy_private_header_data
5603 #define coff_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
5606 #ifndef coff_bfd_copy_private_section_data
5607 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5610 #ifndef coff_bfd_copy_private_bfd_data
5611 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5614 #ifndef coff_bfd_merge_private_bfd_data
5615 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5618 #ifndef coff_bfd_set_private_flags
5619 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5622 #ifndef coff_bfd_print_private_bfd_data
5623 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5626 #ifndef coff_bfd_is_local_label_name
5627 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5630 #ifndef coff_bfd_is_target_special_symbol
5631 #define coff_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
5634 #ifndef coff_read_minisymbols
5635 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5638 #ifndef coff_minisymbol_to_symbol
5639 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5642 /* The reloc lookup routine must be supplied by each individual COFF
5644 #ifndef coff_bfd_reloc_type_lookup
5645 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5647 #ifndef coff_bfd_reloc_name_lookup
5648 #define coff_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5651 #ifndef coff_bfd_get_relocated_section_contents
5652 #define coff_bfd_get_relocated_section_contents \
5653 bfd_generic_get_relocated_section_contents
5656 #ifndef coff_bfd_relax_section
5657 #define coff_bfd_relax_section bfd_generic_relax_section
5660 #ifndef coff_bfd_gc_sections
5661 #define coff_bfd_gc_sections bfd_generic_gc_sections
5664 #ifndef coff_bfd_lookup_section_flags
5665 #define coff_bfd_lookup_section_flags bfd_generic_lookup_section_flags
5668 #ifndef coff_bfd_merge_sections
5669 #define coff_bfd_merge_sections bfd_generic_merge_sections
5672 #ifndef coff_bfd_is_group_section
5673 #define coff_bfd_is_group_section bfd_generic_is_group_section
5676 #ifndef coff_bfd_discard_group
5677 #define coff_bfd_discard_group bfd_generic_discard_group
5680 #ifndef coff_section_already_linked
5681 #define coff_section_already_linked \
5682 _bfd_coff_section_already_linked
5685 #ifndef coff_bfd_define_common_symbol
5686 #define coff_bfd_define_common_symbol bfd_generic_define_common_symbol
5689 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5690 const bfd_target VAR = \
5693 bfd_target_coff_flavour, \
5694 BFD_ENDIAN_BIG, /* Data byte order is big. */ \
5695 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5696 /* object flags */ \
5697 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5698 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5699 /* section flags */ \
5700 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5701 UNDER, /* Leading symbol underscore. */ \
5702 '/', /* AR_pad_char. */ \
5703 15, /* AR_max_namelen. */ \
5704 0, /* match priority. */ \
5706 /* Data conversion functions. */ \
5707 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5708 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5709 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5711 /* Header conversion functions. */ \
5712 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5713 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5714 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5716 /* bfd_check_format. */ \
5717 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5718 _bfd_dummy_target }, \
5719 /* bfd_set_format. */ \
5720 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5721 /* bfd_write_contents. */ \
5722 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5725 BFD_JUMP_TABLE_GENERIC (coff), \
5726 BFD_JUMP_TABLE_COPY (coff), \
5727 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5728 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5729 BFD_JUMP_TABLE_SYMBOLS (coff), \
5730 BFD_JUMP_TABLE_RELOCS (coff), \
5731 BFD_JUMP_TABLE_WRITE (coff), \
5732 BFD_JUMP_TABLE_LINK (coff), \
5733 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5740 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5741 const bfd_target VAR = \
5744 bfd_target_coff_flavour, \
5745 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5746 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5747 /* object flags */ \
5748 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5749 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5750 /* section flags */ \
5751 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5752 UNDER, /* Leading symbol underscore. */ \
5753 '/', /* AR_pad_char. */ \
5754 15, /* AR_max_namelen. */ \
5755 0, /* match priority. */ \
5757 /* Data conversion functions. */ \
5758 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5759 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5760 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5762 /* Header conversion functions. */ \
5763 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5764 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5765 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5767 /* bfd_check_format. */ \
5768 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5769 _bfd_dummy_target }, \
5770 /* bfd_set_format. */ \
5771 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5772 /* bfd_write_contents. */ \
5773 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5776 BFD_JUMP_TABLE_GENERIC (coff), \
5777 BFD_JUMP_TABLE_COPY (coff), \
5778 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5779 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5780 BFD_JUMP_TABLE_SYMBOLS (coff), \
5781 BFD_JUMP_TABLE_RELOCS (coff), \
5782 BFD_JUMP_TABLE_WRITE (coff), \
5783 BFD_JUMP_TABLE_LINK (coff), \
5784 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5791 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5792 const bfd_target VAR = \
5795 bfd_target_coff_flavour, \
5796 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5797 BFD_ENDIAN_LITTLE, /* Header byte order is little. */ \
5798 /* object flags */ \
5799 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5800 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5801 /* section flags */ \
5802 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5803 UNDER, /* Leading symbol underscore. */ \
5804 '/', /* AR_pad_char. */ \
5805 15, /* AR_max_namelen. */ \
5806 0, /* match priority. */ \
5808 /* Data conversion functions. */ \
5809 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5810 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5811 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5812 /* Header conversion functions. */ \
5813 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5814 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5815 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5816 /* bfd_check_format. */ \
5817 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5818 _bfd_dummy_target }, \
5819 /* bfd_set_format. */ \
5820 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5821 /* bfd_write_contents. */ \
5822 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5825 BFD_JUMP_TABLE_GENERIC (coff), \
5826 BFD_JUMP_TABLE_COPY (coff), \
5827 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5828 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5829 BFD_JUMP_TABLE_SYMBOLS (coff), \
5830 BFD_JUMP_TABLE_RELOCS (coff), \
5831 BFD_JUMP_TABLE_WRITE (coff), \
5832 BFD_JUMP_TABLE_LINK (coff), \
5833 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \