1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
5 Written by Cygnus Support.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
24 /* Most of this hacked by Steve Chamberlain,
30 BFD supports a number of different flavours of coff format.
31 The major differences between formats are the sizes and
32 alignments of fields in structures on disk, and the occasional
35 Coff in all its varieties is implemented with a few common
36 files and a number of implementation specific files. For
37 example, The 88k bcs coff format is implemented in the file
38 @file{coff-m88k.c}. This file @code{#include}s
39 @file{coff/m88k.h} which defines the external structure of the
40 coff format for the 88k, and @file{coff/internal.h} which
41 defines the internal structure. @file{coff-m88k.c} also
42 defines the relocations used by the 88k format
45 The Intel i960 processor version of coff is implemented in
46 @file{coff-i960.c}. This file has the same structure as
47 @file{coff-m88k.c}, except that it includes @file{coff/i960.h}
48 rather than @file{coff-m88k.h}.
51 Porting to a new version of coff
53 The recommended method is to select from the existing
54 implementations the version of coff which is most like the one
55 you want to use. For example, we'll say that i386 coff is
56 the one you select, and that your coff flavour is called foo.
57 Copy @file{i386coff.c} to @file{foocoff.c}, copy
58 @file{../include/coff/i386.h} to @file{../include/coff/foo.h},
59 and add the lines to @file{targets.c} and @file{Makefile.in}
60 so that your new back end is used. Alter the shapes of the
61 structures in @file{../include/coff/foo.h} so that they match
62 what you need. You will probably also have to add
63 @code{#ifdef}s to the code in @file{coff/internal.h} and
64 @file{coffcode.h} if your version of coff is too wild.
66 You can verify that your new BFD backend works quite simply by
67 building @file{objdump} from the @file{binutils} directory,
68 and making sure that its version of what's going on and your
69 host system's idea (assuming it has the pretty standard coff
70 dump utility, usually called @code{att-dump} or just
71 @code{dump}) are the same. Then clean up your code, and send
72 what you've done to Cygnus. Then your stuff will be in the
73 next release, and you won't have to keep integrating it.
76 How the coff backend works
81 The Coff backend is split into generic routines that are
82 applicable to any Coff target and routines that are specific
83 to a particular target. The target-specific routines are
84 further split into ones which are basically the same for all
85 Coff targets except that they use the external symbol format
86 or use different values for certain constants.
88 The generic routines are in @file{coffgen.c}. These routines
89 work for any Coff target. They use some hooks into the target
90 specific code; the hooks are in a @code{bfd_coff_backend_data}
91 structure, one of which exists for each target.
93 The essentially similar target-specific routines are in
94 @file{coffcode.h}. This header file includes executable C code.
95 The various Coff targets first include the appropriate Coff
96 header file, make any special defines that are needed, and
97 then include @file{coffcode.h}.
99 Some of the Coff targets then also have additional routines in
100 the target source file itself.
102 For example, @file{coff-i960.c} includes
103 @file{coff/internal.h} and @file{coff/i960.h}. It then
104 defines a few constants, such as @code{I960}, and includes
105 @file{coffcode.h}. Since the i960 has complex relocation
106 types, @file{coff-i960.c} also includes some code to
107 manipulate the i960 relocs. This code is not in
108 @file{coffcode.h} because it would not be used by any other
112 Coff long section names
114 In the standard Coff object format, section names are limited to
115 the eight bytes available in the @code{s_name} field of the
116 @code{SCNHDR} section header structure. The format requires the
117 field to be NUL-padded, but not necessarily NUL-terminated, so
118 the longest section names permitted are a full eight characters.
120 The Microsoft PE variants of the Coff object file format add
121 an extension to support the use of long section names. This
122 extension is defined in section 4 of the Microsoft PE/COFF
123 specification (rev 8.1). If a section name is too long to fit
124 into the section header's @code{s_name} field, it is instead
125 placed into the string table, and the @code{s_name} field is
126 filled with a slash ("/") followed by the ASCII decimal
127 representation of the offset of the full name relative to the
130 Note that this implies that the extension can only be used in object
131 files, as executables do not contain a string table. The standard
132 specifies that long section names from objects emitted into executable
133 images are to be truncated.
135 However, as a GNU extension, BFD can generate executable images
136 that contain a string table and long section names. This
137 would appear to be technically valid, as the standard only says
138 that Coff debugging information is deprecated, not forbidden,
139 and in practice it works, although some tools that parse PE files
140 expecting the MS standard format may become confused; @file{PEview} is
143 The functionality is supported in BFD by code implemented under
144 the control of the macro @code{COFF_LONG_SECTION_NAMES}. If not
145 defined, the format does not support long section names in any way.
146 If defined, it is used to initialise a flag,
147 @code{_bfd_coff_long_section_names}, and a hook function pointer,
148 @code{_bfd_coff_set_long_section_names}, in the Coff backend data
149 structure. The flag controls the generation of long section names
150 in output BFDs at runtime; if it is false, as it will be by default
151 when generating an executable image, long section names are truncated;
152 if true, the long section names extension is employed. The hook
153 points to a function that allows the value of the flag to be altered
154 at runtime, on formats that support long section names at all; on
155 other formats it points to a stub that returns an error indication.
157 With input BFDs, the flag is set according to whether any long section
158 names are detected while reading the section headers. For a completely
159 new BFD, the flag is set to the default for the target format. This
160 information can be used by a client of the BFD library when deciding
161 what output format to generate, and means that a BFD that is opened
162 for read and subsequently converted to a writeable BFD and modified
163 in-place will retain whatever format it had on input.
165 If @code{COFF_LONG_SECTION_NAMES} is simply defined (blank), or is
166 defined to the value "1", then long section names are enabled by
167 default; if it is defined to the value zero, they are disabled by
168 default (but still accepted in input BFDs). The header @file{coffcode.h}
169 defines a macro, @code{COFF_DEFAULT_LONG_SECTION_NAMES}, which is
170 used in the backends to initialise the backend data structure fields
171 appropriately; see the comments for further detail.
176 Each flavour of coff supported in BFD has its own header file
177 describing the external layout of the structures. There is also
178 an internal description of the coff layout, in
179 @file{coff/internal.h}. A major function of the
180 coff backend is swapping the bytes and twiddling the bits to
181 translate the external form of the structures into the normal
182 internal form. This is all performed in the
183 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
184 elements are different sizes between different versions of
185 coff; it is the duty of the coff version specific include file
186 to override the definitions of various packing routines in
187 @file{coffcode.h}. E.g., the size of line number entry in coff is
188 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
189 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
190 correct one. No doubt, some day someone will find a version of
191 coff which has a varying field size not catered to at the
192 moment. To port BFD, that person will have to add more @code{#defines}.
193 Three of the bit twiddling routines are exported to
194 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
195 and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol
196 table on its own, but uses BFD to fix things up. More of the
197 bit twiddlers are exported for @code{gas};
198 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
199 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
200 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
201 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
202 of all the symbol table and reloc drudgery itself, thereby
203 saving the internal BFD overhead, but uses BFD to swap things
204 on the way out, making cross ports much safer. Doing so also
205 allows BFD (and thus the linker) to use the same header files
206 as @code{gas}, which makes one avenue to disaster disappear.
211 The simple canonical form for symbols used by BFD is not rich
212 enough to keep all the information available in a coff symbol
213 table. The back end gets around this problem by keeping the original
214 symbol table around, "behind the scenes".
216 When a symbol table is requested (through a call to
217 @code{bfd_canonicalize_symtab}), a request gets through to
218 @code{coff_get_normalized_symtab}. This reads the symbol table from
219 the coff file and swaps all the structures inside into the
220 internal form. It also fixes up all the pointers in the table
221 (represented in the file by offsets from the first symbol in
222 the table) into physical pointers to elements in the new
223 internal table. This involves some work since the meanings of
224 fields change depending upon context: a field that is a
225 pointer to another structure in the symbol table at one moment
226 may be the size in bytes of a structure at the next. Another
227 pass is made over the table. All symbols which mark file names
228 (<<C_FILE>> symbols) are modified so that the internal
229 string points to the value in the auxent (the real filename)
230 rather than the normal text associated with the symbol
233 At this time the symbol names are moved around. Coff stores
234 all symbols less than nine characters long physically
235 within the symbol table; longer strings are kept at the end of
236 the file in the string table. This pass moves all strings
237 into memory and replaces them with pointers to the strings.
239 The symbol table is massaged once again, this time to create
240 the canonical table used by the BFD application. Each symbol
241 is inspected in turn, and a decision made (using the
242 @code{sclass} field) about the various flags to set in the
243 @code{asymbol}. @xref{Symbols}. The generated canonical table
244 shares strings with the hidden internal symbol table.
246 Any linenumbers are read from the coff file too, and attached
247 to the symbols which own the functions the linenumbers belong to.
252 Writing a symbol to a coff file which didn't come from a coff
253 file will lose any debugging information. The @code{asymbol}
254 structure remembers the BFD from which the symbol was taken, and on
255 output the back end makes sure that the same destination target as
256 source target is present.
258 When the symbols have come from a coff file then all the
259 debugging information is preserved.
261 Symbol tables are provided for writing to the back end in a
262 vector of pointers to pointers. This allows applications like
263 the linker to accumulate and output large symbol tables
264 without having to do too much byte copying.
266 This function runs through the provided symbol table and
267 patches each symbol marked as a file place holder
268 (@code{C_FILE}) to point to the next file place holder in the
269 list. It also marks each @code{offset} field in the list with
270 the offset from the first symbol of the current symbol.
272 Another function of this procedure is to turn the canonical
273 value form of BFD into the form used by coff. Internally, BFD
274 expects symbol values to be offsets from a section base; so a
275 symbol physically at 0x120, but in a section starting at
276 0x100, would have the value 0x20. Coff expects symbols to
277 contain their final value, so symbols have their values
278 changed at this point to reflect their sum with their owning
279 section. This transformation uses the
280 <<output_section>> field of the @code{asymbol}'s
281 @code{asection} @xref{Sections}.
283 o <<coff_mangle_symbols>>
285 This routine runs though the provided symbol table and uses
286 the offsets generated by the previous pass and the pointers
287 generated when the symbol table was read in to create the
288 structured hierarchy required by coff. It changes each pointer
289 to a symbol into the index into the symbol table of the asymbol.
291 o <<coff_write_symbols>>
293 This routine runs through the symbol table and patches up the
294 symbols from their internal form into the coff way, calls the
295 bit twiddlers, and writes out the table to the file.
304 The hidden information for an <<asymbol>> is described in a
305 <<combined_entry_type>>:
309 .typedef struct coff_ptr_struct
311 . {* Remembers the offset from the first symbol in the file for
312 . this symbol. Generated by coff_renumber_symbols. *}
313 . unsigned int offset;
315 . {* Should the value of this symbol be renumbered. Used for
316 . XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
317 . unsigned int fix_value : 1;
319 . {* Should the tag field of this symbol be renumbered.
320 . Created by coff_pointerize_aux. *}
321 . unsigned int fix_tag : 1;
323 . {* Should the endidx field of this symbol be renumbered.
324 . Created by coff_pointerize_aux. *}
325 . unsigned int fix_end : 1;
327 . {* Should the x_csect.x_scnlen field be renumbered.
328 . Created by coff_pointerize_aux. *}
329 . unsigned int fix_scnlen : 1;
331 . {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
332 . index into the line number entries. Set by coff_slurp_symbol_table. *}
333 . unsigned int fix_line : 1;
335 . {* The container for the symbol structure as read and translated
339 . union internal_auxent auxent;
340 . struct internal_syment syment;
342 .} combined_entry_type;
345 .{* Each canonical asymbol really looks like this: *}
347 .typedef struct coff_symbol_struct
349 . {* The actual symbol which the rest of BFD works with *}
352 . {* A pointer to the hidden information for this symbol *}
353 . combined_entry_type *native;
355 . {* A pointer to the linenumber information for this symbol *}
356 . struct lineno_cache_entry *lineno;
358 . {* Have the line numbers been relocated yet ? *}
359 . bfd_boolean done_lineno;
367 #include "coffswap.h"
370 #define STRING_SIZE_SIZE 4
372 #define DOT_DEBUG ".debug"
373 #define GNU_LINKONCE_WI ".gnu.linkonce.wi."
375 #if defined (COFF_LONG_SECTION_NAMES)
376 /* Needed to expand the inputs to BLANKOR1TOODD. */
377 #define COFFLONGSECTIONCATHELPER(x,y) x ## y
378 /* If the input macro Y is blank or '1', return an odd number; if it is
379 '0', return an even number. Result undefined in all other cases. */
380 #define BLANKOR1TOODD(y) COFFLONGSECTIONCATHELPER(1,y)
381 /* Defined to numerical 0 or 1 according to whether generation of long
382 section names is disabled or enabled by default. */
383 #define COFF_ENABLE_LONG_SECTION_NAMES (BLANKOR1TOODD(COFF_LONG_SECTION_NAMES) & 1)
384 /* Where long section names are supported, we allow them to be enabled
385 and disabled at runtime, so select an appropriate hook function for
386 _bfd_coff_set_long_section_names. */
387 #define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_allowed
388 #else /* !defined (COFF_LONG_SECTION_NAMES) */
389 /* If long section names are not supported, this stub disallows any
390 attempt to enable them at run-time. */
391 #define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_disallowed
392 #endif /* defined (COFF_LONG_SECTION_NAMES) */
394 /* Define a macro that can be used to initialise both the fields relating
395 to long section names in the backend data struct simultaneously. */
396 #if COFF_ENABLE_LONG_SECTION_NAMES
397 #define COFF_DEFAULT_LONG_SECTION_NAMES (TRUE), COFF_LONG_SECTION_NAMES_SETTER
398 #else /* !COFF_ENABLE_LONG_SECTION_NAMES */
399 #define COFF_DEFAULT_LONG_SECTION_NAMES (FALSE), COFF_LONG_SECTION_NAMES_SETTER
400 #endif /* COFF_ENABLE_LONG_SECTION_NAMES */
402 #if defined (COFF_LONG_SECTION_NAMES)
403 static bfd_boolean bfd_coff_set_long_section_names_allowed
405 #else /* !defined (COFF_LONG_SECTION_NAMES) */
406 static bfd_boolean bfd_coff_set_long_section_names_disallowed
408 #endif /* defined (COFF_LONG_SECTION_NAMES) */
409 static long sec_to_styp_flags
410 (const char *, flagword);
411 static bfd_boolean styp_to_sec_flags
412 (bfd *, void *, const char *, asection *, flagword *);
413 static bfd_boolean coff_bad_format_hook
415 static void coff_set_custom_section_alignment
416 (bfd *, asection *, const struct coff_section_alignment_entry *,
418 static bfd_boolean coff_new_section_hook
420 static bfd_boolean coff_set_arch_mach_hook
422 static bfd_boolean coff_write_relocs
424 static bfd_boolean coff_set_flags
425 (bfd *, unsigned int *, unsigned short *);
426 static bfd_boolean coff_set_arch_mach
427 (bfd *, enum bfd_architecture, unsigned long) ATTRIBUTE_UNUSED;
428 static bfd_boolean coff_compute_section_file_positions
430 static bfd_boolean coff_write_object_contents
431 (bfd *) ATTRIBUTE_UNUSED;
432 static bfd_boolean coff_set_section_contents
433 (bfd *, asection *, const void *, file_ptr, bfd_size_type);
434 static void * buy_and_read
435 (bfd *, file_ptr, bfd_size_type);
436 static bfd_boolean coff_slurp_line_table
438 static bfd_boolean coff_slurp_symbol_table
440 static enum coff_symbol_classification coff_classify_symbol
441 (bfd *, struct internal_syment *);
442 static bfd_boolean coff_slurp_reloc_table
443 (bfd *, asection *, asymbol **);
444 static long coff_canonicalize_reloc
445 (bfd *, asection *, arelent **, asymbol **);
446 #ifndef coff_mkobject_hook
447 static void * coff_mkobject_hook
448 (bfd *, void *, void *);
451 static flagword handle_COMDAT
452 (bfd *, flagword, void *, const char *, asection *);
454 #ifdef COFF_IMAGE_WITH_PE
455 static bfd_boolean coff_read_word
456 (bfd *, unsigned int *);
457 static unsigned int coff_compute_checksum
459 static bfd_boolean coff_apply_checksum
463 static bfd_boolean ticoff0_bad_format_hook
465 static bfd_boolean ticoff1_bad_format_hook
469 /* void warning(); */
471 #if defined (COFF_LONG_SECTION_NAMES)
473 bfd_coff_set_long_section_names_allowed (bfd *abfd, int enable)
475 coff_backend_info (abfd)->_bfd_coff_long_section_names = enable;
478 #else /* !defined (COFF_LONG_SECTION_NAMES) */
480 bfd_coff_set_long_section_names_disallowed (bfd *abfd, int enable)
486 #endif /* defined (COFF_LONG_SECTION_NAMES) */
488 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
489 the incoming SEC_* flags. The inverse of this function is
490 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
491 should probably mirror the changes in styp_to_sec_flags(). */
495 /* Macros for setting debugging flags. */
498 #define STYP_XCOFF_DEBUG STYP_DEBUG
500 #define STYP_XCOFF_DEBUG STYP_INFO
503 #ifdef COFF_ALIGN_IN_S_FLAGS
504 #define STYP_DEBUG_INFO STYP_DSECT
506 #define STYP_DEBUG_INFO STYP_INFO
510 sec_to_styp_flags (const char *sec_name, flagword sec_flags)
514 if (!strcmp (sec_name, _TEXT))
516 styp_flags = STYP_TEXT;
518 else if (!strcmp (sec_name, _DATA))
520 styp_flags = STYP_DATA;
522 else if (!strcmp (sec_name, _BSS))
524 styp_flags = STYP_BSS;
527 else if (!strcmp (sec_name, _COMMENT))
529 styp_flags = STYP_INFO;
530 #endif /* _COMMENT */
533 else if (!strcmp (sec_name, _LIB))
535 styp_flags = STYP_LIB;
539 else if (!strcmp (sec_name, _LIT))
541 styp_flags = STYP_LIT;
544 else if (CONST_STRNEQ (sec_name, DOT_DEBUG))
546 /* Handle the XCOFF debug section and DWARF2 debug sections. */
548 styp_flags = STYP_XCOFF_DEBUG;
550 styp_flags = STYP_DEBUG_INFO;
552 else if (CONST_STRNEQ (sec_name, ".stab"))
554 styp_flags = STYP_DEBUG_INFO;
556 #ifdef COFF_LONG_SECTION_NAMES
557 else if (CONST_STRNEQ (sec_name, GNU_LINKONCE_WI))
559 styp_flags = STYP_DEBUG_INFO;
563 else if (!strcmp (sec_name, _PAD))
565 styp_flags = STYP_PAD;
567 else if (!strcmp (sec_name, _LOADER))
569 styp_flags = STYP_LOADER;
571 else if (!strcmp (sec_name, _EXCEPT))
573 styp_flags = STYP_EXCEPT;
575 else if (!strcmp (sec_name, _TYPCHK))
577 styp_flags = STYP_TYPCHK;
580 /* Try and figure out what it should be */
581 else if (sec_flags & SEC_CODE)
583 styp_flags = STYP_TEXT;
585 else if (sec_flags & SEC_DATA)
587 styp_flags = STYP_DATA;
589 else if (sec_flags & SEC_READONLY)
591 #ifdef STYP_LIT /* 29k readonly text/data section */
592 styp_flags = STYP_LIT;
594 styp_flags = STYP_TEXT;
595 #endif /* STYP_LIT */
597 else if (sec_flags & SEC_LOAD)
599 styp_flags = STYP_TEXT;
601 else if (sec_flags & SEC_ALLOC)
603 styp_flags = STYP_BSS;
607 if (sec_flags & SEC_TIC54X_CLINK)
608 styp_flags |= STYP_CLINK;
612 if (sec_flags & SEC_TIC54X_BLOCK)
613 styp_flags |= STYP_BLOCK;
617 if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
618 styp_flags |= STYP_NOLOAD;
624 #else /* COFF_WITH_PE */
626 /* The PE version; see above for the general comments. The non-PE
627 case seems to be more guessing, and breaks PE format; specifically,
628 .rdata is readonly, but it sure ain't text. Really, all this
629 should be set up properly in gas (or whatever assembler is in use),
630 and honor whatever objcopy/strip, etc. sent us as input. */
633 sec_to_styp_flags (const char *sec_name, flagword sec_flags)
637 /* caution: there are at least three groups of symbols that have
638 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
639 SEC_* are the BFD internal flags, used for generic BFD
640 information. STYP_* are the COFF section flags which appear in
641 COFF files. IMAGE_SCN_* are the PE section flags which appear in
642 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
643 but there are more IMAGE_SCN_* flags. */
645 /* FIXME: There is no gas syntax to specify the debug section flag. */
646 if (CONST_STRNEQ (sec_name, DOT_DEBUG)
647 || CONST_STRNEQ (sec_name, GNU_LINKONCE_WI))
648 sec_flags = SEC_DEBUGGING | SEC_READONLY;
653 if ((sec_flags & SEC_CODE) != 0)
654 styp_flags |= IMAGE_SCN_CNT_CODE;
655 if ((sec_flags & SEC_DATA) != 0)
656 styp_flags |= IMAGE_SCN_CNT_INITIALIZED_DATA;
657 if ((sec_flags & SEC_ALLOC) != 0 && (sec_flags & SEC_LOAD) == 0)
658 styp_flags |= IMAGE_SCN_CNT_UNINITIALIZED_DATA; /* ==STYP_BSS */
660 /* skip constRUCTOR */
662 if ((sec_flags & SEC_IS_COMMON) != 0)
663 styp_flags |= IMAGE_SCN_LNK_COMDAT;
664 if ((sec_flags & SEC_DEBUGGING) != 0)
665 styp_flags |= IMAGE_SCN_MEM_DISCARDABLE;
666 if ((sec_flags & SEC_EXCLUDE) != 0)
667 styp_flags |= IMAGE_SCN_LNK_REMOVE;
668 if ((sec_flags & SEC_NEVER_LOAD) != 0)
669 styp_flags |= IMAGE_SCN_LNK_REMOVE;
672 if (sec_flags & SEC_LINK_ONCE)
673 styp_flags |= IMAGE_SCN_LNK_COMDAT;
674 /* skip LINK_DUPLICATES */
675 /* skip LINKER_CREATED */
677 if ((sec_flags & SEC_COFF_NOREAD) == 0)
678 styp_flags |= IMAGE_SCN_MEM_READ; /* Invert NOREAD for read. */
679 if ((sec_flags & SEC_READONLY) == 0)
680 styp_flags |= IMAGE_SCN_MEM_WRITE; /* Invert READONLY for write. */
681 if (sec_flags & SEC_CODE)
682 styp_flags |= IMAGE_SCN_MEM_EXECUTE; /* CODE->EXECUTE. */
683 if (sec_flags & SEC_COFF_SHARED)
684 styp_flags |= IMAGE_SCN_MEM_SHARED; /* Shared remains meaningful. */
689 #endif /* COFF_WITH_PE */
691 /* Return a word with SEC_* flags set to represent the incoming STYP_*
692 flags (from scnhdr.s_flags). The inverse of this function is
693 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
694 should probably mirror the changes in sec_to_styp_flags(). */
699 styp_to_sec_flags (bfd *abfd ATTRIBUTE_UNUSED,
702 asection *section ATTRIBUTE_UNUSED,
705 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
706 long styp_flags = internal_s->s_flags;
707 flagword sec_flags = 0;
710 if (styp_flags & STYP_BLOCK)
711 sec_flags |= SEC_TIC54X_BLOCK;
715 if (styp_flags & STYP_CLINK)
716 sec_flags |= SEC_TIC54X_CLINK;
720 if (styp_flags & STYP_NOLOAD)
721 sec_flags |= SEC_NEVER_LOAD;
722 #endif /* STYP_NOLOAD */
724 /* For 386 COFF, at least, an unloadable text or data section is
725 actually a shared library section. */
726 if (styp_flags & STYP_TEXT)
728 if (sec_flags & SEC_NEVER_LOAD)
729 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
731 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
733 else if (styp_flags & STYP_DATA)
735 if (sec_flags & SEC_NEVER_LOAD)
736 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
738 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
740 else if (styp_flags & STYP_BSS)
742 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
743 if (sec_flags & SEC_NEVER_LOAD)
744 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
747 sec_flags |= SEC_ALLOC;
749 else if (styp_flags & STYP_INFO)
751 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
752 defined. coff_compute_section_file_positions uses
753 COFF_PAGE_SIZE to ensure that the low order bits of the
754 section VMA and the file offset match. If we don't know
755 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
756 and demand page loading of the file will fail. */
757 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
758 sec_flags |= SEC_DEBUGGING;
761 else if (styp_flags & STYP_PAD)
763 else if (strcmp (name, _TEXT) == 0)
765 if (sec_flags & SEC_NEVER_LOAD)
766 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
768 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
770 else if (strcmp (name, _DATA) == 0)
772 if (sec_flags & SEC_NEVER_LOAD)
773 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
775 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
777 else if (strcmp (name, _BSS) == 0)
779 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
780 if (sec_flags & SEC_NEVER_LOAD)
781 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
784 sec_flags |= SEC_ALLOC;
786 else if (CONST_STRNEQ (name, DOT_DEBUG)
788 || strcmp (name, _COMMENT) == 0
790 #ifdef COFF_LONG_SECTION_NAMES
791 || CONST_STRNEQ (name, GNU_LINKONCE_WI)
793 || CONST_STRNEQ (name, ".stab"))
795 #ifdef COFF_PAGE_SIZE
796 sec_flags |= SEC_DEBUGGING;
800 else if (strcmp (name, _LIB) == 0)
804 else if (strcmp (name, _LIT) == 0)
805 sec_flags = SEC_LOAD | SEC_ALLOC | SEC_READONLY;
808 sec_flags |= SEC_ALLOC | SEC_LOAD;
810 #ifdef STYP_LIT /* A29k readonly text/data section type. */
811 if ((styp_flags & STYP_LIT) == STYP_LIT)
812 sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
813 #endif /* STYP_LIT */
815 #ifdef STYP_OTHER_LOAD /* Other loaded sections. */
816 if (styp_flags & STYP_OTHER_LOAD)
817 sec_flags = (SEC_LOAD | SEC_ALLOC);
818 #endif /* STYP_SDATA */
820 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
821 /* As a GNU extension, if the name begins with .gnu.linkonce, we
822 only link a single copy of the section. This is used to support
823 g++. g++ will emit each template expansion in its own section.
824 The symbols will be defined as weak, so that multiple definitions
825 are permitted. The GNU linker extension is to actually discard
826 all but one of the sections. */
827 if (CONST_STRNEQ (name, ".gnu.linkonce"))
828 sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
831 if (flags_ptr == NULL)
834 * flags_ptr = sec_flags;
838 #else /* COFF_WITH_PE */
841 handle_COMDAT (bfd * abfd,
847 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
848 bfd_byte *esymstart, *esym, *esymend;
850 char *target_name = NULL;
852 sec_flags |= SEC_LINK_ONCE;
854 /* Unfortunately, the PE format stores essential information in
855 the symbol table, of all places. We need to extract that
856 information now, so that objdump and the linker will know how
857 to handle the section without worrying about the symbols. We
858 can't call slurp_symtab, because the linker doesn't want the
861 /* COMDAT sections are special. The first symbol is the section
862 symbol, which tells what kind of COMDAT section it is. The
863 second symbol is the "comdat symbol" - the one with the
864 unique name. GNU uses the section symbol for the unique
865 name; MS uses ".text" for every comdat section. Sigh. - DJ */
867 /* This is not mirrored in sec_to_styp_flags(), but there
868 doesn't seem to be a need to, either, and it would at best be
871 if (! _bfd_coff_get_external_symbols (abfd))
874 esymstart = esym = (bfd_byte *) obj_coff_external_syms (abfd);
875 esymend = esym + obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd);
877 while (esym < esymend)
879 struct internal_syment isym;
880 char buf[SYMNMLEN + 1];
883 bfd_coff_swap_sym_in (abfd, esym, & isym);
885 if (sizeof (internal_s->s_name) > SYMNMLEN)
887 /* This case implies that the matching
888 symbol name will be in the string table. */
892 if (isym.n_scnum == section->target_index)
894 /* According to the MSVC documentation, the first
895 TWO entries with the section # are both of
896 interest to us. The first one is the "section
897 symbol" (section name). The second is the comdat
898 symbol name. Here, we've found the first
899 qualifying entry; we distinguish it from the
900 second with a state flag.
902 In the case of gas-generated (at least until that
903 is fixed) .o files, it isn't necessarily the
904 second one. It may be some other later symbol.
906 Since gas also doesn't follow MS conventions and
907 emits the section similar to .text$<name>, where
908 <something> is the name we're looking for, we
909 distinguish the two as follows:
911 If the section name is simply a section name (no
912 $) we presume it's MS-generated, and look at
913 precisely the second symbol for the comdat name.
914 If the section name has a $, we assume it's
915 gas-generated, and look for <something> (whatever
916 follows the $) as the comdat symbol. */
918 /* All 3 branches use this. */
919 symname = _bfd_coff_internal_syment_name (abfd, &isym, buf);
928 /* The first time we've seen the symbol. */
929 union internal_auxent aux;
931 /* If it isn't the stuff we're expecting, die;
932 The MS documentation is vague, but it
933 appears that the second entry serves BOTH
934 as the comdat symbol and the defining
935 symbol record (either C_STAT or C_EXT,
936 possibly with an aux entry with debug
937 information if it's a function.) It
938 appears the only way to find the second one
939 is to count. (On Intel, they appear to be
940 adjacent, but on Alpha, they have been
943 Here, we think we've found the first one,
944 but there's some checking we can do to be
947 if (! ((isym.n_sclass == C_STAT
948 || isym.n_sclass == C_EXT)
949 && isym.n_type == T_NULL
950 && isym.n_value == 0))
953 /* FIXME LATER: MSVC generates section names
954 like .text for comdats. Gas generates
955 names like .text$foo__Fv (in the case of a
956 function). See comment above for more. */
958 if (isym.n_sclass == C_STAT && strcmp (name, symname) != 0)
959 _bfd_error_handler (_("%B: warning: COMDAT symbol '%s' does not match section name '%s'"),
960 abfd, symname, name);
964 /* This is the section symbol. */
965 bfd_coff_swap_aux_in (abfd, (esym + bfd_coff_symesz (abfd)),
966 isym.n_type, isym.n_sclass,
967 0, isym.n_numaux, & aux);
969 target_name = strchr (name, '$');
970 if (target_name != NULL)
978 /* FIXME: Microsoft uses NODUPLICATES and
979 ASSOCIATIVE, but gnu uses ANY and
980 SAME_SIZE. Unfortunately, gnu doesn't do
981 the comdat symbols right. So, until we can
982 fix it to do the right thing, we are
983 temporarily disabling comdats for the MS
984 types (they're used in DLLs and C++, but we
985 don't support *their* C++ libraries anyway
988 /* Cygwin does not follow the MS style, and
989 uses ANY and SAME_SIZE where NODUPLICATES
990 and ASSOCIATIVE should be used. For
991 Interix, we just do the right thing up
994 switch (aux.x_scn.x_comdat)
996 case IMAGE_COMDAT_SELECT_NODUPLICATES:
997 #ifdef STRICT_PE_FORMAT
998 sec_flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
1000 sec_flags &= ~SEC_LINK_ONCE;
1004 case IMAGE_COMDAT_SELECT_ANY:
1005 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
1008 case IMAGE_COMDAT_SELECT_SAME_SIZE:
1009 sec_flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
1012 case IMAGE_COMDAT_SELECT_EXACT_MATCH:
1013 /* Not yet fully implemented ??? */
1014 sec_flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
1017 /* debug$S gets this case; other
1020 /* There may be no symbol... we'll search
1021 the whole table... Is this the right
1022 place to play this game? Or should we do
1023 it when reading it in. */
1024 case IMAGE_COMDAT_SELECT_ASSOCIATIVE:
1025 #ifdef STRICT_PE_FORMAT
1026 /* FIXME: This is not currently implemented. */
1027 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
1029 sec_flags &= ~SEC_LINK_ONCE;
1033 default: /* 0 means "no symbol" */
1034 /* debug$F gets this case; other
1036 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
1043 /* Gas mode: the first matching on partial name. */
1045 #ifndef TARGET_UNDERSCORE
1046 #define TARGET_UNDERSCORE 0
1048 /* Is this the name we're looking for ? */
1049 if (strcmp (target_name,
1050 symname + (TARGET_UNDERSCORE ? 1 : 0)) != 0)
1052 /* Not the name we're looking for */
1053 esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd);
1058 /* MSVC mode: the lexically second symbol (or
1059 drop through from the above). */
1064 /* This must the second symbol with the
1065 section #. It is the actual symbol name.
1066 Intel puts the two adjacent, but Alpha (at
1067 least) spreads them out. */
1069 amt = sizeof (struct coff_comdat_info);
1070 coff_section_data (abfd, section)->comdat
1071 = bfd_alloc (abfd, amt);
1072 if (coff_section_data (abfd, section)->comdat == NULL)
1075 coff_section_data (abfd, section)->comdat->symbol =
1076 (esym - esymstart) / bfd_coff_symesz (abfd);
1078 amt = strlen (symname) + 1;
1079 newname = bfd_alloc (abfd, amt);
1080 if (newname == NULL)
1083 strcpy (newname, symname);
1084 coff_section_data (abfd, section)->comdat->name
1092 esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd);
1100 /* The PE version; see above for the general comments.
1102 Since to set the SEC_LINK_ONCE and associated flags, we have to
1103 look at the symbol table anyway, we return the symbol table index
1104 of the symbol being used as the COMDAT symbol. This is admittedly
1105 ugly, but there's really nowhere else that we have access to the
1106 required information. FIXME: Is the COMDAT symbol index used for
1107 any purpose other than objdump? */
1110 styp_to_sec_flags (bfd *abfd,
1114 flagword *flags_ptr)
1116 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
1117 long styp_flags = internal_s->s_flags;
1119 bfd_boolean result = TRUE;
1121 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
1122 sec_flags = SEC_READONLY;
1124 /* If section disallows read, then set the NOREAD flag. */
1125 if ((styp_flags & IMAGE_SCN_MEM_READ) == 0)
1126 sec_flags |= SEC_COFF_NOREAD;
1128 /* Process each flag bit in styp_flags in turn. */
1131 long flag = styp_flags & - styp_flags;
1132 char * unhandled = NULL;
1134 styp_flags &= ~ flag;
1136 /* We infer from the distinct read/write/execute bits the settings
1137 of some of the bfd flags; the actual values, should we need them,
1138 are also in pei_section_data (abfd, section)->pe_flags. */
1143 unhandled = "STYP_DSECT";
1146 unhandled = "STYP_GROUP";
1149 unhandled = "STYP_COPY";
1152 unhandled = "STYP_OVER";
1154 #ifdef SEC_NEVER_LOAD
1156 sec_flags |= SEC_NEVER_LOAD;
1159 case IMAGE_SCN_MEM_READ:
1160 sec_flags &= ~SEC_COFF_NOREAD;
1162 case IMAGE_SCN_TYPE_NO_PAD:
1165 case IMAGE_SCN_LNK_OTHER:
1166 unhandled = "IMAGE_SCN_LNK_OTHER";
1168 case IMAGE_SCN_MEM_NOT_CACHED:
1169 unhandled = "IMAGE_SCN_MEM_NOT_CACHED";
1171 case IMAGE_SCN_MEM_NOT_PAGED:
1172 /* Generate a warning message rather using the 'unhandled'
1173 variable as this will allow some .sys files generate by
1174 other toolchains to be processed. See bugzilla issue 196. */
1175 _bfd_error_handler (_("%B: Warning: Ignoring section flag IMAGE_SCN_MEM_NOT_PAGED in section %s"),
1178 case IMAGE_SCN_MEM_EXECUTE:
1179 sec_flags |= SEC_CODE;
1181 case IMAGE_SCN_MEM_WRITE:
1182 sec_flags &= ~ SEC_READONLY;
1184 case IMAGE_SCN_MEM_DISCARDABLE:
1185 /* The MS PE spec says that debug sections are DISCARDABLE,
1186 but the presence of a DISCARDABLE flag does not necessarily
1187 mean that a given section contains debug information. Thus
1188 we only set the SEC_DEBUGGING flag on sections that we
1189 recognise as containing debug information. */
1190 if (CONST_STRNEQ (name, DOT_DEBUG)
1192 || strcmp (name, _COMMENT) == 0
1194 #ifdef COFF_LONG_SECTION_NAMES
1195 || CONST_STRNEQ (name, GNU_LINKONCE_WI)
1197 || CONST_STRNEQ (name, ".stab"))
1198 sec_flags |= SEC_DEBUGGING;
1200 case IMAGE_SCN_MEM_SHARED:
1201 sec_flags |= SEC_COFF_SHARED;
1203 case IMAGE_SCN_LNK_REMOVE:
1204 sec_flags |= SEC_EXCLUDE;
1206 case IMAGE_SCN_CNT_CODE:
1207 sec_flags |= SEC_CODE | SEC_ALLOC | SEC_LOAD;
1209 case IMAGE_SCN_CNT_INITIALIZED_DATA:
1210 sec_flags |= SEC_DATA | SEC_ALLOC | SEC_LOAD;
1212 case IMAGE_SCN_CNT_UNINITIALIZED_DATA:
1213 sec_flags |= SEC_ALLOC;
1215 case IMAGE_SCN_LNK_INFO:
1216 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1217 defined. coff_compute_section_file_positions uses
1218 COFF_PAGE_SIZE to ensure that the low order bits of the
1219 section VMA and the file offset match. If we don't know
1220 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1221 and demand page loading of the file will fail. */
1222 #ifdef COFF_PAGE_SIZE
1223 sec_flags |= SEC_DEBUGGING;
1226 case IMAGE_SCN_LNK_COMDAT:
1227 /* COMDAT gets very special treatment. */
1228 sec_flags = handle_COMDAT (abfd, sec_flags, hdr, name, section);
1231 /* Silently ignore for now. */
1235 /* If the section flag was not handled, report it here. */
1236 if (unhandled != NULL)
1238 (*_bfd_error_handler)
1239 (_("%B (%s): Section flag %s (0x%x) ignored"),
1240 abfd, name, unhandled, flag);
1245 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1246 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1247 only link a single copy of the section. This is used to support
1248 g++. g++ will emit each template expansion in its own section.
1249 The symbols will be defined as weak, so that multiple definitions
1250 are permitted. The GNU linker extension is to actually discard
1251 all but one of the sections. */
1252 if (CONST_STRNEQ (name, ".gnu.linkonce"))
1253 sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1257 * flags_ptr = sec_flags;
1262 #endif /* COFF_WITH_PE */
1264 #define get_index(symbol) ((symbol)->udata.i)
1268 bfd_coff_backend_data
1272 .{* COFF symbol classifications. *}
1274 .enum coff_symbol_classification
1276 . {* Global symbol. *}
1277 . COFF_SYMBOL_GLOBAL,
1278 . {* Common symbol. *}
1279 . COFF_SYMBOL_COMMON,
1280 . {* Undefined symbol. *}
1281 . COFF_SYMBOL_UNDEFINED,
1282 . {* Local symbol. *}
1283 . COFF_SYMBOL_LOCAL,
1284 . {* PE section symbol. *}
1285 . COFF_SYMBOL_PE_SECTION
1288 Special entry points for gdb to swap in coff symbol table parts:
1291 . void (*_bfd_coff_swap_aux_in)
1292 . (bfd *, void *, int, int, int, int, void *);
1294 . void (*_bfd_coff_swap_sym_in)
1295 . (bfd *, void *, void *);
1297 . void (*_bfd_coff_swap_lineno_in)
1298 . (bfd *, void *, void *);
1300 . unsigned int (*_bfd_coff_swap_aux_out)
1301 . (bfd *, void *, int, int, int, int, void *);
1303 . unsigned int (*_bfd_coff_swap_sym_out)
1304 . (bfd *, void *, void *);
1306 . unsigned int (*_bfd_coff_swap_lineno_out)
1307 . (bfd *, void *, void *);
1309 . unsigned int (*_bfd_coff_swap_reloc_out)
1310 . (bfd *, void *, void *);
1312 . unsigned int (*_bfd_coff_swap_filehdr_out)
1313 . (bfd *, void *, void *);
1315 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1316 . (bfd *, void *, void *);
1318 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1319 . (bfd *, void *, void *);
1321 . unsigned int _bfd_filhsz;
1322 . unsigned int _bfd_aoutsz;
1323 . unsigned int _bfd_scnhsz;
1324 . unsigned int _bfd_symesz;
1325 . unsigned int _bfd_auxesz;
1326 . unsigned int _bfd_relsz;
1327 . unsigned int _bfd_linesz;
1328 . unsigned int _bfd_filnmlen;
1329 . bfd_boolean _bfd_coff_long_filenames;
1331 . bfd_boolean _bfd_coff_long_section_names;
1332 . bfd_boolean (*_bfd_coff_set_long_section_names)
1335 . unsigned int _bfd_coff_default_section_alignment_power;
1336 . bfd_boolean _bfd_coff_force_symnames_in_strings;
1337 . unsigned int _bfd_coff_debug_string_prefix_length;
1339 . void (*_bfd_coff_swap_filehdr_in)
1340 . (bfd *, void *, void *);
1342 . void (*_bfd_coff_swap_aouthdr_in)
1343 . (bfd *, void *, void *);
1345 . void (*_bfd_coff_swap_scnhdr_in)
1346 . (bfd *, void *, void *);
1348 . void (*_bfd_coff_swap_reloc_in)
1349 . (bfd *abfd, void *, void *);
1351 . bfd_boolean (*_bfd_coff_bad_format_hook)
1354 . bfd_boolean (*_bfd_coff_set_arch_mach_hook)
1357 . void * (*_bfd_coff_mkobject_hook)
1358 . (bfd *, void *, void *);
1360 . bfd_boolean (*_bfd_styp_to_sec_flags_hook)
1361 . (bfd *, void *, const char *, asection *, flagword *);
1363 . void (*_bfd_set_alignment_hook)
1364 . (bfd *, asection *, void *);
1366 . bfd_boolean (*_bfd_coff_slurp_symbol_table)
1369 . bfd_boolean (*_bfd_coff_symname_in_debug)
1370 . (bfd *, struct internal_syment *);
1372 . bfd_boolean (*_bfd_coff_pointerize_aux_hook)
1373 . (bfd *, combined_entry_type *, combined_entry_type *,
1374 . unsigned int, combined_entry_type *);
1376 . bfd_boolean (*_bfd_coff_print_aux)
1377 . (bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1378 . combined_entry_type *, unsigned int);
1380 . void (*_bfd_coff_reloc16_extra_cases)
1381 . (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1382 . bfd_byte *, unsigned int *, unsigned int *);
1384 . int (*_bfd_coff_reloc16_estimate)
1385 . (bfd *, asection *, arelent *, unsigned int,
1386 . struct bfd_link_info *);
1388 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1389 . (bfd *, struct internal_syment *);
1391 . bfd_boolean (*_bfd_coff_compute_section_file_positions)
1394 . bfd_boolean (*_bfd_coff_start_final_link)
1395 . (bfd *, struct bfd_link_info *);
1397 . bfd_boolean (*_bfd_coff_relocate_section)
1398 . (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1399 . struct internal_reloc *, struct internal_syment *, asection **);
1401 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1402 . (bfd *, asection *, struct internal_reloc *,
1403 . struct coff_link_hash_entry *, struct internal_syment *,
1406 . bfd_boolean (*_bfd_coff_adjust_symndx)
1407 . (bfd *, struct bfd_link_info *, bfd *, asection *,
1408 . struct internal_reloc *, bfd_boolean *);
1410 . bfd_boolean (*_bfd_coff_link_add_one_symbol)
1411 . (struct bfd_link_info *, bfd *, const char *, flagword,
1412 . asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
1413 . struct bfd_link_hash_entry **);
1415 . bfd_boolean (*_bfd_coff_link_output_has_begun)
1416 . (bfd *, struct coff_final_link_info *);
1418 . bfd_boolean (*_bfd_coff_final_link_postscript)
1419 . (bfd *, struct coff_final_link_info *);
1421 . bfd_boolean (*_bfd_coff_print_pdata)
1424 .} bfd_coff_backend_data;
1426 .#define coff_backend_info(abfd) \
1427 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1429 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1430 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1432 .#define bfd_coff_swap_sym_in(a,e,i) \
1433 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1435 .#define bfd_coff_swap_lineno_in(a,e,i) \
1436 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1438 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1439 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1441 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1442 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1444 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1445 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1447 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1448 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1450 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1451 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1453 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1454 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1456 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1457 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1459 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1460 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1461 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1462 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1463 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1464 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1465 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1466 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1467 .#define bfd_coff_long_filenames(abfd) \
1468 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1469 .#define bfd_coff_long_section_names(abfd) \
1470 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1471 .#define bfd_coff_set_long_section_names(abfd, enable) \
1472 . ((coff_backend_info (abfd)->_bfd_coff_set_long_section_names) (abfd, enable))
1473 .#define bfd_coff_default_section_alignment_power(abfd) \
1474 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1475 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1476 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1478 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1479 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1481 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1482 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1484 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1485 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1487 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1488 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1490 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1491 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1492 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1493 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1494 . (abfd, filehdr, aouthdr))
1496 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1497 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1498 . (abfd, scnhdr, name, section, flags_ptr))
1500 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1501 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1503 .#define bfd_coff_slurp_symbol_table(abfd)\
1504 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1506 .#define bfd_coff_symname_in_debug(abfd, sym)\
1507 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1509 .#define bfd_coff_force_symnames_in_strings(abfd)\
1510 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1512 .#define bfd_coff_debug_string_prefix_length(abfd)\
1513 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1515 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1516 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1517 . (abfd, file, base, symbol, aux, indaux))
1519 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1520 . reloc, data, src_ptr, dst_ptr)\
1521 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1522 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1524 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1525 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1526 . (abfd, section, reloc, shrink, link_info))
1528 .#define bfd_coff_classify_symbol(abfd, sym)\
1529 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1532 .#define bfd_coff_compute_section_file_positions(abfd)\
1533 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1536 .#define bfd_coff_start_final_link(obfd, info)\
1537 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1539 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1540 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1541 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1542 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1543 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1544 . (abfd, sec, rel, h, sym, addendp))
1545 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1546 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1547 . (obfd, info, ibfd, sec, rel, adjustedp))
1548 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1549 . value, string, cp, coll, hashp)\
1550 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1551 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1553 .#define bfd_coff_link_output_has_begun(a,p) \
1554 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p))
1555 .#define bfd_coff_final_link_postscript(a,p) \
1556 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p))
1558 .#define bfd_coff_have_print_pdata(a) \
1559 . (coff_backend_info (a)->_bfd_coff_print_pdata)
1560 .#define bfd_coff_print_pdata(a,p) \
1561 . ((coff_backend_info (a)->_bfd_coff_print_pdata) (a, p))
1565 /* See whether the magic number matches. */
1568 coff_bad_format_hook (bfd * abfd ATTRIBUTE_UNUSED, void * filehdr)
1570 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1572 if (BADMAG (*internal_f))
1575 /* If the optional header is NULL or not the correct size then
1576 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1577 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1578 optional header is of a different size.
1580 But the mips keeps extra stuff in it's opthdr, so dont check
1583 #if defined(M88) || defined(I960)
1584 if (internal_f->f_opthdr != 0 && bfd_coff_aoutsz (abfd) != internal_f->f_opthdr)
1593 ticoff0_bad_format_hook (bfd *abfd ATTRIBUTE_UNUSED, void * filehdr)
1595 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1597 if (COFF0_BADMAG (*internal_f))
1606 ticoff1_bad_format_hook (bfd *abfd ATTRIBUTE_UNUSED, void * filehdr)
1608 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1610 if (COFF1_BADMAG (*internal_f))
1617 /* Check whether this section uses an alignment other than the
1621 coff_set_custom_section_alignment (bfd *abfd ATTRIBUTE_UNUSED,
1623 const struct coff_section_alignment_entry *alignment_table,
1624 const unsigned int table_size)
1626 const unsigned int default_alignment = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1629 for (i = 0; i < table_size; ++i)
1631 const char *secname = bfd_get_section_name (abfd, section);
1633 if (alignment_table[i].comparison_length == (unsigned int) -1
1634 ? strcmp (alignment_table[i].name, secname) == 0
1635 : strncmp (alignment_table[i].name, secname,
1636 alignment_table[i].comparison_length) == 0)
1639 if (i >= table_size)
1642 if (alignment_table[i].default_alignment_min != COFF_ALIGNMENT_FIELD_EMPTY
1643 && default_alignment < alignment_table[i].default_alignment_min)
1646 if (alignment_table[i].default_alignment_max != COFF_ALIGNMENT_FIELD_EMPTY
1647 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1648 && default_alignment > alignment_table[i].default_alignment_max
1653 section->alignment_power = alignment_table[i].alignment_power;
1656 /* Custom section alignment records. */
1658 static const struct coff_section_alignment_entry
1659 coff_section_alignment_table[] =
1661 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1662 COFF_SECTION_ALIGNMENT_ENTRIES,
1664 /* There must not be any gaps between .stabstr sections. */
1665 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1666 1, COFF_ALIGNMENT_FIELD_EMPTY, 0 },
1667 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1668 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1669 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1670 /* Similarly for the .ctors and .dtors sections. */
1671 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1672 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1673 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1674 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 }
1677 static const unsigned int coff_section_alignment_table_size =
1678 sizeof coff_section_alignment_table / sizeof coff_section_alignment_table[0];
1680 /* Initialize a section structure with information peculiar to this
1681 particular implementation of COFF. */
1684 coff_new_section_hook (bfd * abfd, asection * section)
1686 combined_entry_type *native;
1689 section->alignment_power = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1692 if (bfd_xcoff_text_align_power (abfd) != 0
1693 && strcmp (bfd_get_section_name (abfd, section), ".text") == 0)
1694 section->alignment_power = bfd_xcoff_text_align_power (abfd);
1695 if (bfd_xcoff_data_align_power (abfd) != 0
1696 && strcmp (bfd_get_section_name (abfd, section), ".data") == 0)
1697 section->alignment_power = bfd_xcoff_data_align_power (abfd);
1700 /* Set up the section symbol. */
1701 if (!_bfd_generic_new_section_hook (abfd, section))
1704 /* Allocate aux records for section symbols, to store size and
1707 @@ The 10 is a guess at a plausible maximum number of aux entries
1708 (but shouldn't be a constant). */
1709 amt = sizeof (combined_entry_type) * 10;
1710 native = bfd_zalloc (abfd, amt);
1714 /* We don't need to set up n_name, n_value, or n_scnum in the native
1715 symbol information, since they'll be overridden by the BFD symbol
1716 anyhow. However, we do need to set the type and storage class,
1717 in case this symbol winds up getting written out. The value 0
1718 for n_numaux is already correct. */
1720 native->u.syment.n_type = T_NULL;
1721 native->u.syment.n_sclass = C_STAT;
1723 coffsymbol (section->symbol)->native = native;
1725 coff_set_custom_section_alignment (abfd, section,
1726 coff_section_alignment_table,
1727 coff_section_alignment_table_size);
1732 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1734 /* Set the alignment of a BFD section. */
1737 coff_set_alignment_hook (bfd * abfd ATTRIBUTE_UNUSED,
1741 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1745 /* Extract ALIGN from 2**ALIGN stored in section header. */
1746 for (i = 0; i < 32; i++)
1747 if ((1 << i) >= hdr->s_align)
1751 /* TI tools puts the alignment power in bits 8-11. */
1752 i = (hdr->s_flags >> 8) & 0xF ;
1754 #ifdef COFF_DECODE_ALIGNMENT
1755 i = COFF_DECODE_ALIGNMENT(hdr->s_flags);
1757 section->alignment_power = i;
1759 #ifdef coff_set_section_load_page
1760 coff_set_section_load_page (section, hdr->s_page);
1764 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1768 coff_set_alignment_hook (bfd * abfd ATTRIBUTE_UNUSED,
1772 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1774 unsigned int alignment_power_const
1775 = hdr->s_flags & IMAGE_SCN_ALIGN_POWER_BIT_MASK;
1777 switch (alignment_power_const)
1779 case IMAGE_SCN_ALIGN_8192BYTES:
1780 case IMAGE_SCN_ALIGN_4096BYTES:
1781 case IMAGE_SCN_ALIGN_2048BYTES:
1782 case IMAGE_SCN_ALIGN_1024BYTES:
1783 case IMAGE_SCN_ALIGN_512BYTES:
1784 case IMAGE_SCN_ALIGN_256BYTES:
1785 case IMAGE_SCN_ALIGN_128BYTES:
1786 case IMAGE_SCN_ALIGN_64BYTES:
1787 case IMAGE_SCN_ALIGN_32BYTES:
1788 case IMAGE_SCN_ALIGN_16BYTES:
1789 case IMAGE_SCN_ALIGN_8BYTES:
1790 case IMAGE_SCN_ALIGN_4BYTES:
1791 case IMAGE_SCN_ALIGN_2BYTES:
1792 case IMAGE_SCN_ALIGN_1BYTES:
1793 section->alignment_power
1794 = IMAGE_SCN_ALIGN_POWER_NUM (alignment_power_const);
1800 /* In a PE image file, the s_paddr field holds the virtual size of a
1801 section, while the s_size field holds the raw size. We also keep
1802 the original section flag value, since not every bit can be
1803 mapped onto a generic BFD section bit. */
1804 if (coff_section_data (abfd, section) == NULL)
1806 amt = sizeof (struct coff_section_tdata);
1807 section->used_by_bfd = bfd_zalloc (abfd, amt);
1808 if (section->used_by_bfd == NULL)
1809 /* FIXME: Return error. */
1813 if (pei_section_data (abfd, section) == NULL)
1815 amt = sizeof (struct pei_section_tdata);
1816 coff_section_data (abfd, section)->tdata = bfd_zalloc (abfd, amt);
1817 if (coff_section_data (abfd, section)->tdata == NULL)
1818 /* FIXME: Return error. */
1821 pei_section_data (abfd, section)->virt_size = hdr->s_paddr;
1822 pei_section_data (abfd, section)->pe_flags = hdr->s_flags;
1824 section->lma = hdr->s_vaddr;
1826 /* Check for extended relocs. */
1827 if (hdr->s_flags & IMAGE_SCN_LNK_NRELOC_OVFL)
1829 struct external_reloc dst;
1830 struct internal_reloc n;
1831 file_ptr oldpos = bfd_tell (abfd);
1832 bfd_size_type relsz = bfd_coff_relsz (abfd);
1834 bfd_seek (abfd, (file_ptr) hdr->s_relptr, 0);
1835 if (bfd_bread (& dst, relsz, abfd) != relsz)
1838 coff_swap_reloc_in (abfd, &dst, &n);
1839 bfd_seek (abfd, oldpos, 0);
1840 section->reloc_count = hdr->s_nreloc = n.r_vaddr - 1;
1841 section->rel_filepos += relsz;
1843 else if (hdr->s_nreloc == 0xffff)
1844 (*_bfd_error_handler)
1845 ("%s: warning: claims to have 0xffff relocs, without overflow",
1846 bfd_get_filename (abfd));
1849 #undef ELIFALIGN_SET
1851 #else /* ! COFF_WITH_PE */
1854 /* We grossly abuse this function to handle XCOFF overflow headers.
1855 When we see one, we correct the reloc and line number counts in the
1856 real header, and remove the section we just created. */
1859 coff_set_alignment_hook (bfd *abfd, asection *section, void * scnhdr)
1861 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1864 if ((hdr->s_flags & STYP_OVRFLO) == 0)
1867 real_sec = coff_section_from_bfd_index (abfd, (int) hdr->s_nreloc);
1868 if (real_sec == NULL)
1871 real_sec->reloc_count = hdr->s_paddr;
1872 real_sec->lineno_count = hdr->s_vaddr;
1874 if (!bfd_section_removed_from_list (abfd, section))
1876 bfd_section_list_remove (abfd, section);
1877 --abfd->section_count;
1881 #else /* ! RS6000COFF_C */
1883 #define coff_set_alignment_hook \
1884 ((void (*) (bfd *, asection *, void *)) bfd_void)
1886 #endif /* ! RS6000COFF_C */
1887 #endif /* ! COFF_WITH_PE */
1888 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1890 #ifndef coff_mkobject
1893 coff_mkobject (bfd * abfd)
1895 coff_data_type *coff;
1896 bfd_size_type amt = sizeof (coff_data_type);
1898 abfd->tdata.coff_obj_data = bfd_zalloc (abfd, amt);
1899 if (abfd->tdata.coff_obj_data == NULL)
1901 coff = coff_data (abfd);
1902 coff->symbols = NULL;
1903 coff->conversion_table = NULL;
1904 coff->raw_syments = NULL;
1905 coff->relocbase = 0;
1906 coff->local_toc_sym_map = 0;
1908 /* make_abs_section(abfd);*/
1914 /* Create the COFF backend specific information. */
1916 #ifndef coff_mkobject_hook
1918 coff_mkobject_hook (bfd * abfd,
1920 void * aouthdr ATTRIBUTE_UNUSED)
1922 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1923 coff_data_type *coff;
1925 if (! coff_mkobject (abfd))
1928 coff = coff_data (abfd);
1930 coff->sym_filepos = internal_f->f_symptr;
1932 /* These members communicate important constants about the symbol
1933 table to GDB's symbol-reading code. These `constants'
1934 unfortunately vary among coff implementations... */
1935 coff->local_n_btmask = N_BTMASK;
1936 coff->local_n_btshft = N_BTSHFT;
1937 coff->local_n_tmask = N_TMASK;
1938 coff->local_n_tshift = N_TSHIFT;
1939 coff->local_symesz = bfd_coff_symesz (abfd);
1940 coff->local_auxesz = bfd_coff_auxesz (abfd);
1941 coff->local_linesz = bfd_coff_linesz (abfd);
1943 coff->timestamp = internal_f->f_timdat;
1945 obj_raw_syment_count (abfd) =
1946 obj_conv_table_size (abfd) =
1947 internal_f->f_nsyms;
1950 if ((internal_f->f_flags & F_SHROBJ) != 0)
1951 abfd->flags |= DYNAMIC;
1952 if (aouthdr != NULL && internal_f->f_opthdr >= bfd_coff_aoutsz (abfd))
1954 struct internal_aouthdr *internal_a =
1955 (struct internal_aouthdr *) aouthdr;
1956 struct xcoff_tdata *xcoff;
1958 xcoff = xcoff_data (abfd);
1959 # ifdef U803XTOCMAGIC
1960 xcoff->xcoff64 = internal_f->f_magic == U803XTOCMAGIC;
1964 xcoff->full_aouthdr = TRUE;
1965 xcoff->toc = internal_a->o_toc;
1966 xcoff->sntoc = internal_a->o_sntoc;
1967 xcoff->snentry = internal_a->o_snentry;
1968 bfd_xcoff_text_align_power (abfd) = internal_a->o_algntext;
1969 bfd_xcoff_data_align_power (abfd) = internal_a->o_algndata;
1970 xcoff->modtype = internal_a->o_modtype;
1971 xcoff->cputype = internal_a->o_cputype;
1972 xcoff->maxdata = internal_a->o_maxdata;
1973 xcoff->maxstack = internal_a->o_maxstack;
1978 /* Set the flags field from the COFF header read in. */
1979 if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags))
1984 /* FIXME: I'm not sure this is ever executed, since peicode.h
1985 defines coff_mkobject_hook. */
1986 if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0)
1987 abfd->flags |= HAS_DEBUG;
1994 /* Determine the machine architecture and type. FIXME: This is target
1995 dependent because the magic numbers are defined in the target
1996 dependent header files. But there is no particular need for this.
1997 If the magic numbers were moved to a separate file, this function
1998 would be target independent and would also be much more successful
1999 at linking together COFF files for different architectures. */
2002 coff_set_arch_mach_hook (bfd *abfd, void * filehdr)
2004 unsigned long machine;
2005 enum bfd_architecture arch;
2006 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
2008 /* Zero selects the default machine for an arch. */
2010 switch (internal_f->f_magic)
2012 #ifdef OR32_MAGIC_BIG
2013 case OR32_MAGIC_BIG:
2014 case OR32_MAGIC_LITTLE:
2015 arch = bfd_arch_or32;
2020 arch = bfd_arch_powerpc;
2026 case I386AIXMAGIC: /* Danbury PS/2 AIX C Compiler. */
2027 case LYNXCOFFMAGIC: /* Shadows the m68k Lynx number below, sigh. */
2028 arch = bfd_arch_i386;
2033 arch = bfd_arch_i386;
2034 machine = bfd_mach_x86_64;
2039 arch = bfd_arch_ia64;
2046 arch = bfd_arch_arm;
2047 machine = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
2048 if (machine == bfd_mach_arm_unknown)
2050 switch (internal_f->f_flags & F_ARM_ARCHITECTURE_MASK)
2052 case F_ARM_2: machine = bfd_mach_arm_2; break;
2053 case F_ARM_2a: machine = bfd_mach_arm_2a; break;
2054 case F_ARM_3: machine = bfd_mach_arm_3; break;
2056 case F_ARM_3M: machine = bfd_mach_arm_3M; break;
2057 case F_ARM_4: machine = bfd_mach_arm_4; break;
2058 case F_ARM_4T: machine = bfd_mach_arm_4T; break;
2059 /* The COFF header does not have enough bits available
2060 to cover all the different ARM architectures. So
2061 we interpret F_ARM_5, the highest flag value to mean
2062 "the highest ARM architecture known to BFD" which is
2063 currently the XScale. */
2064 case F_ARM_5: machine = bfd_mach_arm_XScale; break;
2072 #ifdef MC68KBCSMAGIC
2075 #ifdef APOLLOM68KMAGIC
2076 case APOLLOM68KMAGIC:
2078 #ifdef LYNXCOFFMAGIC
2081 arch = bfd_arch_m68k;
2082 machine = bfd_mach_m68020;
2087 arch = bfd_arch_maxq;
2088 switch (internal_f->f_flags & F_MACHMASK)
2091 machine = bfd_mach_maxq10;
2094 machine = bfd_mach_maxq20;
2105 arch = bfd_arch_m88k;
2111 arch = bfd_arch_z80;
2112 switch (internal_f->f_flags & F_MACHMASK)
2115 case bfd_mach_z80strict << 12:
2116 case bfd_mach_z80 << 12:
2117 case bfd_mach_z80full << 12:
2118 case bfd_mach_r800 << 12:
2119 machine = ((unsigned)internal_f->f_flags & F_MACHMASK) >> 12;
2128 arch = bfd_arch_z8k;
2129 switch (internal_f->f_flags & F_MACHMASK)
2132 machine = bfd_mach_z8001;
2135 machine = bfd_mach_z8002;
2144 arch = bfd_arch_i860;
2151 arch = bfd_arch_i960;
2152 switch (F_I960TYPE & internal_f->f_flags)
2156 machine = bfd_mach_i960_core;
2159 machine = bfd_mach_i960_kb_sb;
2162 machine = bfd_mach_i960_mc;
2165 machine = bfd_mach_i960_xa;
2168 machine = bfd_mach_i960_ca;
2171 machine = bfd_mach_i960_ka_sa;
2174 machine = bfd_mach_i960_jx;
2177 machine = bfd_mach_i960_hx;
2196 if (xcoff_data (abfd)->cputype != -1)
2197 cputype = xcoff_data (abfd)->cputype & 0xff;
2200 /* We did not get a value from the a.out header. If the
2201 file has not been stripped, we may be able to get the
2202 architecture information from the first symbol, if it
2203 is a .file symbol. */
2204 if (obj_raw_syment_count (abfd) == 0)
2209 struct internal_syment sym;
2210 bfd_size_type amt = bfd_coff_symesz (abfd);
2212 buf = bfd_malloc (amt);
2213 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
2214 || bfd_bread (buf, amt, abfd) != amt)
2219 bfd_coff_swap_sym_in (abfd, buf, & sym);
2220 if (sym.n_sclass == C_FILE)
2221 cputype = sym.n_type & 0xff;
2228 /* FIXME: We don't handle all cases here. */
2233 arch = bfd_xcoff_architecture (abfd);
2234 machine = bfd_xcoff_machine (abfd);
2238 arch = bfd_arch_powerpc;
2239 machine = bfd_mach_ppc_601;
2241 case 2: /* 64 bit PowerPC */
2242 arch = bfd_arch_powerpc;
2243 machine = bfd_mach_ppc_620;
2246 arch = bfd_arch_powerpc;
2247 machine = bfd_mach_ppc;
2250 arch = bfd_arch_rs6000;
2251 machine = bfd_mach_rs6k;
2260 arch = bfd_arch_we32k;
2266 arch = bfd_arch_h8300;
2267 machine = bfd_mach_h8300;
2268 /* !! FIXME this probably isn't the right place for this. */
2269 abfd->flags |= BFD_IS_RELAXABLE;
2275 arch = bfd_arch_h8300;
2276 machine = bfd_mach_h8300h;
2277 /* !! FIXME this probably isn't the right place for this. */
2278 abfd->flags |= BFD_IS_RELAXABLE;
2284 arch = bfd_arch_h8300;
2285 machine = bfd_mach_h8300s;
2286 /* !! FIXME this probably isn't the right place for this. */
2287 abfd->flags |= BFD_IS_RELAXABLE;
2293 arch = bfd_arch_h8300;
2294 machine = bfd_mach_h8300hn;
2295 /* !! FIXME this probably isn't the right place for this. */
2296 abfd->flags |= BFD_IS_RELAXABLE;
2302 arch = bfd_arch_h8300;
2303 machine = bfd_mach_h8300sn;
2304 /* !! FIXME this probably isn't the right place for this. */
2305 abfd->flags |= BFD_IS_RELAXABLE;
2309 #ifdef SH_ARCH_MAGIC_BIG
2310 case SH_ARCH_MAGIC_BIG:
2311 case SH_ARCH_MAGIC_LITTLE:
2313 case SH_ARCH_MAGIC_WINCE:
2319 #ifdef MIPS_ARCH_MAGIC_WINCE
2320 case MIPS_ARCH_MAGIC_WINCE:
2321 arch = bfd_arch_mips;
2327 arch = bfd_arch_h8500;
2333 #ifdef LYNXCOFFMAGIC
2336 arch = bfd_arch_sparc;
2342 arch = bfd_arch_tic30;
2347 #ifdef TICOFF_TARGET_ARCH
2348 /* This TI COFF section should be used by all new TI COFF v0 targets. */
2350 arch = TICOFF_TARGET_ARCH;
2351 machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags);
2357 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */
2358 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */
2361 switch (internal_f->f_target_id)
2365 arch = TICOFF_TARGET_ARCH;
2366 machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags);
2370 arch = bfd_arch_obscure;
2371 (*_bfd_error_handler)
2372 (_("Unrecognized TI COFF target id '0x%x'"),
2373 internal_f->f_target_id);
2379 #ifdef TIC80_ARCH_MAGIC
2380 case TIC80_ARCH_MAGIC:
2381 arch = bfd_arch_tic80;
2387 arch = bfd_arch_mcore;
2393 arch = bfd_arch_w65;
2397 default: /* Unreadable input file type. */
2398 arch = bfd_arch_obscure;
2402 bfd_default_set_arch_mach (abfd, arch, machine);
2406 #ifdef SYMNAME_IN_DEBUG
2409 symname_in_debug_hook (bfd * abfd ATTRIBUTE_UNUSED, struct internal_syment *sym)
2411 return SYMNAME_IN_DEBUG (sym) != 0;
2416 #define symname_in_debug_hook \
2417 (bfd_boolean (*) (bfd *, struct internal_syment *)) bfd_false
2424 #define FORCE_SYMNAMES_IN_STRINGS
2427 /* Handle the csect auxent of a C_EXT, C_AIX_WEAKEXT or C_HIDEXT symbol. */
2430 coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED,
2431 combined_entry_type *table_base,
2432 combined_entry_type *symbol,
2433 unsigned int indaux,
2434 combined_entry_type *aux)
2436 int class = symbol->u.syment.n_sclass;
2438 if (CSECT_SYM_P (class)
2439 && indaux + 1 == symbol->u.syment.n_numaux)
2441 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
2443 aux->u.auxent.x_csect.x_scnlen.p =
2444 table_base + aux->u.auxent.x_csect.x_scnlen.l;
2445 aux->fix_scnlen = 1;
2448 /* Return TRUE to indicate that the caller should not do any
2449 further work on this auxent. */
2453 /* Return FALSE to indicate that this auxent should be handled by
2461 /* We don't want to pointerize bal entries. */
2464 coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED,
2465 combined_entry_type *table_base ATTRIBUTE_UNUSED,
2466 combined_entry_type *symbol,
2467 unsigned int indaux,
2468 combined_entry_type *aux ATTRIBUTE_UNUSED)
2470 /* Return TRUE if we don't want to pointerize this aux entry, which
2471 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2473 && (symbol->u.syment.n_sclass == C_LEAFPROC
2474 || symbol->u.syment.n_sclass == C_LEAFSTAT
2475 || symbol->u.syment.n_sclass == C_LEAFEXT));
2480 #define coff_pointerize_aux_hook 0
2483 #endif /* ! RS6000COFF_C */
2485 /* Print an aux entry. This returns TRUE if it has printed it. */
2488 coff_print_aux (bfd *abfd ATTRIBUTE_UNUSED,
2489 FILE *file ATTRIBUTE_UNUSED,
2490 combined_entry_type *table_base ATTRIBUTE_UNUSED,
2491 combined_entry_type *symbol ATTRIBUTE_UNUSED,
2492 combined_entry_type *aux ATTRIBUTE_UNUSED,
2493 unsigned int indaux ATTRIBUTE_UNUSED)
2496 if (CSECT_SYM_P (symbol->u.syment.n_sclass)
2497 && indaux + 1 == symbol->u.syment.n_numaux)
2499 /* This is a csect entry. */
2500 fprintf (file, "AUX ");
2501 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
2503 BFD_ASSERT (! aux->fix_scnlen);
2505 fprintf (file, "val %5lld",
2506 (long long) aux->u.auxent.x_csect.x_scnlen.l);
2508 fprintf (file, "val %5ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
2513 fprintf (file, "indx ");
2514 if (! aux->fix_scnlen)
2516 fprintf (file, "%4lld",
2517 (long long) aux->u.auxent.x_csect.x_scnlen.l);
2519 fprintf (file, "%4ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
2522 fprintf (file, "%4ld",
2523 (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base));
2526 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2527 aux->u.auxent.x_csect.x_parmhash,
2528 (unsigned int) aux->u.auxent.x_csect.x_snhash,
2529 SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp),
2530 SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp),
2531 (unsigned int) aux->u.auxent.x_csect.x_smclas,
2532 aux->u.auxent.x_csect.x_stab,
2533 (unsigned int) aux->u.auxent.x_csect.x_snstab);
2538 /* Return FALSE to indicate that no special action was taken. */
2546 To write relocations, the back end steps though the
2547 canonical relocation table and create an
2548 @code{internal_reloc}. The symbol index to use is removed from
2549 the @code{offset} field in the symbol table supplied. The
2550 address comes directly from the sum of the section base
2551 address and the relocation offset; the type is dug directly
2552 from the howto field. Then the @code{internal_reloc} is
2553 swapped into the shape of an @code{external_reloc} and written
2561 /* AUX's ld wants relocations to be sorted. */
2563 compare_arelent_ptr (const void * x, const void * y)
2565 const arelent **a = (const arelent **) x;
2566 const arelent **b = (const arelent **) y;
2567 bfd_size_type aadr = (*a)->address;
2568 bfd_size_type badr = (*b)->address;
2570 return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
2573 #endif /* TARG_AUX */
2576 coff_write_relocs (bfd * abfd, int first_undef)
2580 for (s = abfd->sections; s != NULL; s = s->next)
2583 struct external_reloc dst;
2590 /* Sort relocations before we write them out. */
2593 amt = s->reloc_count;
2594 amt *= sizeof (arelent *);
2595 p = bfd_malloc (amt);
2596 if (p == NULL && s->reloc_count > 0)
2598 memcpy (p, s->orelocation, (size_t) amt);
2599 qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr);
2603 if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
2607 if (obj_pe (abfd) && s->reloc_count >= 0xffff)
2609 /* Encode real count here as first reloc. */
2610 struct internal_reloc n;
2612 memset (& n, 0, sizeof (n));
2613 /* Add one to count *this* reloc (grr). */
2614 n.r_vaddr = s->reloc_count + 1;
2615 coff_swap_reloc_out (abfd, &n, &dst);
2616 if (bfd_bwrite (& dst, (bfd_size_type) bfd_coff_relsz (abfd),
2617 abfd) != bfd_coff_relsz (abfd))
2622 for (i = 0; i < s->reloc_count; i++)
2624 struct internal_reloc n;
2627 memset (& n, 0, sizeof (n));
2629 /* Now we've renumbered the symbols we know where the
2630 undefined symbols live in the table. Check the reloc
2631 entries for symbols who's output bfd isn't the right one.
2632 This is because the symbol was undefined (which means
2633 that all the pointers are never made to point to the same
2634 place). This is a bad thing,'cause the symbols attached
2635 to the output bfd are indexed, so that the relocation
2636 entries know which symbol index they point to. So we
2637 have to look up the output symbol here. */
2639 if (q->sym_ptr_ptr[0]->the_bfd != abfd)
2642 const char *sname = q->sym_ptr_ptr[0]->name;
2643 asymbol **outsyms = abfd->outsymbols;
2645 for (j = first_undef; outsyms[j]; j++)
2647 const char *intable = outsyms[j]->name;
2649 if (strcmp (intable, sname) == 0)
2651 /* Got a hit, so repoint the reloc. */
2652 q->sym_ptr_ptr = outsyms + j;
2658 n.r_vaddr = q->address + s->vma;
2661 /* The 29k const/consth reloc pair is a real kludge. The consth
2662 part doesn't have a symbol; it has an offset. So rebuilt
2664 if (q->howto->type == R_IHCONST)
2665 n.r_symndx = q->addend;
2670 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2671 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q, s))
2673 if ((*q->sym_ptr_ptr)->section == bfd_abs_section_ptr
2674 && ((*q->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0)
2676 /* This is a relocation relative to the absolute symbol. */
2680 n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
2681 /* Check to see if the symbol reloc points to a symbol
2682 we don't have in our symbol table. */
2683 if (n.r_symndx > obj_conv_table_size (abfd))
2685 bfd_set_error (bfd_error_bad_value);
2686 _bfd_error_handler (_("%B: reloc against a non-existant symbol index: %ld"),
2693 #ifdef SWAP_OUT_RELOC_OFFSET
2694 n.r_offset = q->addend;
2698 /* Work out reloc type from what is required. */
2699 SELECT_RELOC (n, q->howto);
2701 n.r_type = q->howto->type;
2703 coff_swap_reloc_out (abfd, &n, &dst);
2705 if (bfd_bwrite (& dst, (bfd_size_type) bfd_coff_relsz (abfd),
2706 abfd) != bfd_coff_relsz (abfd))
2719 /* Set flags and magic number of a coff file from architecture and machine
2720 type. Result is TRUE if we can represent the arch&type, FALSE if not. */
2723 coff_set_flags (bfd * abfd,
2724 unsigned int *magicp ATTRIBUTE_UNUSED,
2725 unsigned short *flagsp ATTRIBUTE_UNUSED)
2727 switch (bfd_get_arch (abfd))
2732 switch (bfd_get_mach (abfd))
2735 case bfd_mach_z80strict:
2737 case bfd_mach_z80full:
2739 *flagsp = bfd_get_mach (abfd) << 12;
2751 switch (bfd_get_mach (abfd))
2753 case bfd_mach_z8001: *flagsp = F_Z8001; break;
2754 case bfd_mach_z8002: *flagsp = F_Z8002; break;
2755 default: return FALSE;
2766 *magicp = I960ROMAGIC;
2768 switch (bfd_get_mach (abfd))
2770 case bfd_mach_i960_core: flags = F_I960CORE; break;
2771 case bfd_mach_i960_kb_sb: flags = F_I960KB; break;
2772 case bfd_mach_i960_mc: flags = F_I960MC; break;
2773 case bfd_mach_i960_xa: flags = F_I960XA; break;
2774 case bfd_mach_i960_ca: flags = F_I960CA; break;
2775 case bfd_mach_i960_ka_sa: flags = F_I960KA; break;
2776 case bfd_mach_i960_jx: flags = F_I960JX; break;
2777 case bfd_mach_i960_hx: flags = F_I960HX; break;
2778 default: return FALSE;
2787 case bfd_arch_tic30:
2788 *magicp = TIC30MAGIC;
2792 #ifdef TICOFF_DEFAULT_MAGIC
2793 case TICOFF_TARGET_ARCH:
2794 /* If there's no indication of which version we want, use the default. */
2796 *magicp = TICOFF_DEFAULT_MAGIC;
2799 /* We may want to output in a different COFF version. */
2800 switch (abfd->xvec->name[4])
2803 *magicp = TICOFF0MAGIC;
2806 *magicp = TICOFF1MAGIC;
2809 *magicp = TICOFF2MAGIC;
2815 TICOFF_TARGET_MACHINE_SET (flagsp, bfd_get_mach (abfd));
2819 #ifdef TIC80_ARCH_MAGIC
2820 case bfd_arch_tic80:
2821 *magicp = TIC80_ARCH_MAGIC;
2828 * magicp = ARMPEMAGIC;
2830 * magicp = ARMMAGIC;
2833 if (APCS_SET (abfd))
2835 if (APCS_26_FLAG (abfd))
2836 * flagsp |= F_APCS26;
2838 if (APCS_FLOAT_FLAG (abfd))
2839 * flagsp |= F_APCS_FLOAT;
2841 if (PIC_FLAG (abfd))
2844 if (INTERWORK_SET (abfd) && INTERWORK_FLAG (abfd))
2845 * flagsp |= F_INTERWORK;
2846 switch (bfd_get_mach (abfd))
2848 case bfd_mach_arm_2: * flagsp |= F_ARM_2; break;
2849 case bfd_mach_arm_2a: * flagsp |= F_ARM_2a; break;
2850 case bfd_mach_arm_3: * flagsp |= F_ARM_3; break;
2851 case bfd_mach_arm_3M: * flagsp |= F_ARM_3M; break;
2852 case bfd_mach_arm_4: * flagsp |= F_ARM_4; break;
2853 case bfd_mach_arm_4T: * flagsp |= F_ARM_4T; break;
2854 case bfd_mach_arm_5: * flagsp |= F_ARM_5; break;
2855 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2856 See also the comment in coff_set_arch_mach_hook(). */
2857 case bfd_mach_arm_5T: * flagsp |= F_ARM_5; break;
2858 case bfd_mach_arm_5TE: * flagsp |= F_ARM_5; break;
2859 case bfd_mach_arm_XScale: * flagsp |= F_ARM_5; break;
2865 case bfd_arch_powerpc:
2870 #if defined(I386MAGIC) || defined(AMD64MAGIC)
2872 #if defined(I386MAGIC)
2873 *magicp = I386MAGIC;
2876 /* Just overwrite the usual value if we're doing Lynx. */
2877 *magicp = LYNXCOFFMAGIC;
2879 #if defined AMD64MAGIC
2880 *magicp = AMD64MAGIC;
2887 *magicp = I860MAGIC;
2893 *magicp = IA64MAGIC;
2899 #ifdef APOLLOM68KMAGIC
2900 *magicp = APOLLO_COFF_VERSION_NUMBER;
2902 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2903 #ifdef NAMES_HAVE_UNDERSCORE
2904 *magicp = MC68KBCSMAGIC;
2906 *magicp = MC68MAGIC;
2910 /* Just overwrite the usual value if we're doing Lynx. */
2911 *magicp = LYNXCOFFMAGIC;
2918 *magicp = MC88OMAGIC;
2923 case bfd_arch_h8300:
2924 switch (bfd_get_mach (abfd))
2926 case bfd_mach_h8300: *magicp = H8300MAGIC; return TRUE;
2927 case bfd_mach_h8300h: *magicp = H8300HMAGIC; return TRUE;
2928 case bfd_mach_h8300s: *magicp = H8300SMAGIC; return TRUE;
2929 case bfd_mach_h8300hn: *magicp = H8300HNMAGIC; return TRUE;
2930 case bfd_mach_h8300sn: *magicp = H8300SNMAGIC; return TRUE;
2936 #ifdef SH_ARCH_MAGIC_BIG
2938 #ifdef COFF_IMAGE_WITH_PE
2939 *magicp = SH_ARCH_MAGIC_WINCE;
2941 if (bfd_big_endian (abfd))
2942 *magicp = SH_ARCH_MAGIC_BIG;
2944 *magicp = SH_ARCH_MAGIC_LITTLE;
2949 #ifdef MIPS_ARCH_MAGIC_WINCE
2951 *magicp = MIPS_ARCH_MAGIC_WINCE;
2956 case bfd_arch_sparc:
2957 *magicp = SPARCMAGIC;
2959 /* Just overwrite the usual value if we're doing Lynx. */
2960 *magicp = LYNXCOFFMAGIC;
2966 case bfd_arch_h8500:
2967 *magicp = H8500MAGIC;
2973 case bfd_arch_we32k:
2974 *magicp = WE32KMAGIC;
2979 case bfd_arch_rs6000:
2981 case bfd_arch_powerpc:
2983 BFD_ASSERT (bfd_get_flavour (abfd) == bfd_target_xcoff_flavour);
2984 *magicp = bfd_xcoff_magic_number (abfd);
2989 case bfd_arch_mcore:
2990 * magicp = MCOREMAGIC;
3000 #ifdef OR32_MAGIC_BIG
3002 if (bfd_big_endian (abfd))
3003 * magicp = OR32_MAGIC_BIG;
3005 * magicp = OR32_MAGIC_LITTLE;
3011 * magicp = MAXQ20MAGIC;
3012 switch (bfd_get_mach (abfd))
3014 case bfd_mach_maxq10: * flagsp = F_MAXQ10; return TRUE;
3015 case bfd_mach_maxq20: * flagsp = F_MAXQ20; return TRUE;
3016 default: return FALSE;
3020 default: /* Unknown architecture. */
3021 /* Fall through to "return FALSE" below, to avoid
3022 "statement never reached" errors on the one below. */
3030 coff_set_arch_mach (bfd * abfd,
3031 enum bfd_architecture arch,
3032 unsigned long machine)
3035 unsigned short dummy2;
3037 if (! bfd_default_set_arch_mach (abfd, arch, machine))
3040 if (arch != bfd_arch_unknown
3041 && ! coff_set_flags (abfd, &dummy1, &dummy2))
3042 return FALSE; /* We can't represent this type. */
3044 return TRUE; /* We're easy... */
3047 #ifdef COFF_IMAGE_WITH_PE
3049 /* This is used to sort sections by VMA, as required by PE image
3053 sort_by_secaddr (const void * arg1, const void * arg2)
3055 const asection *a = *(const asection **) arg1;
3056 const asection *b = *(const asection **) arg2;
3058 if (a->vma < b->vma)
3060 else if (a->vma > b->vma)
3066 #endif /* COFF_IMAGE_WITH_PE */
3068 /* Calculate the file position for each section. */
3071 #define ALIGN_SECTIONS_IN_FILE
3073 #if defined(TIC80COFF) || defined(TICOFF)
3074 #undef ALIGN_SECTIONS_IN_FILE
3078 coff_compute_section_file_positions (bfd * abfd)
3081 asection *previous = NULL;
3082 file_ptr sofar = bfd_coff_filhsz (abfd);
3083 bfd_boolean align_adjust;
3084 #ifdef ALIGN_SECTIONS_IN_FILE
3089 /* On XCOFF, if we have symbols, set up the .debug section. */
3090 if (bfd_get_symcount (abfd) > 0)
3093 bfd_size_type i, symcount;
3097 symcount = bfd_get_symcount (abfd);
3098 for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++)
3100 coff_symbol_type *cf;
3102 cf = coff_symbol_from (abfd, *symp);
3104 && cf->native != NULL
3105 && SYMNAME_IN_DEBUG (&cf->native->u.syment))
3109 len = strlen (bfd_asymbol_name (*symp));
3110 if (len > SYMNMLEN || bfd_coff_force_symnames_in_strings (abfd))
3111 sz += len + 1 + bfd_coff_debug_string_prefix_length (abfd);
3118 dsec = bfd_make_section_old_way (abfd, DOT_DEBUG);
3122 dsec->flags |= SEC_HAS_CONTENTS;
3127 #ifdef COFF_IMAGE_WITH_PE
3130 if (coff_data (abfd)->link_info)
3132 page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
3134 /* If no file alignment has been set, default to one.
3135 This repairs 'ld -r' for arm-wince-pe target. */
3140 page_size = PE_DEF_FILE_ALIGNMENT;
3142 #ifdef COFF_PAGE_SIZE
3143 int page_size = COFF_PAGE_SIZE;
3147 if (bfd_get_start_address (abfd))
3148 /* A start address may have been added to the original file. In this
3149 case it will need an optional header to record it. */
3150 abfd->flags |= EXEC_P;
3152 if (abfd->flags & EXEC_P)
3153 sofar += bfd_coff_aoutsz (abfd);
3155 else if (xcoff_data (abfd)->full_aouthdr)
3156 sofar += bfd_coff_aoutsz (abfd);
3158 sofar += SMALL_AOUTSZ;
3161 sofar += abfd->section_count * bfd_coff_scnhsz (abfd);
3164 /* XCOFF handles overflows in the reloc and line number count fields
3165 by allocating a new section header to hold the correct counts. */
3166 for (current = abfd->sections; current != NULL; current = current->next)
3167 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3168 sofar += bfd_coff_scnhsz (abfd);
3171 #ifdef COFF_IMAGE_WITH_PE
3173 /* PE requires the sections to be in memory order when listed in
3174 the section headers. It also does not like empty loadable
3175 sections. The sections apparently do not have to be in the
3176 right order in the image file itself, but we do need to get the
3177 target_index values right. */
3180 asection **section_list;
3186 for (current = abfd->sections; current != NULL; current = current->next)
3189 /* We allocate an extra cell to simplify the final loop. */
3190 amt = sizeof (struct asection *) * (count + 1);
3191 section_list = bfd_malloc (amt);
3192 if (section_list == NULL)
3196 for (current = abfd->sections; current != NULL; current = current->next)
3198 section_list[i] = current;
3201 section_list[i] = NULL;
3203 qsort (section_list, count, sizeof (asection *), sort_by_secaddr);
3205 /* Rethread the linked list into sorted order; at the same time,
3206 assign target_index values. */
3208 abfd->sections = NULL;
3209 abfd->section_last = NULL;
3210 for (i = 0; i < count; i++)
3212 current = section_list[i];
3213 bfd_section_list_append (abfd, current);
3215 /* Later, if the section has zero size, we'll be throwing it
3216 away, so we don't want to number it now. Note that having
3217 a zero size and having real contents are different
3218 concepts: .bss has no contents, but (usually) non-zero
3220 if (current->size == 0)
3222 /* Discard. However, it still might have (valid) symbols
3223 in it, so arbitrarily set it to section 1 (indexing is
3224 1-based here; usually .text). __end__ and other
3225 contents of .endsection really have this happen.
3226 FIXME: This seems somewhat dubious. */
3227 current->target_index = 1;
3230 current->target_index = target_index++;
3233 free (section_list);
3235 #else /* ! COFF_IMAGE_WITH_PE */
3237 /* Set the target_index field. */
3241 for (current = abfd->sections; current != NULL; current = current->next)
3242 current->target_index = target_index++;
3244 #endif /* ! COFF_IMAGE_WITH_PE */
3246 align_adjust = FALSE;
3247 for (current = abfd->sections;
3249 current = current->next)
3251 #ifdef COFF_IMAGE_WITH_PE
3252 /* With PE we have to pad each section to be a multiple of its
3253 page size too, and remember both sizes. */
3254 if (coff_section_data (abfd, current) == NULL)
3256 bfd_size_type amt = sizeof (struct coff_section_tdata);
3258 current->used_by_bfd = bfd_zalloc (abfd, amt);
3259 if (current->used_by_bfd == NULL)
3262 if (pei_section_data (abfd, current) == NULL)
3264 bfd_size_type amt = sizeof (struct pei_section_tdata);
3266 coff_section_data (abfd, current)->tdata = bfd_zalloc (abfd, amt);
3267 if (coff_section_data (abfd, current)->tdata == NULL)
3270 if (pei_section_data (abfd, current)->virt_size == 0)
3271 pei_section_data (abfd, current)->virt_size = current->size;
3274 /* Only deal with sections which have contents. */
3275 if (!(current->flags & SEC_HAS_CONTENTS))
3278 #ifdef COFF_IMAGE_WITH_PE
3279 /* Make sure we skip empty sections in a PE image. */
3280 if (current->size == 0)
3284 /* Align the sections in the file to the same boundary on
3285 which they are aligned in virtual memory. I960 doesn't
3286 do this (FIXME) so we can stay in sync with Intel. 960
3287 doesn't yet page from files... */
3288 #ifdef ALIGN_SECTIONS_IN_FILE
3289 if ((abfd->flags & EXEC_P) != 0)
3291 /* Make sure this section is aligned on the right boundary - by
3292 padding the previous section up if necessary. */
3296 /* AIX loader checks the text section alignment of (vma - filepos)
3297 So even though the filepos may be aligned wrt the o_algntext, for
3298 AIX executables, this check fails. This shows up when a native
3299 AIX executable is stripped with gnu strip because the default vma
3300 of native is 0x10000150 but default for gnu is 0x10000140. Gnu
3301 stripped gnu excutable passes this check because the filepos is
3302 0x0140. This problem also show up with 64 bit shared objects. The
3303 data section must also be aligned. */
3304 if (!strcmp (current->name, _TEXT)
3305 || !strcmp (current->name, _DATA))
3310 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3312 align = 1 << current->alignment_power;
3313 pad = abs (current->vma - sofar) % align;
3324 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3327 if (previous != NULL)
3328 previous->size += sofar - old_sofar;
3333 /* In demand paged files the low order bits of the file offset
3334 must match the low order bits of the virtual address. */
3335 #ifdef COFF_PAGE_SIZE
3336 if ((abfd->flags & D_PAGED) != 0
3337 && (current->flags & SEC_ALLOC) != 0)
3338 sofar += (current->vma - (bfd_vma) sofar) % page_size;
3340 current->filepos = sofar;
3342 #ifdef COFF_IMAGE_WITH_PE
3343 /* Set the padded size. */
3344 current->size = (current->size + page_size -1) & -page_size;
3347 sofar += current->size;
3349 #ifdef ALIGN_SECTIONS_IN_FILE
3350 /* Make sure that this section is of the right size too. */
3351 if ((abfd->flags & EXEC_P) == 0)
3353 bfd_size_type old_size;
3355 old_size = current->size;
3356 current->size = BFD_ALIGN (current->size,
3357 1 << current->alignment_power);
3358 align_adjust = current->size != old_size;
3359 sofar += current->size - old_size;
3364 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3365 align_adjust = sofar != old_sofar;
3366 current->size += sofar - old_sofar;
3370 #ifdef COFF_IMAGE_WITH_PE
3371 /* For PE we need to make sure we pad out to the aligned
3372 size, in case the caller only writes out data to the
3374 if (pei_section_data (abfd, current)->virt_size < current->size)
3375 align_adjust = TRUE;
3379 /* Force .lib sections to start at zero. The vma is then
3380 incremented in coff_set_section_contents. This is right for
3382 if (strcmp (current->name, _LIB) == 0)
3383 bfd_set_section_vma (abfd, current, 0);
3389 /* It is now safe to write to the output file. If we needed an
3390 alignment adjustment for the last section, then make sure that
3391 there is a byte at offset sofar. If there are no symbols and no
3392 relocs, then nothing follows the last section. If we don't force
3393 the last byte out, then the file may appear to be truncated. */
3399 if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0
3400 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
3404 /* Make sure the relocations are aligned. We don't need to make
3405 sure that this byte exists, because it will only matter if there
3406 really are relocs. */
3407 sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER);
3409 obj_relocbase (abfd) = sofar;
3410 abfd->output_has_begun = TRUE;
3415 #ifdef COFF_IMAGE_WITH_PE
3417 static unsigned int pelength;
3418 static unsigned int peheader;
3421 coff_read_word (bfd *abfd, unsigned int *value)
3426 status = bfd_bread (b, (bfd_size_type) 2, abfd);
3434 *value = (unsigned int) b[0];
3436 *value = (unsigned int) (b[0] + (b[1] << 8));
3438 pelength += (unsigned int) status;
3444 coff_compute_checksum (bfd *abfd)
3446 bfd_boolean more_data;
3453 filepos = (file_ptr) 0;
3457 if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
3460 more_data = coff_read_word (abfd, &value);
3462 total = 0xffff & (total + (total >> 0x10));
3467 return (0xffff & (total + (total >> 0x10)));
3471 coff_apply_checksum (bfd *abfd)
3473 unsigned int computed;
3474 unsigned int checksum = 0;
3476 if (bfd_seek (abfd, 0x3c, SEEK_SET) != 0)
3479 if (!coff_read_word (abfd, &peheader))
3482 if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
3486 bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
3488 if (bfd_seek (abfd, peheader, SEEK_SET) != 0)
3491 computed = coff_compute_checksum (abfd);
3493 checksum = computed + pelength;
3495 if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
3498 bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
3503 #endif /* COFF_IMAGE_WITH_PE */
3506 coff_write_object_contents (bfd * abfd)
3509 bfd_boolean hasrelocs = FALSE;
3510 bfd_boolean haslinno = FALSE;
3511 bfd_boolean hasdebug = FALSE;
3513 file_ptr reloc_base;
3514 file_ptr lineno_base;
3516 unsigned long reloc_size = 0, reloc_count = 0;
3517 unsigned long lnno_size = 0;
3518 bfd_boolean long_section_names;
3519 asection *text_sec = NULL;
3520 asection *data_sec = NULL;
3521 asection *bss_sec = NULL;
3522 struct internal_filehdr internal_f;
3523 struct internal_aouthdr internal_a;
3524 #ifdef COFF_LONG_SECTION_NAMES
3525 size_t string_size = STRING_SIZE_SIZE;
3528 bfd_set_error (bfd_error_system_call);
3530 /* Make a pass through the symbol table to count line number entries and
3531 put them into the correct asections. */
3532 lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd);
3534 if (! abfd->output_has_begun)
3536 if (! coff_compute_section_file_positions (abfd))
3540 reloc_base = obj_relocbase (abfd);
3542 /* Work out the size of the reloc and linno areas. */
3544 for (current = abfd->sections; current != NULL; current =
3548 /* We store the actual reloc count in the first reloc's addr. */
3549 if (obj_pe (abfd) && current->reloc_count >= 0xffff)
3552 reloc_count += current->reloc_count;
3555 reloc_size = reloc_count * bfd_coff_relsz (abfd);
3557 lineno_base = reloc_base + reloc_size;
3558 sym_base = lineno_base + lnno_size;
3560 /* Indicate in each section->line_filepos its actual file address. */
3561 for (current = abfd->sections; current != NULL; current =
3564 if (current->lineno_count)
3566 current->line_filepos = lineno_base;
3567 current->moving_line_filepos = lineno_base;
3568 lineno_base += current->lineno_count * bfd_coff_linesz (abfd);
3571 current->line_filepos = 0;
3573 if (current->reloc_count)
3575 current->rel_filepos = reloc_base;
3576 reloc_base += current->reloc_count * bfd_coff_relsz (abfd);
3578 /* Extra reloc to hold real count. */
3579 if (obj_pe (abfd) && current->reloc_count >= 0xffff)
3580 reloc_base += bfd_coff_relsz (abfd);
3584 current->rel_filepos = 0;
3587 /* Write section headers to the file. */
3588 internal_f.f_nscns = 0;
3590 if ((abfd->flags & EXEC_P) != 0)
3591 scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
3594 scn_base = bfd_coff_filhsz (abfd);
3597 if (xcoff_data (abfd)->full_aouthdr)
3598 scn_base += bfd_coff_aoutsz (abfd);
3600 scn_base += SMALL_AOUTSZ;
3605 if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
3608 long_section_names = FALSE;
3609 for (current = abfd->sections;
3611 current = current->next)
3613 struct internal_scnhdr section;
3614 bfd_boolean is_reloc_section = FALSE;
3616 #ifdef COFF_IMAGE_WITH_PE
3617 if (strcmp (current->name, ".reloc") == 0)
3619 is_reloc_section = TRUE;
3621 pe_data (abfd)->has_reloc_section = 1;
3625 internal_f.f_nscns++;
3627 strncpy (section.s_name, current->name, SCNNMLEN);
3629 #ifdef COFF_LONG_SECTION_NAMES
3630 /* Handle long section names as in PE. This must be compatible
3631 with the code in coff_write_symbols and _bfd_coff_final_link. */
3632 if (bfd_coff_long_section_names (abfd))
3636 len = strlen (current->name);
3639 /* The s_name field is defined to be NUL-padded but need not be
3640 NUL-terminated. We use a temporary buffer so that we can still
3641 sprintf all eight chars without splatting a terminating NUL
3642 over the first byte of the following member (s_paddr). */
3643 char s_name_buf[SCNNMLEN + 1];
3645 /* An inherent limitation of the /nnnnnnn notation used to indicate
3646 the offset of the long name in the string table is that we
3647 cannot address entries beyone the ten million byte boundary. */
3648 if (string_size >= 10000000)
3650 bfd_set_error (bfd_error_file_too_big);
3651 (*_bfd_error_handler)
3652 (_("%B: section %s: string table overflow at offset %ld"),
3653 abfd, current->name, string_size);
3657 /* snprintf not strictly necessary now we've verified the value
3658 has less than eight ASCII digits, but never mind. */
3659 snprintf (s_name_buf, SCNNMLEN + 1, "/%lu", (unsigned long) string_size);
3660 /* Then strncpy takes care of any padding for us. */
3661 strncpy (section.s_name, s_name_buf, SCNNMLEN);
3662 string_size += len + 1;
3663 long_section_names = TRUE;
3669 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3670 Ian Taylor <ian@cygnus.com>. */
3671 if (strcmp (current->name, _LIB) == 0)
3672 section.s_vaddr = 0;
3675 section.s_vaddr = current->vma;
3676 section.s_paddr = current->lma;
3677 section.s_size = current->size;
3678 #ifdef coff_get_section_load_page
3679 section.s_page = coff_get_section_load_page (current);
3685 section.s_paddr = 0;
3687 #ifdef COFF_IMAGE_WITH_PE
3688 /* Reminder: s_paddr holds the virtual size of the section. */
3689 if (coff_section_data (abfd, current) != NULL
3690 && pei_section_data (abfd, current) != NULL)
3691 section.s_paddr = pei_section_data (abfd, current)->virt_size;
3693 section.s_paddr = 0;
3696 /* If this section has no size or is unloadable then the scnptr
3698 if (current->size == 0
3699 || (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
3700 section.s_scnptr = 0;
3702 section.s_scnptr = current->filepos;
3704 section.s_relptr = current->rel_filepos;
3705 section.s_lnnoptr = current->line_filepos;
3706 section.s_nreloc = current->reloc_count;
3707 section.s_nlnno = current->lineno_count;
3708 #ifndef COFF_IMAGE_WITH_PE
3709 /* In PEI, relocs come in the .reloc section. */
3710 if (current->reloc_count != 0)
3713 if (current->lineno_count != 0)
3715 if ((current->flags & SEC_DEBUGGING) != 0
3716 && ! is_reloc_section)
3721 /* Indicate the use of an XCOFF overflow section header. */
3722 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3724 section.s_nreloc = 0xffff;
3725 section.s_nlnno = 0xffff;
3730 section.s_flags = sec_to_styp_flags (current->name, current->flags);
3732 if (!strcmp (current->name, _TEXT))
3734 else if (!strcmp (current->name, _DATA))
3736 else if (!strcmp (current->name, _BSS))
3740 section.s_align = (current->alignment_power
3741 ? 1 << current->alignment_power
3745 /* TI COFF puts the alignment power in bits 8-11 of the flags. */
3746 section.s_flags |= (current->alignment_power & 0xF) << 8;
3748 #ifdef COFF_ENCODE_ALIGNMENT
3749 COFF_ENCODE_ALIGNMENT(section, current->alignment_power);
3752 #ifdef COFF_IMAGE_WITH_PE
3753 /* Suppress output of the sections if they are null. ld
3754 includes the bss and data sections even if there is no size
3755 assigned to them. NT loader doesn't like it if these section
3756 headers are included if the sections themselves are not
3757 needed. See also coff_compute_section_file_positions. */
3758 if (section.s_size == 0)
3759 internal_f.f_nscns--;
3764 bfd_size_type amt = bfd_coff_scnhsz (abfd);
3766 if (coff_swap_scnhdr_out (abfd, §ion, &buff) == 0
3767 || bfd_bwrite (& buff, amt, abfd) != amt)
3772 /* PE stores COMDAT section information in the symbol table. If
3773 this section is supposed to have some COMDAT info, track down
3774 the symbol in the symbol table and modify it. */
3775 if ((current->flags & SEC_LINK_ONCE) != 0)
3777 unsigned int i, count;
3779 coff_symbol_type *csym = NULL;
3783 count = bfd_get_symcount (abfd);
3784 for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++)
3786 if ((*psym)->section != current)
3789 /* Remember the location of the first symbol in this
3791 if (psymsec == NULL)
3794 /* See if this is the section symbol. */
3795 if (strcmp ((*psym)->name, current->name) == 0)
3797 csym = coff_symbol_from (abfd, *psym);
3799 || csym->native == NULL
3800 || csym->native->u.syment.n_numaux < 1
3801 || csym->native->u.syment.n_sclass != C_STAT
3802 || csym->native->u.syment.n_type != T_NULL)
3805 /* Here *PSYM is the section symbol for CURRENT. */
3812 Note that we might not if we're converting the file from
3813 some other object file format. */
3816 combined_entry_type *aux;
3818 /* We don't touch the x_checksum field. The
3819 x_associated field is not currently supported. */
3821 aux = csym->native + 1;
3822 switch (current->flags & SEC_LINK_DUPLICATES)
3824 case SEC_LINK_DUPLICATES_DISCARD:
3825 aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY;
3828 case SEC_LINK_DUPLICATES_ONE_ONLY:
3829 aux->u.auxent.x_scn.x_comdat =
3830 IMAGE_COMDAT_SELECT_NODUPLICATES;
3833 case SEC_LINK_DUPLICATES_SAME_SIZE:
3834 aux->u.auxent.x_scn.x_comdat =
3835 IMAGE_COMDAT_SELECT_SAME_SIZE;
3838 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
3839 aux->u.auxent.x_scn.x_comdat =
3840 IMAGE_COMDAT_SELECT_EXACT_MATCH;
3844 /* The COMDAT symbol must be the first symbol from this
3845 section in the symbol table. In order to make this
3846 work, we move the COMDAT symbol before the first
3847 symbol we found in the search above. It's OK to
3848 rearrange the symbol table at this point, because
3849 coff_renumber_symbols is going to rearrange it
3850 further and fix up all the aux entries. */
3851 if (psym != psymsec)
3857 for (pcopy = psym; pcopy > psymsec; pcopy--)
3858 pcopy[0] = pcopy[-1];
3863 #endif /* COFF_WITH_PE */
3868 /* XCOFF handles overflows in the reloc and line number count fields
3869 by creating a new section header to hold the correct values. */
3870 for (current = abfd->sections; current != NULL; current = current->next)
3872 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3874 struct internal_scnhdr scnhdr;
3878 internal_f.f_nscns++;
3879 strncpy (&(scnhdr.s_name[0]), current->name, 8);
3880 scnhdr.s_paddr = current->reloc_count;
3881 scnhdr.s_vaddr = current->lineno_count;
3883 scnhdr.s_scnptr = 0;
3884 scnhdr.s_relptr = current->rel_filepos;
3885 scnhdr.s_lnnoptr = current->line_filepos;
3886 scnhdr.s_nreloc = current->target_index;
3887 scnhdr.s_nlnno = current->target_index;
3888 scnhdr.s_flags = STYP_OVRFLO;
3889 amt = bfd_coff_scnhsz (abfd);
3890 if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
3891 || bfd_bwrite (& buff, amt, abfd) != amt)
3898 /* OK, now set up the filehdr... */
3900 /* Don't include the internal abs section in the section count */
3902 /* We will NOT put a fucking timestamp in the header here. Every time you
3903 put it back, I will come in and take it out again. I'm sorry. This
3904 field does not belong here. We fill it with a 0 so it compares the
3905 same but is not a reasonable time. -- gnu@cygnus.com */
3906 internal_f.f_timdat = 0;
3907 internal_f.f_flags = 0;
3909 if (abfd->flags & EXEC_P)
3910 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3913 internal_f.f_opthdr = 0;
3916 if (xcoff_data (abfd)->full_aouthdr)
3917 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3919 internal_f.f_opthdr = SMALL_AOUTSZ;
3925 internal_f.f_flags |= F_RELFLG;
3927 internal_f.f_flags |= F_LNNO;
3928 if (abfd->flags & EXEC_P)
3929 internal_f.f_flags |= F_EXEC;
3930 #ifdef COFF_IMAGE_WITH_PE
3932 internal_f.f_flags |= IMAGE_FILE_DEBUG_STRIPPED;
3933 if (pe_data (abfd)->real_flags & IMAGE_FILE_LARGE_ADDRESS_AWARE)
3934 internal_f.f_flags |= IMAGE_FILE_LARGE_ADDRESS_AWARE;
3937 #ifndef COFF_WITH_pex64
3939 internal_f.f_flags |= IMAGE_FILE_32BIT_MACHINE;
3941 if (bfd_little_endian (abfd))
3942 internal_f.f_flags |= F_AR32WR;
3944 internal_f.f_flags |= F_AR32W;
3949 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
3950 but it doesn't hurt to set it internally. */
3951 internal_f.f_target_id = TI_TARGET_ID;
3953 #ifdef TIC80_TARGET_ID
3954 internal_f.f_target_id = TIC80_TARGET_ID;
3957 /* FIXME, should do something about the other byte orders and
3961 if ((abfd->flags & DYNAMIC) != 0)
3962 internal_f.f_flags |= F_SHROBJ;
3963 if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
3964 internal_f.f_flags |= F_DYNLOAD;
3967 memset (&internal_a, 0, sizeof internal_a);
3969 /* Set up architecture-dependent stuff. */
3971 unsigned int magic = 0;
3972 unsigned short flags = 0;
3974 coff_set_flags (abfd, &magic, &flags);
3975 internal_f.f_magic = magic;
3976 internal_f.f_flags |= flags;
3977 /* ...and the "opt"hdr... */
3979 #ifdef TICOFF_AOUT_MAGIC
3980 internal_a.magic = TICOFF_AOUT_MAGIC;
3981 #define __A_MAGIC_SET__
3984 internal_a.magic = TIC80_ARCH_MAGIC;
3985 #define __A_MAGIC_SET__
3988 /* FIXME: What are the a.out magic numbers for the i860? */
3989 internal_a.magic = 0;
3990 #define __A_MAGIC_SET__
3993 internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
3994 #define __A_MAGIC_SET__
3997 #define __A_MAGIC_SET__
3998 internal_a.magic = PAGEMAGICBCS;
4002 #define __A_MAGIC_SET__
4003 internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
4006 #if defined(M68) || defined(WE32K) || defined(M68K)
4007 #define __A_MAGIC_SET__
4009 internal_a.magic = LYNXCOFFMAGIC;
4011 #if defined(TARG_AUX)
4012 internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED :
4013 abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED :
4014 PAGEMAGICEXECSWAPPED);
4016 #if defined (PAGEMAGICPEXECPAGED)
4017 internal_a.magic = PAGEMAGICPEXECPAGED;
4019 #endif /* TARG_AUX */
4021 #endif /* M68 || WE32K || M68K */
4024 #define __A_MAGIC_SET__
4025 internal_a.magic = ZMAGIC;
4029 #define __A_MAGIC_SET__
4030 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
4033 #if defined MCORE_PE
4034 #define __A_MAGIC_SET__
4035 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
4039 #define __A_MAGIC_SET__
4041 internal_a.magic = LYNXCOFFMAGIC;
4043 internal_a.magic = IMAGE_NT_OPTIONAL_HDR64_MAGIC;
4045 internal_a.magic = ZMAGIC;
4050 #define __A_MAGIC_SET__
4051 internal_a.magic = PE32PMAGIC;
4055 #define __A_MAGIC_SET__
4057 internal_a.magic = LYNXCOFFMAGIC;
4062 #define __A_MAGIC_SET__
4063 internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
4064 (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
4065 RS6K_AOUTHDR_OMAGIC;
4068 #if defined(SH) && defined(COFF_WITH_PE)
4069 #define __A_MAGIC_SET__
4070 internal_a.magic = SH_PE_MAGIC;
4073 #if defined(MIPS) && defined(COFF_WITH_PE)
4074 #define __A_MAGIC_SET__
4075 internal_a.magic = MIPS_PE_MAGIC;
4079 #define __A_MAGIC_SET__
4080 internal_a.magic = NMAGIC; /* Assume separate i/d. */
4084 #define __A_MAGIC_SET__
4085 internal_a.magic = MAXQ20MAGIC;
4088 #ifndef __A_MAGIC_SET__
4089 #include "Your aouthdr magic number is not being set!"
4091 #undef __A_MAGIC_SET__
4095 /* FIXME: Does anybody ever set this to another value? */
4096 internal_a.vstamp = 0;
4098 /* Now should write relocs, strings, syms. */
4099 obj_sym_filepos (abfd) = sym_base;
4101 if (bfd_get_symcount (abfd) != 0)
4105 if (!coff_renumber_symbols (abfd, &firstundef))
4107 coff_mangle_symbols (abfd);
4108 if (! coff_write_symbols (abfd))
4110 if (! coff_write_linenumbers (abfd))
4112 if (! coff_write_relocs (abfd, firstundef))
4115 #ifdef COFF_LONG_SECTION_NAMES
4116 else if (long_section_names && ! obj_coff_strings_written (abfd))
4118 /* If we have long section names we have to write out the string
4119 table even if there are no symbols. */
4120 if (! coff_write_symbols (abfd))
4124 #ifdef COFF_IMAGE_WITH_PE
4126 else if ((abfd->flags & EXEC_P) != 0)
4130 /* PowerPC PE appears to require that all executable files be
4131 rounded up to the page size. */
4134 (file_ptr) BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1,
4136 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
4142 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
4143 backend linker, and obj_raw_syment_count is not valid until after
4144 coff_write_symbols is called. */
4145 if (obj_raw_syment_count (abfd) != 0)
4147 internal_f.f_symptr = sym_base;
4149 /* AIX appears to require that F_RELFLG not be set if there are
4150 local symbols but no relocations. */
4151 internal_f.f_flags &=~ F_RELFLG;
4156 if (long_section_names)
4157 internal_f.f_symptr = sym_base;
4159 internal_f.f_symptr = 0;
4160 internal_f.f_flags |= F_LSYMS;
4165 internal_a.tsize = text_sec->size;
4166 internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
4170 internal_a.dsize = data_sec->size;
4171 internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
4175 internal_a.bsize = bss_sec->size;
4176 if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
4177 internal_a.data_start = bss_sec->vma;
4180 internal_a.entry = bfd_get_start_address (abfd);
4181 internal_f.f_nsyms = obj_raw_syment_count (abfd);
4184 if (xcoff_data (abfd)->full_aouthdr)
4187 asection *loader_sec;
4189 internal_a.vstamp = 1;
4191 internal_a.o_snentry = xcoff_data (abfd)->snentry;
4192 if (internal_a.o_snentry == 0)
4193 internal_a.entry = (bfd_vma) -1;
4195 if (text_sec != NULL)
4197 internal_a.o_sntext = text_sec->target_index;
4198 internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
4202 internal_a.o_sntext = 0;
4203 internal_a.o_algntext = 0;
4205 if (data_sec != NULL)
4207 internal_a.o_sndata = data_sec->target_index;
4208 internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
4212 internal_a.o_sndata = 0;
4213 internal_a.o_algndata = 0;
4215 loader_sec = bfd_get_section_by_name (abfd, ".loader");
4216 if (loader_sec != NULL)
4217 internal_a.o_snloader = loader_sec->target_index;
4219 internal_a.o_snloader = 0;
4220 if (bss_sec != NULL)
4221 internal_a.o_snbss = bss_sec->target_index;
4223 internal_a.o_snbss = 0;
4225 toc = xcoff_data (abfd)->toc;
4226 internal_a.o_toc = toc;
4227 internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
4229 internal_a.o_modtype = xcoff_data (abfd)->modtype;
4230 if (xcoff_data (abfd)->cputype != -1)
4231 internal_a.o_cputype = xcoff_data (abfd)->cputype;
4234 switch (bfd_get_arch (abfd))
4236 case bfd_arch_rs6000:
4237 internal_a.o_cputype = 4;
4239 case bfd_arch_powerpc:
4240 if (bfd_get_mach (abfd) == bfd_mach_ppc)
4241 internal_a.o_cputype = 3;
4243 internal_a.o_cputype = 1;
4249 internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
4250 internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
4254 /* Now write them. */
4255 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
4260 bfd_size_type amount = bfd_coff_filhsz (abfd);
4262 buff = bfd_malloc (amount);
4266 bfd_coff_swap_filehdr_out (abfd, & internal_f, buff);
4267 amount = bfd_bwrite (buff, amount, abfd);
4271 if (amount != bfd_coff_filhsz (abfd))
4275 if (abfd->flags & EXEC_P)
4277 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4278 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4280 bfd_size_type amount = bfd_coff_aoutsz (abfd);
4282 buff = bfd_malloc (amount);
4286 coff_swap_aouthdr_out (abfd, & internal_a, buff);
4287 amount = bfd_bwrite (buff, amount, abfd);
4291 if (amount != bfd_coff_aoutsz (abfd))
4294 #ifdef COFF_IMAGE_WITH_PE
4295 if (! coff_apply_checksum (abfd))
4305 /* XCOFF seems to always write at least a small a.out header. */
4306 coff_swap_aouthdr_out (abfd, & internal_a, & buff);
4307 if (xcoff_data (abfd)->full_aouthdr)
4308 size = bfd_coff_aoutsz (abfd);
4310 size = SMALL_AOUTSZ;
4311 if (bfd_bwrite (& buff, (bfd_size_type) size, abfd) != size)
4320 coff_set_section_contents (bfd * abfd,
4322 const void * location,
4324 bfd_size_type count)
4326 if (! abfd->output_has_begun) /* Set by bfd.c handler. */
4328 if (! coff_compute_section_file_positions (abfd))
4332 #if defined(_LIB) && !defined(TARG_AUX)
4333 /* The physical address field of a .lib section is used to hold the
4334 number of shared libraries in the section. This code counts the
4335 number of sections being written, and increments the lma field
4338 I have found no documentation on the contents of this section.
4339 Experimentation indicates that the section contains zero or more
4340 records, each of which has the following structure:
4342 - a (four byte) word holding the length of this record, in words,
4343 - a word that always seems to be set to "2",
4344 - the path to a shared library, null-terminated and then padded
4345 to a whole word boundary.
4347 bfd_assert calls have been added to alert if an attempt is made
4348 to write a section which doesn't follow these assumptions. The
4349 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4350 <robertl@arnet.com> (Thanks!).
4352 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4353 if (strcmp (section->name, _LIB) == 0)
4355 bfd_byte *rec, *recend;
4357 rec = (bfd_byte *) location;
4358 recend = rec + count;
4359 while (rec < recend)
4362 rec += bfd_get_32 (abfd, rec) * 4;
4365 BFD_ASSERT (rec == recend);
4369 /* Don't write out bss sections - one way to do this is to
4370 see if the filepos has not been set. */
4371 if (section->filepos == 0)
4374 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
4380 return bfd_bwrite (location, count, abfd) == count;
4384 buy_and_read (bfd *abfd, file_ptr where, bfd_size_type size)
4386 void * area = bfd_alloc (abfd, size);
4390 if (bfd_seek (abfd, where, SEEK_SET) != 0
4391 || bfd_bread (area, size, abfd) != size)
4400 Creating the linenumber table is done by reading in the entire
4401 coff linenumber table, and creating another table for internal use.
4403 A coff linenumber table is structured so that each function
4404 is marked as having a line number of 0. Each line within the
4405 function is an offset from the first line in the function. The
4406 base of the line number information for the table is stored in
4407 the symbol associated with the function.
4409 Note: The PE format uses line number 0 for a flag indicating a
4412 The information is copied from the external to the internal
4413 table, and each symbol which marks a function is marked by
4416 How does this work ?
4420 coff_sort_func_alent (const void * arg1, const void * arg2)
4422 const alent *al1 = *(const alent **) arg1;
4423 const alent *al2 = *(const alent **) arg2;
4424 const coff_symbol_type *s1 = (const coff_symbol_type *) (al1->u.sym);
4425 const coff_symbol_type *s2 = (const coff_symbol_type *) (al2->u.sym);
4427 if (s1->symbol.value < s2->symbol.value)
4429 else if (s1->symbol.value > s2->symbol.value)
4436 coff_slurp_line_table (bfd *abfd, asection *asect)
4438 LINENO *native_lineno;
4439 alent *lineno_cache;
4441 unsigned int counter;
4443 bfd_vma prev_offset = 0;
4445 unsigned int nbr_func;
4448 BFD_ASSERT (asect->lineno == NULL);
4450 amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
4451 lineno_cache = bfd_alloc (abfd, amt);
4452 if (lineno_cache == NULL)
4455 amt = (bfd_size_type) bfd_coff_linesz (abfd) * asect->lineno_count;
4456 native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos, amt);
4457 if (native_lineno == NULL)
4459 (*_bfd_error_handler)
4460 (_("%B: warning: line number table read failed"), abfd);
4461 bfd_release (abfd, lineno_cache);
4465 cache_ptr = lineno_cache;
4466 asect->lineno = lineno_cache;
4467 src = native_lineno;
4470 for (counter = 0; counter < asect->lineno_count; counter++)
4472 struct internal_lineno dst;
4474 bfd_coff_swap_lineno_in (abfd, src, &dst);
4475 cache_ptr->line_number = dst.l_lnno;
4477 if (cache_ptr->line_number == 0)
4480 bfd_signed_vma symndx;
4481 coff_symbol_type *sym;
4485 symndx = dst.l_addr.l_symndx;
4487 || (bfd_vma) symndx >= obj_raw_syment_count (abfd))
4489 (*_bfd_error_handler)
4490 (_("%B: warning: illegal symbol index %ld in line numbers"),
4491 abfd, dst.l_addr.l_symndx);
4496 /* FIXME: We should not be casting between ints and
4497 pointers like this. */
4498 sym = ((coff_symbol_type *)
4499 ((symndx + obj_raw_syments (abfd))
4500 ->u.syment._n._n_n._n_zeroes));
4501 cache_ptr->u.sym = (asymbol *) sym;
4502 if (sym->lineno != NULL && ! warned)
4503 (*_bfd_error_handler)
4504 (_("%B: warning: duplicate line number information for `%s'"),
4505 abfd, bfd_asymbol_name (&sym->symbol));
4507 sym->lineno = cache_ptr;
4508 if (sym->symbol.value < prev_offset)
4510 prev_offset = sym->symbol.value;
4513 cache_ptr->u.offset = dst.l_addr.l_paddr
4514 - bfd_section_vma (abfd, asect);
4519 cache_ptr->line_number = 0;
4520 bfd_release (abfd, native_lineno);
4522 /* On some systems (eg AIX5.3) the lineno table may not be sorted. */
4525 /* Sort the table. */
4527 alent *n_lineno_cache;
4529 /* Create a table of functions. */
4530 func_table = bfd_alloc (abfd, nbr_func * sizeof (alent *));
4531 if (func_table != NULL)
4533 alent **p = func_table;
4536 for (i = 0; i < counter; i++)
4537 if (lineno_cache[i].line_number == 0)
4538 *p++ = &lineno_cache[i];
4540 /* Sort by functions. */
4541 qsort (func_table, nbr_func, sizeof (alent *), coff_sort_func_alent);
4543 /* Create the new sorted table. */
4544 amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
4545 n_lineno_cache = bfd_alloc (abfd, amt);
4546 if (n_lineno_cache != NULL)
4548 alent *n_cache_ptr = n_lineno_cache;
4550 for (i = 0; i < nbr_func; i++)
4552 coff_symbol_type *sym;
4553 alent *old_ptr = func_table[i];
4555 /* Copy the function entry and update it. */
4556 *n_cache_ptr = *old_ptr;
4557 sym = (coff_symbol_type *)n_cache_ptr->u.sym;
4558 sym->lineno = n_cache_ptr;
4562 /* Copy the line number entries. */
4563 while (old_ptr->line_number != 0)
4564 *n_cache_ptr++ = *old_ptr++;
4566 n_cache_ptr->line_number = 0;
4567 memcpy (lineno_cache, n_lineno_cache, amt);
4569 bfd_release (abfd, func_table);
4576 /* Slurp in the symbol table, converting it to generic form. Note
4577 that if coff_relocate_section is defined, the linker will read
4578 symbols via coff_link_add_symbols, rather than via this routine. */
4581 coff_slurp_symbol_table (bfd * abfd)
4583 combined_entry_type *native_symbols;
4584 coff_symbol_type *cached_area;
4585 unsigned int *table_ptr;
4587 unsigned int number_of_symbols = 0;
4589 if (obj_symbols (abfd))
4592 /* Read in the symbol table. */
4593 if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
4596 /* Allocate enough room for all the symbols in cached form. */
4597 amt = obj_raw_syment_count (abfd);
4598 amt *= sizeof (coff_symbol_type);
4599 cached_area = bfd_alloc (abfd, amt);
4600 if (cached_area == NULL)
4603 amt = obj_raw_syment_count (abfd);
4604 amt *= sizeof (unsigned int);
4605 table_ptr = bfd_alloc (abfd, amt);
4607 if (table_ptr == NULL)
4611 coff_symbol_type *dst = cached_area;
4612 unsigned int last_native_index = obj_raw_syment_count (abfd);
4613 unsigned int this_index = 0;
4615 while (this_index < last_native_index)
4617 combined_entry_type *src = native_symbols + this_index;
4618 table_ptr[this_index] = number_of_symbols;
4619 dst->symbol.the_bfd = abfd;
4621 dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
4622 /* We use the native name field to point to the cached field. */
4623 src->u.syment._n._n_n._n_zeroes = (bfd_hostptr_t) dst;
4624 dst->symbol.section = coff_section_from_bfd_index (abfd,
4625 src->u.syment.n_scnum);
4626 dst->symbol.flags = 0;
4627 dst->done_lineno = FALSE;
4629 switch (src->u.syment.n_sclass)
4633 /* Fall through to next case. */
4640 case C_THUMBEXTFUNC:
4646 case C_SYSTEM: /* System Wide variable. */
4649 /* In PE, 0x68 (104) denotes a section symbol. */
4651 /* In PE, 0x69 (105) denotes a weak external symbol. */
4654 switch (coff_classify_symbol (abfd, &src->u.syment))
4656 case COFF_SYMBOL_GLOBAL:
4657 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
4658 #if defined COFF_WITH_PE
4659 /* PE sets the symbol to a value relative to the
4660 start of the section. */
4661 dst->symbol.value = src->u.syment.n_value;
4663 dst->symbol.value = (src->u.syment.n_value
4664 - dst->symbol.section->vma);
4666 if (ISFCN ((src->u.syment.n_type)))
4667 /* A function ext does not go at the end of a
4669 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4672 case COFF_SYMBOL_COMMON:
4673 dst->symbol.section = bfd_com_section_ptr;
4674 dst->symbol.value = src->u.syment.n_value;
4677 case COFF_SYMBOL_UNDEFINED:
4678 dst->symbol.section = bfd_und_section_ptr;
4679 dst->symbol.value = 0;
4682 case COFF_SYMBOL_PE_SECTION:
4683 dst->symbol.flags |= BSF_EXPORT | BSF_SECTION_SYM;
4684 dst->symbol.value = 0;
4687 case COFF_SYMBOL_LOCAL:
4688 dst->symbol.flags = BSF_LOCAL;
4689 #if defined COFF_WITH_PE
4690 /* PE sets the symbol to a value relative to the
4691 start of the section. */
4692 dst->symbol.value = src->u.syment.n_value;
4694 dst->symbol.value = (src->u.syment.n_value
4695 - dst->symbol.section->vma);
4697 if (ISFCN ((src->u.syment.n_type)))
4698 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4703 /* A symbol with a csect entry should not go at the end. */
4704 if (src->u.syment.n_numaux > 0)
4705 dst->symbol.flags |= BSF_NOT_AT_END;
4709 if (src->u.syment.n_sclass == C_NT_WEAK)
4710 dst->symbol.flags |= BSF_WEAK;
4712 if (src->u.syment.n_sclass == C_SECTION
4713 && src->u.syment.n_scnum > 0)
4714 dst->symbol.flags = BSF_LOCAL;
4716 if (src->u.syment.n_sclass == C_WEAKEXT)
4717 dst->symbol.flags |= BSF_WEAK;
4721 case C_STAT: /* Static. */
4723 case C_LEAFSTAT: /* Static leaf procedure. */
4726 case C_THUMBSTAT: /* Thumb static. */
4727 case C_THUMBLABEL: /* Thumb label. */
4728 case C_THUMBSTATFUNC:/* Thumb static function. */
4730 case C_LABEL: /* Label. */
4731 if (src->u.syment.n_scnum == N_DEBUG)
4732 dst->symbol.flags = BSF_DEBUGGING;
4734 dst->symbol.flags = BSF_LOCAL;
4736 /* Base the value as an index from the base of the
4737 section, if there is one. */
4738 if (dst->symbol.section)
4740 #if defined COFF_WITH_PE
4741 /* PE sets the symbol to a value relative to the
4742 start of the section. */
4743 dst->symbol.value = src->u.syment.n_value;
4745 dst->symbol.value = (src->u.syment.n_value
4746 - dst->symbol.section->vma);
4750 dst->symbol.value = src->u.syment.n_value;
4753 case C_MOS: /* Member of structure. */
4754 case C_EOS: /* End of structure. */
4755 case C_REGPARM: /* Register parameter. */
4756 case C_REG: /* register variable. */
4757 /* C_AUTOARG conflicts with TI COFF C_UEXT. */
4758 #if !defined (TIC80COFF) && !defined (TICOFF)
4760 case C_AUTOARG: /* 960-specific storage class. */
4763 case C_TPDEF: /* Type definition. */
4765 case C_AUTO: /* Automatic variable. */
4766 case C_FIELD: /* Bit field. */
4767 case C_ENTAG: /* Enumeration tag. */
4768 case C_MOE: /* Member of enumeration. */
4769 case C_MOU: /* Member of union. */
4770 case C_UNTAG: /* Union tag. */
4771 dst->symbol.flags = BSF_DEBUGGING;
4772 dst->symbol.value = (src->u.syment.n_value);
4775 case C_FILE: /* File name. */
4776 case C_STRTAG: /* Structure tag. */
4793 dst->symbol.flags = BSF_DEBUGGING;
4794 dst->symbol.value = (src->u.syment.n_value);
4798 case C_BINCL: /* Beginning of include file. */
4799 case C_EINCL: /* Ending of include file. */
4800 /* The value is actually a pointer into the line numbers
4801 of the file. We locate the line number entry, and
4802 set the section to the section which contains it, and
4803 the value to the index in that section. */
4807 dst->symbol.flags = BSF_DEBUGGING;
4808 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4809 if (sec->line_filepos <= (file_ptr) src->u.syment.n_value
4810 && ((file_ptr) (sec->line_filepos
4811 + sec->lineno_count * bfd_coff_linesz (abfd))
4812 > (file_ptr) src->u.syment.n_value))
4815 dst->symbol.value = 0;
4818 dst->symbol.section = sec;
4819 dst->symbol.value = ((src->u.syment.n_value
4820 - sec->line_filepos)
4821 / bfd_coff_linesz (abfd));
4828 dst->symbol.flags = BSF_DEBUGGING;
4830 /* The value is actually a symbol index. Save a pointer
4831 to the symbol instead of the index. FIXME: This
4832 should use a union. */
4833 src->u.syment.n_value =
4834 (long) (native_symbols + src->u.syment.n_value);
4835 dst->symbol.value = src->u.syment.n_value;
4840 case C_BLOCK: /* ".bb" or ".eb". */
4841 case C_FCN: /* ".bf" or ".ef" (or PE ".lf"). */
4842 case C_EFCN: /* Physical end of function. */
4843 #if defined COFF_WITH_PE
4844 /* PE sets the symbol to a value relative to the start
4846 dst->symbol.value = src->u.syment.n_value;
4847 if (strcmp (dst->symbol.name, ".bf") != 0)
4849 /* PE uses funny values for .ef and .lf; don't
4851 dst->symbol.flags = BSF_DEBUGGING;
4854 dst->symbol.flags = BSF_DEBUGGING | BSF_DEBUGGING_RELOC;
4856 /* Base the value as an index from the base of the
4858 dst->symbol.flags = BSF_LOCAL;
4859 dst->symbol.value = (src->u.syment.n_value
4860 - dst->symbol.section->vma);
4864 case C_STATLAB: /* Static load time label. */
4865 dst->symbol.value = src->u.syment.n_value;
4866 dst->symbol.flags = BSF_GLOBAL;
4870 /* PE DLLs sometimes have zeroed out symbols for some
4871 reason. Just ignore them without a warning. */
4872 if (src->u.syment.n_type == 0
4873 && src->u.syment.n_value == 0
4874 && src->u.syment.n_scnum == 0)
4877 case C_EXTDEF: /* External definition. */
4878 case C_ULABEL: /* Undefined label. */
4879 case C_USTATIC: /* Undefined static. */
4880 #ifndef COFF_WITH_PE
4881 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4882 class to represent a section symbol. */
4883 case C_LINE: /* line # reformatted as symbol table entry. */
4884 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4885 case C_ALIAS: /* Duplicate tag. */
4887 /* New storage classes for TI COFF. */
4888 #if defined(TIC80COFF) || defined(TICOFF)
4889 case C_UEXT: /* Tentative external definition. */
4891 case C_EXTLAB: /* External load time label. */
4892 case C_HIDDEN: /* Ext symbol in dmert public lib. */
4894 (*_bfd_error_handler)
4895 (_("%B: Unrecognized storage class %d for %s symbol `%s'"),
4896 abfd, src->u.syment.n_sclass,
4897 dst->symbol.section->name, dst->symbol.name);
4898 dst->symbol.flags = BSF_DEBUGGING;
4899 dst->symbol.value = (src->u.syment.n_value);
4905 dst->symbol.udata.i = 0;
4907 this_index += (src->u.syment.n_numaux) + 1;
4909 number_of_symbols++;
4913 obj_symbols (abfd) = cached_area;
4914 obj_raw_syments (abfd) = native_symbols;
4916 bfd_get_symcount (abfd) = number_of_symbols;
4917 obj_convert (abfd) = table_ptr;
4918 /* Slurp the line tables for each section too. */
4925 coff_slurp_line_table (abfd, p);
4933 /* Classify a COFF symbol. A couple of targets have globally visible
4934 symbols which are not class C_EXT, and this handles those. It also
4935 recognizes some special PE cases. */
4937 static enum coff_symbol_classification
4938 coff_classify_symbol (bfd *abfd,
4939 struct internal_syment *syment)
4941 /* FIXME: This partially duplicates the switch in
4942 coff_slurp_symbol_table. */
4943 switch (syment->n_sclass)
4952 case C_THUMBEXTFUNC:
4960 if (syment->n_scnum == 0)
4962 if (syment->n_value == 0)
4963 return COFF_SYMBOL_UNDEFINED;
4965 return COFF_SYMBOL_COMMON;
4967 return COFF_SYMBOL_GLOBAL;
4974 if (syment->n_sclass == C_STAT)
4976 if (syment->n_scnum == 0)
4977 /* The Microsoft compiler sometimes generates these if a
4978 small static function is inlined every time it is used.
4979 The function is discarded, but the symbol table entry
4981 return COFF_SYMBOL_LOCAL;
4983 #ifdef STRICT_PE_FORMAT
4984 /* This is correct for Microsoft generated objects, but it
4985 breaks gas generated objects. */
4986 if (syment->n_value == 0)
4989 char buf[SYMNMLEN + 1];
4991 sec = coff_section_from_bfd_index (abfd, syment->n_scnum);
4993 && (strcmp (bfd_get_section_name (abfd, sec),
4994 _bfd_coff_internal_syment_name (abfd, syment, buf))
4996 return COFF_SYMBOL_PE_SECTION;
5000 return COFF_SYMBOL_LOCAL;
5003 if (syment->n_sclass == C_SECTION)
5005 /* In some cases in a DLL generated by the Microsoft linker, the
5006 n_value field will contain garbage. FIXME: This should
5007 probably be handled by the swapping function instead. */
5008 syment->n_value = 0;
5009 if (syment->n_scnum == 0)
5010 return COFF_SYMBOL_UNDEFINED;
5011 return COFF_SYMBOL_PE_SECTION;
5013 #endif /* COFF_WITH_PE */
5015 /* If it is not a global symbol, we presume it is a local symbol. */
5016 if (syment->n_scnum == 0)
5018 char buf[SYMNMLEN + 1];
5020 (*_bfd_error_handler)
5021 (_("warning: %B: local symbol `%s' has no section"),
5022 abfd, _bfd_coff_internal_syment_name (abfd, syment, buf));
5025 return COFF_SYMBOL_LOCAL;
5032 Coff relocations are easily transformed into the internal BFD form
5035 Reading a coff relocation table is done in the following stages:
5037 o Read the entire coff relocation table into memory.
5039 o Process each relocation in turn; first swap it from the
5040 external to the internal form.
5042 o Turn the symbol referenced in the relocation's symbol index
5043 into a pointer into the canonical symbol table.
5044 This table is the same as the one returned by a call to
5045 @code{bfd_canonicalize_symtab}. The back end will call that
5046 routine and save the result if a canonicalization hasn't been done.
5048 o The reloc index is turned into a pointer to a howto
5049 structure, in a back end specific way. For instance, the 386
5050 and 960 use the @code{r_type} to directly produce an index
5051 into a howto table vector; the 88k subtracts a number from the
5052 @code{r_type} field and creates an addend field.
5056 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
5058 coff_symbol_type *coffsym = NULL; \
5060 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
5061 coffsym = (obj_symbols (abfd) \
5062 + (cache_ptr->sym_ptr_ptr - symbols)); \
5064 coffsym = coff_symbol_from (abfd, ptr); \
5065 if (coffsym != NULL \
5066 && coffsym->native->u.syment.n_scnum == 0) \
5067 cache_ptr->addend = 0; \
5068 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
5069 && ptr->section != NULL) \
5070 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
5072 cache_ptr->addend = 0; \
5077 coff_slurp_reloc_table (bfd * abfd, sec_ptr asect, asymbol ** symbols)
5079 RELOC *native_relocs;
5080 arelent *reloc_cache;
5085 if (asect->relocation)
5087 if (asect->reloc_count == 0)
5089 if (asect->flags & SEC_CONSTRUCTOR)
5091 if (!coff_slurp_symbol_table (abfd))
5094 amt = (bfd_size_type) bfd_coff_relsz (abfd) * asect->reloc_count;
5095 native_relocs = (RELOC *) buy_and_read (abfd, asect->rel_filepos, amt);
5096 amt = (bfd_size_type) asect->reloc_count * sizeof (arelent);
5097 reloc_cache = bfd_alloc (abfd, amt);
5099 if (reloc_cache == NULL || native_relocs == NULL)
5102 for (idx = 0; idx < asect->reloc_count; idx++)
5104 struct internal_reloc dst;
5105 struct external_reloc *src;
5106 #ifndef RELOC_PROCESSING
5110 cache_ptr = reloc_cache + idx;
5111 src = native_relocs + idx;
5114 coff_swap_reloc_in (abfd, src, &dst);
5116 #ifdef RELOC_PROCESSING
5117 RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
5119 cache_ptr->address = dst.r_vaddr;
5121 if (dst.r_symndx != -1)
5123 if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd))
5125 (*_bfd_error_handler)
5126 (_("%B: warning: illegal symbol index %ld in relocs"),
5127 abfd, dst.r_symndx);
5128 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
5133 cache_ptr->sym_ptr_ptr = (symbols
5134 + obj_convert (abfd)[dst.r_symndx]);
5135 ptr = *(cache_ptr->sym_ptr_ptr);
5140 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
5144 /* The symbols definitions that we have read in have been
5145 relocated as if their sections started at 0. But the offsets
5146 refering to the symbols in the raw data have not been
5147 modified, so we have to have a negative addend to compensate.
5149 Note that symbols which used to be common must be left alone. */
5151 /* Calculate any reloc addend by looking at the symbol. */
5152 CALC_ADDEND (abfd, ptr, dst, cache_ptr);
5154 cache_ptr->address -= asect->vma;
5155 /* !! cache_ptr->section = NULL;*/
5157 /* Fill in the cache_ptr->howto field from dst.r_type. */
5158 RTYPE2HOWTO (cache_ptr, &dst);
5159 #endif /* RELOC_PROCESSING */
5161 if (cache_ptr->howto == NULL)
5163 (*_bfd_error_handler)
5164 (_("%B: illegal relocation type %d at address 0x%lx"),
5165 abfd, dst.r_type, (long) dst.r_vaddr);
5166 bfd_set_error (bfd_error_bad_value);
5171 asect->relocation = reloc_cache;
5175 #ifndef coff_rtype_to_howto
5178 /* Get the howto structure for a reloc. This is only used if the file
5179 including this one defines coff_relocate_section to be
5180 _bfd_coff_generic_relocate_section, so it is OK if it does not
5181 always work. It is the responsibility of the including file to
5182 make sure it is reasonable if it is needed. */
5184 static reloc_howto_type *
5185 coff_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
5186 asection *sec ATTRIBUTE_UNUSED,
5187 struct internal_reloc *rel,
5188 struct coff_link_hash_entry *h ATTRIBUTE_UNUSED,
5189 struct internal_syment *sym ATTRIBUTE_UNUSED,
5190 bfd_vma *addendp ATTRIBUTE_UNUSED)
5194 genrel.howto = NULL;
5195 RTYPE2HOWTO (&genrel, rel);
5196 return genrel.howto;
5199 #else /* ! defined (RTYPE2HOWTO) */
5201 #define coff_rtype_to_howto NULL
5203 #endif /* ! defined (RTYPE2HOWTO) */
5204 #endif /* ! defined (coff_rtype_to_howto) */
5206 /* This is stupid. This function should be a boolean predicate. */
5209 coff_canonicalize_reloc (bfd * abfd,
5214 arelent *tblptr = section->relocation;
5215 unsigned int count = 0;
5217 if (section->flags & SEC_CONSTRUCTOR)
5219 /* This section has relocs made up by us, they are not in the
5220 file, so take them out of their chain and place them into
5221 the data area provided. */
5222 arelent_chain *chain = section->constructor_chain;
5224 for (count = 0; count < section->reloc_count; count++)
5226 *relptr++ = &chain->relent;
5227 chain = chain->next;
5232 if (! coff_slurp_reloc_table (abfd, section, symbols))
5235 tblptr = section->relocation;
5237 for (; count++ < section->reloc_count;)
5238 *relptr++ = tblptr++;
5241 return section->reloc_count;
5244 #ifndef coff_reloc16_estimate
5245 #define coff_reloc16_estimate dummy_reloc16_estimate
5248 dummy_reloc16_estimate (bfd *abfd ATTRIBUTE_UNUSED,
5249 asection *input_section ATTRIBUTE_UNUSED,
5250 arelent *reloc ATTRIBUTE_UNUSED,
5251 unsigned int shrink ATTRIBUTE_UNUSED,
5252 struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
5260 #ifndef coff_reloc16_extra_cases
5262 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5264 /* This works even if abort is not declared in any header file. */
5267 dummy_reloc16_extra_cases (bfd *abfd ATTRIBUTE_UNUSED,
5268 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
5269 struct bfd_link_order *link_order ATTRIBUTE_UNUSED,
5270 arelent *reloc ATTRIBUTE_UNUSED,
5271 bfd_byte *data ATTRIBUTE_UNUSED,
5272 unsigned int *src_ptr ATTRIBUTE_UNUSED,
5273 unsigned int *dst_ptr ATTRIBUTE_UNUSED)
5279 #ifndef coff_bfd_link_hash_table_free
5280 #define coff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
5283 /* If coff_relocate_section is defined, we can use the optimized COFF
5284 backend linker. Otherwise we must continue to use the old linker. */
5286 #ifdef coff_relocate_section
5288 #ifndef coff_bfd_link_hash_table_create
5289 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5291 #ifndef coff_bfd_link_add_symbols
5292 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5294 #ifndef coff_bfd_final_link
5295 #define coff_bfd_final_link _bfd_coff_final_link
5298 #else /* ! defined (coff_relocate_section) */
5300 #define coff_relocate_section NULL
5301 #ifndef coff_bfd_link_hash_table_create
5302 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5304 #ifndef coff_bfd_link_add_symbols
5305 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5307 #define coff_bfd_final_link _bfd_generic_final_link
5309 #endif /* ! defined (coff_relocate_section) */
5311 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5312 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5314 #ifndef coff_start_final_link
5315 #define coff_start_final_link NULL
5318 #ifndef coff_adjust_symndx
5319 #define coff_adjust_symndx NULL
5322 #ifndef coff_link_add_one_symbol
5323 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5326 #ifndef coff_link_output_has_begun
5329 coff_link_output_has_begun (bfd * abfd,
5330 struct coff_final_link_info * info ATTRIBUTE_UNUSED)
5332 return abfd->output_has_begun;
5336 #ifndef coff_final_link_postscript
5339 coff_final_link_postscript (bfd * abfd ATTRIBUTE_UNUSED,
5340 struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED)
5346 #ifndef coff_SWAP_aux_in
5347 #define coff_SWAP_aux_in coff_swap_aux_in
5349 #ifndef coff_SWAP_sym_in
5350 #define coff_SWAP_sym_in coff_swap_sym_in
5352 #ifndef coff_SWAP_lineno_in
5353 #define coff_SWAP_lineno_in coff_swap_lineno_in
5355 #ifndef coff_SWAP_aux_out
5356 #define coff_SWAP_aux_out coff_swap_aux_out
5358 #ifndef coff_SWAP_sym_out
5359 #define coff_SWAP_sym_out coff_swap_sym_out
5361 #ifndef coff_SWAP_lineno_out
5362 #define coff_SWAP_lineno_out coff_swap_lineno_out
5364 #ifndef coff_SWAP_reloc_out
5365 #define coff_SWAP_reloc_out coff_swap_reloc_out
5367 #ifndef coff_SWAP_filehdr_out
5368 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5370 #ifndef coff_SWAP_aouthdr_out
5371 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5373 #ifndef coff_SWAP_scnhdr_out
5374 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5376 #ifndef coff_SWAP_reloc_in
5377 #define coff_SWAP_reloc_in coff_swap_reloc_in
5379 #ifndef coff_SWAP_filehdr_in
5380 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5382 #ifndef coff_SWAP_aouthdr_in
5383 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5385 #ifndef coff_SWAP_scnhdr_in
5386 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5389 static bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED =
5391 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5392 coff_SWAP_aux_out, coff_SWAP_sym_out,
5393 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5394 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5395 coff_SWAP_scnhdr_out,
5396 FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
5397 #ifdef COFF_LONG_FILENAMES
5402 COFF_DEFAULT_LONG_SECTION_NAMES,
5403 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5404 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5409 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5414 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5415 coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
5416 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5417 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5418 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5419 coff_classify_symbol, coff_compute_section_file_positions,
5420 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5421 coff_adjust_symndx, coff_link_add_one_symbol,
5422 coff_link_output_has_begun, coff_final_link_postscript,
5427 /* COFF0 differs in file/section header size and relocation entry size. */
5429 static bfd_coff_backend_data ticoff0_swap_table =
5431 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5432 coff_SWAP_aux_out, coff_SWAP_sym_out,
5433 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5434 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5435 coff_SWAP_scnhdr_out,
5436 FILHSZ_V0, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ_V0, LINESZ, FILNMLEN,
5437 #ifdef COFF_LONG_FILENAMES
5442 COFF_DEFAULT_LONG_SECTION_NAMES,
5443 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5444 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5449 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5454 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5455 coff_SWAP_reloc_in, ticoff0_bad_format_hook, coff_set_arch_mach_hook,
5456 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5457 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5458 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5459 coff_classify_symbol, coff_compute_section_file_positions,
5460 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5461 coff_adjust_symndx, coff_link_add_one_symbol,
5462 coff_link_output_has_begun, coff_final_link_postscript,
5468 /* COFF1 differs in section header size. */
5470 static bfd_coff_backend_data ticoff1_swap_table =
5472 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5473 coff_SWAP_aux_out, coff_SWAP_sym_out,
5474 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5475 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5476 coff_SWAP_scnhdr_out,
5477 FILHSZ, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
5478 #ifdef COFF_LONG_FILENAMES
5483 COFF_DEFAULT_LONG_SECTION_NAMES,
5484 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5485 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5490 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5495 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5496 coff_SWAP_reloc_in, ticoff1_bad_format_hook, coff_set_arch_mach_hook,
5497 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5498 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5499 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5500 coff_classify_symbol, coff_compute_section_file_positions,
5501 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5502 coff_adjust_symndx, coff_link_add_one_symbol,
5503 coff_link_output_has_begun, coff_final_link_postscript,
5504 bfd_pe_print_pdata /* huh */
5508 #ifndef coff_close_and_cleanup
5509 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5512 #ifndef coff_bfd_free_cached_info
5513 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5516 #ifndef coff_get_section_contents
5517 #define coff_get_section_contents _bfd_generic_get_section_contents
5520 #ifndef coff_bfd_copy_private_symbol_data
5521 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5524 #ifndef coff_bfd_copy_private_header_data
5525 #define coff_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
5528 #ifndef coff_bfd_copy_private_section_data
5529 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5532 #ifndef coff_bfd_copy_private_bfd_data
5533 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5536 #ifndef coff_bfd_merge_private_bfd_data
5537 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5540 #ifndef coff_bfd_set_private_flags
5541 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5544 #ifndef coff_bfd_print_private_bfd_data
5545 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5548 #ifndef coff_bfd_is_local_label_name
5549 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5552 #ifndef coff_bfd_is_target_special_symbol
5553 #define coff_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
5556 #ifndef coff_read_minisymbols
5557 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5560 #ifndef coff_minisymbol_to_symbol
5561 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5564 /* The reloc lookup routine must be supplied by each individual COFF
5566 #ifndef coff_bfd_reloc_type_lookup
5567 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5569 #ifndef coff_bfd_reloc_name_lookup
5570 #define coff_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5573 #ifndef coff_bfd_get_relocated_section_contents
5574 #define coff_bfd_get_relocated_section_contents \
5575 bfd_generic_get_relocated_section_contents
5578 #ifndef coff_bfd_relax_section
5579 #define coff_bfd_relax_section bfd_generic_relax_section
5582 #ifndef coff_bfd_gc_sections
5583 #define coff_bfd_gc_sections bfd_generic_gc_sections
5586 #ifndef coff_bfd_merge_sections
5587 #define coff_bfd_merge_sections bfd_generic_merge_sections
5590 #ifndef coff_bfd_is_group_section
5591 #define coff_bfd_is_group_section bfd_generic_is_group_section
5594 #ifndef coff_bfd_discard_group
5595 #define coff_bfd_discard_group bfd_generic_discard_group
5598 #ifndef coff_section_already_linked
5599 #define coff_section_already_linked \
5600 _bfd_generic_section_already_linked
5603 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5604 const bfd_target VAR = \
5607 bfd_target_coff_flavour, \
5608 BFD_ENDIAN_BIG, /* Data byte order is big. */ \
5609 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5610 /* object flags */ \
5611 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5612 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5613 /* section flags */ \
5614 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5615 UNDER, /* Leading symbol underscore. */ \
5616 '/', /* AR_pad_char. */ \
5617 15, /* AR_max_namelen. */ \
5619 /* Data conversion functions. */ \
5620 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5621 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5622 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5624 /* Header conversion functions. */ \
5625 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5626 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5627 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5629 /* bfd_check_format. */ \
5630 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5631 _bfd_dummy_target }, \
5632 /* bfd_set_format. */ \
5633 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5634 /* bfd_write_contents. */ \
5635 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5638 BFD_JUMP_TABLE_GENERIC (coff), \
5639 BFD_JUMP_TABLE_COPY (coff), \
5640 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5641 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5642 BFD_JUMP_TABLE_SYMBOLS (coff), \
5643 BFD_JUMP_TABLE_RELOCS (coff), \
5644 BFD_JUMP_TABLE_WRITE (coff), \
5645 BFD_JUMP_TABLE_LINK (coff), \
5646 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5653 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5654 const bfd_target VAR = \
5657 bfd_target_coff_flavour, \
5658 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5659 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5660 /* object flags */ \
5661 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5662 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5663 /* section flags */ \
5664 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5665 UNDER, /* Leading symbol underscore. */ \
5666 '/', /* AR_pad_char. */ \
5667 15, /* AR_max_namelen. */ \
5669 /* Data conversion functions. */ \
5670 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5671 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5672 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5674 /* Header conversion functions. */ \
5675 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5676 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5677 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5679 /* bfd_check_format. */ \
5680 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5681 _bfd_dummy_target }, \
5682 /* bfd_set_format. */ \
5683 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5684 /* bfd_write_contents. */ \
5685 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5688 BFD_JUMP_TABLE_GENERIC (coff), \
5689 BFD_JUMP_TABLE_COPY (coff), \
5690 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5691 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5692 BFD_JUMP_TABLE_SYMBOLS (coff), \
5693 BFD_JUMP_TABLE_RELOCS (coff), \
5694 BFD_JUMP_TABLE_WRITE (coff), \
5695 BFD_JUMP_TABLE_LINK (coff), \
5696 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5703 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5704 const bfd_target VAR = \
5707 bfd_target_coff_flavour, \
5708 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5709 BFD_ENDIAN_LITTLE, /* Header byte order is little. */ \
5710 /* object flags */ \
5711 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5712 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5713 /* section flags */ \
5714 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5715 UNDER, /* Leading symbol underscore. */ \
5716 '/', /* AR_pad_char. */ \
5717 15, /* AR_max_namelen. */ \
5719 /* Data conversion functions. */ \
5720 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5721 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5722 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5723 /* Header conversion functions. */ \
5724 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5725 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5726 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5727 /* bfd_check_format. */ \
5728 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5729 _bfd_dummy_target }, \
5730 /* bfd_set_format. */ \
5731 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5732 /* bfd_write_contents. */ \
5733 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5736 BFD_JUMP_TABLE_GENERIC (coff), \
5737 BFD_JUMP_TABLE_COPY (coff), \
5738 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5739 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5740 BFD_JUMP_TABLE_SYMBOLS (coff), \
5741 BFD_JUMP_TABLE_RELOCS (coff), \
5742 BFD_JUMP_TABLE_WRITE (coff), \
5743 BFD_JUMP_TABLE_LINK (coff), \
5744 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \