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
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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
24 Most of this hacked by Steve Chamberlain,
32 BFD supports a number of different flavours of coff format.
33 The major differences between formats are the sizes and
34 alignments of fields in structures on disk, and the occasional
37 Coff in all its varieties is implemented with a few common
38 files and a number of implementation specific files. For
39 example, The 88k bcs coff format is implemented in the file
40 @file{coff-m88k.c}. This file @code{#include}s
41 @file{coff/m88k.h} which defines the external structure of the
42 coff format for the 88k, and @file{coff/internal.h} which
43 defines the internal structure. @file{coff-m88k.c} also
44 defines the relocations used by the 88k format
47 The Intel i960 processor version of coff is implemented in
48 @file{coff-i960.c}. This file has the same structure as
49 @file{coff-m88k.c}, except that it includes @file{coff/i960.h}
50 rather than @file{coff-m88k.h}.
53 Porting to a new version of coff
55 The recommended method is to select from the existing
56 implementations the version of coff which is most like the one
57 you want to use. For example, we'll say that i386 coff is
58 the one you select, and that your coff flavour is called foo.
59 Copy @file{i386coff.c} to @file{foocoff.c}, copy
60 @file{../include/coff/i386.h} to @file{../include/coff/foo.h},
61 and add the lines to @file{targets.c} and @file{Makefile.in}
62 so that your new back end is used. Alter the shapes of the
63 structures in @file{../include/coff/foo.h} so that they match
64 what you need. You will probably also have to add
65 @code{#ifdef}s to the code in @file{coff/internal.h} and
66 @file{coffcode.h} if your version of coff is too wild.
68 You can verify that your new BFD backend works quite simply by
69 building @file{objdump} from the @file{binutils} directory,
70 and making sure that its version of what's going on and your
71 host system's idea (assuming it has the pretty standard coff
72 dump utility, usually called @code{att-dump} or just
73 @code{dump}) are the same. Then clean up your code, and send
74 what you've done to Cygnus. Then your stuff will be in the
75 next release, and you won't have to keep integrating it.
78 How the coff backend works
83 The Coff backend is split into generic routines that are
84 applicable to any Coff target and routines that are specific
85 to a particular target. The target-specific routines are
86 further split into ones which are basically the same for all
87 Coff targets except that they use the external symbol format
88 or use different values for certain constants.
90 The generic routines are in @file{coffgen.c}. These routines
91 work for any Coff target. They use some hooks into the target
92 specific code; the hooks are in a @code{bfd_coff_backend_data}
93 structure, one of which exists for each target.
95 The essentially similar target-specific routines are in
96 @file{coffcode.h}. This header file includes executable C code.
97 The various Coff targets first include the appropriate Coff
98 header file, make any special defines that are needed, and
99 then include @file{coffcode.h}.
101 Some of the Coff targets then also have additional routines in
102 the target source file itself.
104 For example, @file{coff-i960.c} includes
105 @file{coff/internal.h} and @file{coff/i960.h}. It then
106 defines a few constants, such as @code{I960}, and includes
107 @file{coffcode.h}. Since the i960 has complex relocation
108 types, @file{coff-i960.c} also includes some code to
109 manipulate the i960 relocs. This code is not in
110 @file{coffcode.h} because it would not be used by any other
116 Each flavour of coff supported in BFD has its own header file
117 describing the external layout of the structures. There is also
118 an internal description of the coff layout, in
119 @file{coff/internal.h}. A major function of the
120 coff backend is swapping the bytes and twiddling the bits to
121 translate the external form of the structures into the normal
122 internal form. This is all performed in the
123 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
124 elements are different sizes between different versions of
125 coff; it is the duty of the coff version specific include file
126 to override the definitions of various packing routines in
127 @file{coffcode.h}. E.g., the size of line number entry in coff is
128 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
129 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
130 correct one. No doubt, some day someone will find a version of
131 coff which has a varying field size not catered to at the
132 moment. To port BFD, that person will have to add more @code{#defines}.
133 Three of the bit twiddling routines are exported to
134 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
135 and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol
136 table on its own, but uses BFD to fix things up. More of the
137 bit twiddlers are exported for @code{gas};
138 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
139 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
140 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
141 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
142 of all the symbol table and reloc drudgery itself, thereby
143 saving the internal BFD overhead, but uses BFD to swap things
144 on the way out, making cross ports much safer. Doing so also
145 allows BFD (and thus the linker) to use the same header files
146 as @code{gas}, which makes one avenue to disaster disappear.
151 The simple canonical form for symbols used by BFD is not rich
152 enough to keep all the information available in a coff symbol
153 table. The back end gets around this problem by keeping the original
154 symbol table around, "behind the scenes".
156 When a symbol table is requested (through a call to
157 @code{bfd_canonicalize_symtab}), a request gets through to
158 @code{coff_get_normalized_symtab}. This reads the symbol table from
159 the coff file and swaps all the structures inside into the
160 internal form. It also fixes up all the pointers in the table
161 (represented in the file by offsets from the first symbol in
162 the table) into physical pointers to elements in the new
163 internal table. This involves some work since the meanings of
164 fields change depending upon context: a field that is a
165 pointer to another structure in the symbol table at one moment
166 may be the size in bytes of a structure at the next. Another
167 pass is made over the table. All symbols which mark file names
168 (<<C_FILE>> symbols) are modified so that the internal
169 string points to the value in the auxent (the real filename)
170 rather than the normal text associated with the symbol
173 At this time the symbol names are moved around. Coff stores
174 all symbols less than nine characters long physically
175 within the symbol table; longer strings are kept at the end of
176 the file in the string table. This pass moves all strings
177 into memory and replaces them with pointers to the strings.
179 The symbol table is massaged once again, this time to create
180 the canonical table used by the BFD application. Each symbol
181 is inspected in turn, and a decision made (using the
182 @code{sclass} field) about the various flags to set in the
183 @code{asymbol}. @xref{Symbols}. The generated canonical table
184 shares strings with the hidden internal symbol table.
186 Any linenumbers are read from the coff file too, and attached
187 to the symbols which own the functions the linenumbers belong to.
192 Writing a symbol to a coff file which didn't come from a coff
193 file will lose any debugging information. The @code{asymbol}
194 structure remembers the BFD from which the symbol was taken, and on
195 output the back end makes sure that the same destination target as
196 source target is present.
198 When the symbols have come from a coff file then all the
199 debugging information is preserved.
201 Symbol tables are provided for writing to the back end in a
202 vector of pointers to pointers. This allows applications like
203 the linker to accumulate and output large symbol tables
204 without having to do too much byte copying.
206 This function runs through the provided symbol table and
207 patches each symbol marked as a file place holder
208 (@code{C_FILE}) to point to the next file place holder in the
209 list. It also marks each @code{offset} field in the list with
210 the offset from the first symbol of the current symbol.
212 Another function of this procedure is to turn the canonical
213 value form of BFD into the form used by coff. Internally, BFD
214 expects symbol values to be offsets from a section base; so a
215 symbol physically at 0x120, but in a section starting at
216 0x100, would have the value 0x20. Coff expects symbols to
217 contain their final value, so symbols have their values
218 changed at this point to reflect their sum with their owning
219 section. This transformation uses the
220 <<output_section>> field of the @code{asymbol}'s
221 @code{asection} @xref{Sections}.
223 o <<coff_mangle_symbols>>
225 This routine runs though the provided symbol table and uses
226 the offsets generated by the previous pass and the pointers
227 generated when the symbol table was read in to create the
228 structured hierarchy required by coff. It changes each pointer
229 to a symbol into the index into the symbol table of the asymbol.
231 o <<coff_write_symbols>>
233 This routine runs through the symbol table and patches up the
234 symbols from their internal form into the coff way, calls the
235 bit twiddlers, and writes out the table to the file.
244 The hidden information for an <<asymbol>> is described in a
245 <<combined_entry_type>>:
249 .typedef struct coff_ptr_struct
251 . {* Remembers the offset from the first symbol in the file for
252 . this symbol. Generated by coff_renumber_symbols. *}
253 . unsigned int offset;
255 . {* Should the value of this symbol be renumbered. Used for
256 . XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
257 . unsigned int fix_value : 1;
259 . {* Should the tag field of this symbol be renumbered.
260 . Created by coff_pointerize_aux. *}
261 . unsigned int fix_tag : 1;
263 . {* Should the endidx field of this symbol be renumbered.
264 . Created by coff_pointerize_aux. *}
265 . unsigned int fix_end : 1;
267 . {* Should the x_csect.x_scnlen field be renumbered.
268 . Created by coff_pointerize_aux. *}
269 . unsigned int fix_scnlen : 1;
271 . {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
272 . index into the line number entries. Set by coff_slurp_symbol_table. *}
273 . unsigned int fix_line : 1;
275 . {* The container for the symbol structure as read and translated
279 . union internal_auxent auxent;
280 . struct internal_syment syment;
282 .} combined_entry_type;
285 .{* Each canonical asymbol really looks like this: *}
287 .typedef struct coff_symbol_struct
289 . {* The actual symbol which the rest of BFD works with *}
292 . {* A pointer to the hidden information for this symbol *}
293 . combined_entry_type *native;
295 . {* A pointer to the linenumber information for this symbol *}
296 . struct lineno_cache_entry *lineno;
298 . {* Have the line numbers been relocated yet ? *}
299 . bfd_boolean done_lineno;
307 #include "coffswap.h"
310 #define STRING_SIZE_SIZE (4)
312 #define DOT_DEBUG ".debug"
313 #define GNU_LINKONCE_WI ".gnu.linkonce.wi."
315 static long sec_to_styp_flags
316 PARAMS ((const char *, flagword
));
317 static bfd_boolean styp_to_sec_flags
318 PARAMS ((bfd
*, PTR
, const char *, asection
*, flagword
*));
319 static bfd_boolean coff_bad_format_hook
320 PARAMS ((bfd
*, PTR
));
321 static void coff_set_custom_section_alignment
322 PARAMS ((bfd
*, asection
*, const struct coff_section_alignment_entry
*,
323 const unsigned int));
324 static bfd_boolean coff_new_section_hook
325 PARAMS ((bfd
*, asection
*));
326 static bfd_boolean coff_set_arch_mach_hook
327 PARAMS ((bfd
*, PTR
));
328 static bfd_boolean coff_write_relocs
329 PARAMS ((bfd
*, int));
330 static bfd_boolean coff_set_flags
331 PARAMS ((bfd
*, unsigned int *, unsigned short *));
332 static bfd_boolean coff_set_arch_mach
333 PARAMS ((bfd
*, enum bfd_architecture
, unsigned long)) ATTRIBUTE_UNUSED
;
334 static bfd_boolean coff_compute_section_file_positions
336 static bfd_boolean coff_write_object_contents
337 PARAMS ((bfd
*)) ATTRIBUTE_UNUSED
;
338 static bfd_boolean coff_set_section_contents
339 PARAMS ((bfd
*, asection
*, const PTR
, file_ptr
, bfd_size_type
));
340 static PTR buy_and_read
341 PARAMS ((bfd
*, file_ptr
, bfd_size_type
));
342 static bfd_boolean coff_slurp_line_table
343 PARAMS ((bfd
*, asection
*));
344 static bfd_boolean coff_slurp_symbol_table
346 static enum coff_symbol_classification coff_classify_symbol
347 PARAMS ((bfd
*, struct internal_syment
*));
348 static bfd_boolean coff_slurp_reloc_table
349 PARAMS ((bfd
*, asection
*, asymbol
**));
350 static long coff_canonicalize_reloc
351 PARAMS ((bfd
*, asection
*, arelent
**, asymbol
**));
352 #ifndef coff_mkobject_hook
353 static PTR coff_mkobject_hook
354 PARAMS ((bfd
*, PTR
, PTR
));
357 static flagword handle_COMDAT
358 PARAMS ((bfd
*, flagword
, PTR
, const char *, asection
*));
360 #ifdef COFF_IMAGE_WITH_PE
361 static bfd_boolean coff_read_word
362 PARAMS ((bfd
*, unsigned int *));
363 static unsigned int coff_compute_checksum
365 static bfd_boolean coff_apply_checksum
369 static bfd_boolean ticoff0_bad_format_hook
370 PARAMS ((bfd
*, PTR
));
371 static bfd_boolean ticoff1_bad_format_hook
372 PARAMS ((bfd
*, PTR
));
375 /* void warning(); */
377 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
378 the incoming SEC_* flags. The inverse of this function is
379 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
380 should probably mirror the changes in styp_to_sec_flags(). */
384 /* Macros for setting debugging flags. */
386 #define STYP_XCOFF_DEBUG STYP_DEBUG
388 #define STYP_XCOFF_DEBUG STYP_INFO
391 #ifdef COFF_ALIGN_IN_S_FLAGS
392 #define STYP_DEBUG_INFO STYP_DSECT
394 #define STYP_DEBUG_INFO STYP_INFO
398 sec_to_styp_flags (sec_name
, sec_flags
)
399 const char *sec_name
;
404 if (!strcmp (sec_name
, _TEXT
))
406 styp_flags
= STYP_TEXT
;
408 else if (!strcmp (sec_name
, _DATA
))
410 styp_flags
= STYP_DATA
;
412 else if (!strcmp (sec_name
, _BSS
))
414 styp_flags
= STYP_BSS
;
417 else if (!strcmp (sec_name
, _COMMENT
))
419 styp_flags
= STYP_INFO
;
420 #endif /* _COMMENT */
423 else if (!strcmp (sec_name
, _LIB
))
425 styp_flags
= STYP_LIB
;
429 else if (!strcmp (sec_name
, _LIT
))
431 styp_flags
= STYP_LIT
;
434 else if (!strncmp (sec_name
, DOT_DEBUG
, sizeof (DOT_DEBUG
) - 1))
436 /* Handle the XCOFF debug section and DWARF2 debug sections. */
438 styp_flags
= STYP_XCOFF_DEBUG
;
440 styp_flags
= STYP_DEBUG_INFO
;
442 else if (!strncmp (sec_name
, ".stab", 5))
444 styp_flags
= STYP_DEBUG_INFO
;
446 #ifdef COFF_LONG_SECTION_NAMES
447 else if (!strncmp (sec_name
, GNU_LINKONCE_WI
, sizeof (GNU_LINKONCE_WI
) - 1))
449 styp_flags
= STYP_DEBUG_INFO
;
453 else if (!strcmp (sec_name
, _PAD
))
455 styp_flags
= STYP_PAD
;
457 else if (!strcmp (sec_name
, _LOADER
))
459 styp_flags
= STYP_LOADER
;
461 else if (!strcmp (sec_name
, _EXCEPT
))
463 styp_flags
= STYP_EXCEPT
;
465 else if (!strcmp (sec_name
, _TYPCHK
))
467 styp_flags
= STYP_TYPCHK
;
470 /* Try and figure out what it should be */
471 else if (sec_flags
& SEC_CODE
)
473 styp_flags
= STYP_TEXT
;
475 else if (sec_flags
& SEC_DATA
)
477 styp_flags
= STYP_DATA
;
479 else if (sec_flags
& SEC_READONLY
)
481 #ifdef STYP_LIT /* 29k readonly text/data section */
482 styp_flags
= STYP_LIT
;
484 styp_flags
= STYP_TEXT
;
485 #endif /* STYP_LIT */
487 else if (sec_flags
& SEC_LOAD
)
489 styp_flags
= STYP_TEXT
;
491 else if (sec_flags
& SEC_ALLOC
)
493 styp_flags
= STYP_BSS
;
497 if (sec_flags
& SEC_CLINK
)
498 styp_flags
|= STYP_CLINK
;
502 if (sec_flags
& SEC_BLOCK
)
503 styp_flags
|= STYP_BLOCK
;
507 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
508 styp_flags
|= STYP_NOLOAD
;
514 #else /* COFF_WITH_PE */
516 /* The PE version; see above for the general comments. The non-PE
517 case seems to be more guessing, and breaks PE format; specifically,
518 .rdata is readonly, but it sure ain't text. Really, all this
519 should be set up properly in gas (or whatever assembler is in use),
520 and honor whatever objcopy/strip, etc. sent us as input. */
523 sec_to_styp_flags (sec_name
, sec_flags
)
524 const char *sec_name
;
529 /* caution: there are at least three groups of symbols that have
530 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
531 SEC_* are the BFD internal flags, used for generic BFD
532 information. STYP_* are the COFF section flags which appear in
533 COFF files. IMAGE_SCN_* are the PE section flags which appear in
534 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
535 but there are more IMAGE_SCN_* flags. */
537 /* FIXME: There is no gas syntax to specify the debug section flag. */
538 if (strncmp (sec_name
, DOT_DEBUG
, sizeof (DOT_DEBUG
) - 1) == 0
539 || strncmp (sec_name
, GNU_LINKONCE_WI
, sizeof (GNU_LINKONCE_WI
) - 1) == 0)
540 sec_flags
= SEC_READONLY
| SEC_DEBUGGING
;
545 if ((sec_flags
& SEC_CODE
) != 0)
546 styp_flags
|= IMAGE_SCN_CNT_CODE
;
547 if ((sec_flags
& SEC_DATA
) != 0)
548 styp_flags
|= IMAGE_SCN_CNT_INITIALIZED_DATA
;
549 if ((sec_flags
& SEC_ALLOC
) != 0 && (sec_flags
& SEC_LOAD
) == 0)
550 styp_flags
|= IMAGE_SCN_CNT_UNINITIALIZED_DATA
; /* ==STYP_BSS */
552 /* skip constRUCTOR */
555 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
556 styp_flags
|= STYP_NOLOAD
;
558 if ((sec_flags
& SEC_IS_COMMON
) != 0)
559 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
560 if ((sec_flags
& SEC_DEBUGGING
) != 0)
561 styp_flags
|= IMAGE_SCN_MEM_DISCARDABLE
;
562 if ((sec_flags
& SEC_EXCLUDE
) != 0)
563 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
564 if ((sec_flags
& SEC_NEVER_LOAD
) != 0)
565 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
568 if (sec_flags
& SEC_LINK_ONCE
)
569 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
570 /* skip LINK_DUPLICATES */
571 /* skip LINKER_CREATED */
573 /* For now, the read/write bits are mapped onto SEC_READONLY, even
574 though the semantics don't quite match. The bits from the input
575 are retained in pei_section_data(abfd, section)->pe_flags. */
577 styp_flags
|= IMAGE_SCN_MEM_READ
; /* Always readable. */
578 if ((sec_flags
& SEC_READONLY
) == 0)
579 styp_flags
|= IMAGE_SCN_MEM_WRITE
; /* Invert READONLY for write. */
580 if (sec_flags
& SEC_CODE
)
581 styp_flags
|= IMAGE_SCN_MEM_EXECUTE
; /* CODE->EXECUTE. */
582 if (sec_flags
& SEC_SHARED
)
583 styp_flags
|= IMAGE_SCN_MEM_SHARED
; /* Shared remains meaningful. */
588 #endif /* COFF_WITH_PE */
590 /* Return a word with SEC_* flags set to represent the incoming STYP_*
591 flags (from scnhdr.s_flags). The inverse of this function is
592 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
593 should probably mirror the changes in sec_to_styp_flags(). */
598 styp_to_sec_flags (abfd
, hdr
, name
, section
, flags_ptr
)
599 bfd
*abfd ATTRIBUTE_UNUSED
;
602 asection
*section ATTRIBUTE_UNUSED
;
605 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
606 long styp_flags
= internal_s
->s_flags
;
607 flagword sec_flags
= 0;
610 if (styp_flags
& STYP_BLOCK
)
611 sec_flags
|= SEC_BLOCK
;
615 if (styp_flags
& STYP_CLINK
)
616 sec_flags
|= SEC_CLINK
;
620 if (styp_flags
& STYP_NOLOAD
)
621 sec_flags
|= SEC_NEVER_LOAD
;
622 #endif /* STYP_NOLOAD */
624 /* For 386 COFF, at least, an unloadable text or data section is
625 actually a shared library section. */
626 if (styp_flags
& STYP_TEXT
)
628 if (sec_flags
& SEC_NEVER_LOAD
)
629 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
631 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
633 else if (styp_flags
& STYP_DATA
)
635 if (sec_flags
& SEC_NEVER_LOAD
)
636 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
638 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
640 else if (styp_flags
& STYP_BSS
)
642 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
643 if (sec_flags
& SEC_NEVER_LOAD
)
644 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
647 sec_flags
|= SEC_ALLOC
;
649 else if (styp_flags
& STYP_INFO
)
651 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
652 defined. coff_compute_section_file_positions uses
653 COFF_PAGE_SIZE to ensure that the low order bits of the
654 section VMA and the file offset match. If we don't know
655 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
656 and demand page loading of the file will fail. */
657 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
658 sec_flags
|= SEC_DEBUGGING
;
661 else if (styp_flags
& STYP_PAD
)
663 else if (strcmp (name
, _TEXT
) == 0)
665 if (sec_flags
& SEC_NEVER_LOAD
)
666 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
668 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
670 else if (strcmp (name
, _DATA
) == 0)
672 if (sec_flags
& SEC_NEVER_LOAD
)
673 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
675 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
677 else if (strcmp (name
, _BSS
) == 0)
679 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
680 if (sec_flags
& SEC_NEVER_LOAD
)
681 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
684 sec_flags
|= SEC_ALLOC
;
686 else if (strncmp (name
, DOT_DEBUG
, sizeof (DOT_DEBUG
) - 1) == 0
688 || strcmp (name
, _COMMENT
) == 0
690 #ifdef COFF_LONG_SECTION_NAMES
691 || strncmp (name
, GNU_LINKONCE_WI
, sizeof (GNU_LINKONCE_WI
) - 1) == 0
693 || strncmp (name
, ".stab", 5) == 0)
695 #ifdef COFF_PAGE_SIZE
696 sec_flags
|= SEC_DEBUGGING
;
700 else if (strcmp (name
, _LIB
) == 0)
704 else if (strcmp (name
, _LIT
) == 0)
705 sec_flags
= SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
708 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
710 #ifdef STYP_LIT /* A29k readonly text/data section type. */
711 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
712 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
713 #endif /* STYP_LIT */
715 #ifdef STYP_OTHER_LOAD /* Other loaded sections. */
716 if (styp_flags
& STYP_OTHER_LOAD
)
717 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
718 #endif /* STYP_SDATA */
720 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
721 /* As a GNU extension, if the name begins with .gnu.linkonce, we
722 only link a single copy of the section. This is used to support
723 g++. g++ will emit each template expansion in its own section.
724 The symbols will be defined as weak, so that multiple definitions
725 are permitted. The GNU linker extension is to actually discard
726 all but one of the sections. */
727 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
728 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
731 if (flags_ptr
== NULL
)
734 * flags_ptr
= sec_flags
;
738 #else /* COFF_WITH_PE */
741 handle_COMDAT (abfd
, sec_flags
, hdr
, name
, section
)
748 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
749 bfd_byte
*esymstart
, *esym
, *esymend
;
751 char *target_name
= NULL
;
753 sec_flags
|= SEC_LINK_ONCE
;
755 /* Unfortunately, the PE format stores essential information in
756 the symbol table, of all places. We need to extract that
757 information now, so that objdump and the linker will know how
758 to handle the section without worrying about the symbols. We
759 can't call slurp_symtab, because the linker doesn't want the
762 /* COMDAT sections are special. The first symbol is the section
763 symbol, which tells what kind of COMDAT section it is. The
764 second symbol is the "comdat symbol" - the one with the
765 unique name. GNU uses the section symbol for the unique
766 name; MS uses ".text" for every comdat section. Sigh. - DJ */
768 /* This is not mirrored in sec_to_styp_flags(), but there
769 doesn't seem to be a need to, either, and it would at best be
772 if (! _bfd_coff_get_external_symbols (abfd
))
775 esymstart
= esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
776 esymend
= esym
+ obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
778 while (esym
< esymend
)
780 struct internal_syment isym
;
781 char buf
[SYMNMLEN
+ 1];
784 bfd_coff_swap_sym_in (abfd
, (PTR
) esym
, (PTR
) &isym
);
786 if (sizeof (internal_s
->s_name
) > SYMNMLEN
)
788 /* This case implies that the matching
789 symbol name will be in the string table. */
793 if (isym
.n_scnum
== section
->target_index
)
795 /* According to the MSVC documentation, the first
796 TWO entries with the section # are both of
797 interest to us. The first one is the "section
798 symbol" (section name). The second is the comdat
799 symbol name. Here, we've found the first
800 qualifying entry; we distinguish it from the
801 second with a state flag.
803 In the case of gas-generated (at least until that
804 is fixed) .o files, it isn't necessarily the
805 second one. It may be some other later symbol.
807 Since gas also doesn't follow MS conventions and
808 emits the section similar to .text$<name>, where
809 <something> is the name we're looking for, we
810 distinguish the two as follows:
812 If the section name is simply a section name (no
813 $) we presume it's MS-generated, and look at
814 precisely the second symbol for the comdat name.
815 If the section name has a $, we assume it's
816 gas-generated, and look for <something> (whatever
817 follows the $) as the comdat symbol. */
819 /* All 3 branches use this. */
820 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
, buf
);
829 /* The first time we've seen the symbol. */
830 union internal_auxent aux
;
834 /* If it isn't the stuff we're expecting, die;
835 The MS documentation is vague, but it
836 appears that the second entry serves BOTH
837 as the comdat symbol and the defining
838 symbol record (either C_STAT or C_EXT,
839 possibly with an aux entry with debug
840 information if it's a function.) It
841 appears the only way to find the second one
842 is to count. (On Intel, they appear to be
843 adjacent, but on Alpha, they have been
846 Here, we think we've found the first one,
847 but there's some checking we can do to be
850 if (! (isym
.n_sclass
== C_STAT
851 && isym
.n_type
== T_NULL
852 && isym
.n_value
== 0))
855 /* FIXME LATER: MSVC generates section names
856 like .text for comdats. Gas generates
857 names like .text$foo__Fv (in the case of a
858 function). See comment above for more. */
860 if (strcmp (name
, symname
) != 0)
863 /* This is the section symbol. */
864 bfd_coff_swap_aux_in (abfd
, (PTR
) (esym
+ bfd_coff_symesz (abfd
)),
865 isym
.n_type
, isym
.n_sclass
,
866 0, isym
.n_numaux
, (PTR
) &aux
);
868 target_name
= strchr (name
, '$');
869 if (target_name
!= NULL
)
877 /* FIXME: Microsoft uses NODUPLICATES and
878 ASSOCIATIVE, but gnu uses ANY and
879 SAME_SIZE. Unfortunately, gnu doesn't do
880 the comdat symbols right. So, until we can
881 fix it to do the right thing, we are
882 temporarily disabling comdats for the MS
883 types (they're used in DLLs and C++, but we
884 don't support *their* C++ libraries anyway
887 /* Cygwin does not follow the MS style, and
888 uses ANY and SAME_SIZE where NODUPLICATES
889 and ASSOCIATIVE should be used. For
890 Interix, we just do the right thing up
893 switch (aux
.x_scn
.x_comdat
)
895 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
896 #ifdef STRICT_PE_FORMAT
897 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
899 sec_flags
&= ~SEC_LINK_ONCE
;
903 case IMAGE_COMDAT_SELECT_ANY
:
904 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
907 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
908 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
911 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
912 /* Not yet fully implemented ??? */
913 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
916 /* debug$S gets this case; other
919 /* There may be no symbol... we'll search
920 the whole table... Is this the right
921 place to play this game? Or should we do
922 it when reading it in. */
923 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
924 #ifdef STRICT_PE_FORMAT
925 /* FIXME: This is not currently implemented. */
926 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
928 sec_flags
&= ~SEC_LINK_ONCE
;
932 default: /* 0 means "no symbol" */
933 /* debug$F gets this case; other
935 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
942 /* Gas mode: the first matching on partial name. */
944 #ifndef TARGET_UNDERSCORE
945 #define TARGET_UNDERSCORE 0
947 /* Is this the name we're looking for ? */
948 if (strcmp (target_name
,
949 symname
+ (TARGET_UNDERSCORE
? 1 : 0)) != 0)
951 /* Not the name we're looking for */
952 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
957 /* MSVC mode: the lexically second symbol (or
958 drop through from the above). */
963 /* This must the second symbol with the
964 section #. It is the actual symbol name.
965 Intel puts the two adjacent, but Alpha (at
966 least) spreads them out. */
968 amt
= sizeof (struct bfd_comdat_info
);
969 section
->comdat
= bfd_alloc (abfd
, amt
);
970 if (section
->comdat
== NULL
)
973 section
->comdat
->symbol
=
974 (esym
- esymstart
) / bfd_coff_symesz (abfd
);
976 amt
= strlen (symname
) + 1;
977 newname
= bfd_alloc (abfd
, amt
);
981 strcpy (newname
, symname
);
982 section
->comdat
->name
= newname
;
989 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
997 /* The PE version; see above for the general comments.
999 Since to set the SEC_LINK_ONCE and associated flags, we have to
1000 look at the symbol table anyway, we return the symbol table index
1001 of the symbol being used as the COMDAT symbol. This is admittedly
1002 ugly, but there's really nowhere else that we have access to the
1003 required information. FIXME: Is the COMDAT symbol index used for
1004 any purpose other than objdump? */
1007 styp_to_sec_flags (abfd
, hdr
, name
, section
, flags_ptr
)
1012 flagword
*flags_ptr
;
1014 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
1015 long styp_flags
= internal_s
->s_flags
;
1017 bfd_boolean result
= TRUE
;
1019 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
1020 sec_flags
= SEC_READONLY
;
1022 /* Process each flag bit in styp_flags in turn. */
1025 long flag
= styp_flags
& - styp_flags
;
1026 char * unhandled
= NULL
;
1028 styp_flags
&= ~ flag
;
1030 /* We infer from the distinct read/write/execute bits the settings
1031 of some of the bfd flags; the actual values, should we need them,
1032 are also in pei_section_data (abfd, section)->pe_flags. */
1037 unhandled
= "STYP_DSECT";
1040 unhandled
= "STYP_GROUP";
1043 unhandled
= "STYP_COPY";
1046 unhandled
= "STYP_OVER";
1048 #ifdef SEC_NEVER_LOAD
1050 sec_flags
|= SEC_NEVER_LOAD
;
1053 case IMAGE_SCN_MEM_READ
:
1054 /* Ignored, assume it always to be true. */
1056 case IMAGE_SCN_TYPE_NO_PAD
:
1059 case IMAGE_SCN_LNK_OTHER
:
1060 unhandled
= "IMAGE_SCN_LNK_OTHER";
1062 case IMAGE_SCN_MEM_NOT_CACHED
:
1063 unhandled
= "IMAGE_SCN_MEM_NOT_CACHED";
1065 case IMAGE_SCN_MEM_NOT_PAGED
:
1067 unhandled
= "IMAGE_SCN_MEM_NOT_PAGED";
1069 /* Generate a warning message rather using the 'unhandled'
1070 variable as this will allow some .sys files generate by
1071 other toolchains to be processed. See bugzilla issue 196. */
1072 _bfd_error_handler (_("%s: Warning: Ignoring section flag IMAGE_SCN_MEM_NOT_PAGED in section %s"),
1073 bfd_archive_filename (abfd
), name
);
1076 case IMAGE_SCN_MEM_EXECUTE
:
1077 sec_flags
|= SEC_CODE
;
1079 case IMAGE_SCN_MEM_WRITE
:
1080 sec_flags
&= ~ SEC_READONLY
;
1082 case IMAGE_SCN_MEM_DISCARDABLE
:
1083 /* The MS PE spec sets the DISCARDABLE flag on .reloc sections
1084 but we do not want them to be labelled as debug section, since
1085 then strip would remove them. */
1086 if (strncmp (name
, ".reloc", sizeof ".reloc" - 1) != 0)
1087 sec_flags
|= SEC_DEBUGGING
;
1089 case IMAGE_SCN_MEM_SHARED
:
1090 sec_flags
|= SEC_SHARED
;
1092 case IMAGE_SCN_LNK_REMOVE
:
1093 sec_flags
|= SEC_EXCLUDE
;
1095 case IMAGE_SCN_CNT_CODE
:
1096 sec_flags
|= SEC_CODE
| SEC_ALLOC
| SEC_LOAD
;
1098 case IMAGE_SCN_CNT_INITIALIZED_DATA
:
1099 sec_flags
|= SEC_DATA
| SEC_ALLOC
| SEC_LOAD
;
1101 case IMAGE_SCN_CNT_UNINITIALIZED_DATA
:
1102 sec_flags
|= SEC_ALLOC
;
1104 case IMAGE_SCN_LNK_INFO
:
1105 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1106 defined. coff_compute_section_file_positions uses
1107 COFF_PAGE_SIZE to ensure that the low order bits of the
1108 section VMA and the file offset match. If we don't know
1109 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1110 and demand page loading of the file will fail. */
1111 #ifdef COFF_PAGE_SIZE
1112 sec_flags
|= SEC_DEBUGGING
;
1115 case IMAGE_SCN_LNK_COMDAT
:
1116 /* COMDAT gets very special treatment. */
1117 sec_flags
= handle_COMDAT (abfd
, sec_flags
, hdr
, name
, section
);
1120 /* Silently ignore for now. */
1124 /* If the section flag was not handled, report it here. */
1125 if (unhandled
!= NULL
)
1127 (*_bfd_error_handler
)
1128 (_("%s (%s): Section flag %s (0x%x) ignored"),
1129 bfd_archive_filename (abfd
), name
, unhandled
, flag
);
1134 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1135 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1136 only link a single copy of the section. This is used to support
1137 g++. g++ will emit each template expansion in its own section.
1138 The symbols will be defined as weak, so that multiple definitions
1139 are permitted. The GNU linker extension is to actually discard
1140 all but one of the sections. */
1141 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
1142 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1146 * flags_ptr
= sec_flags
;
1151 #endif /* COFF_WITH_PE */
1153 #define get_index(symbol) ((symbol)->udata.i)
1157 bfd_coff_backend_data
1161 .{* COFF symbol classifications. *}
1163 .enum coff_symbol_classification
1165 . {* Global symbol. *}
1166 . COFF_SYMBOL_GLOBAL,
1167 . {* Common symbol. *}
1168 . COFF_SYMBOL_COMMON,
1169 . {* Undefined symbol. *}
1170 . COFF_SYMBOL_UNDEFINED,
1171 . {* Local symbol. *}
1172 . COFF_SYMBOL_LOCAL,
1173 . {* PE section symbol. *}
1174 . COFF_SYMBOL_PE_SECTION
1177 Special entry points for gdb to swap in coff symbol table parts:
1180 . void (*_bfd_coff_swap_aux_in)
1181 . PARAMS ((bfd *, PTR, int, int, int, int, PTR));
1183 . void (*_bfd_coff_swap_sym_in)
1184 . PARAMS ((bfd *, PTR, PTR));
1186 . void (*_bfd_coff_swap_lineno_in)
1187 . PARAMS ((bfd *, PTR, PTR));
1189 . unsigned int (*_bfd_coff_swap_aux_out)
1190 . PARAMS ((bfd *, PTR, int, int, int, int, PTR));
1192 . unsigned int (*_bfd_coff_swap_sym_out)
1193 . PARAMS ((bfd *, PTR, PTR));
1195 . unsigned int (*_bfd_coff_swap_lineno_out)
1196 . PARAMS ((bfd *, PTR, PTR));
1198 . unsigned int (*_bfd_coff_swap_reloc_out)
1199 . PARAMS ((bfd *, PTR, PTR));
1201 . unsigned int (*_bfd_coff_swap_filehdr_out)
1202 . PARAMS ((bfd *, PTR, PTR));
1204 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1205 . PARAMS ((bfd *, PTR, PTR));
1207 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1208 . PARAMS ((bfd *, PTR, PTR));
1210 . unsigned int _bfd_filhsz;
1211 . unsigned int _bfd_aoutsz;
1212 . unsigned int _bfd_scnhsz;
1213 . unsigned int _bfd_symesz;
1214 . unsigned int _bfd_auxesz;
1215 . unsigned int _bfd_relsz;
1216 . unsigned int _bfd_linesz;
1217 . unsigned int _bfd_filnmlen;
1218 . bfd_boolean _bfd_coff_long_filenames;
1219 . bfd_boolean _bfd_coff_long_section_names;
1220 . unsigned int _bfd_coff_default_section_alignment_power;
1221 . bfd_boolean _bfd_coff_force_symnames_in_strings;
1222 . unsigned int _bfd_coff_debug_string_prefix_length;
1224 . void (*_bfd_coff_swap_filehdr_in)
1225 . PARAMS ((bfd *, PTR, PTR));
1227 . void (*_bfd_coff_swap_aouthdr_in)
1228 . PARAMS ((bfd *, PTR, PTR));
1230 . void (*_bfd_coff_swap_scnhdr_in)
1231 . PARAMS ((bfd *, PTR, PTR));
1233 . void (*_bfd_coff_swap_reloc_in)
1234 . PARAMS ((bfd *abfd, PTR, PTR));
1236 . bfd_boolean (*_bfd_coff_bad_format_hook)
1237 . PARAMS ((bfd *, PTR));
1239 . bfd_boolean (*_bfd_coff_set_arch_mach_hook)
1240 . PARAMS ((bfd *, PTR));
1242 . PTR (*_bfd_coff_mkobject_hook)
1243 . PARAMS ((bfd *, PTR, PTR));
1245 . bfd_boolean (*_bfd_styp_to_sec_flags_hook)
1246 . PARAMS ((bfd *, PTR, const char *, asection *, flagword *));
1248 . void (*_bfd_set_alignment_hook)
1249 . PARAMS ((bfd *, asection *, PTR));
1251 . bfd_boolean (*_bfd_coff_slurp_symbol_table)
1254 . bfd_boolean (*_bfd_coff_symname_in_debug)
1255 . PARAMS ((bfd *, struct internal_syment *));
1257 . bfd_boolean (*_bfd_coff_pointerize_aux_hook)
1258 . PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
1259 . unsigned int, combined_entry_type *));
1261 . bfd_boolean (*_bfd_coff_print_aux)
1262 . PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1263 . combined_entry_type *, unsigned int));
1265 . void (*_bfd_coff_reloc16_extra_cases)
1266 . PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1267 . bfd_byte *, unsigned int *, unsigned int *));
1269 . int (*_bfd_coff_reloc16_estimate)
1270 . PARAMS ((bfd *, asection *, arelent *, unsigned int,
1271 . struct bfd_link_info *));
1273 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1274 . PARAMS ((bfd *, struct internal_syment *));
1276 . bfd_boolean (*_bfd_coff_compute_section_file_positions)
1279 . bfd_boolean (*_bfd_coff_start_final_link)
1280 . PARAMS ((bfd *, struct bfd_link_info *));
1282 . bfd_boolean (*_bfd_coff_relocate_section)
1283 . PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1284 . struct internal_reloc *, struct internal_syment *, asection **));
1286 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1287 . PARAMS ((bfd *, asection *, struct internal_reloc *,
1288 . struct coff_link_hash_entry *, struct internal_syment *,
1291 . bfd_boolean (*_bfd_coff_adjust_symndx)
1292 . PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
1293 . struct internal_reloc *, bfd_boolean *));
1295 . bfd_boolean (*_bfd_coff_link_add_one_symbol)
1296 . PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword,
1297 . asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
1298 . struct bfd_link_hash_entry **));
1300 . bfd_boolean (*_bfd_coff_link_output_has_begun)
1301 . PARAMS ((bfd *, struct coff_final_link_info *));
1303 . bfd_boolean (*_bfd_coff_final_link_postscript)
1304 . PARAMS ((bfd *, struct coff_final_link_info *));
1306 .} bfd_coff_backend_data;
1308 .#define coff_backend_info(abfd) \
1309 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1311 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1312 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1314 .#define bfd_coff_swap_sym_in(a,e,i) \
1315 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1317 .#define bfd_coff_swap_lineno_in(a,e,i) \
1318 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1320 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1321 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1323 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1324 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1326 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1327 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1329 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1330 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1332 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1333 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1335 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1336 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1338 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1339 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1341 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1342 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1343 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1344 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1345 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1346 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1347 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1348 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1349 .#define bfd_coff_long_filenames(abfd) \
1350 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1351 .#define bfd_coff_long_section_names(abfd) \
1352 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1353 .#define bfd_coff_default_section_alignment_power(abfd) \
1354 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1355 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1356 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1358 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1359 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1361 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1362 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1364 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1365 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1367 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1368 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1370 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1371 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1372 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1373 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1374 . (abfd, filehdr, aouthdr))
1376 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1377 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1378 . (abfd, scnhdr, name, section, flags_ptr))
1380 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1381 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1383 .#define bfd_coff_slurp_symbol_table(abfd)\
1384 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1386 .#define bfd_coff_symname_in_debug(abfd, sym)\
1387 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1389 .#define bfd_coff_force_symnames_in_strings(abfd)\
1390 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1392 .#define bfd_coff_debug_string_prefix_length(abfd)\
1393 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1395 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1396 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1397 . (abfd, file, base, symbol, aux, indaux))
1399 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1400 . reloc, data, src_ptr, dst_ptr)\
1401 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1402 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1404 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1405 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1406 . (abfd, section, reloc, shrink, link_info))
1408 .#define bfd_coff_classify_symbol(abfd, sym)\
1409 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1412 .#define bfd_coff_compute_section_file_positions(abfd)\
1413 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1416 .#define bfd_coff_start_final_link(obfd, info)\
1417 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1419 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1420 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1421 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1422 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1423 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1424 . (abfd, sec, rel, h, sym, addendp))
1425 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1426 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1427 . (obfd, info, ibfd, sec, rel, adjustedp))
1428 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1429 . value, string, cp, coll, hashp)\
1430 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1431 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1433 .#define bfd_coff_link_output_has_begun(a,p) \
1434 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p))
1435 .#define bfd_coff_final_link_postscript(a,p) \
1436 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
1440 /* See whether the magic number matches. */
1443 coff_bad_format_hook (abfd
, filehdr
)
1444 bfd
* abfd ATTRIBUTE_UNUSED
;
1447 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1449 if (BADMAG (*internal_f
))
1452 /* If the optional header is NULL or not the correct size then
1453 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1454 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1455 optional header is of a different size.
1457 But the mips keeps extra stuff in it's opthdr, so dont check
1460 #if defined(M88) || defined(I960)
1461 if (internal_f
->f_opthdr
!= 0 && bfd_coff_aoutsz (abfd
) != internal_f
->f_opthdr
)
1470 ticoff0_bad_format_hook (abfd
, filehdr
)
1471 bfd
*abfd ATTRIBUTE_UNUSED
;
1474 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1476 if (COFF0_BADMAG (*internal_f
))
1485 ticoff1_bad_format_hook (abfd
, filehdr
)
1486 bfd
*abfd ATTRIBUTE_UNUSED
;
1489 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1491 if (COFF1_BADMAG (*internal_f
))
1498 /* Check whether this section uses an alignment other than the
1502 coff_set_custom_section_alignment (abfd
, section
, alignment_table
, table_size
)
1503 bfd
*abfd ATTRIBUTE_UNUSED
;
1505 const struct coff_section_alignment_entry
*alignment_table
;
1506 const unsigned int table_size
;
1508 const unsigned int default_alignment
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1511 for (i
= 0; i
< table_size
; ++i
)
1513 const char *secname
= bfd_get_section_name (abfd
, section
);
1515 if (alignment_table
[i
].comparison_length
== (unsigned int) -1
1516 ? strcmp (alignment_table
[i
].name
, secname
) == 0
1517 : strncmp (alignment_table
[i
].name
, secname
,
1518 alignment_table
[i
].comparison_length
) == 0)
1521 if (i
>= table_size
)
1524 if (alignment_table
[i
].default_alignment_min
!= COFF_ALIGNMENT_FIELD_EMPTY
1525 && default_alignment
< alignment_table
[i
].default_alignment_min
)
1528 if (alignment_table
[i
].default_alignment_max
!= COFF_ALIGNMENT_FIELD_EMPTY
1529 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1530 && default_alignment
> alignment_table
[i
].default_alignment_max
1535 section
->alignment_power
= alignment_table
[i
].alignment_power
;
1538 /* Custom section alignment records. */
1540 static const struct coff_section_alignment_entry
1541 coff_section_alignment_table
[] =
1543 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1544 COFF_SECTION_ALIGNMENT_ENTRIES
,
1546 /* There must not be any gaps between .stabstr sections. */
1547 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1548 1, COFF_ALIGNMENT_FIELD_EMPTY
, 0 },
1549 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1550 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1551 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1552 /* Similarly for the .ctors and .dtors sections. */
1553 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1554 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1555 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1556 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 }
1559 static const unsigned int coff_section_alignment_table_size
=
1560 sizeof coff_section_alignment_table
/ sizeof coff_section_alignment_table
[0];
1562 /* Initialize a section structure with information peculiar to this
1563 particular implementation of COFF. */
1566 coff_new_section_hook (abfd
, section
)
1570 combined_entry_type
*native
;
1573 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1576 if (bfd_xcoff_text_align_power (abfd
) != 0
1577 && strcmp (bfd_get_section_name (abfd
, section
), ".text") == 0)
1578 section
->alignment_power
= bfd_xcoff_text_align_power (abfd
);
1579 if (bfd_xcoff_data_align_power (abfd
) != 0
1580 && strcmp (bfd_get_section_name (abfd
, section
), ".data") == 0)
1581 section
->alignment_power
= bfd_xcoff_data_align_power (abfd
);
1584 /* Allocate aux records for section symbols, to store size and
1587 @@ The 10 is a guess at a plausible maximum number of aux entries
1588 (but shouldn't be a constant). */
1589 amt
= sizeof (combined_entry_type
) * 10;
1590 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
1594 /* We don't need to set up n_name, n_value, or n_scnum in the native
1595 symbol information, since they'll be overridden by the BFD symbol
1596 anyhow. However, we do need to set the type and storage class,
1597 in case this symbol winds up getting written out. The value 0
1598 for n_numaux is already correct. */
1600 native
->u
.syment
.n_type
= T_NULL
;
1601 native
->u
.syment
.n_sclass
= C_STAT
;
1603 coffsymbol (section
->symbol
)->native
= native
;
1605 coff_set_custom_section_alignment (abfd
, section
,
1606 coff_section_alignment_table
,
1607 coff_section_alignment_table_size
);
1612 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1614 /* Set the alignment of a BFD section. */
1616 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1619 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1620 bfd
* abfd ATTRIBUTE_UNUSED
;
1624 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1628 /* Extract ALIGN from 2**ALIGN stored in section header. */
1629 for (i
= 0; i
< 32; i
++)
1630 if ((1 << i
) >= hdr
->s_align
)
1634 /* TI tools puts the alignment power in bits 8-11. */
1635 i
= (hdr
->s_flags
>> 8) & 0xF ;
1637 #ifdef COFF_DECODE_ALIGNMENT
1638 i
= COFF_DECODE_ALIGNMENT(hdr
->s_flags
);
1640 section
->alignment_power
= i
;
1642 #ifdef coff_set_section_load_page
1643 coff_set_section_load_page (section
, hdr
->s_page
);
1647 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1650 /* A couple of macros to help setting the alignment power field. */
1651 #define ALIGN_SET(field,x,y) \
1652 if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1654 section->alignment_power = y;\
1657 #define ELIFALIGN_SET(field,x,y) \
1658 else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1660 section->alignment_power = y;\
1663 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1666 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1667 bfd
* abfd ATTRIBUTE_UNUSED
;
1671 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1674 ALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_64BYTES
, 6)
1675 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_32BYTES
, 5)
1676 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_16BYTES
, 4)
1677 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_8BYTES
, 3)
1678 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_4BYTES
, 2)
1679 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_2BYTES
, 1)
1680 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_1BYTES
, 0)
1682 /* In a PE image file, the s_paddr field holds the virtual size of a
1683 section, while the s_size field holds the raw size. We also keep
1684 the original section flag value, since not every bit can be
1685 mapped onto a generic BFD section bit. */
1686 if (coff_section_data (abfd
, section
) == NULL
)
1688 amt
= sizeof (struct coff_section_tdata
);
1689 section
->used_by_bfd
= (PTR
) bfd_zalloc (abfd
, amt
);
1690 if (section
->used_by_bfd
== NULL
)
1692 /* FIXME: Return error. */
1696 if (pei_section_data (abfd
, section
) == NULL
)
1698 amt
= sizeof (struct pei_section_tdata
);
1699 coff_section_data (abfd
, section
)->tdata
= (PTR
) bfd_zalloc (abfd
, amt
);
1700 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1702 /* FIXME: Return error. */
1706 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1707 pei_section_data (abfd
, section
)->pe_flags
= hdr
->s_flags
;
1709 section
->lma
= hdr
->s_vaddr
;
1711 /* Check for extended relocs. */
1712 if (hdr
->s_flags
& IMAGE_SCN_LNK_NRELOC_OVFL
)
1714 struct external_reloc dst
;
1715 struct internal_reloc n
;
1716 file_ptr oldpos
= bfd_tell (abfd
);
1717 bfd_size_type relsz
= bfd_coff_relsz (abfd
);
1719 bfd_seek (abfd
, (file_ptr
) hdr
->s_relptr
, 0);
1720 if (bfd_bread ((PTR
) &dst
, relsz
, abfd
) != relsz
)
1723 coff_swap_reloc_in (abfd
, &dst
, &n
);
1724 bfd_seek (abfd
, oldpos
, 0);
1725 section
->reloc_count
= hdr
->s_nreloc
= n
.r_vaddr
- 1;
1726 section
->rel_filepos
+= relsz
;
1728 else if (hdr
->s_nreloc
== 0xffff)
1729 (*_bfd_error_handler
)
1730 ("%s: warning: claims to have 0xffff relocs, without overflow",
1731 bfd_get_filename (abfd
));
1734 #undef ELIFALIGN_SET
1736 #else /* ! COFF_WITH_PE */
1739 /* We grossly abuse this function to handle XCOFF overflow headers.
1740 When we see one, we correct the reloc and line number counts in the
1741 real header, and remove the section we just created. */
1743 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1746 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1751 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1755 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1758 real_sec
= coff_section_from_bfd_index (abfd
, (int) hdr
->s_nreloc
);
1759 if (real_sec
== NULL
)
1762 real_sec
->reloc_count
= hdr
->s_paddr
;
1763 real_sec
->lineno_count
= hdr
->s_vaddr
;
1765 for (ps
= &abfd
->sections
; *ps
!= NULL
; ps
= &(*ps
)->next
)
1769 bfd_section_list_remove (abfd
, ps
);
1770 --abfd
->section_count
;
1776 #else /* ! RS6000COFF_C */
1778 #define coff_set_alignment_hook \
1779 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1781 #endif /* ! RS6000COFF_C */
1782 #endif /* ! COFF_WITH_PE */
1783 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1785 #ifndef coff_mkobject
1787 static bfd_boolean coff_mkobject
PARAMS ((bfd
*));
1790 coff_mkobject (abfd
)
1793 coff_data_type
*coff
;
1794 bfd_size_type amt
= sizeof (coff_data_type
);
1796 abfd
->tdata
.coff_obj_data
= (struct coff_tdata
*) bfd_zalloc (abfd
, amt
);
1797 if (abfd
->tdata
.coff_obj_data
== 0)
1799 coff
= coff_data (abfd
);
1800 coff
->symbols
= (coff_symbol_type
*) NULL
;
1801 coff
->conversion_table
= (unsigned int *) NULL
;
1802 coff
->raw_syments
= (struct coff_ptr_struct
*) NULL
;
1803 coff
->relocbase
= 0;
1804 coff
->local_toc_sym_map
= 0;
1806 /* make_abs_section(abfd);*/
1812 /* Create the COFF backend specific information. */
1814 #ifndef coff_mkobject_hook
1816 coff_mkobject_hook (abfd
, filehdr
, aouthdr
)
1819 PTR aouthdr ATTRIBUTE_UNUSED
;
1821 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1822 coff_data_type
*coff
;
1824 if (! coff_mkobject (abfd
))
1827 coff
= coff_data (abfd
);
1829 coff
->sym_filepos
= internal_f
->f_symptr
;
1831 /* These members communicate important constants about the symbol
1832 table to GDB's symbol-reading code. These `constants'
1833 unfortunately vary among coff implementations... */
1834 coff
->local_n_btmask
= N_BTMASK
;
1835 coff
->local_n_btshft
= N_BTSHFT
;
1836 coff
->local_n_tmask
= N_TMASK
;
1837 coff
->local_n_tshift
= N_TSHIFT
;
1838 coff
->local_symesz
= bfd_coff_symesz (abfd
);
1839 coff
->local_auxesz
= bfd_coff_auxesz (abfd
);
1840 coff
->local_linesz
= bfd_coff_linesz (abfd
);
1842 coff
->timestamp
= internal_f
->f_timdat
;
1844 obj_raw_syment_count (abfd
) =
1845 obj_conv_table_size (abfd
) =
1846 internal_f
->f_nsyms
;
1849 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
1850 abfd
->flags
|= DYNAMIC
;
1851 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= bfd_coff_aoutsz (abfd
))
1853 struct internal_aouthdr
*internal_a
=
1854 (struct internal_aouthdr
*) aouthdr
;
1855 struct xcoff_tdata
*xcoff
;
1857 xcoff
= xcoff_data (abfd
);
1858 # ifdef U803XTOCMAGIC
1859 xcoff
->xcoff64
= internal_f
->f_magic
== U803XTOCMAGIC
;
1863 xcoff
->full_aouthdr
= TRUE
;
1864 xcoff
->toc
= internal_a
->o_toc
;
1865 xcoff
->sntoc
= internal_a
->o_sntoc
;
1866 xcoff
->snentry
= internal_a
->o_snentry
;
1867 bfd_xcoff_text_align_power (abfd
) = internal_a
->o_algntext
;
1868 bfd_xcoff_data_align_power (abfd
) = internal_a
->o_algndata
;
1869 xcoff
->modtype
= internal_a
->o_modtype
;
1870 xcoff
->cputype
= internal_a
->o_cputype
;
1871 xcoff
->maxdata
= internal_a
->o_maxdata
;
1872 xcoff
->maxstack
= internal_a
->o_maxstack
;
1877 /* Set the flags field from the COFF header read in. */
1878 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
1883 /* FIXME: I'm not sure this is ever executed, since peicode.h
1884 defines coff_mkobject_hook. */
1885 if ((internal_f
->f_flags
& IMAGE_FILE_DEBUG_STRIPPED
) == 0)
1886 abfd
->flags
|= HAS_DEBUG
;
1893 /* Determine the machine architecture and type. FIXME: This is target
1894 dependent because the magic numbers are defined in the target
1895 dependent header files. But there is no particular need for this.
1896 If the magic numbers were moved to a separate file, this function
1897 would be target independent and would also be much more successful
1898 at linking together COFF files for different architectures. */
1901 coff_set_arch_mach_hook (abfd
, filehdr
)
1905 unsigned long machine
;
1906 enum bfd_architecture arch
;
1907 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1909 /* Zero selects the default machine for an arch. */
1911 switch (internal_f
->f_magic
)
1913 #ifdef OR32_MAGIC_BIG
1914 case OR32_MAGIC_BIG
:
1915 case OR32_MAGIC_LITTLE
:
1916 arch
= bfd_arch_or32
;
1921 arch
= bfd_arch_powerpc
;
1927 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler */
1928 case LYNXCOFFMAGIC
: /* shadows the m68k Lynx number below, sigh */
1929 arch
= bfd_arch_i386
;
1934 arch
= bfd_arch_ia64
;
1937 #ifdef A29K_MAGIC_BIG
1938 case A29K_MAGIC_BIG
:
1939 case A29K_MAGIC_LITTLE
:
1940 arch
= bfd_arch_a29k
;
1947 arch
= bfd_arch_arm
;
1948 machine
= bfd_arm_get_mach_from_notes (abfd
, ARM_NOTE_SECTION
);
1949 if (machine
== bfd_mach_arm_unknown
)
1951 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
1953 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
1954 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
1955 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
1957 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
1958 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
1959 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
1960 /* The COFF header does not have enough bits available
1961 to cover all the different ARM architectures. So
1962 we interpret F_ARM_5, the highest flag value to mean
1963 "the highest ARM architecture known to BFD" which is
1964 currently the XScale. */
1965 case F_ARM_5
: machine
= bfd_mach_arm_XScale
; break;
1973 #ifdef MC68KBCSMAGIC
1976 #ifdef APOLLOM68KMAGIC
1977 case APOLLOM68KMAGIC
:
1979 #ifdef LYNXCOFFMAGIC
1982 arch
= bfd_arch_m68k
;
1983 machine
= bfd_mach_m68020
;
1990 arch
= bfd_arch_m88k
;
1996 arch
= bfd_arch_z8k
;
1997 switch (internal_f
->f_flags
& F_MACHMASK
)
2000 machine
= bfd_mach_z8001
;
2003 machine
= bfd_mach_z8002
;
2012 arch
= bfd_arch_i860
;
2019 arch
= bfd_arch_i960
;
2020 switch (F_I960TYPE
& internal_f
->f_flags
)
2024 machine
= bfd_mach_i960_core
;
2027 machine
= bfd_mach_i960_kb_sb
;
2030 machine
= bfd_mach_i960_mc
;
2033 machine
= bfd_mach_i960_xa
;
2036 machine
= bfd_mach_i960_ca
;
2039 machine
= bfd_mach_i960_ka_sa
;
2042 machine
= bfd_mach_i960_jx
;
2045 machine
= bfd_mach_i960_hx
;
2064 if (xcoff_data (abfd
)->cputype
!= -1)
2065 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
2068 /* We did not get a value from the a.out header. If the
2069 file has not been stripped, we may be able to get the
2070 architecture information from the first symbol, if it
2071 is a .file symbol. */
2072 if (obj_raw_syment_count (abfd
) == 0)
2077 struct internal_syment sym
;
2078 bfd_size_type amt
= bfd_coff_symesz (abfd
);
2080 buf
= (bfd_byte
*) bfd_malloc (amt
);
2081 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
2082 || bfd_bread (buf
, amt
, abfd
) != amt
)
2087 bfd_coff_swap_sym_in (abfd
, (PTR
) buf
, (PTR
) &sym
);
2088 if (sym
.n_sclass
== C_FILE
)
2089 cputype
= sym
.n_type
& 0xff;
2096 /* FIXME: We don't handle all cases here. */
2101 arch
= bfd_xcoff_architecture (abfd
);
2102 machine
= bfd_xcoff_machine (abfd
);
2106 arch
= bfd_arch_powerpc
;
2107 machine
= bfd_mach_ppc_601
;
2109 case 2: /* 64 bit PowerPC */
2110 arch
= bfd_arch_powerpc
;
2111 machine
= bfd_mach_ppc_620
;
2114 arch
= bfd_arch_powerpc
;
2115 machine
= bfd_mach_ppc
;
2118 arch
= bfd_arch_rs6000
;
2119 machine
= bfd_mach_rs6k
;
2128 arch
= bfd_arch_we32k
;
2134 arch
= bfd_arch_h8300
;
2135 machine
= bfd_mach_h8300
;
2136 /* !! FIXME this probably isn't the right place for this. */
2137 abfd
->flags
|= BFD_IS_RELAXABLE
;
2143 arch
= bfd_arch_h8300
;
2144 machine
= bfd_mach_h8300h
;
2145 /* !! FIXME this probably isn't the right place for this. */
2146 abfd
->flags
|= BFD_IS_RELAXABLE
;
2152 arch
= bfd_arch_h8300
;
2153 machine
= bfd_mach_h8300s
;
2154 /* !! FIXME this probably isn't the right place for this. */
2155 abfd
->flags
|= BFD_IS_RELAXABLE
;
2161 arch
= bfd_arch_h8300
;
2162 machine
= bfd_mach_h8300hn
;
2163 /* !! FIXME this probably isn't the right place for this. */
2164 abfd
->flags
|= BFD_IS_RELAXABLE
;
2170 arch
= bfd_arch_h8300
;
2171 machine
= bfd_mach_h8300sn
;
2172 /* !! FIXME this probably isn't the right place for this. */
2173 abfd
->flags
|= BFD_IS_RELAXABLE
;
2177 #ifdef SH_ARCH_MAGIC_BIG
2178 case SH_ARCH_MAGIC_BIG
:
2179 case SH_ARCH_MAGIC_LITTLE
:
2181 case SH_ARCH_MAGIC_WINCE
:
2187 #ifdef MIPS_ARCH_MAGIC_WINCE
2188 case MIPS_ARCH_MAGIC_WINCE
:
2189 arch
= bfd_arch_mips
;
2195 arch
= bfd_arch_h8500
;
2201 #ifdef LYNXCOFFMAGIC
2204 arch
= bfd_arch_sparc
;
2210 arch
= bfd_arch_tic30
;
2215 #ifdef TICOFF_TARGET_ARCH
2216 /* This TI COFF section should be used by all new TI COFF v0 targets. */
2218 arch
= TICOFF_TARGET_ARCH
;
2219 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2225 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */
2226 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */
2229 switch (internal_f
->f_target_id
)
2233 arch
= TICOFF_TARGET_ARCH
;
2234 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2238 arch
= bfd_arch_obscure
;
2239 (*_bfd_error_handler
)
2240 (_("Unrecognized TI COFF target id '0x%x'"),
2241 internal_f
->f_target_id
);
2247 #ifdef TIC80_ARCH_MAGIC
2248 case TIC80_ARCH_MAGIC
:
2249 arch
= bfd_arch_tic80
;
2255 arch
= bfd_arch_mcore
;
2261 arch
= bfd_arch_w65
;
2265 default: /* Unreadable input file type. */
2266 arch
= bfd_arch_obscure
;
2270 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2274 #ifdef SYMNAME_IN_DEBUG
2276 static bfd_boolean symname_in_debug_hook
2277 PARAMS ((bfd
*, struct internal_syment
*));
2280 symname_in_debug_hook (abfd
, sym
)
2281 bfd
* abfd ATTRIBUTE_UNUSED
;
2282 struct internal_syment
*sym
;
2284 return SYMNAME_IN_DEBUG (sym
) != 0;
2289 #define symname_in_debug_hook \
2290 (bfd_boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
2297 #define FORCE_SYMNAMES_IN_STRINGS
2300 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
2302 static bfd_boolean coff_pointerize_aux_hook
2303 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
2304 unsigned int, combined_entry_type
*));
2307 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
2308 bfd
*abfd ATTRIBUTE_UNUSED
;
2309 combined_entry_type
*table_base
;
2310 combined_entry_type
*symbol
;
2311 unsigned int indaux
;
2312 combined_entry_type
*aux
;
2314 int class = symbol
->u
.syment
.n_sclass
;
2316 if ((class == C_EXT
|| class == C_HIDEXT
)
2317 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2319 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2321 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2322 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2323 aux
->fix_scnlen
= 1;
2326 /* Return TRUE to indicate that the caller should not do any
2327 further work on this auxent. */
2331 /* Return FALSE to indicate that this auxent should be handled by
2339 /* We don't want to pointerize bal entries. */
2341 static bfd_boolean coff_pointerize_aux_hook
2342 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
2343 unsigned int, combined_entry_type
*));
2346 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
2347 bfd
*abfd ATTRIBUTE_UNUSED
;
2348 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
2349 combined_entry_type
*symbol
;
2350 unsigned int indaux
;
2351 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
2353 /* Return TRUE if we don't want to pointerize this aux entry, which
2354 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2356 && (symbol
->u
.syment
.n_sclass
== C_LEAFPROC
2357 || symbol
->u
.syment
.n_sclass
== C_LEAFSTAT
2358 || symbol
->u
.syment
.n_sclass
== C_LEAFEXT
));
2363 #define coff_pointerize_aux_hook 0
2366 #endif /* ! RS6000COFF_C */
2368 /* Print an aux entry. This returns TRUE if it has printed it. */
2370 static bfd_boolean coff_print_aux
2371 PARAMS ((bfd
*, FILE *, combined_entry_type
*, combined_entry_type
*,
2372 combined_entry_type
*, unsigned int));
2375 coff_print_aux (abfd
, file
, table_base
, symbol
, aux
, indaux
)
2376 bfd
*abfd ATTRIBUTE_UNUSED
;
2377 FILE *file ATTRIBUTE_UNUSED
;
2378 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
2379 combined_entry_type
*symbol ATTRIBUTE_UNUSED
;
2380 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
2381 unsigned int indaux ATTRIBUTE_UNUSED
;
2384 if ((symbol
->u
.syment
.n_sclass
== C_EXT
2385 || symbol
->u
.syment
.n_sclass
== C_HIDEXT
)
2386 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2388 /* This is a csect entry. */
2389 fprintf (file
, "AUX ");
2390 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2392 BFD_ASSERT (! aux
->fix_scnlen
);
2394 fprintf (file
, "val %5lld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2396 fprintf (file
, "val %5ld", (long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2401 fprintf (file
, "indx ");
2402 if (! aux
->fix_scnlen
)
2404 fprintf (file
, "%4lld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2406 fprintf (file
, "%4ld", (long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2409 fprintf (file
, "%4ld",
2410 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2413 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2414 aux
->u
.auxent
.x_csect
.x_parmhash
,
2415 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2416 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2417 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2418 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2419 aux
->u
.auxent
.x_csect
.x_stab
,
2420 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2425 /* Return FALSE to indicate that no special action was taken. */
2433 To write relocations, the back end steps though the
2434 canonical relocation table and create an
2435 @code{internal_reloc}. The symbol index to use is removed from
2436 the @code{offset} field in the symbol table supplied. The
2437 address comes directly from the sum of the section base
2438 address and the relocation offset; the type is dug directly
2439 from the howto field. Then the @code{internal_reloc} is
2440 swapped into the shape of an @code{external_reloc} and written
2447 static int compare_arelent_ptr
PARAMS ((const PTR
, const PTR
));
2449 /* AUX's ld wants relocations to be sorted. */
2451 compare_arelent_ptr (x
, y
)
2455 const arelent
**a
= (const arelent
**) x
;
2456 const arelent
**b
= (const arelent
**) y
;
2457 bfd_size_type aadr
= (*a
)->address
;
2458 bfd_size_type badr
= (*b
)->address
;
2460 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2463 #endif /* TARG_AUX */
2466 coff_write_relocs (abfd
, first_undef
)
2472 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
2475 struct external_reloc dst
;
2482 /* Sort relocations before we write them out. */
2485 amt
= s
->reloc_count
;
2486 amt
*= sizeof (arelent
*);
2487 p
= (arelent
**) bfd_malloc (amt
);
2488 if (p
== NULL
&& s
->reloc_count
> 0)
2490 memcpy (p
, s
->orelocation
, (size_t) amt
);
2491 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2495 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2499 if (obj_pe (abfd
) && s
->reloc_count
>= 0xffff)
2501 /* Encode real count here as first reloc. */
2502 struct internal_reloc n
;
2504 memset ((PTR
) & n
, 0, sizeof (n
));
2505 /* Add one to count *this* reloc (grr). */
2506 n
.r_vaddr
= s
->reloc_count
+ 1;
2507 coff_swap_reloc_out (abfd
, &n
, &dst
);
2508 if (bfd_bwrite ((PTR
) & dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2509 abfd
) != bfd_coff_relsz (abfd
))
2514 for (i
= 0; i
< s
->reloc_count
; i
++)
2516 struct internal_reloc n
;
2519 memset ((PTR
) & n
, 0, sizeof (n
));
2521 /* Now we've renumbered the symbols we know where the
2522 undefined symbols live in the table. Check the reloc
2523 entries for symbols who's output bfd isn't the right one.
2524 This is because the symbol was undefined (which means
2525 that all the pointers are never made to point to the same
2526 place). This is a bad thing,'cause the symbols attached
2527 to the output bfd are indexed, so that the relocation
2528 entries know which symbol index they point to. So we
2529 have to look up the output symbol here. */
2531 if (q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2534 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2535 asymbol
**outsyms
= abfd
->outsymbols
;
2537 for (j
= first_undef
; outsyms
[j
]; j
++)
2539 const char *intable
= outsyms
[j
]->name
;
2541 if (strcmp (intable
, sname
) == 0) {
2542 /* Got a hit, so repoint the reloc. */
2543 q
->sym_ptr_ptr
= outsyms
+ j
;
2549 n
.r_vaddr
= q
->address
+ s
->vma
;
2552 /* The 29k const/consth reloc pair is a real kludge. The consth
2553 part doesn't have a symbol; it has an offset. So rebuilt
2555 if (q
->howto
->type
== R_IHCONST
)
2556 n
.r_symndx
= q
->addend
;
2561 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2562 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
,s
))
2564 if ((*q
->sym_ptr_ptr
)->section
== bfd_abs_section_ptr
2565 && ((*q
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) != 0)
2567 /* This is a relocation relative to the absolute symbol. */
2571 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2572 /* Take notice if the symbol reloc points to a symbol
2573 we don't have in our symbol table. What should we
2575 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2580 #ifdef SWAP_OUT_RELOC_OFFSET
2581 n
.r_offset
= q
->addend
;
2585 /* Work out reloc type from what is required. */
2586 SELECT_RELOC (n
, q
->howto
);
2588 n
.r_type
= q
->howto
->type
;
2590 coff_swap_reloc_out (abfd
, &n
, &dst
);
2592 if (bfd_bwrite ((PTR
) & dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2593 abfd
) != bfd_coff_relsz (abfd
))
2606 /* Set flags and magic number of a coff file from architecture and machine
2607 type. Result is TRUE if we can represent the arch&type, FALSE if not. */
2610 coff_set_flags (abfd
, magicp
, flagsp
)
2612 unsigned int *magicp ATTRIBUTE_UNUSED
;
2613 unsigned short *flagsp ATTRIBUTE_UNUSED
;
2615 switch (bfd_get_arch (abfd
))
2620 switch (bfd_get_mach (abfd
))
2622 case bfd_mach_z8001
:
2625 case bfd_mach_z8002
:
2639 *magicp
= I960ROMAGIC
;
2641 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2642 I960RWMAGIC); FIXME???
2644 switch (bfd_get_mach (abfd
))
2646 case bfd_mach_i960_core
:
2649 case bfd_mach_i960_kb_sb
:
2652 case bfd_mach_i960_mc
:
2655 case bfd_mach_i960_xa
:
2658 case bfd_mach_i960_ca
:
2661 case bfd_mach_i960_ka_sa
:
2664 case bfd_mach_i960_jx
:
2667 case bfd_mach_i960_hx
:
2680 case bfd_arch_tic30
:
2681 *magicp
= TIC30MAGIC
;
2685 #ifdef TICOFF_DEFAULT_MAGIC
2686 case TICOFF_TARGET_ARCH
:
2687 /* If there's no indication of which version we want, use the default. */
2689 *magicp
= TICOFF_DEFAULT_MAGIC
;
2692 /* We may want to output in a different COFF version. */
2693 switch (abfd
->xvec
->name
[4])
2696 *magicp
= TICOFF0MAGIC
;
2699 *magicp
= TICOFF1MAGIC
;
2702 *magicp
= TICOFF2MAGIC
;
2708 TICOFF_TARGET_MACHINE_SET (flagsp
, bfd_get_mach (abfd
));
2712 #ifdef TIC80_ARCH_MAGIC
2713 case bfd_arch_tic80
:
2714 *magicp
= TIC80_ARCH_MAGIC
;
2720 * magicp
= ARMPEMAGIC
;
2722 * magicp
= ARMMAGIC
;
2725 if (APCS_SET (abfd
))
2727 if (APCS_26_FLAG (abfd
))
2728 * flagsp
|= F_APCS26
;
2730 if (APCS_FLOAT_FLAG (abfd
))
2731 * flagsp
|= F_APCS_FLOAT
;
2733 if (PIC_FLAG (abfd
))
2736 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2737 * flagsp
|= F_INTERWORK
;
2738 switch (bfd_get_mach (abfd
))
2740 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2741 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2742 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2743 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2744 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2745 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2746 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2747 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2748 See also the comment in coff_set_arch_mach_hook(). */
2749 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break;
2750 case bfd_mach_arm_5TE
: * flagsp
|= F_ARM_5
; break;
2751 case bfd_mach_arm_XScale
: * flagsp
|= F_ARM_5
; break;
2756 case bfd_arch_powerpc
:
2763 *magicp
= I386MAGIC
;
2765 /* Just overwrite the usual value if we're doing Lynx. */
2766 *magicp
= LYNXCOFFMAGIC
;
2773 *magicp
= I860MAGIC
;
2779 *magicp
= IA64MAGIC
;
2785 #ifdef APOLLOM68KMAGIC
2786 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
2788 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2789 #ifdef NAMES_HAVE_UNDERSCORE
2790 *magicp
= MC68KBCSMAGIC
;
2792 *magicp
= MC68MAGIC
;
2796 /* Just overwrite the usual value if we're doing Lynx. */
2797 *magicp
= LYNXCOFFMAGIC
;
2805 *magicp
= MC88OMAGIC
;
2810 case bfd_arch_h8300
:
2811 switch (bfd_get_mach (abfd
))
2813 case bfd_mach_h8300
:
2814 *magicp
= H8300MAGIC
;
2816 case bfd_mach_h8300h
:
2817 *magicp
= H8300HMAGIC
;
2819 case bfd_mach_h8300s
:
2820 *magicp
= H8300SMAGIC
;
2822 case bfd_mach_h8300hn
:
2823 *magicp
= H8300HNMAGIC
;
2825 case bfd_mach_h8300sn
:
2826 *magicp
= H8300SNMAGIC
;
2832 #ifdef SH_ARCH_MAGIC_BIG
2834 #ifdef COFF_IMAGE_WITH_PE
2835 *magicp
= SH_ARCH_MAGIC_WINCE
;
2837 if (bfd_big_endian (abfd
))
2838 *magicp
= SH_ARCH_MAGIC_BIG
;
2840 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2846 #ifdef MIPS_ARCH_MAGIC_WINCE
2848 *magicp
= MIPS_ARCH_MAGIC_WINCE
;
2854 case bfd_arch_sparc
:
2855 *magicp
= SPARCMAGIC
;
2857 /* Just overwrite the usual value if we're doing Lynx. */
2858 *magicp
= LYNXCOFFMAGIC
;
2865 case bfd_arch_h8500
:
2866 *magicp
= H8500MAGIC
;
2870 #ifdef A29K_MAGIC_BIG
2872 if (bfd_big_endian (abfd
))
2873 *magicp
= A29K_MAGIC_BIG
;
2875 *magicp
= A29K_MAGIC_LITTLE
;
2881 case bfd_arch_we32k
:
2882 *magicp
= WE32KMAGIC
;
2888 case bfd_arch_rs6000
:
2890 case bfd_arch_powerpc
:
2892 BFD_ASSERT (bfd_get_flavour (abfd
) == bfd_target_xcoff_flavour
);
2893 *magicp
= bfd_xcoff_magic_number (abfd
);
2899 case bfd_arch_mcore
:
2900 * magicp
= MCOREMAGIC
;
2910 #ifdef OR32_MAGIC_BIG
2912 if (bfd_big_endian (abfd
))
2913 * magicp
= OR32_MAGIC_BIG
;
2915 * magicp
= OR32_MAGIC_LITTLE
;
2919 default: /* Unknown architecture. */
2920 /* Fall through to "return FALSE" below, to avoid
2921 "statement never reached" errors on the one below. */
2929 coff_set_arch_mach (abfd
, arch
, machine
)
2931 enum bfd_architecture arch
;
2932 unsigned long machine
;
2935 unsigned short dummy2
;
2937 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
2940 if (arch
!= bfd_arch_unknown
2941 && ! coff_set_flags (abfd
, &dummy1
, &dummy2
))
2942 return FALSE
; /* We can't represent this type */
2944 return TRUE
; /* We're easy ... */
2947 #ifdef COFF_IMAGE_WITH_PE
2949 /* This is used to sort sections by VMA, as required by PE image
2952 static int sort_by_secaddr
PARAMS ((const PTR
, const PTR
));
2955 sort_by_secaddr (arg1
, arg2
)
2959 const asection
*a
= *(const asection
**) arg1
;
2960 const asection
*b
= *(const asection
**) arg2
;
2962 if (a
->vma
< b
->vma
)
2964 else if (a
->vma
> b
->vma
)
2970 #endif /* COFF_IMAGE_WITH_PE */
2972 /* Calculate the file position for each section. */
2975 #define ALIGN_SECTIONS_IN_FILE
2977 #if defined(TIC80COFF) || defined(TICOFF)
2978 #undef ALIGN_SECTIONS_IN_FILE
2982 coff_compute_section_file_positions (abfd
)
2986 asection
*previous
= (asection
*) NULL
;
2987 file_ptr sofar
= bfd_coff_filhsz (abfd
);
2988 bfd_boolean align_adjust
;
2989 #ifdef ALIGN_SECTIONS_IN_FILE
2994 /* On XCOFF, if we have symbols, set up the .debug section. */
2995 if (bfd_get_symcount (abfd
) > 0)
2998 bfd_size_type i
, symcount
;
3002 symcount
= bfd_get_symcount (abfd
);
3003 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
3005 coff_symbol_type
*cf
;
3007 cf
= coff_symbol_from (abfd
, *symp
);
3009 && cf
->native
!= NULL
3010 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
3014 len
= strlen (bfd_asymbol_name (*symp
));
3015 if (len
> SYMNMLEN
|| bfd_coff_force_symnames_in_strings (abfd
))
3016 sz
+= len
+ 1 + bfd_coff_debug_string_prefix_length (abfd
);
3023 dsec
= bfd_make_section_old_way (abfd
, DOT_DEBUG
);
3027 dsec
->flags
|= SEC_HAS_CONTENTS
;
3032 #ifdef COFF_IMAGE_WITH_PE
3034 if (coff_data (abfd
)->link_info
)
3036 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
3038 /* If no file alignment has been set, default to one.
3039 This repairs 'ld -r' for arm-wince-pe target. */
3044 page_size
= PE_DEF_FILE_ALIGNMENT
;
3046 #ifdef COFF_PAGE_SIZE
3047 int page_size
= COFF_PAGE_SIZE
;
3051 if (bfd_get_start_address (abfd
))
3053 /* A start address may have been added to the original file. In this
3054 case it will need an optional header to record it. */
3055 abfd
->flags
|= EXEC_P
;
3058 if (abfd
->flags
& EXEC_P
)
3059 sofar
+= bfd_coff_aoutsz (abfd
);
3061 else if (xcoff_data (abfd
)->full_aouthdr
)
3062 sofar
+= bfd_coff_aoutsz (abfd
);
3064 sofar
+= SMALL_AOUTSZ
;
3067 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
3070 /* XCOFF handles overflows in the reloc and line number count fields
3071 by allocating a new section header to hold the correct counts. */
3072 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3073 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3074 sofar
+= bfd_coff_scnhsz (abfd
);
3077 #ifdef COFF_IMAGE_WITH_PE
3079 /* PE requires the sections to be in memory order when listed in
3080 the section headers. It also does not like empty loadable
3081 sections. The sections apparently do not have to be in the
3082 right order in the image file itself, but we do need to get the
3083 target_index values right. */
3086 asection
**section_list
;
3092 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3095 /* We allocate an extra cell to simplify the final loop. */
3096 amt
= sizeof (struct asection
*) * (count
+ 1);
3097 section_list
= bfd_malloc (amt
);
3098 if (section_list
== NULL
)
3102 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3104 section_list
[i
] = current
;
3107 section_list
[i
] = NULL
;
3109 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
3111 /* Rethread the linked list into sorted order; at the same time,
3112 assign target_index values. */
3114 abfd
->sections
= section_list
[0];
3115 for (i
= 0; i
< count
; i
++)
3117 current
= section_list
[i
];
3118 current
->next
= section_list
[i
+ 1];
3120 /* Later, if the section has zero size, we'll be throwing it
3121 away, so we don't want to number it now. Note that having
3122 a zero size and having real contents are different
3123 concepts: .bss has no contents, but (usually) non-zero
3125 if (current
->size
== 0)
3127 /* Discard. However, it still might have (valid) symbols
3128 in it, so arbitrarily set it to section 1 (indexing is
3129 1-based here; usually .text). __end__ and other
3130 contents of .endsection really have this happen.
3131 FIXME: This seems somewhat dubious. */
3132 current
->target_index
= 1;
3135 current
->target_index
= target_index
++;
3137 abfd
->section_tail
= ¤t
->next
;
3139 free (section_list
);
3141 #else /* ! COFF_IMAGE_WITH_PE */
3143 /* Set the target_index field. */
3147 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3148 current
->target_index
= target_index
++;
3150 #endif /* ! COFF_IMAGE_WITH_PE */
3152 align_adjust
= FALSE
;
3153 for (current
= abfd
->sections
;
3154 current
!= (asection
*) NULL
;
3155 current
= current
->next
)
3157 #ifdef COFF_IMAGE_WITH_PE
3158 /* With PE we have to pad each section to be a multiple of its
3159 page size too, and remember both sizes. */
3160 if (coff_section_data (abfd
, current
) == NULL
)
3162 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
3163 current
->used_by_bfd
= (PTR
) bfd_zalloc (abfd
, amt
);
3164 if (current
->used_by_bfd
== NULL
)
3167 if (pei_section_data (abfd
, current
) == NULL
)
3169 bfd_size_type amt
= sizeof (struct pei_section_tdata
);
3170 coff_section_data (abfd
, current
)->tdata
3171 = (PTR
) bfd_zalloc (abfd
, amt
);
3172 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
3175 if (pei_section_data (abfd
, current
)->virt_size
== 0)
3176 pei_section_data (abfd
, current
)->virt_size
= current
->size
;
3179 /* Only deal with sections which have contents. */
3180 if (!(current
->flags
& SEC_HAS_CONTENTS
))
3183 #ifdef COFF_IMAGE_WITH_PE
3184 /* Make sure we skip empty sections in a PE image. */
3185 if (current
->size
== 0)
3189 /* Align the sections in the file to the same boundary on
3190 which they are aligned in virtual memory. I960 doesn't
3191 do this (FIXME) so we can stay in sync with Intel. 960
3192 doesn't yet page from files... */
3193 #ifdef ALIGN_SECTIONS_IN_FILE
3194 if ((abfd
->flags
& EXEC_P
) != 0)
3196 /* Make sure this section is aligned on the right boundary - by
3197 padding the previous section up if necessary. */
3201 /* AIX loader checks the text section alignment of (vma - filepos)
3202 So even though the filepos may be aligned wrt the o_algntext, for
3203 AIX executables, this check fails. This shows up when a native
3204 AIX executable is stripped with gnu strip because the default vma
3205 of native is 0x10000150 but default for gnu is 0x10000140. Gnu
3206 stripped gnu excutable passes this check because the filepos is
3207 0x0140. This problem also show up with 64 bit shared objects. The
3208 data section must also be aligned. */
3209 if (!strcmp (current
->name
, _TEXT
)
3210 || !strcmp (current
->name
, _DATA
))
3215 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3217 align
= 1 << current
->alignment_power
;
3218 pad
= abs (current
->vma
- sofar
) % align
;
3229 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3232 if (previous
!= (asection
*) NULL
)
3233 previous
->size
+= sofar
- old_sofar
;
3238 /* In demand paged files the low order bits of the file offset
3239 must match the low order bits of the virtual address. */
3240 #ifdef COFF_PAGE_SIZE
3241 if ((abfd
->flags
& D_PAGED
) != 0
3242 && (current
->flags
& SEC_ALLOC
) != 0)
3243 sofar
+= (current
->vma
- sofar
) % page_size
;
3245 current
->filepos
= sofar
;
3247 #ifdef COFF_IMAGE_WITH_PE
3248 /* Set the padded size. */
3249 current
->size
= (current
->size
+ page_size
-1) & -page_size
;
3252 sofar
+= current
->size
;
3254 #ifdef ALIGN_SECTIONS_IN_FILE
3255 /* Make sure that this section is of the right size too. */
3256 if ((abfd
->flags
& EXEC_P
) == 0)
3258 bfd_size_type old_size
;
3260 old_size
= current
->size
;
3261 current
->size
= BFD_ALIGN (current
->size
,
3262 1 << current
->alignment_power
);
3263 align_adjust
= current
->size
!= old_size
;
3264 sofar
+= current
->size
- old_size
;
3269 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3270 align_adjust
= sofar
!= old_sofar
;
3271 current
->size
+= sofar
- old_sofar
;
3275 #ifdef COFF_IMAGE_WITH_PE
3276 /* For PE we need to make sure we pad out to the aligned
3277 size, in case the caller only writes out data to the
3279 if (pei_section_data (abfd
, current
)->virt_size
< current
->size
)
3280 align_adjust
= TRUE
;
3284 /* Force .lib sections to start at zero. The vma is then
3285 incremented in coff_set_section_contents. This is right for
3287 if (strcmp (current
->name
, _LIB
) == 0)
3288 bfd_set_section_vma (abfd
, current
, 0);
3294 /* It is now safe to write to the output file. If we needed an
3295 alignment adjustment for the last section, then make sure that
3296 there is a byte at offset sofar. If there are no symbols and no
3297 relocs, then nothing follows the last section. If we don't force
3298 the last byte out, then the file may appear to be truncated. */
3304 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
3305 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3309 /* Make sure the relocations are aligned. We don't need to make
3310 sure that this byte exists, because it will only matter if there
3311 really are relocs. */
3312 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
3314 obj_relocbase (abfd
) = sofar
;
3315 abfd
->output_has_begun
= TRUE
;
3322 /* This can never work, because it is called too late--after the
3323 section positions have been set. I can't figure out what it is
3324 for, so I am going to disable it--Ian Taylor 20 March 1996. */
3326 /* If .file, .text, .data, .bss symbols are missing, add them. */
3327 /* @@ Should we only be adding missing symbols, or overriding the aux
3328 values for existing section symbols? */
3330 coff_add_missing_symbols (abfd
)
3333 unsigned int nsyms
= bfd_get_symcount (abfd
);
3334 asymbol
**sympp
= abfd
->outsymbols
;
3337 int need_text
= 1, need_data
= 1, need_bss
= 1, need_file
= 1;
3340 for (i
= 0; i
< nsyms
; i
++)
3342 coff_symbol_type
*csym
= coff_symbol_from (abfd
, sympp
[i
]);
3347 /* Only do this if there is a coff representation of the input
3349 if (csym
->native
&& csym
->native
->u
.syment
.n_sclass
== C_FILE
)
3354 name
= csym
->symbol
.name
;
3357 if (!strcmp (name
, _TEXT
))
3360 else if (!strcmp (name
, ".wtext"))
3363 else if (!strcmp (name
, _DATA
))
3365 else if (!strcmp (name
, _BSS
))
3369 /* Now i == bfd_get_symcount (abfd). */
3370 /* @@ For now, don't deal with .file symbol. */
3373 if (!need_text
&& !need_data
&& !need_bss
&& !need_file
)
3375 nsyms
+= need_text
+ need_data
+ need_bss
+ need_file
;
3377 amt
*= sizeof (asymbol
*);
3378 sympp2
= (asymbol
**) bfd_alloc (abfd
, amt
);
3381 memcpy (sympp2
, sympp
, i
* sizeof (asymbol
*));
3384 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
3388 sympp2
[i
++] = coff_section_symbol (abfd
, _TEXT
);
3390 sympp2
[i
++] = coff_section_symbol (abfd
, _DATA
);
3392 sympp2
[i
++] = coff_section_symbol (abfd
, _BSS
);
3393 BFD_ASSERT (i
== nsyms
);
3394 bfd_set_symtab (abfd
, sympp2
, nsyms
);
3400 #ifdef COFF_IMAGE_WITH_PE
3402 static unsigned int pelength
;
3403 static unsigned int peheader
;
3406 coff_read_word (abfd
, value
)
3408 unsigned int *value
;
3413 status
= bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3421 *value
= (unsigned int) b
[0];
3423 *value
= (unsigned int) (b
[0] + (b
[1] << 8));
3425 pelength
+= (unsigned int) status
;
3431 coff_compute_checksum (abfd
)
3434 bfd_boolean more_data
;
3441 filepos
= (file_ptr
) 0;
3445 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
3448 more_data
= coff_read_word (abfd
, &value
);
3450 total
= 0xffff & (total
+ (total
>> 0x10));
3455 return (0xffff & (total
+ (total
>> 0x10)));
3459 coff_apply_checksum (abfd
)
3462 unsigned int computed
;
3463 unsigned int checksum
= 0;
3465 if (bfd_seek (abfd
, 0x3c, SEEK_SET
) != 0)
3468 if (!coff_read_word (abfd
, &peheader
))
3471 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3475 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3477 if (bfd_seek (abfd
, peheader
, SEEK_SET
) != 0)
3480 computed
= coff_compute_checksum (abfd
);
3482 checksum
= computed
+ pelength
;
3484 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3487 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3492 #endif /* COFF_IMAGE_WITH_PE */
3497 coff_write_object_contents (abfd
)
3501 bfd_boolean hasrelocs
= FALSE
;
3502 bfd_boolean haslinno
= FALSE
;
3503 bfd_boolean hasdebug
= FALSE
;
3505 file_ptr reloc_base
;
3506 file_ptr lineno_base
;
3508 unsigned long reloc_size
= 0, reloc_count
= 0;
3509 unsigned long lnno_size
= 0;
3510 bfd_boolean long_section_names
;
3511 asection
*text_sec
= NULL
;
3512 asection
*data_sec
= NULL
;
3513 asection
*bss_sec
= NULL
;
3514 struct internal_filehdr internal_f
;
3515 struct internal_aouthdr internal_a
;
3516 #ifdef COFF_LONG_SECTION_NAMES
3517 size_t string_size
= STRING_SIZE_SIZE
;
3520 bfd_set_error (bfd_error_system_call
);
3522 /* Make a pass through the symbol table to count line number entries and
3523 put them into the correct asections. */
3525 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3527 if (! abfd
->output_has_begun
)
3529 if (! coff_compute_section_file_positions (abfd
))
3533 reloc_base
= obj_relocbase (abfd
);
3535 /* Work out the size of the reloc and linno areas. */
3537 for (current
= abfd
->sections
; current
!= NULL
; current
=
3541 /* We store the actual reloc count in the first reloc's addr. */
3542 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3545 reloc_count
+= current
->reloc_count
;
3548 reloc_size
= reloc_count
* bfd_coff_relsz (abfd
);
3550 lineno_base
= reloc_base
+ reloc_size
;
3551 sym_base
= lineno_base
+ lnno_size
;
3553 /* Indicate in each section->line_filepos its actual file address. */
3554 for (current
= abfd
->sections
; current
!= NULL
; current
=
3557 if (current
->lineno_count
)
3559 current
->line_filepos
= lineno_base
;
3560 current
->moving_line_filepos
= lineno_base
;
3561 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3565 current
->line_filepos
= 0;
3567 if (current
->reloc_count
)
3569 current
->rel_filepos
= reloc_base
;
3570 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3572 /* Extra reloc to hold real count. */
3573 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3574 reloc_base
+= bfd_coff_relsz (abfd
);
3579 current
->rel_filepos
= 0;
3583 /* Write section headers to the file. */
3584 internal_f
.f_nscns
= 0;
3586 if ((abfd
->flags
& EXEC_P
) != 0)
3587 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3590 scn_base
= bfd_coff_filhsz (abfd
);
3593 if (xcoff_data (abfd
)->full_aouthdr
)
3594 scn_base
+= bfd_coff_aoutsz (abfd
);
3596 scn_base
+= SMALL_AOUTSZ
;
3601 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3604 long_section_names
= FALSE
;
3605 for (current
= abfd
->sections
;
3607 current
= current
->next
)
3609 struct internal_scnhdr section
;
3610 bfd_boolean is_reloc_section
= FALSE
;
3612 #ifdef COFF_IMAGE_WITH_PE
3613 if (strcmp (current
->name
, ".reloc") == 0)
3615 is_reloc_section
= TRUE
;
3617 pe_data (abfd
)->has_reloc_section
= 1;
3621 internal_f
.f_nscns
++;
3623 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3625 #ifdef COFF_LONG_SECTION_NAMES
3626 /* Handle long section names as in PE. This must be compatible
3627 with the code in coff_write_symbols and _bfd_coff_final_link. */
3631 len
= strlen (current
->name
);
3634 memset (section
.s_name
, 0, SCNNMLEN
);
3635 sprintf (section
.s_name
, "/%lu", (unsigned long) string_size
);
3636 string_size
+= len
+ 1;
3637 long_section_names
= TRUE
;
3643 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3644 Ian Taylor <ian@cygnus.com>. */
3645 if (strcmp (current
->name
, _LIB
) == 0)
3646 section
.s_vaddr
= 0;
3649 section
.s_vaddr
= current
->vma
;
3650 section
.s_paddr
= current
->lma
;
3651 section
.s_size
= current
->size
;
3652 #ifdef coff_get_section_load_page
3653 section
.s_page
= coff_get_section_load_page (current
);
3657 section
.s_paddr
= 0;
3659 #ifdef COFF_IMAGE_WITH_PE
3660 /* Reminder: s_paddr holds the virtual size of the section. */
3661 if (coff_section_data (abfd
, current
) != NULL
3662 && pei_section_data (abfd
, current
) != NULL
)
3663 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3665 section
.s_paddr
= 0;
3668 /* If this section has no size or is unloadable then the scnptr
3670 if (current
->size
== 0
3671 || (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3672 section
.s_scnptr
= 0;
3674 section
.s_scnptr
= current
->filepos
;
3676 section
.s_relptr
= current
->rel_filepos
;
3677 section
.s_lnnoptr
= current
->line_filepos
;
3678 section
.s_nreloc
= current
->reloc_count
;
3679 section
.s_nlnno
= current
->lineno_count
;
3680 #ifndef COFF_IMAGE_WITH_PE
3681 /* In PEI, relocs come in the .reloc section. */
3682 if (current
->reloc_count
!= 0)
3685 if (current
->lineno_count
!= 0)
3687 if ((current
->flags
& SEC_DEBUGGING
) != 0
3688 && ! is_reloc_section
)
3693 /* Indicate the use of an XCOFF overflow section header. */
3694 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3696 section
.s_nreloc
= 0xffff;
3697 section
.s_nlnno
= 0xffff;
3702 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3704 if (!strcmp (current
->name
, _TEXT
))
3706 else if (!strcmp (current
->name
, _DATA
))
3708 else if (!strcmp (current
->name
, _BSS
))
3712 section
.s_align
= (current
->alignment_power
3713 ? 1 << current
->alignment_power
3717 /* TI COFF puts the alignment power in bits 8-11 of the flags. */
3718 section
.s_flags
|= (current
->alignment_power
& 0xF) << 8;
3720 #ifdef COFF_ENCODE_ALIGNMENT
3721 COFF_ENCODE_ALIGNMENT(section
, current
->alignment_power
);
3724 #ifdef COFF_IMAGE_WITH_PE
3725 /* Suppress output of the sections if they are null. ld
3726 includes the bss and data sections even if there is no size
3727 assigned to them. NT loader doesn't like it if these section
3728 headers are included if the sections themselves are not
3729 needed. See also coff_compute_section_file_positions. */
3730 if (section
.s_size
== 0)
3731 internal_f
.f_nscns
--;
3736 bfd_size_type amt
= bfd_coff_scnhsz (abfd
);
3738 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3739 || bfd_bwrite ((PTR
) &buff
, amt
, abfd
) != amt
)
3744 /* PE stores COMDAT section information in the symbol table. If
3745 this section is supposed to have some COMDAT info, track down
3746 the symbol in the symbol table and modify it. */
3747 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3749 unsigned int i
, count
;
3751 coff_symbol_type
*csym
= NULL
;
3755 count
= bfd_get_symcount (abfd
);
3756 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3758 if ((*psym
)->section
!= current
)
3761 /* Remember the location of the first symbol in this
3763 if (psymsec
== NULL
)
3766 /* See if this is the section symbol. */
3767 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3769 csym
= coff_symbol_from (abfd
, *psym
);
3771 || csym
->native
== NULL
3772 || csym
->native
->u
.syment
.n_numaux
< 1
3773 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3774 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3777 /* Here *PSYM is the section symbol for CURRENT. */
3784 Note that we might not if we're converting the file from
3785 some other object file format. */
3788 combined_entry_type
*aux
;
3790 /* We don't touch the x_checksum field. The
3791 x_associated field is not currently supported. */
3793 aux
= csym
->native
+ 1;
3794 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3796 case SEC_LINK_DUPLICATES_DISCARD
:
3797 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3800 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3801 aux
->u
.auxent
.x_scn
.x_comdat
=
3802 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3805 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3806 aux
->u
.auxent
.x_scn
.x_comdat
=
3807 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3810 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3811 aux
->u
.auxent
.x_scn
.x_comdat
=
3812 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3816 /* The COMDAT symbol must be the first symbol from this
3817 section in the symbol table. In order to make this
3818 work, we move the COMDAT symbol before the first
3819 symbol we found in the search above. It's OK to
3820 rearrange the symbol table at this point, because
3821 coff_renumber_symbols is going to rearrange it
3822 further and fix up all the aux entries. */
3823 if (psym
!= psymsec
)
3829 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3830 pcopy
[0] = pcopy
[-1];
3835 #endif /* COFF_WITH_PE */
3840 /* XCOFF handles overflows in the reloc and line number count fields
3841 by creating a new section header to hold the correct values. */
3842 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3844 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3846 struct internal_scnhdr scnhdr
;
3850 internal_f
.f_nscns
++;
3851 strncpy (&(scnhdr
.s_name
[0]), current
->name
, 8);
3852 scnhdr
.s_paddr
= current
->reloc_count
;
3853 scnhdr
.s_vaddr
= current
->lineno_count
;
3855 scnhdr
.s_scnptr
= 0;
3856 scnhdr
.s_relptr
= current
->rel_filepos
;
3857 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3858 scnhdr
.s_nreloc
= current
->target_index
;
3859 scnhdr
.s_nlnno
= current
->target_index
;
3860 scnhdr
.s_flags
= STYP_OVRFLO
;
3861 amt
= bfd_coff_scnhsz (abfd
);
3862 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3863 || bfd_bwrite ((PTR
) &buff
, amt
, abfd
) != amt
)
3870 /* OK, now set up the filehdr... */
3872 /* Don't include the internal abs section in the section count */
3874 /* We will NOT put a fucking timestamp in the header here. Every time you
3875 put it back, I will come in and take it out again. I'm sorry. This
3876 field does not belong here. We fill it with a 0 so it compares the
3877 same but is not a reasonable time. -- gnu@cygnus.com */
3878 internal_f
.f_timdat
= 0;
3879 internal_f
.f_flags
= 0;
3881 if (abfd
->flags
& EXEC_P
)
3882 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3885 internal_f
.f_opthdr
= 0;
3888 if (xcoff_data (abfd
)->full_aouthdr
)
3889 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3891 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
3897 internal_f
.f_flags
|= F_RELFLG
;
3899 internal_f
.f_flags
|= F_LNNO
;
3900 if (abfd
->flags
& EXEC_P
)
3901 internal_f
.f_flags
|= F_EXEC
;
3902 #ifdef COFF_IMAGE_WITH_PE
3904 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
3905 if (pe_data (abfd
)->real_flags
& IMAGE_FILE_LARGE_ADDRESS_AWARE
)
3906 internal_f
.f_flags
|= IMAGE_FILE_LARGE_ADDRESS_AWARE
;
3910 internal_f
.f_flags
|= IMAGE_FILE_32BIT_MACHINE
;
3912 if (bfd_little_endian (abfd
))
3913 internal_f
.f_flags
|= F_AR32WR
;
3915 internal_f
.f_flags
|= F_AR32W
;
3919 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
3920 but it doesn't hurt to set it internally. */
3921 internal_f
.f_target_id
= TI_TARGET_ID
;
3923 #ifdef TIC80_TARGET_ID
3924 internal_f
.f_target_id
= TIC80_TARGET_ID
;
3927 /* FIXME, should do something about the other byte orders and
3931 if ((abfd
->flags
& DYNAMIC
) != 0)
3932 internal_f
.f_flags
|= F_SHROBJ
;
3933 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
3934 internal_f
.f_flags
|= F_DYNLOAD
;
3937 memset (&internal_a
, 0, sizeof internal_a
);
3939 /* Set up architecture-dependent stuff. */
3941 unsigned int magic
= 0;
3942 unsigned short flags
= 0;
3944 coff_set_flags (abfd
, &magic
, &flags
);
3945 internal_f
.f_magic
= magic
;
3946 internal_f
.f_flags
|= flags
;
3947 /* ...and the "opt"hdr... */
3950 #ifdef ULTRA3 /* NYU's machine */
3951 /* FIXME: This is a bogus check. I really want to see if there
3952 is a .shbss or a .shdata section, if so then set the magic
3953 number to indicate a shared data executable. */
3954 if (internal_f
.f_nscns
>= 7)
3955 internal_a
.magic
= SHMAGIC
; /* Shared magic. */
3958 internal_a
.magic
= NMAGIC
; /* Assume separate i/d. */
3959 #define __A_MAGIC_SET__
3961 #ifdef TICOFF_AOUT_MAGIC
3962 internal_a
.magic
= TICOFF_AOUT_MAGIC
;
3963 #define __A_MAGIC_SET__
3966 internal_a
.magic
= TIC80_ARCH_MAGIC
;
3967 #define __A_MAGIC_SET__
3970 /* FIXME: What are the a.out magic numbers for the i860? */
3971 internal_a
.magic
= 0;
3972 #define __A_MAGIC_SET__
3975 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
3976 #define __A_MAGIC_SET__
3979 #define __A_MAGIC_SET__
3980 internal_a
.magic
= PAGEMAGICBCS
;
3984 #define __A_MAGIC_SET__
3985 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
3988 #if defined(M68) || defined(WE32K) || defined(M68K)
3989 #define __A_MAGIC_SET__
3991 internal_a
.magic
= LYNXCOFFMAGIC
;
3993 #if defined(TARG_AUX)
3994 internal_a
.magic
= (abfd
->flags
& D_PAGED
? PAGEMAGICPEXECPAGED
:
3995 abfd
->flags
& WP_TEXT
? PAGEMAGICPEXECSWAPPED
:
3996 PAGEMAGICEXECSWAPPED
);
3998 #if defined (PAGEMAGICPEXECPAGED)
3999 internal_a
.magic
= PAGEMAGICPEXECPAGED
;
4001 #endif /* TARG_AUX */
4003 #endif /* M68 || WE32K || M68K */
4006 #define __A_MAGIC_SET__
4007 internal_a
.magic
= ZMAGIC
;
4011 #define __A_MAGIC_SET__
4012 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
4015 #if defined MCORE_PE
4016 #define __A_MAGIC_SET__
4017 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
4021 #define __A_MAGIC_SET__
4023 internal_a
.magic
= LYNXCOFFMAGIC
;
4025 internal_a
.magic
= ZMAGIC
;
4030 #define __A_MAGIC_SET__
4031 internal_a
.magic
= ZMAGIC
;
4035 #define __A_MAGIC_SET__
4037 internal_a
.magic
= LYNXCOFFMAGIC
;
4042 #define __A_MAGIC_SET__
4043 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
4044 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
4045 RS6K_AOUTHDR_OMAGIC
;
4048 #if defined(SH) && defined(COFF_WITH_PE)
4049 #define __A_MAGIC_SET__
4050 internal_a
.magic
= SH_PE_MAGIC
;
4053 #if defined(MIPS) && defined(COFF_WITH_PE)
4054 #define __A_MAGIC_SET__
4055 internal_a
.magic
= MIPS_PE_MAGIC
;
4059 #define __A_MAGIC_SET__
4060 internal_a
.magic
= NMAGIC
; /* Assume separate i/d. */
4063 #ifndef __A_MAGIC_SET__
4064 #include "Your aouthdr magic number is not being set!"
4066 #undef __A_MAGIC_SET__
4070 /* FIXME: Does anybody ever set this to another value? */
4071 internal_a
.vstamp
= 0;
4073 /* Now should write relocs, strings, syms. */
4074 obj_sym_filepos (abfd
) = sym_base
;
4076 if (bfd_get_symcount (abfd
) != 0)
4080 if (!coff_add_missing_symbols (abfd
))
4083 if (!coff_renumber_symbols (abfd
, &firstundef
))
4085 coff_mangle_symbols (abfd
);
4086 if (! coff_write_symbols (abfd
))
4088 if (! coff_write_linenumbers (abfd
))
4090 if (! coff_write_relocs (abfd
, firstundef
))
4093 #ifdef COFF_LONG_SECTION_NAMES
4094 else if (long_section_names
&& ! obj_coff_strings_written (abfd
))
4096 /* If we have long section names we have to write out the string
4097 table even if there are no symbols. */
4098 if (! coff_write_symbols (abfd
))
4102 #ifdef COFF_IMAGE_WITH_PE
4104 else if ((abfd
->flags
& EXEC_P
) != 0)
4108 /* PowerPC PE appears to require that all executable files be
4109 rounded up to the page size. */
4112 (file_ptr
) BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
4114 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
4120 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
4121 backend linker, and obj_raw_syment_count is not valid until after
4122 coff_write_symbols is called. */
4123 if (obj_raw_syment_count (abfd
) != 0)
4125 internal_f
.f_symptr
= sym_base
;
4127 /* AIX appears to require that F_RELFLG not be set if there are
4128 local symbols but no relocations. */
4129 internal_f
.f_flags
&=~ F_RELFLG
;
4134 if (long_section_names
)
4135 internal_f
.f_symptr
= sym_base
;
4137 internal_f
.f_symptr
= 0;
4138 internal_f
.f_flags
|= F_LSYMS
;
4143 internal_a
.tsize
= text_sec
->size
;
4144 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
4148 internal_a
.dsize
= data_sec
->size
;
4149 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
4153 internal_a
.bsize
= bss_sec
->size
;
4154 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
4155 internal_a
.data_start
= bss_sec
->vma
;
4158 internal_a
.entry
= bfd_get_start_address (abfd
);
4159 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
4162 if (xcoff_data (abfd
)->full_aouthdr
)
4165 asection
*loader_sec
;
4167 internal_a
.vstamp
= 1;
4169 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
4170 if (internal_a
.o_snentry
== 0)
4171 internal_a
.entry
= (bfd_vma
) -1;
4173 if (text_sec
!= NULL
)
4175 internal_a
.o_sntext
= text_sec
->target_index
;
4176 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
4180 internal_a
.o_sntext
= 0;
4181 internal_a
.o_algntext
= 0;
4183 if (data_sec
!= NULL
)
4185 internal_a
.o_sndata
= data_sec
->target_index
;
4186 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
4190 internal_a
.o_sndata
= 0;
4191 internal_a
.o_algndata
= 0;
4193 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
4194 if (loader_sec
!= NULL
)
4195 internal_a
.o_snloader
= loader_sec
->target_index
;
4197 internal_a
.o_snloader
= 0;
4198 if (bss_sec
!= NULL
)
4199 internal_a
.o_snbss
= bss_sec
->target_index
;
4201 internal_a
.o_snbss
= 0;
4203 toc
= xcoff_data (abfd
)->toc
;
4204 internal_a
.o_toc
= toc
;
4205 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
4207 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
4208 if (xcoff_data (abfd
)->cputype
!= -1)
4209 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
4212 switch (bfd_get_arch (abfd
))
4214 case bfd_arch_rs6000
:
4215 internal_a
.o_cputype
= 4;
4217 case bfd_arch_powerpc
:
4218 if (bfd_get_mach (abfd
) == bfd_mach_ppc
)
4219 internal_a
.o_cputype
= 3;
4221 internal_a
.o_cputype
= 1;
4227 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
4228 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
4232 /* now write them */
4233 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
4238 bfd_size_type amount
= bfd_coff_filhsz (abfd
);
4240 buff
= bfd_malloc (amount
);
4244 bfd_coff_swap_filehdr_out (abfd
, (PTR
) &internal_f
, (PTR
) buff
);
4245 amount
= bfd_bwrite ((PTR
) buff
, amount
, abfd
);
4249 if (amount
!= bfd_coff_filhsz (abfd
))
4253 if (abfd
->flags
& EXEC_P
)
4255 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4256 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4258 bfd_size_type amount
= bfd_coff_aoutsz (abfd
);
4260 buff
= bfd_malloc (amount
);
4264 coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, (PTR
) buff
);
4265 amount
= bfd_bwrite ((PTR
) buff
, amount
, abfd
);
4269 if (amount
!= bfd_coff_aoutsz (abfd
))
4272 #ifdef COFF_IMAGE_WITH_PE
4273 if (! coff_apply_checksum (abfd
))
4283 /* XCOFF seems to always write at least a small a.out header. */
4284 coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, (PTR
) &buff
);
4285 if (xcoff_data (abfd
)->full_aouthdr
)
4286 size
= bfd_coff_aoutsz (abfd
);
4288 size
= SMALL_AOUTSZ
;
4289 if (bfd_bwrite ((PTR
) &buff
, (bfd_size_type
) size
, abfd
) != size
)
4298 coff_set_section_contents (abfd
, section
, location
, offset
, count
)
4303 bfd_size_type count
;
4305 if (! abfd
->output_has_begun
) /* Set by bfd.c handler. */
4307 if (! coff_compute_section_file_positions (abfd
))
4311 #if defined(_LIB) && !defined(TARG_AUX)
4313 /* The physical address field of a .lib section is used to hold the
4314 number of shared libraries in the section. This code counts the
4315 number of sections being written, and increments the lma field
4318 I have found no documentation on the contents of this section.
4319 Experimentation indicates that the section contains zero or more
4320 records, each of which has the following structure:
4322 - a (four byte) word holding the length of this record, in words,
4323 - a word that always seems to be set to "2",
4324 - the path to a shared library, null-terminated and then padded
4325 to a whole word boundary.
4327 bfd_assert calls have been added to alert if an attempt is made
4328 to write a section which doesn't follow these assumptions. The
4329 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4330 <robertl@arnet.com> (Thanks!).
4332 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4334 if (strcmp (section
->name
, _LIB
) == 0)
4336 bfd_byte
*rec
, *recend
;
4338 rec
= (bfd_byte
*) location
;
4339 recend
= rec
+ count
;
4340 while (rec
< recend
)
4343 rec
+= bfd_get_32 (abfd
, rec
) * 4;
4346 BFD_ASSERT (rec
== recend
);
4351 /* Don't write out bss sections - one way to do this is to
4352 see if the filepos has not been set. */
4353 if (section
->filepos
== 0)
4356 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0)
4362 return bfd_bwrite (location
, count
, abfd
) == count
;
4366 coff_close_and_cleanup (abfd
)
4369 if (!bfd_read_p (abfd
))
4370 switch (abfd
->format
)
4373 if (!_bfd_write_archive_contents (abfd
))
4377 if (!coff_write_object_contents (abfd
))
4381 bfd_set_error (bfd_error_invalid_operation
);
4385 /* We depend on bfd_close to free all the memory on the objalloc. */
4392 buy_and_read (abfd
, where
, size
)
4397 PTR area
= (PTR
) bfd_alloc (abfd
, size
);
4400 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0
4401 || bfd_bread (area
, size
, abfd
) != size
)
4404 } /* buy_and_read() */
4410 Creating the linenumber table is done by reading in the entire
4411 coff linenumber table, and creating another table for internal use.
4413 A coff linenumber table is structured so that each function
4414 is marked as having a line number of 0. Each line within the
4415 function is an offset from the first line in the function. The
4416 base of the line number information for the table is stored in
4417 the symbol associated with the function.
4419 Note: The PE format uses line number 0 for a flag indicating a
4422 The information is copied from the external to the internal
4423 table, and each symbol which marks a function is marked by
4426 How does this work ?
4431 coff_slurp_line_table (abfd
, asect
)
4435 LINENO
*native_lineno
;
4436 alent
*lineno_cache
;
4439 BFD_ASSERT (asect
->lineno
== (alent
*) NULL
);
4441 amt
= (bfd_size_type
) bfd_coff_linesz (abfd
) * asect
->lineno_count
;
4442 native_lineno
= (LINENO
*) buy_and_read (abfd
, asect
->line_filepos
, amt
);
4443 if (native_lineno
== NULL
)
4445 (*_bfd_error_handler
)
4446 (_("%s: warning: line number table read failed"),
4447 bfd_archive_filename (abfd
));
4450 amt
= ((bfd_size_type
) asect
->lineno_count
+ 1) * sizeof (alent
);
4451 lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
);
4452 if (lineno_cache
== NULL
)
4456 unsigned int counter
= 0;
4457 alent
*cache_ptr
= lineno_cache
;
4458 LINENO
*src
= native_lineno
;
4460 while (counter
< asect
->lineno_count
)
4462 struct internal_lineno dst
;
4464 bfd_coff_swap_lineno_in (abfd
, src
, &dst
);
4465 cache_ptr
->line_number
= dst
.l_lnno
;
4467 if (cache_ptr
->line_number
== 0)
4470 bfd_signed_vma symndx
;
4471 coff_symbol_type
*sym
;
4474 symndx
= dst
.l_addr
.l_symndx
;
4476 || (bfd_vma
) symndx
>= obj_raw_syment_count (abfd
))
4478 (*_bfd_error_handler
)
4479 (_("%s: warning: illegal symbol index %ld in line numbers"),
4480 bfd_archive_filename (abfd
), dst
.l_addr
.l_symndx
);
4484 /* FIXME: We should not be casting between ints and
4485 pointers like this. */
4486 sym
= ((coff_symbol_type
*)
4487 ((symndx
+ obj_raw_syments (abfd
))
4488 ->u
.syment
._n
._n_n
._n_zeroes
));
4489 cache_ptr
->u
.sym
= (asymbol
*) sym
;
4490 if (sym
->lineno
!= NULL
&& ! warned
)
4492 (*_bfd_error_handler
)
4493 (_("%s: warning: duplicate line number information for `%s'"),
4494 bfd_archive_filename (abfd
),
4495 bfd_asymbol_name (&sym
->symbol
));
4497 sym
->lineno
= cache_ptr
;
4501 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
4502 - bfd_section_vma (abfd
, asect
);
4503 } /* If no linenumber expect a symbol index */
4509 cache_ptr
->line_number
= 0;
4512 asect
->lineno
= lineno_cache
;
4513 /* FIXME, free native_lineno here, or use alloca or something. */
4517 /* Slurp in the symbol table, converting it to generic form. Note
4518 that if coff_relocate_section is defined, the linker will read
4519 symbols via coff_link_add_symbols, rather than via this routine. */
4522 coff_slurp_symbol_table (abfd
)
4525 combined_entry_type
*native_symbols
;
4526 coff_symbol_type
*cached_area
;
4527 unsigned int *table_ptr
;
4529 unsigned int number_of_symbols
= 0;
4531 if (obj_symbols (abfd
))
4534 /* Read in the symbol table. */
4535 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4538 /* Allocate enough room for all the symbols in cached form. */
4539 amt
= obj_raw_syment_count (abfd
);
4540 amt
*= sizeof (coff_symbol_type
);
4541 cached_area
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
4542 if (cached_area
== NULL
)
4545 amt
= obj_raw_syment_count (abfd
);
4546 amt
*= sizeof (unsigned int);
4547 table_ptr
= (unsigned int *) bfd_alloc (abfd
, amt
);
4549 if (table_ptr
== NULL
)
4553 coff_symbol_type
*dst
= cached_area
;
4554 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4555 unsigned int this_index
= 0;
4557 while (this_index
< last_native_index
)
4559 combined_entry_type
*src
= native_symbols
+ this_index
;
4560 table_ptr
[this_index
] = number_of_symbols
;
4561 dst
->symbol
.the_bfd
= abfd
;
4563 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4564 /* We use the native name field to point to the cached field. */
4565 src
->u
.syment
._n
._n_n
._n_zeroes
= (long) dst
;
4566 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4567 src
->u
.syment
.n_scnum
);
4568 dst
->symbol
.flags
= 0;
4569 dst
->done_lineno
= FALSE
;
4571 switch (src
->u
.syment
.n_sclass
)
4576 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
4577 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4578 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4580 /* Fall through to next case. */
4587 case C_THUMBEXTFUNC
:
4593 case C_SYSTEM
: /* System Wide variable. */
4596 /* In PE, 0x68 (104) denotes a section symbol. */
4598 /* In PE, 0x69 (105) denotes a weak external symbol. */
4601 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4603 case COFF_SYMBOL_GLOBAL
:
4604 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4605 #if defined COFF_WITH_PE
4606 /* PE sets the symbol to a value relative to the
4607 start of the section. */
4608 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4610 dst
->symbol
.value
= (src
->u
.syment
.n_value
4611 - dst
->symbol
.section
->vma
);
4613 if (ISFCN ((src
->u
.syment
.n_type
)))
4615 /* A function ext does not go at the end of a
4617 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4621 case COFF_SYMBOL_COMMON
:
4622 dst
->symbol
.section
= bfd_com_section_ptr
;
4623 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4626 case COFF_SYMBOL_UNDEFINED
:
4627 dst
->symbol
.section
= bfd_und_section_ptr
;
4628 dst
->symbol
.value
= 0;
4631 case COFF_SYMBOL_PE_SECTION
:
4632 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4633 dst
->symbol
.value
= 0;
4636 case COFF_SYMBOL_LOCAL
:
4637 dst
->symbol
.flags
= BSF_LOCAL
;
4638 #if defined COFF_WITH_PE
4639 /* PE sets the symbol to a value relative to the
4640 start of the section. */
4641 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4643 dst
->symbol
.value
= (src
->u
.syment
.n_value
4644 - dst
->symbol
.section
->vma
);
4646 if (ISFCN ((src
->u
.syment
.n_type
)))
4647 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4652 /* A symbol with a csect entry should not go at the end. */
4653 if (src
->u
.syment
.n_numaux
> 0)
4654 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4658 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4659 dst
->symbol
.flags
|= BSF_WEAK
;
4661 if (src
->u
.syment
.n_sclass
== C_SECTION
4662 && src
->u
.syment
.n_scnum
> 0)
4663 dst
->symbol
.flags
= BSF_LOCAL
;
4665 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
)
4666 dst
->symbol
.flags
|= BSF_WEAK
;
4670 case C_STAT
: /* Static. */
4672 case C_LEAFSTAT
: /* Static leaf procedure. */
4675 case C_THUMBSTAT
: /* Thumb static. */
4676 case C_THUMBLABEL
: /* Thumb label. */
4677 case C_THUMBSTATFUNC
:/* Thumb static function. */
4679 case C_LABEL
: /* Label. */
4680 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4681 dst
->symbol
.flags
= BSF_DEBUGGING
;
4683 dst
->symbol
.flags
= BSF_LOCAL
;
4685 /* Base the value as an index from the base of the
4686 section, if there is one. */
4687 if (dst
->symbol
.section
)
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
);
4699 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4702 case C_MOS
: /* Member of structure. */
4703 case C_EOS
: /* End of structure. */
4704 #ifdef NOTDEF /* C_AUTOARG has the same value. */
4706 case C_GLBLREG
: /* A29k-specific storage class. */
4709 case C_REGPARM
: /* Register parameter. */
4710 case C_REG
: /* register variable. */
4711 /* C_AUTOARG conflicts with TI COFF C_UEXT. */
4712 #if !defined (TIC80COFF) && !defined (TICOFF)
4714 case C_AUTOARG
: /* 960-specific storage class. */
4717 case C_TPDEF
: /* Type definition. */
4719 case C_AUTO
: /* Automatic variable. */
4720 case C_FIELD
: /* Bit field. */
4721 case C_ENTAG
: /* Enumeration tag. */
4722 case C_MOE
: /* Member of enumeration. */
4723 case C_MOU
: /* Member of union. */
4724 case C_UNTAG
: /* Union tag. */
4725 dst
->symbol
.flags
= BSF_DEBUGGING
;
4726 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4729 case C_FILE
: /* File name. */
4730 case C_STRTAG
: /* Structure tag. */
4747 dst
->symbol
.flags
= BSF_DEBUGGING
;
4748 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4752 case C_BINCL
: /* Beginning of include file. */
4753 case C_EINCL
: /* Ending of include file. */
4754 /* The value is actually a pointer into the line numbers
4755 of the file. We locate the line number entry, and
4756 set the section to the section which contains it, and
4757 the value to the index in that section. */
4761 dst
->symbol
.flags
= BSF_DEBUGGING
;
4762 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4763 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4764 && ((file_ptr
) (sec
->line_filepos
4765 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4766 > (file_ptr
) src
->u
.syment
.n_value
))
4769 dst
->symbol
.value
= 0;
4772 dst
->symbol
.section
= sec
;
4773 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4774 - sec
->line_filepos
)
4775 / bfd_coff_linesz (abfd
));
4782 dst
->symbol
.flags
= BSF_DEBUGGING
;
4784 /* The value is actually a symbol index. Save a pointer
4785 to the symbol instead of the index. FIXME: This
4786 should use a union. */
4787 src
->u
.syment
.n_value
=
4788 (long) (native_symbols
+ src
->u
.syment
.n_value
);
4789 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4794 case C_BLOCK
: /* ".bb" or ".eb". */
4795 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf"). */
4796 case C_EFCN
: /* Physical end of function. */
4797 #if defined COFF_WITH_PE
4798 /* PE sets the symbol to a value relative to the start
4800 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4801 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4803 /* PE uses funny values for .ef and .lf; don't
4805 dst
->symbol
.flags
= BSF_DEBUGGING
;
4808 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4810 /* Base the value as an index from the base of the
4812 dst
->symbol
.flags
= BSF_LOCAL
;
4813 dst
->symbol
.value
= (src
->u
.syment
.n_value
4814 - dst
->symbol
.section
->vma
);
4818 case C_STATLAB
: /* Static load time label. */
4819 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4820 dst
->symbol
.flags
= BSF_GLOBAL
;
4824 /* PE DLLs sometimes have zeroed out symbols for some
4825 reason. Just ignore them without a warning. */
4826 if (src
->u
.syment
.n_type
== 0
4827 && src
->u
.syment
.n_value
== 0
4828 && src
->u
.syment
.n_scnum
== 0)
4831 case C_EXTDEF
: /* External definition. */
4832 case C_ULABEL
: /* Undefined label. */
4833 case C_USTATIC
: /* Undefined static. */
4834 #ifndef COFF_WITH_PE
4835 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4836 class to represent a section symbol. */
4837 case C_LINE
: /* line # reformatted as symbol table entry. */
4838 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4839 case C_ALIAS
: /* Duplicate tag. */
4841 /* New storage classes for TI COFF. */
4842 #if defined(TIC80COFF) || defined(TICOFF)
4843 case C_UEXT
: /* Tentative external definition. */
4845 case C_EXTLAB
: /* External load time label. */
4846 case C_HIDDEN
: /* Ext symbol in dmert public lib. */
4848 (*_bfd_error_handler
)
4849 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
4850 bfd_archive_filename (abfd
), src
->u
.syment
.n_sclass
,
4851 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4852 dst
->symbol
.flags
= BSF_DEBUGGING
;
4853 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4857 /* BFD_ASSERT(dst->symbol.flags != 0);*/
4861 dst
->symbol
.udata
.i
= 0;
4862 dst
->lineno
= (alent
*) NULL
;
4863 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
4865 number_of_symbols
++;
4869 obj_symbols (abfd
) = cached_area
;
4870 obj_raw_syments (abfd
) = native_symbols
;
4872 bfd_get_symcount (abfd
) = number_of_symbols
;
4873 obj_convert (abfd
) = table_ptr
;
4874 /* Slurp the line tables for each section too. */
4881 coff_slurp_line_table (abfd
, p
);
4887 } /* coff_slurp_symbol_table() */
4889 /* Classify a COFF symbol. A couple of targets have globally visible
4890 symbols which are not class C_EXT, and this handles those. It also
4891 recognizes some special PE cases. */
4893 static enum coff_symbol_classification
4894 coff_classify_symbol (abfd
, syment
)
4896 struct internal_syment
*syment
;
4898 /* FIXME: This partially duplicates the switch in
4899 coff_slurp_symbol_table. */
4900 switch (syment
->n_sclass
)
4909 case C_THUMBEXTFUNC
:
4917 if (syment
->n_scnum
== 0)
4919 if (syment
->n_value
== 0)
4920 return COFF_SYMBOL_UNDEFINED
;
4922 return COFF_SYMBOL_COMMON
;
4924 return COFF_SYMBOL_GLOBAL
;
4931 if (syment
->n_sclass
== C_STAT
)
4933 if (syment
->n_scnum
== 0)
4935 /* The Microsoft compiler sometimes generates these if a
4936 small static function is inlined every time it is used.
4937 The function is discarded, but the symbol table entry
4939 return COFF_SYMBOL_LOCAL
;
4942 #ifdef STRICT_PE_FORMAT
4943 /* This is correct for Microsoft generated objects, but it
4944 breaks gas generated objects. */
4946 if (syment
->n_value
== 0)
4949 char buf
[SYMNMLEN
+ 1];
4951 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
4953 && (strcmp (bfd_get_section_name (abfd
, sec
),
4954 _bfd_coff_internal_syment_name (abfd
, syment
, buf
))
4956 return COFF_SYMBOL_PE_SECTION
;
4960 return COFF_SYMBOL_LOCAL
;
4963 if (syment
->n_sclass
== C_SECTION
)
4965 /* In some cases in a DLL generated by the Microsoft linker, the
4966 n_value field will contain garbage. FIXME: This should
4967 probably be handled by the swapping function instead. */
4968 syment
->n_value
= 0;
4969 if (syment
->n_scnum
== 0)
4970 return COFF_SYMBOL_UNDEFINED
;
4971 return COFF_SYMBOL_PE_SECTION
;
4973 #endif /* COFF_WITH_PE */
4975 /* If it is not a global symbol, we presume it is a local symbol. */
4977 if (syment
->n_scnum
== 0)
4979 char buf
[SYMNMLEN
+ 1];
4981 (*_bfd_error_handler
)
4982 (_("warning: %s: local symbol `%s' has no section"),
4983 bfd_archive_filename (abfd
),
4984 _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
4987 return COFF_SYMBOL_LOCAL
;
4994 Coff relocations are easily transformed into the internal BFD form
4997 Reading a coff relocation table is done in the following stages:
4999 o Read the entire coff relocation table into memory.
5001 o Process each relocation in turn; first swap it from the
5002 external to the internal form.
5004 o Turn the symbol referenced in the relocation's symbol index
5005 into a pointer into the canonical symbol table.
5006 This table is the same as the one returned by a call to
5007 @code{bfd_canonicalize_symtab}. The back end will call that
5008 routine and save the result if a canonicalization hasn't been done.
5010 o The reloc index is turned into a pointer to a howto
5011 structure, in a back end specific way. For instance, the 386
5012 and 960 use the @code{r_type} to directly produce an index
5013 into a howto table vector; the 88k subtracts a number from the
5014 @code{r_type} field and creates an addend field.
5019 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
5021 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
5022 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
5023 coffsym = (obj_symbols (abfd) \
5024 + (cache_ptr->sym_ptr_ptr - symbols)); \
5026 coffsym = coff_symbol_from (abfd, ptr); \
5027 if (coffsym != (coff_symbol_type *) NULL \
5028 && coffsym->native->u.syment.n_scnum == 0) \
5029 cache_ptr->addend = 0; \
5030 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
5031 && ptr->section != (asection *) NULL) \
5032 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
5034 cache_ptr->addend = 0; \
5039 coff_slurp_reloc_table (abfd
, asect
, symbols
)
5044 RELOC
*native_relocs
;
5045 arelent
*reloc_cache
;
5050 if (asect
->relocation
)
5052 if (asect
->reloc_count
== 0)
5054 if (asect
->flags
& SEC_CONSTRUCTOR
)
5056 if (!coff_slurp_symbol_table (abfd
))
5058 amt
= (bfd_size_type
) bfd_coff_relsz (abfd
) * asect
->reloc_count
;
5059 native_relocs
= (RELOC
*) buy_and_read (abfd
, asect
->rel_filepos
, amt
);
5060 amt
= (bfd_size_type
) asect
->reloc_count
* sizeof (arelent
);
5061 reloc_cache
= (arelent
*) bfd_alloc (abfd
, amt
);
5063 if (reloc_cache
== NULL
)
5066 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
5068 struct internal_reloc dst
;
5069 struct external_reloc
*src
;
5070 #ifndef RELOC_PROCESSING
5074 cache_ptr
= reloc_cache
+ idx
;
5075 src
= native_relocs
+ idx
;
5077 coff_swap_reloc_in (abfd
, src
, &dst
);
5079 #ifdef RELOC_PROCESSING
5080 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
5082 cache_ptr
->address
= dst
.r_vaddr
;
5084 if (dst
.r_symndx
!= -1)
5086 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
5088 (*_bfd_error_handler
)
5089 (_("%s: warning: illegal symbol index %ld in relocs"),
5090 bfd_archive_filename (abfd
), dst
.r_symndx
);
5091 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5096 cache_ptr
->sym_ptr_ptr
= (symbols
5097 + obj_convert (abfd
)[dst
.r_symndx
]);
5098 ptr
= *(cache_ptr
->sym_ptr_ptr
);
5103 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5107 /* The symbols definitions that we have read in have been
5108 relocated as if their sections started at 0. But the offsets
5109 refering to the symbols in the raw data have not been
5110 modified, so we have to have a negative addend to compensate.
5112 Note that symbols which used to be common must be left alone. */
5114 /* Calculate any reloc addend by looking at the symbol. */
5115 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
5117 cache_ptr
->address
-= asect
->vma
;
5118 /* !! cache_ptr->section = (asection *) NULL;*/
5120 /* Fill in the cache_ptr->howto field from dst.r_type. */
5121 RTYPE2HOWTO (cache_ptr
, &dst
);
5122 #endif /* RELOC_PROCESSING */
5124 if (cache_ptr
->howto
== NULL
)
5126 (*_bfd_error_handler
)
5127 (_("%s: illegal relocation type %d at address 0x%lx"),
5128 bfd_archive_filename (abfd
), dst
.r_type
, (long) dst
.r_vaddr
);
5129 bfd_set_error (bfd_error_bad_value
);
5134 asect
->relocation
= reloc_cache
;
5138 #ifndef coff_rtype_to_howto
5141 /* Get the howto structure for a reloc. This is only used if the file
5142 including this one defines coff_relocate_section to be
5143 _bfd_coff_generic_relocate_section, so it is OK if it does not
5144 always work. It is the responsibility of the including file to
5145 make sure it is reasonable if it is needed. */
5147 static reloc_howto_type
*coff_rtype_to_howto
5148 PARAMS ((bfd
*, asection
*, struct internal_reloc
*,
5149 struct coff_link_hash_entry
*, struct internal_syment
*,
5152 static reloc_howto_type
*
5153 coff_rtype_to_howto (abfd
, sec
, rel
, h
, sym
, addendp
)
5154 bfd
*abfd ATTRIBUTE_UNUSED
;
5155 asection
*sec ATTRIBUTE_UNUSED
;
5156 struct internal_reloc
*rel
;
5157 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
;
5158 struct internal_syment
*sym ATTRIBUTE_UNUSED
;
5159 bfd_vma
*addendp ATTRIBUTE_UNUSED
;
5163 RTYPE2HOWTO (&genrel
, rel
);
5164 return genrel
.howto
;
5167 #else /* ! defined (RTYPE2HOWTO) */
5169 #define coff_rtype_to_howto NULL
5171 #endif /* ! defined (RTYPE2HOWTO) */
5172 #endif /* ! defined (coff_rtype_to_howto) */
5174 /* This is stupid. This function should be a boolean predicate. */
5176 coff_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
5182 arelent
*tblptr
= section
->relocation
;
5183 unsigned int count
= 0;
5185 if (section
->flags
& SEC_CONSTRUCTOR
)
5187 /* This section has relocs made up by us, they are not in the
5188 file, so take them out of their chain and place them into
5189 the data area provided. */
5190 arelent_chain
*chain
= section
->constructor_chain
;
5192 for (count
= 0; count
< section
->reloc_count
; count
++)
5194 *relptr
++ = &chain
->relent
;
5195 chain
= chain
->next
;
5200 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
5203 tblptr
= section
->relocation
;
5205 for (; count
++ < section
->reloc_count
;)
5206 *relptr
++ = tblptr
++;
5209 return section
->reloc_count
;
5214 coff_sym_filepos (abfd
)
5217 return obj_sym_filepos (abfd
);
5221 #ifndef coff_reloc16_estimate
5222 #define coff_reloc16_estimate dummy_reloc16_estimate
5224 static int dummy_reloc16_estimate
5225 PARAMS ((bfd
*, asection
*, arelent
*, unsigned int,
5226 struct bfd_link_info
*));
5229 dummy_reloc16_estimate (abfd
, input_section
, reloc
, shrink
, link_info
)
5230 bfd
*abfd ATTRIBUTE_UNUSED
;
5231 asection
*input_section ATTRIBUTE_UNUSED
;
5232 arelent
*reloc ATTRIBUTE_UNUSED
;
5233 unsigned int shrink ATTRIBUTE_UNUSED
;
5234 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
5242 #ifndef coff_reloc16_extra_cases
5244 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5246 /* This works even if abort is not declared in any header file. */
5248 static void dummy_reloc16_extra_cases
5249 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*, arelent
*,
5250 bfd_byte
*, unsigned int *, unsigned int *));
5253 dummy_reloc16_extra_cases (abfd
, link_info
, link_order
, reloc
, data
, src_ptr
,
5255 bfd
*abfd ATTRIBUTE_UNUSED
;
5256 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
5257 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
;
5258 arelent
*reloc ATTRIBUTE_UNUSED
;
5259 bfd_byte
*data ATTRIBUTE_UNUSED
;
5260 unsigned int *src_ptr ATTRIBUTE_UNUSED
;
5261 unsigned int *dst_ptr ATTRIBUTE_UNUSED
;
5267 #ifndef coff_bfd_link_hash_table_free
5268 #define coff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
5271 /* If coff_relocate_section is defined, we can use the optimized COFF
5272 backend linker. Otherwise we must continue to use the old linker. */
5273 #ifdef coff_relocate_section
5274 #ifndef coff_bfd_link_hash_table_create
5275 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5277 #ifndef coff_bfd_link_add_symbols
5278 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5280 #ifndef coff_bfd_final_link
5281 #define coff_bfd_final_link _bfd_coff_final_link
5283 #else /* ! defined (coff_relocate_section) */
5284 #define coff_relocate_section NULL
5285 #ifndef coff_bfd_link_hash_table_create
5286 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5288 #ifndef coff_bfd_link_add_symbols
5289 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5291 #define coff_bfd_final_link _bfd_generic_final_link
5292 #endif /* ! defined (coff_relocate_section) */
5294 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5295 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5297 #ifndef coff_start_final_link
5298 #define coff_start_final_link NULL
5301 #ifndef coff_adjust_symndx
5302 #define coff_adjust_symndx NULL
5305 #ifndef coff_link_add_one_symbol
5306 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5309 #ifndef coff_link_output_has_begun
5311 static bfd_boolean coff_link_output_has_begun
5312 PARAMS ((bfd
*, struct coff_final_link_info
*));
5315 coff_link_output_has_begun (abfd
, info
)
5317 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
;
5319 return abfd
->output_has_begun
;
5323 #ifndef coff_final_link_postscript
5325 static bfd_boolean coff_final_link_postscript
5326 PARAMS ((bfd
*, struct coff_final_link_info
*));
5329 coff_final_link_postscript (abfd
, pfinfo
)
5330 bfd
* abfd ATTRIBUTE_UNUSED
;
5331 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
;
5337 #ifndef coff_SWAP_aux_in
5338 #define coff_SWAP_aux_in coff_swap_aux_in
5340 #ifndef coff_SWAP_sym_in
5341 #define coff_SWAP_sym_in coff_swap_sym_in
5343 #ifndef coff_SWAP_lineno_in
5344 #define coff_SWAP_lineno_in coff_swap_lineno_in
5346 #ifndef coff_SWAP_aux_out
5347 #define coff_SWAP_aux_out coff_swap_aux_out
5349 #ifndef coff_SWAP_sym_out
5350 #define coff_SWAP_sym_out coff_swap_sym_out
5352 #ifndef coff_SWAP_lineno_out
5353 #define coff_SWAP_lineno_out coff_swap_lineno_out
5355 #ifndef coff_SWAP_reloc_out
5356 #define coff_SWAP_reloc_out coff_swap_reloc_out
5358 #ifndef coff_SWAP_filehdr_out
5359 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5361 #ifndef coff_SWAP_aouthdr_out
5362 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5364 #ifndef coff_SWAP_scnhdr_out
5365 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5367 #ifndef coff_SWAP_reloc_in
5368 #define coff_SWAP_reloc_in coff_swap_reloc_in
5370 #ifndef coff_SWAP_filehdr_in
5371 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5373 #ifndef coff_SWAP_aouthdr_in
5374 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5376 #ifndef coff_SWAP_scnhdr_in
5377 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5380 static const bfd_coff_backend_data bfd_coff_std_swap_table
=
5382 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5383 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5384 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5385 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5386 coff_SWAP_scnhdr_out
,
5387 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5388 #ifdef COFF_LONG_FILENAMES
5393 #ifdef COFF_LONG_SECTION_NAMES
5398 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5399 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5404 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5409 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5410 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5411 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5412 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5413 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5414 coff_classify_symbol
, coff_compute_section_file_positions
,
5415 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5416 coff_adjust_symndx
, coff_link_add_one_symbol
,
5417 coff_link_output_has_begun
, coff_final_link_postscript
5421 /* COFF0 differs in file/section header size and relocation entry size. */
5422 static const bfd_coff_backend_data ticoff0_swap_table
=
5424 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5425 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5426 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5427 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5428 coff_SWAP_scnhdr_out
,
5429 FILHSZ_V0
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ_V0
, LINESZ
, FILNMLEN
,
5430 #ifdef COFF_LONG_FILENAMES
5435 #ifdef COFF_LONG_SECTION_NAMES
5440 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5441 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5446 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5451 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5452 coff_SWAP_reloc_in
, ticoff0_bad_format_hook
, coff_set_arch_mach_hook
,
5453 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5454 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5455 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5456 coff_classify_symbol
, coff_compute_section_file_positions
,
5457 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5458 coff_adjust_symndx
, coff_link_add_one_symbol
,
5459 coff_link_output_has_begun
, coff_final_link_postscript
5464 /* COFF1 differs in section header size. */
5465 static const bfd_coff_backend_data ticoff1_swap_table
=
5467 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5468 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5469 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5470 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5471 coff_SWAP_scnhdr_out
,
5472 FILHSZ
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5473 #ifdef COFF_LONG_FILENAMES
5478 #ifdef COFF_LONG_SECTION_NAMES
5483 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5484 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5489 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5494 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5495 coff_SWAP_reloc_in
, ticoff1_bad_format_hook
, coff_set_arch_mach_hook
,
5496 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5497 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5498 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5499 coff_classify_symbol
, coff_compute_section_file_positions
,
5500 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5501 coff_adjust_symndx
, coff_link_add_one_symbol
,
5502 coff_link_output_has_begun
, coff_final_link_postscript
5506 #ifndef coff_close_and_cleanup
5507 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5510 #ifndef coff_bfd_free_cached_info
5511 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5514 #ifndef coff_get_section_contents
5515 #define coff_get_section_contents _bfd_generic_get_section_contents
5518 #ifndef coff_bfd_copy_private_symbol_data
5519 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5522 #ifndef coff_bfd_copy_private_header_data
5523 #define coff_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
5526 #ifndef coff_bfd_copy_private_section_data
5527 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5530 #ifndef coff_bfd_copy_private_bfd_data
5531 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5534 #ifndef coff_bfd_merge_private_bfd_data
5535 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5538 #ifndef coff_bfd_set_private_flags
5539 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5542 #ifndef coff_bfd_print_private_bfd_data
5543 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5546 #ifndef coff_bfd_is_local_label_name
5547 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5550 #ifndef coff_read_minisymbols
5551 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5554 #ifndef coff_minisymbol_to_symbol
5555 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5558 /* The reloc lookup routine must be supplied by each individual COFF
5560 #ifndef coff_bfd_reloc_type_lookup
5561 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5564 #ifndef coff_bfd_get_relocated_section_contents
5565 #define coff_bfd_get_relocated_section_contents \
5566 bfd_generic_get_relocated_section_contents
5569 #ifndef coff_bfd_relax_section
5570 #define coff_bfd_relax_section bfd_generic_relax_section
5573 #ifndef coff_bfd_gc_sections
5574 #define coff_bfd_gc_sections bfd_generic_gc_sections
5577 #ifndef coff_bfd_merge_sections
5578 #define coff_bfd_merge_sections bfd_generic_merge_sections
5581 #ifndef coff_bfd_is_group_section
5582 #define coff_bfd_is_group_section bfd_generic_is_group_section
5585 #ifndef coff_bfd_discard_group
5586 #define coff_bfd_discard_group bfd_generic_discard_group
5589 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5590 const bfd_target VAR = \
5593 bfd_target_coff_flavour, \
5594 BFD_ENDIAN_BIG, /* data byte order is big */ \
5595 BFD_ENDIAN_BIG, /* header byte order is big */ \
5596 /* object flags */ \
5597 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5598 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5599 /* section flags */ \
5600 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5601 UNDER, /* leading symbol underscore */ \
5602 '/', /* ar_pad_char */ \
5603 15, /* ar_max_namelen */ \
5605 /* Data conversion functions. */ \
5606 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5607 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5608 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5610 /* Header conversion functions. */ \
5611 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5612 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5613 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5615 /* bfd_check_format */ \
5616 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5617 _bfd_dummy_target }, \
5618 /* bfd_set_format */ \
5619 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5620 /* bfd_write_contents */ \
5621 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5624 BFD_JUMP_TABLE_GENERIC (coff), \
5625 BFD_JUMP_TABLE_COPY (coff), \
5626 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5627 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5628 BFD_JUMP_TABLE_SYMBOLS (coff), \
5629 BFD_JUMP_TABLE_RELOCS (coff), \
5630 BFD_JUMP_TABLE_WRITE (coff), \
5631 BFD_JUMP_TABLE_LINK (coff), \
5632 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5639 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5640 const bfd_target VAR = \
5643 bfd_target_coff_flavour, \
5644 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
5645 BFD_ENDIAN_BIG, /* header byte order is big */ \
5646 /* object flags */ \
5647 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5648 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5649 /* section flags */ \
5650 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5651 UNDER, /* leading symbol underscore */ \
5652 '/', /* ar_pad_char */ \
5653 15, /* ar_max_namelen */ \
5655 /* Data conversion functions. */ \
5656 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5657 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5658 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5660 /* Header conversion functions. */ \
5661 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5662 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5663 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5665 /* bfd_check_format */ \
5666 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5667 _bfd_dummy_target }, \
5668 /* bfd_set_format */ \
5669 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5670 /* bfd_write_contents */ \
5671 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5674 BFD_JUMP_TABLE_GENERIC (coff), \
5675 BFD_JUMP_TABLE_COPY (coff), \
5676 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5677 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5678 BFD_JUMP_TABLE_SYMBOLS (coff), \
5679 BFD_JUMP_TABLE_RELOCS (coff), \
5680 BFD_JUMP_TABLE_WRITE (coff), \
5681 BFD_JUMP_TABLE_LINK (coff), \
5682 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5689 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5690 const bfd_target VAR = \
5693 bfd_target_coff_flavour, \
5694 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
5695 BFD_ENDIAN_LITTLE, /* header byte order is little */ \
5696 /* object flags */ \
5697 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5698 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5699 /* section flags */ \
5700 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5701 UNDER, /* leading symbol underscore */ \
5702 '/', /* ar_pad_char */ \
5703 15, /* ar_max_namelen */ \
5705 /* Data conversion functions. */ \
5706 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5707 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5708 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5709 /* Header conversion functions. */ \
5710 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5711 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5712 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5713 /* bfd_check_format */ \
5714 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5715 _bfd_dummy_target }, \
5716 /* bfd_set_format */ \
5717 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5718 /* bfd_write_contents */ \
5719 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5722 BFD_JUMP_TABLE_GENERIC (coff), \
5723 BFD_JUMP_TABLE_COPY (coff), \
5724 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5725 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5726 BFD_JUMP_TABLE_SYMBOLS (coff), \
5727 BFD_JUMP_TABLE_RELOCS (coff), \
5728 BFD_JUMP_TABLE_WRITE (coff), \
5729 BFD_JUMP_TABLE_LINK (coff), \
5730 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \