1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
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 static long sec_to_styp_flags
313 PARAMS ((const char *, flagword
));
314 static bfd_boolean styp_to_sec_flags
315 PARAMS ((bfd
*, PTR
, const char *, asection
*, flagword
*));
316 static bfd_boolean coff_bad_format_hook
317 PARAMS ((bfd
*, PTR
));
318 static void coff_set_custom_section_alignment
319 PARAMS ((bfd
*, asection
*, const struct coff_section_alignment_entry
*,
320 const unsigned int));
321 static bfd_boolean coff_new_section_hook
322 PARAMS ((bfd
*, asection
*));
323 static bfd_boolean coff_set_arch_mach_hook
324 PARAMS ((bfd
*, PTR
));
325 static bfd_boolean coff_write_relocs
326 PARAMS ((bfd
*, int));
327 static bfd_boolean coff_set_flags
328 PARAMS ((bfd
*, unsigned int *, unsigned short *));
329 static bfd_boolean coff_set_arch_mach
330 PARAMS ((bfd
*, enum bfd_architecture
, unsigned long)) ATTRIBUTE_UNUSED
;
331 static bfd_boolean coff_compute_section_file_positions
333 static bfd_boolean coff_write_object_contents
334 PARAMS ((bfd
*)) ATTRIBUTE_UNUSED
;
335 static bfd_boolean coff_set_section_contents
336 PARAMS ((bfd
*, asection
*, PTR
, file_ptr
, bfd_size_type
));
337 static PTR buy_and_read
338 PARAMS ((bfd
*, file_ptr
, bfd_size_type
));
339 static bfd_boolean coff_slurp_line_table
340 PARAMS ((bfd
*, asection
*));
341 static bfd_boolean coff_slurp_symbol_table
343 static enum coff_symbol_classification coff_classify_symbol
344 PARAMS ((bfd
*, struct internal_syment
*));
345 static bfd_boolean coff_slurp_reloc_table
346 PARAMS ((bfd
*, asection
*, asymbol
**));
347 static long coff_canonicalize_reloc
348 PARAMS ((bfd
*, asection
*, arelent
**, asymbol
**));
349 #ifndef coff_mkobject_hook
350 static PTR coff_mkobject_hook
351 PARAMS ((bfd
*, PTR
, PTR
));
354 static flagword handle_COMDAT
355 PARAMS ((bfd
*, flagword
, PTR
, const char *, asection
*));
357 #ifdef COFF_IMAGE_WITH_PE
358 static bfd_boolean coff_read_word
359 PARAMS ((bfd
*, unsigned int *));
360 static unsigned int coff_compute_checksum
362 static bfd_boolean coff_apply_checksum
366 /* void warning(); */
368 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
369 the incoming SEC_* flags. The inverse of this function is
370 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
371 should probably mirror the changes in styp_to_sec_flags(). */
375 /* Macros for setting debugging flags. */
377 #define STYP_XCOFF_DEBUG STYP_DEBUG
379 #define STYP_XCOFF_DEBUG STYP_INFO
382 #ifdef COFF_ALIGN_IN_S_FLAGS
383 #define STYP_DEBUG_INFO STYP_DSECT
385 #define STYP_DEBUG_INFO STYP_INFO
389 sec_to_styp_flags (sec_name
, sec_flags
)
390 const char *sec_name
;
395 if (!strcmp (sec_name
, _TEXT
))
397 styp_flags
= STYP_TEXT
;
399 else if (!strcmp (sec_name
, _DATA
))
401 styp_flags
= STYP_DATA
;
403 else if (!strcmp (sec_name
, _BSS
))
405 styp_flags
= STYP_BSS
;
408 else if (!strcmp (sec_name
, _COMMENT
))
410 styp_flags
= STYP_INFO
;
411 #endif /* _COMMENT */
414 else if (!strcmp (sec_name
, _LIB
))
416 styp_flags
= STYP_LIB
;
420 else if (!strcmp (sec_name
, _LIT
))
422 styp_flags
= STYP_LIT
;
425 else if (!strncmp (sec_name
, ".debug", 6))
427 /* Handle the XCOFF debug section and DWARF2 debug sections. */
429 styp_flags
= STYP_XCOFF_DEBUG
;
431 styp_flags
= STYP_DEBUG_INFO
;
433 else if (!strncmp (sec_name
, ".stab", 5))
435 styp_flags
= STYP_DEBUG_INFO
;
437 #ifdef COFF_LONG_SECTION_NAMES
438 else if (!strncmp (sec_name
, ".gnu.linkonce.wi.", 17))
440 styp_flags
= STYP_DEBUG_INFO
;
444 else if (!strcmp (sec_name
, _PAD
))
446 styp_flags
= STYP_PAD
;
448 else if (!strcmp (sec_name
, _LOADER
))
450 styp_flags
= STYP_LOADER
;
452 else if (!strcmp (sec_name
, _EXCEPT
))
454 styp_flags
= STYP_EXCEPT
;
456 else if (!strcmp (sec_name
, _TYPCHK
))
458 styp_flags
= STYP_TYPCHK
;
461 /* Try and figure out what it should be */
462 else if (sec_flags
& SEC_CODE
)
464 styp_flags
= STYP_TEXT
;
466 else if (sec_flags
& SEC_DATA
)
468 styp_flags
= STYP_DATA
;
470 else if (sec_flags
& SEC_READONLY
)
472 #ifdef STYP_LIT /* 29k readonly text/data section */
473 styp_flags
= STYP_LIT
;
475 styp_flags
= STYP_TEXT
;
476 #endif /* STYP_LIT */
478 else if (sec_flags
& SEC_LOAD
)
480 styp_flags
= STYP_TEXT
;
482 else if (sec_flags
& SEC_ALLOC
)
484 styp_flags
= STYP_BSS
;
488 if (sec_flags
& SEC_CLINK
)
489 styp_flags
|= STYP_CLINK
;
493 if (sec_flags
& SEC_BLOCK
)
494 styp_flags
|= STYP_BLOCK
;
498 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
499 styp_flags
|= STYP_NOLOAD
;
505 #else /* COFF_WITH_PE */
507 /* The PE version; see above for the general comments. The non-PE
508 case seems to be more guessing, and breaks PE format; specifically,
509 .rdata is readonly, but it sure ain't text. Really, all this
510 should be set up properly in gas (or whatever assembler is in use),
511 and honor whatever objcopy/strip, etc. sent us as input. */
514 sec_to_styp_flags (sec_name
, sec_flags
)
515 const char *sec_name ATTRIBUTE_UNUSED
;
520 /* caution: there are at least three groups of symbols that have
521 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
522 SEC_* are the BFD internal flags, used for generic BFD
523 information. STYP_* are the COFF section flags which appear in
524 COFF files. IMAGE_SCN_* are the PE section flags which appear in
525 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
526 but there are more IMAGE_SCN_* flags. */
531 if ((sec_flags
& SEC_CODE
) != 0)
532 styp_flags
|= IMAGE_SCN_CNT_CODE
;
533 if ((sec_flags
& SEC_DATA
) != 0)
534 styp_flags
|= IMAGE_SCN_CNT_INITIALIZED_DATA
;
535 if ((sec_flags
& SEC_ALLOC
) != 0 && (sec_flags
& SEC_LOAD
) == 0)
536 styp_flags
|= IMAGE_SCN_CNT_UNINITIALIZED_DATA
; /* ==STYP_BSS */
538 /* skip constRUCTOR */
541 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
542 styp_flags
|= STYP_NOLOAD
;
544 if ((sec_flags
& SEC_IS_COMMON
) != 0)
545 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
546 if ((sec_flags
& SEC_DEBUGGING
) != 0)
547 styp_flags
|= IMAGE_SCN_MEM_DISCARDABLE
;
548 if ((sec_flags
& SEC_EXCLUDE
) != 0)
549 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
550 if ((sec_flags
& SEC_NEVER_LOAD
) != 0)
551 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
554 if (sec_flags
& SEC_LINK_ONCE
)
555 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
556 /* skip LINK_DUPLICATES */
557 /* skip LINKER_CREATED */
559 /* For now, the read/write bits are mapped onto SEC_READONLY, even
560 though the semantics don't quite match. The bits from the input
561 are retained in pei_section_data(abfd, section)->pe_flags. */
563 styp_flags
|= IMAGE_SCN_MEM_READ
; /* Always readable. */
564 if ((sec_flags
& SEC_READONLY
) == 0)
565 styp_flags
|= IMAGE_SCN_MEM_WRITE
; /* Invert READONLY for write. */
566 if (sec_flags
& SEC_CODE
)
567 styp_flags
|= IMAGE_SCN_MEM_EXECUTE
; /* CODE->EXECUTE. */
568 if (sec_flags
& SEC_SHARED
)
569 styp_flags
|= IMAGE_SCN_MEM_SHARED
; /* Shared remains meaningful. */
574 #endif /* COFF_WITH_PE */
576 /* Return a word with SEC_* flags set to represent the incoming STYP_*
577 flags (from scnhdr.s_flags). The inverse of this function is
578 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
579 should probably mirror the changes in sec_to_styp_flags(). */
584 styp_to_sec_flags (abfd
, hdr
, name
, section
, flags_ptr
)
585 bfd
*abfd ATTRIBUTE_UNUSED
;
588 asection
*section ATTRIBUTE_UNUSED
;
591 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
592 long styp_flags
= internal_s
->s_flags
;
593 flagword sec_flags
= 0;
596 if (styp_flags
& STYP_BLOCK
)
597 sec_flags
|= SEC_BLOCK
;
601 if (styp_flags
& STYP_CLINK
)
602 sec_flags
|= SEC_CLINK
;
606 if (styp_flags
& STYP_NOLOAD
)
607 sec_flags
|= SEC_NEVER_LOAD
;
608 #endif /* STYP_NOLOAD */
610 /* For 386 COFF, at least, an unloadable text or data section is
611 actually a shared library section. */
612 if (styp_flags
& STYP_TEXT
)
614 if (sec_flags
& SEC_NEVER_LOAD
)
615 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
617 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
619 else if (styp_flags
& STYP_DATA
)
621 if (sec_flags
& SEC_NEVER_LOAD
)
622 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
624 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
626 else if (styp_flags
& STYP_BSS
)
628 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
629 if (sec_flags
& SEC_NEVER_LOAD
)
630 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
633 sec_flags
|= SEC_ALLOC
;
635 else if (styp_flags
& STYP_INFO
)
637 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
638 defined. coff_compute_section_file_positions uses
639 COFF_PAGE_SIZE to ensure that the low order bits of the
640 section VMA and the file offset match. If we don't know
641 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
642 and demand page loading of the file will fail. */
643 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
644 sec_flags
|= SEC_DEBUGGING
;
647 else if (styp_flags
& STYP_PAD
)
649 else if (strcmp (name
, _TEXT
) == 0)
651 if (sec_flags
& SEC_NEVER_LOAD
)
652 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
654 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
656 else if (strcmp (name
, _DATA
) == 0)
658 if (sec_flags
& SEC_NEVER_LOAD
)
659 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
661 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
663 else if (strcmp (name
, _BSS
) == 0)
665 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
666 if (sec_flags
& SEC_NEVER_LOAD
)
667 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
670 sec_flags
|= SEC_ALLOC
;
672 else if (strncmp (name
, ".debug", 6) == 0
674 || strcmp (name
, _COMMENT
) == 0
676 #ifdef COFF_LONG_SECTION_NAMES
677 || strncmp (name
, ".gnu.linkonce.wi.", 17) == 0
679 || strncmp (name
, ".stab", 5) == 0)
681 #ifdef COFF_PAGE_SIZE
682 sec_flags
|= SEC_DEBUGGING
;
686 else if (strcmp (name
, _LIB
) == 0)
690 else if (strcmp (name
, _LIT
) == 0)
691 sec_flags
= SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
694 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
696 #ifdef STYP_LIT /* A29k readonly text/data section type. */
697 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
698 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
699 #endif /* STYP_LIT */
701 #ifdef STYP_OTHER_LOAD /* Other loaded sections. */
702 if (styp_flags
& STYP_OTHER_LOAD
)
703 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
704 #endif /* STYP_SDATA */
706 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
707 /* As a GNU extension, if the name begins with .gnu.linkonce, we
708 only link a single copy of the section. This is used to support
709 g++. g++ will emit each template expansion in its own section.
710 The symbols will be defined as weak, so that multiple definitions
711 are permitted. The GNU linker extension is to actually discard
712 all but one of the sections. */
713 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
714 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
717 if (flags_ptr
== NULL
)
720 * flags_ptr
= sec_flags
;
724 #else /* COFF_WITH_PE */
727 handle_COMDAT (abfd
, sec_flags
, hdr
, name
, section
)
734 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
735 bfd_byte
*esymstart
, *esym
, *esymend
;
737 char *target_name
= NULL
;
739 sec_flags
|= SEC_LINK_ONCE
;
741 /* Unfortunately, the PE format stores essential information in
742 the symbol table, of all places. We need to extract that
743 information now, so that objdump and the linker will know how
744 to handle the section without worrying about the symbols. We
745 can't call slurp_symtab, because the linker doesn't want the
748 /* COMDAT sections are special. The first symbol is the section
749 symbol, which tells what kind of COMDAT section it is. The
750 second symbol is the "comdat symbol" - the one with the
751 unique name. GNU uses the section symbol for the unique
752 name; MS uses ".text" for every comdat section. Sigh. - DJ */
754 /* This is not mirrored in sec_to_styp_flags(), but there
755 doesn't seem to be a need to, either, and it would at best be
758 if (! _bfd_coff_get_external_symbols (abfd
))
761 esymstart
= esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
762 esymend
= esym
+ obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
764 while (esym
< esymend
)
766 struct internal_syment isym
;
767 char buf
[SYMNMLEN
+ 1];
770 bfd_coff_swap_sym_in (abfd
, (PTR
) esym
, (PTR
) &isym
);
772 if (sizeof (internal_s
->s_name
) > SYMNMLEN
)
774 /* This case implies that the matching
775 symbol name will be in the string table. */
779 if (isym
.n_scnum
== section
->target_index
)
781 /* According to the MSVC documentation, the first
782 TWO entries with the section # are both of
783 interest to us. The first one is the "section
784 symbol" (section name). The second is the comdat
785 symbol name. Here, we've found the first
786 qualifying entry; we distinguish it from the
787 second with a state flag.
789 In the case of gas-generated (at least until that
790 is fixed) .o files, it isn't necessarily the
791 second one. It may be some other later symbol.
793 Since gas also doesn't follow MS conventions and
794 emits the section similar to .text$<name>, where
795 <something> is the name we're looking for, we
796 distinguish the two as follows:
798 If the section name is simply a section name (no
799 $) we presume it's MS-generated, and look at
800 precisely the second symbol for the comdat name.
801 If the section name has a $, we assume it's
802 gas-generated, and look for <something> (whatever
803 follows the $) as the comdat symbol. */
805 /* All 3 branches use this. */
806 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
, buf
);
815 /* The first time we've seen the symbol. */
816 union internal_auxent aux
;
820 /* If it isn't the stuff we're expecting, die;
821 The MS documentation is vague, but it
822 appears that the second entry serves BOTH
823 as the comdat symbol and the defining
824 symbol record (either C_STAT or C_EXT,
825 possibly with an aux entry with debug
826 information if it's a function.) It
827 appears the only way to find the second one
828 is to count. (On Intel, they appear to be
829 adjacent, but on Alpha, they have been
832 Here, we think we've found the first one,
833 but there's some checking we can do to be
836 if (! (isym
.n_sclass
== C_STAT
837 && isym
.n_type
== T_NULL
838 && isym
.n_value
== 0))
841 /* FIXME LATER: MSVC generates section names
842 like .text for comdats. Gas generates
843 names like .text$foo__Fv (in the case of a
844 function). See comment above for more. */
846 if (strcmp (name
, symname
) != 0)
849 /* This is the section symbol. */
850 bfd_coff_swap_aux_in (abfd
, (PTR
) (esym
+ bfd_coff_symesz (abfd
)),
851 isym
.n_type
, isym
.n_sclass
,
852 0, isym
.n_numaux
, (PTR
) &aux
);
854 target_name
= strchr (name
, '$');
855 if (target_name
!= NULL
)
863 /* FIXME: Microsoft uses NODUPLICATES and
864 ASSOCIATIVE, but gnu uses ANY and
865 SAME_SIZE. Unfortunately, gnu doesn't do
866 the comdat symbols right. So, until we can
867 fix it to do the right thing, we are
868 temporarily disabling comdats for the MS
869 types (they're used in DLLs and C++, but we
870 don't support *their* C++ libraries anyway
873 /* Cygwin does not follow the MS style, and
874 uses ANY and SAME_SIZE where NODUPLICATES
875 and ASSOCIATIVE should be used. For
876 Interix, we just do the right thing up
879 switch (aux
.x_scn
.x_comdat
)
881 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
882 #ifdef STRICT_PE_FORMAT
883 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
885 sec_flags
&= ~SEC_LINK_ONCE
;
889 case IMAGE_COMDAT_SELECT_ANY
:
890 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
893 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
894 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
897 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
898 /* Not yet fully implemented ??? */
899 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
902 /* debug$S gets this case; other
905 /* There may be no symbol... we'll search
906 the whole table... Is this the right
907 place to play this game? Or should we do
908 it when reading it in. */
909 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
910 #ifdef STRICT_PE_FORMAT
911 /* FIXME: This is not currently implemented. */
912 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
914 sec_flags
&= ~SEC_LINK_ONCE
;
918 default: /* 0 means "no symbol" */
919 /* debug$F gets this case; other
921 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
928 /* Gas mode: the first matching on partial name. */
930 #ifndef TARGET_UNDERSCORE
931 #define TARGET_UNDERSCORE 0
933 /* Is this the name we're looking for ? */
934 if (strcmp (target_name
,
935 symname
+ (TARGET_UNDERSCORE
? 1 : 0)) != 0)
937 /* Not the name we're looking for */
938 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
943 /* MSVC mode: the lexically second symbol (or
944 drop through from the above). */
949 /* This must the second symbol with the
950 section #. It is the actual symbol name.
951 Intel puts the two adjacent, but Alpha (at
952 least) spreads them out. */
954 amt
= sizeof (struct bfd_comdat_info
);
955 section
->comdat
= bfd_alloc (abfd
, amt
);
956 if (section
->comdat
== NULL
)
959 section
->comdat
->symbol
=
960 (esym
- esymstart
) / bfd_coff_symesz (abfd
);
962 amt
= strlen (symname
) + 1;
963 newname
= bfd_alloc (abfd
, amt
);
967 strcpy (newname
, symname
);
968 section
->comdat
->name
= newname
;
975 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
983 /* The PE version; see above for the general comments.
985 Since to set the SEC_LINK_ONCE and associated flags, we have to
986 look at the symbol table anyway, we return the symbol table index
987 of the symbol being used as the COMDAT symbol. This is admittedly
988 ugly, but there's really nowhere else that we have access to the
989 required information. FIXME: Is the COMDAT symbol index used for
990 any purpose other than objdump? */
993 styp_to_sec_flags (abfd
, hdr
, name
, section
, flags_ptr
)
1000 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
1001 long styp_flags
= internal_s
->s_flags
;
1003 bfd_boolean result
= TRUE
;
1005 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
1006 sec_flags
= SEC_READONLY
;
1008 /* Process each flag bit in styp_flags in turn. */
1011 long flag
= styp_flags
& - styp_flags
;
1012 char * unhandled
= NULL
;
1014 styp_flags
&= ~ flag
;
1016 /* We infer from the distinct read/write/execute bits the settings
1017 of some of the bfd flags; the actual values, should we need them,
1018 are also in pei_section_data (abfd, section)->pe_flags. */
1023 unhandled
= "STYP_DSECT";
1026 unhandled
= "STYP_GROUP";
1029 unhandled
= "STYP_COPY";
1032 unhandled
= "STYP_OVER";
1034 #ifdef SEC_NEVER_LOAD
1036 sec_flags
|= SEC_NEVER_LOAD
;
1039 case IMAGE_SCN_MEM_READ
:
1040 /* Ignored, assume it always to be true. */
1042 case IMAGE_SCN_TYPE_NO_PAD
:
1045 case IMAGE_SCN_LNK_OTHER
:
1046 unhandled
= "IMAGE_SCN_LNK_OTHER";
1048 case IMAGE_SCN_MEM_NOT_CACHED
:
1049 unhandled
= "IMAGE_SCN_MEM_NOT_CACHED";
1051 case IMAGE_SCN_MEM_NOT_PAGED
:
1052 unhandled
= "IMAGE_SCN_MEM_NOT_PAGED";
1054 case IMAGE_SCN_MEM_EXECUTE
:
1055 sec_flags
|= SEC_CODE
;
1057 case IMAGE_SCN_MEM_WRITE
:
1058 sec_flags
&= ~ SEC_READONLY
;
1060 case IMAGE_SCN_MEM_DISCARDABLE
:
1061 sec_flags
|= SEC_DEBUGGING
;
1063 case IMAGE_SCN_MEM_SHARED
:
1064 sec_flags
|= SEC_SHARED
;
1066 case IMAGE_SCN_LNK_REMOVE
:
1067 sec_flags
|= SEC_EXCLUDE
;
1069 case IMAGE_SCN_CNT_CODE
:
1070 sec_flags
|= SEC_CODE
| SEC_ALLOC
| SEC_LOAD
;
1072 case IMAGE_SCN_CNT_INITIALIZED_DATA
:
1073 sec_flags
|= SEC_DATA
| SEC_ALLOC
| SEC_LOAD
;
1075 case IMAGE_SCN_CNT_UNINITIALIZED_DATA
:
1076 sec_flags
|= SEC_ALLOC
;
1078 case IMAGE_SCN_LNK_INFO
:
1079 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1080 defined. coff_compute_section_file_positions uses
1081 COFF_PAGE_SIZE to ensure that the low order bits of the
1082 section VMA and the file offset match. If we don't know
1083 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1084 and demand page loading of the file will fail. */
1085 #ifdef COFF_PAGE_SIZE
1086 sec_flags
|= SEC_DEBUGGING
;
1089 case IMAGE_SCN_LNK_COMDAT
:
1090 /* COMDAT gets very special treatment. */
1091 sec_flags
= handle_COMDAT (abfd
, sec_flags
, hdr
, name
, section
);
1094 /* Silently ignore for now. */
1098 /* If the section flag was not handled, report it here. */
1099 if (unhandled
!= NULL
)
1101 (*_bfd_error_handler
)
1102 (_("%s (%s): Section flag %s (0x%x) ignored"),
1103 bfd_archive_filename (abfd
), name
, unhandled
, flag
);
1108 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1109 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1110 only link a single copy of the section. This is used to support
1111 g++. g++ will emit each template expansion in its own section.
1112 The symbols will be defined as weak, so that multiple definitions
1113 are permitted. The GNU linker extension is to actually discard
1114 all but one of the sections. */
1115 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
1116 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1120 * flags_ptr
= sec_flags
;
1125 #endif /* COFF_WITH_PE */
1127 #define get_index(symbol) ((symbol)->udata.i)
1131 bfd_coff_backend_data
1135 .{* COFF symbol classifications. *}
1137 .enum coff_symbol_classification
1139 . {* Global symbol. *}
1140 . COFF_SYMBOL_GLOBAL,
1141 . {* Common symbol. *}
1142 . COFF_SYMBOL_COMMON,
1143 . {* Undefined symbol. *}
1144 . COFF_SYMBOL_UNDEFINED,
1145 . {* Local symbol. *}
1146 . COFF_SYMBOL_LOCAL,
1147 . {* PE section symbol. *}
1148 . COFF_SYMBOL_PE_SECTION
1151 Special entry points for gdb to swap in coff symbol table parts:
1154 . void (*_bfd_coff_swap_aux_in)
1155 . PARAMS ((bfd *, PTR, int, int, int, int, PTR));
1157 . void (*_bfd_coff_swap_sym_in)
1158 . PARAMS ((bfd *, PTR, PTR));
1160 . void (*_bfd_coff_swap_lineno_in)
1161 . PARAMS ((bfd *, PTR, PTR));
1163 . unsigned int (*_bfd_coff_swap_aux_out)
1164 . PARAMS ((bfd *, PTR, int, int, int, int, PTR));
1166 . unsigned int (*_bfd_coff_swap_sym_out)
1167 . PARAMS ((bfd *, PTR, PTR));
1169 . unsigned int (*_bfd_coff_swap_lineno_out)
1170 . PARAMS ((bfd *, PTR, PTR));
1172 . unsigned int (*_bfd_coff_swap_reloc_out)
1173 . PARAMS ((bfd *, PTR, PTR));
1175 . unsigned int (*_bfd_coff_swap_filehdr_out)
1176 . PARAMS ((bfd *, PTR, PTR));
1178 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1179 . PARAMS ((bfd *, PTR, PTR));
1181 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1182 . PARAMS ((bfd *, PTR, PTR));
1184 . unsigned int _bfd_filhsz;
1185 . unsigned int _bfd_aoutsz;
1186 . unsigned int _bfd_scnhsz;
1187 . unsigned int _bfd_symesz;
1188 . unsigned int _bfd_auxesz;
1189 . unsigned int _bfd_relsz;
1190 . unsigned int _bfd_linesz;
1191 . unsigned int _bfd_filnmlen;
1192 . bfd_boolean _bfd_coff_long_filenames;
1193 . bfd_boolean _bfd_coff_long_section_names;
1194 . unsigned int _bfd_coff_default_section_alignment_power;
1195 . bfd_boolean _bfd_coff_force_symnames_in_strings;
1196 . unsigned int _bfd_coff_debug_string_prefix_length;
1198 . void (*_bfd_coff_swap_filehdr_in)
1199 . PARAMS ((bfd *, PTR, PTR));
1201 . void (*_bfd_coff_swap_aouthdr_in)
1202 . PARAMS ((bfd *, PTR, PTR));
1204 . void (*_bfd_coff_swap_scnhdr_in)
1205 . PARAMS ((bfd *, PTR, PTR));
1207 . void (*_bfd_coff_swap_reloc_in)
1208 . PARAMS ((bfd *abfd, PTR, PTR));
1210 . bfd_boolean (*_bfd_coff_bad_format_hook)
1211 . PARAMS ((bfd *, PTR));
1213 . bfd_boolean (*_bfd_coff_set_arch_mach_hook)
1214 . PARAMS ((bfd *, PTR));
1216 . PTR (*_bfd_coff_mkobject_hook)
1217 . PARAMS ((bfd *, PTR, PTR));
1219 . bfd_boolean (*_bfd_styp_to_sec_flags_hook)
1220 . PARAMS ((bfd *, PTR, const char *, asection *, flagword *));
1222 . void (*_bfd_set_alignment_hook)
1223 . PARAMS ((bfd *, asection *, PTR));
1225 . bfd_boolean (*_bfd_coff_slurp_symbol_table)
1228 . bfd_boolean (*_bfd_coff_symname_in_debug)
1229 . PARAMS ((bfd *, struct internal_syment *));
1231 . bfd_boolean (*_bfd_coff_pointerize_aux_hook)
1232 . PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
1233 . unsigned int, combined_entry_type *));
1235 . bfd_boolean (*_bfd_coff_print_aux)
1236 . PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1237 . combined_entry_type *, unsigned int));
1239 . void (*_bfd_coff_reloc16_extra_cases)
1240 . PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1241 . bfd_byte *, unsigned int *, unsigned int *));
1243 . int (*_bfd_coff_reloc16_estimate)
1244 . PARAMS ((bfd *, asection *, arelent *, unsigned int,
1245 . struct bfd_link_info *));
1247 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1248 . PARAMS ((bfd *, struct internal_syment *));
1250 . bfd_boolean (*_bfd_coff_compute_section_file_positions)
1253 . bfd_boolean (*_bfd_coff_start_final_link)
1254 . PARAMS ((bfd *, struct bfd_link_info *));
1256 . bfd_boolean (*_bfd_coff_relocate_section)
1257 . PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1258 . struct internal_reloc *, struct internal_syment *, asection **));
1260 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1261 . PARAMS ((bfd *, asection *, struct internal_reloc *,
1262 . struct coff_link_hash_entry *, struct internal_syment *,
1265 . bfd_boolean (*_bfd_coff_adjust_symndx)
1266 . PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
1267 . struct internal_reloc *, bfd_boolean *));
1269 . bfd_boolean (*_bfd_coff_link_add_one_symbol)
1270 . PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword,
1271 . asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
1272 . struct bfd_link_hash_entry **));
1274 . bfd_boolean (*_bfd_coff_link_output_has_begun)
1275 . PARAMS ((bfd *, struct coff_final_link_info *));
1277 . bfd_boolean (*_bfd_coff_final_link_postscript)
1278 . PARAMS ((bfd *, struct coff_final_link_info *));
1280 .} bfd_coff_backend_data;
1282 .#define coff_backend_info(abfd) \
1283 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1285 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1286 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1288 .#define bfd_coff_swap_sym_in(a,e,i) \
1289 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1291 .#define bfd_coff_swap_lineno_in(a,e,i) \
1292 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1294 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1295 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1297 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1298 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1300 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1301 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1303 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1304 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1306 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1307 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1309 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1310 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1312 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1313 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1315 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1316 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1317 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1318 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1319 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1320 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1321 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1322 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1323 .#define bfd_coff_long_filenames(abfd) \
1324 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1325 .#define bfd_coff_long_section_names(abfd) \
1326 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1327 .#define bfd_coff_default_section_alignment_power(abfd) \
1328 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1329 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1330 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1332 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1333 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1335 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1336 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1338 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1339 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1341 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1342 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1344 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1345 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1346 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1347 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1348 . (abfd, filehdr, aouthdr))
1350 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1351 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1352 . (abfd, scnhdr, name, section, flags_ptr))
1354 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1355 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1357 .#define bfd_coff_slurp_symbol_table(abfd)\
1358 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1360 .#define bfd_coff_symname_in_debug(abfd, sym)\
1361 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1363 .#define bfd_coff_force_symnames_in_strings(abfd)\
1364 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1366 .#define bfd_coff_debug_string_prefix_length(abfd)\
1367 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1369 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1370 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1371 . (abfd, file, base, symbol, aux, indaux))
1373 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1374 . reloc, data, src_ptr, dst_ptr)\
1375 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1376 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1378 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1379 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1380 . (abfd, section, reloc, shrink, link_info))
1382 .#define bfd_coff_classify_symbol(abfd, sym)\
1383 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1386 .#define bfd_coff_compute_section_file_positions(abfd)\
1387 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1390 .#define bfd_coff_start_final_link(obfd, info)\
1391 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1393 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1394 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1395 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1396 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1397 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1398 . (abfd, sec, rel, h, sym, addendp))
1399 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1400 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1401 . (obfd, info, ibfd, sec, rel, adjustedp))
1402 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1403 . value, string, cp, coll, hashp)\
1404 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1405 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1407 .#define bfd_coff_link_output_has_begun(a,p) \
1408 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p))
1409 .#define bfd_coff_final_link_postscript(a,p) \
1410 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
1414 /* See whether the magic number matches. */
1417 coff_bad_format_hook (abfd
, filehdr
)
1418 bfd
* abfd ATTRIBUTE_UNUSED
;
1421 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1423 if (BADMAG (*internal_f
))
1426 /* If the optional header is NULL or not the correct size then
1427 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1428 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1429 optional header is of a different size.
1431 But the mips keeps extra stuff in it's opthdr, so dont check
1434 #if defined(M88) || defined(I960)
1435 if (internal_f
->f_opthdr
!= 0 && bfd_coff_aoutsz (abfd
) != internal_f
->f_opthdr
)
1442 /* Check whether this section uses an alignment other than the
1446 coff_set_custom_section_alignment (abfd
, section
, alignment_table
, table_size
)
1447 bfd
*abfd ATTRIBUTE_UNUSED
;
1449 const struct coff_section_alignment_entry
*alignment_table
;
1450 const unsigned int table_size
;
1452 const unsigned int default_alignment
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1455 for (i
= 0; i
< table_size
; ++i
)
1457 const char *secname
= bfd_get_section_name (abfd
, section
);
1459 if (alignment_table
[i
].comparison_length
== (unsigned int) -1
1460 ? strcmp (alignment_table
[i
].name
, secname
) == 0
1461 : strncmp (alignment_table
[i
].name
, secname
,
1462 alignment_table
[i
].comparison_length
) == 0)
1465 if (i
>= table_size
)
1468 if (alignment_table
[i
].default_alignment_min
!= COFF_ALIGNMENT_FIELD_EMPTY
1469 && default_alignment
< alignment_table
[i
].default_alignment_min
)
1472 if (alignment_table
[i
].default_alignment_max
!= COFF_ALIGNMENT_FIELD_EMPTY
1473 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1474 && default_alignment
> alignment_table
[i
].default_alignment_max
1479 section
->alignment_power
= alignment_table
[i
].alignment_power
;
1482 /* Custom section alignment records. */
1484 static const struct coff_section_alignment_entry
1485 coff_section_alignment_table
[] =
1487 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1488 COFF_SECTION_ALIGNMENT_ENTRIES
,
1490 /* There must not be any gaps between .stabstr sections. */
1491 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1492 1, COFF_ALIGNMENT_FIELD_EMPTY
, 0 },
1493 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1494 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1495 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1496 /* Similarly for the .ctors and .dtors sections. */
1497 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1498 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1499 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1500 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 }
1503 static const unsigned int coff_section_alignment_table_size
=
1504 sizeof coff_section_alignment_table
/ sizeof coff_section_alignment_table
[0];
1506 /* Initialize a section structure with information peculiar to this
1507 particular implementation of COFF. */
1510 coff_new_section_hook (abfd
, section
)
1514 combined_entry_type
*native
;
1517 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1520 if (bfd_xcoff_text_align_power (abfd
) != 0
1521 && strcmp (bfd_get_section_name (abfd
, section
), ".text") == 0)
1522 section
->alignment_power
= bfd_xcoff_text_align_power (abfd
);
1523 if (bfd_xcoff_data_align_power (abfd
) != 0
1524 && strcmp (bfd_get_section_name (abfd
, section
), ".data") == 0)
1525 section
->alignment_power
= bfd_xcoff_data_align_power (abfd
);
1528 /* Allocate aux records for section symbols, to store size and
1531 @@ The 10 is a guess at a plausible maximum number of aux entries
1532 (but shouldn't be a constant). */
1533 amt
= sizeof (combined_entry_type
) * 10;
1534 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
1538 /* We don't need to set up n_name, n_value, or n_scnum in the native
1539 symbol information, since they'll be overriden by the BFD symbol
1540 anyhow. However, we do need to set the type and storage class,
1541 in case this symbol winds up getting written out. The value 0
1542 for n_numaux is already correct. */
1544 native
->u
.syment
.n_type
= T_NULL
;
1545 native
->u
.syment
.n_sclass
= C_STAT
;
1547 coffsymbol (section
->symbol
)->native
= native
;
1549 coff_set_custom_section_alignment (abfd
, section
,
1550 coff_section_alignment_table
,
1551 coff_section_alignment_table_size
);
1556 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1558 /* Set the alignment of a BFD section. */
1560 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1563 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1564 bfd
* abfd ATTRIBUTE_UNUSED
;
1568 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1572 /* Extract ALIGN from 2**ALIGN stored in section header. */
1573 for (i
= 0; i
< 32; i
++)
1574 if ((1 << i
) >= hdr
->s_align
)
1578 /* TI tools puts the alignment power in bits 8-11. */
1579 i
= (hdr
->s_flags
>> 8) & 0xF ;
1581 #ifdef COFF_DECODE_ALIGNMENT
1582 i
= COFF_DECODE_ALIGNMENT(hdr
->s_flags
);
1584 section
->alignment_power
= i
;
1586 #ifdef coff_set_section_load_page
1587 coff_set_section_load_page (section
, hdr
->s_page
);
1591 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1594 /* A couple of macros to help setting the alignment power field. */
1595 #define ALIGN_SET(field,x,y) \
1596 if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1598 section->alignment_power = y;\
1601 #define ELIFALIGN_SET(field,x,y) \
1602 else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1604 section->alignment_power = y;\
1607 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1610 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1611 bfd
* abfd ATTRIBUTE_UNUSED
;
1615 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1618 ALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_64BYTES
, 6)
1619 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_32BYTES
, 5)
1620 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_16BYTES
, 4)
1621 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_8BYTES
, 3)
1622 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_4BYTES
, 2)
1623 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_2BYTES
, 1)
1624 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_1BYTES
, 0)
1626 /* In a PE image file, the s_paddr field holds the virtual size of a
1627 section, while the s_size field holds the raw size. We also keep
1628 the original section flag value, since not every bit can be
1629 mapped onto a generic BFD section bit. */
1630 if (coff_section_data (abfd
, section
) == NULL
)
1632 amt
= sizeof (struct coff_section_tdata
);
1633 section
->used_by_bfd
= (PTR
) bfd_zalloc (abfd
, amt
);
1634 if (section
->used_by_bfd
== NULL
)
1636 /* FIXME: Return error. */
1640 if (pei_section_data (abfd
, section
) == NULL
)
1642 amt
= sizeof (struct pei_section_tdata
);
1643 coff_section_data (abfd
, section
)->tdata
= (PTR
) bfd_zalloc (abfd
, amt
);
1644 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1646 /* FIXME: Return error. */
1650 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1651 pei_section_data (abfd
, section
)->pe_flags
= hdr
->s_flags
;
1653 section
->lma
= hdr
->s_vaddr
;
1655 /* Check for extended relocs. */
1656 if (hdr
->s_flags
& IMAGE_SCN_LNK_NRELOC_OVFL
)
1658 struct external_reloc dst
;
1659 struct internal_reloc n
;
1660 file_ptr oldpos
= bfd_tell (abfd
);
1661 bfd_seek (abfd
, (file_ptr
) hdr
->s_relptr
, 0);
1662 if (bfd_bread ((PTR
) &dst
, (bfd_size_type
) bfd_coff_relsz (abfd
), abfd
)
1663 != bfd_coff_relsz (abfd
))
1666 coff_swap_reloc_in (abfd
, &dst
, &n
);
1667 bfd_seek (abfd
, oldpos
, 0);
1668 section
->reloc_count
= hdr
->s_nreloc
= n
.r_vaddr
;
1672 #undef ELIFALIGN_SET
1674 #else /* ! COFF_WITH_PE */
1677 /* We grossly abuse this function to handle XCOFF overflow headers.
1678 When we see one, we correct the reloc and line number counts in the
1679 real header, and remove the section we just created. */
1681 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1684 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1689 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1693 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1696 real_sec
= coff_section_from_bfd_index (abfd
, (int) hdr
->s_nreloc
);
1697 if (real_sec
== NULL
)
1700 real_sec
->reloc_count
= hdr
->s_paddr
;
1701 real_sec
->lineno_count
= hdr
->s_vaddr
;
1703 for (ps
= &abfd
->sections
; *ps
!= NULL
; ps
= &(*ps
)->next
)
1707 bfd_section_list_remove (abfd
, ps
);
1708 --abfd
->section_count
;
1714 #else /* ! RS6000COFF_C */
1716 #define coff_set_alignment_hook \
1717 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1719 #endif /* ! RS6000COFF_C */
1720 #endif /* ! COFF_WITH_PE */
1721 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1723 #ifndef coff_mkobject
1725 static bfd_boolean coff_mkobject
PARAMS ((bfd
*));
1728 coff_mkobject (abfd
)
1731 coff_data_type
*coff
;
1732 bfd_size_type amt
= sizeof (coff_data_type
);
1734 abfd
->tdata
.coff_obj_data
= (struct coff_tdata
*) bfd_zalloc (abfd
, amt
);
1735 if (abfd
->tdata
.coff_obj_data
== 0)
1737 coff
= coff_data (abfd
);
1738 coff
->symbols
= (coff_symbol_type
*) NULL
;
1739 coff
->conversion_table
= (unsigned int *) NULL
;
1740 coff
->raw_syments
= (struct coff_ptr_struct
*) NULL
;
1741 coff
->relocbase
= 0;
1742 coff
->local_toc_sym_map
= 0;
1744 /* make_abs_section(abfd);*/
1750 /* Create the COFF backend specific information. */
1752 #ifndef coff_mkobject_hook
1754 coff_mkobject_hook (abfd
, filehdr
, aouthdr
)
1757 PTR aouthdr ATTRIBUTE_UNUSED
;
1759 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1760 coff_data_type
*coff
;
1762 if (! coff_mkobject (abfd
))
1765 coff
= coff_data (abfd
);
1767 coff
->sym_filepos
= internal_f
->f_symptr
;
1769 /* These members communicate important constants about the symbol
1770 table to GDB's symbol-reading code. These `constants'
1771 unfortunately vary among coff implementations... */
1772 coff
->local_n_btmask
= N_BTMASK
;
1773 coff
->local_n_btshft
= N_BTSHFT
;
1774 coff
->local_n_tmask
= N_TMASK
;
1775 coff
->local_n_tshift
= N_TSHIFT
;
1776 coff
->local_symesz
= bfd_coff_symesz (abfd
);
1777 coff
->local_auxesz
= bfd_coff_auxesz (abfd
);
1778 coff
->local_linesz
= bfd_coff_linesz (abfd
);
1780 coff
->timestamp
= internal_f
->f_timdat
;
1782 obj_raw_syment_count (abfd
) =
1783 obj_conv_table_size (abfd
) =
1784 internal_f
->f_nsyms
;
1787 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
1788 abfd
->flags
|= DYNAMIC
;
1789 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= bfd_coff_aoutsz (abfd
))
1791 struct internal_aouthdr
*internal_a
=
1792 (struct internal_aouthdr
*) aouthdr
;
1793 struct xcoff_tdata
*xcoff
;
1795 xcoff
= xcoff_data (abfd
);
1796 # ifdef U803XTOCMAGIC
1797 xcoff
->xcoff64
= internal_f
->f_magic
== U803XTOCMAGIC
;
1801 xcoff
->full_aouthdr
= TRUE
;
1802 xcoff
->toc
= internal_a
->o_toc
;
1803 xcoff
->sntoc
= internal_a
->o_sntoc
;
1804 xcoff
->snentry
= internal_a
->o_snentry
;
1805 bfd_xcoff_text_align_power (abfd
) = internal_a
->o_algntext
;
1806 bfd_xcoff_data_align_power (abfd
) = internal_a
->o_algndata
;
1807 xcoff
->modtype
= internal_a
->o_modtype
;
1808 xcoff
->cputype
= internal_a
->o_cputype
;
1809 xcoff
->maxdata
= internal_a
->o_maxdata
;
1810 xcoff
->maxstack
= internal_a
->o_maxstack
;
1815 /* Set the flags field from the COFF header read in. */
1816 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
1821 /* FIXME: I'm not sure this is ever executed, since peicode.h
1822 defines coff_mkobject_hook. */
1823 if ((internal_f
->f_flags
& IMAGE_FILE_DEBUG_STRIPPED
) == 0)
1824 abfd
->flags
|= HAS_DEBUG
;
1831 /* Determine the machine architecture and type. FIXME: This is target
1832 dependent because the magic numbers are defined in the target
1833 dependent header files. But there is no particular need for this.
1834 If the magic numbers were moved to a separate file, this function
1835 would be target independent and would also be much more successful
1836 at linking together COFF files for different architectures. */
1839 coff_set_arch_mach_hook (abfd
, filehdr
)
1843 unsigned long machine
;
1844 enum bfd_architecture arch
;
1845 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1847 /* Zero selects the default machine for an arch. */
1849 switch (internal_f
->f_magic
)
1851 #ifdef OR32_MAGIC_BIG
1852 case OR32_MAGIC_BIG
:
1853 case OR32_MAGIC_LITTLE
:
1854 arch
= bfd_arch_or32
;
1859 arch
= bfd_arch_powerpc
;
1865 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler */
1866 case LYNXCOFFMAGIC
: /* shadows the m68k Lynx number below, sigh */
1867 arch
= bfd_arch_i386
;
1872 arch
= bfd_arch_ia64
;
1875 #ifdef A29K_MAGIC_BIG
1876 case A29K_MAGIC_BIG
:
1877 case A29K_MAGIC_LITTLE
:
1878 arch
= bfd_arch_a29k
;
1885 arch
= bfd_arch_arm
;
1886 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
1888 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
1889 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
1890 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
1892 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
1893 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
1894 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
1895 /* The COFF header does not have enough bits available
1896 to cover all the different ARM architectures. So
1897 we interpret F_ARM_5, the highest flag value to mean
1898 "the highest ARM architecture known to BFD" which is
1899 currently the XScale. */
1900 case F_ARM_5
: machine
= bfd_mach_arm_XScale
; break;
1904 asection
* arm_arch_section
;
1906 arm_arch_section
= bfd_get_section_by_name (abfd
, ".note");
1908 if (arm_arch_section
)
1910 bfd_byte buffer
[4];
1912 if (! bfd_get_section_contents (abfd
, arm_arch_section
, buffer
,
1913 (file_ptr
) 0, sizeof buffer
))
1914 (*_bfd_error_handler
)
1915 (_("%s: warning: unable to retrieve .note section from %s"),
1916 bfd_get_filename (abfd
));
1918 /* We have to extract the value this way to allow for a
1919 host whose endian-ness is different from the target. */
1920 machine
= bfd_get_32 (abfd
, buffer
);
1928 #ifdef MC68KBCSMAGIC
1931 #ifdef APOLLOM68KMAGIC
1932 case APOLLOM68KMAGIC
:
1934 #ifdef LYNXCOFFMAGIC
1937 arch
= bfd_arch_m68k
;
1938 machine
= bfd_mach_m68020
;
1945 arch
= bfd_arch_m88k
;
1951 arch
= bfd_arch_z8k
;
1952 switch (internal_f
->f_flags
& F_MACHMASK
)
1955 machine
= bfd_mach_z8001
;
1958 machine
= bfd_mach_z8002
;
1967 arch
= bfd_arch_i860
;
1974 arch
= bfd_arch_i960
;
1975 switch (F_I960TYPE
& internal_f
->f_flags
)
1979 machine
= bfd_mach_i960_core
;
1982 machine
= bfd_mach_i960_kb_sb
;
1985 machine
= bfd_mach_i960_mc
;
1988 machine
= bfd_mach_i960_xa
;
1991 machine
= bfd_mach_i960_ca
;
1994 machine
= bfd_mach_i960_ka_sa
;
1997 machine
= bfd_mach_i960_jx
;
2000 machine
= bfd_mach_i960_hx
;
2019 if (xcoff_data (abfd
)->cputype
!= -1)
2020 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
2023 /* We did not get a value from the a.out header. If the
2024 file has not been stripped, we may be able to get the
2025 architecture information from the first symbol, if it
2026 is a .file symbol. */
2027 if (obj_raw_syment_count (abfd
) == 0)
2032 struct internal_syment sym
;
2033 bfd_size_type amt
= bfd_coff_symesz (abfd
);
2035 buf
= (bfd_byte
*) bfd_malloc (amt
);
2036 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
2037 || bfd_bread (buf
, amt
, abfd
) != amt
)
2042 bfd_coff_swap_sym_in (abfd
, (PTR
) buf
, (PTR
) &sym
);
2043 if (sym
.n_sclass
== C_FILE
)
2044 cputype
= sym
.n_type
& 0xff;
2051 /* FIXME: We don't handle all cases here. */
2056 arch
= bfd_xcoff_architecture (abfd
);
2057 machine
= bfd_xcoff_machine (abfd
);
2061 arch
= bfd_arch_powerpc
;
2062 machine
= bfd_mach_ppc_601
;
2064 case 2: /* 64 bit PowerPC */
2065 arch
= bfd_arch_powerpc
;
2066 machine
= bfd_mach_ppc_620
;
2069 arch
= bfd_arch_powerpc
;
2070 machine
= bfd_mach_ppc
;
2073 arch
= bfd_arch_rs6000
;
2074 machine
= bfd_mach_rs6k
;
2083 arch
= bfd_arch_we32k
;
2089 arch
= bfd_arch_h8300
;
2090 machine
= bfd_mach_h8300
;
2091 /* !! FIXME this probably isn't the right place for this */
2092 abfd
->flags
|= BFD_IS_RELAXABLE
;
2098 arch
= bfd_arch_h8300
;
2099 machine
= bfd_mach_h8300h
;
2100 /* !! FIXME this probably isn't the right place for this */
2101 abfd
->flags
|= BFD_IS_RELAXABLE
;
2107 arch
= bfd_arch_h8300
;
2108 machine
= bfd_mach_h8300s
;
2109 /* !! FIXME this probably isn't the right place for this */
2110 abfd
->flags
|= BFD_IS_RELAXABLE
;
2114 #ifdef SH_ARCH_MAGIC_BIG
2115 case SH_ARCH_MAGIC_BIG
:
2116 case SH_ARCH_MAGIC_LITTLE
:
2118 case SH_ARCH_MAGIC_WINCE
:
2124 #ifdef MIPS_ARCH_MAGIC_WINCE
2125 case MIPS_ARCH_MAGIC_WINCE
:
2126 arch
= bfd_arch_mips
;
2132 arch
= bfd_arch_h8500
;
2138 #ifdef LYNXCOFFMAGIC
2141 arch
= bfd_arch_sparc
;
2147 arch
= bfd_arch_tic30
;
2152 #ifdef TICOFF_TARGET_ARCH
2153 /* This TI COFF section should be used by all new TI COFF v0 targets. */
2155 arch
= TICOFF_TARGET_ARCH
;
2156 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2162 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */
2163 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */
2166 switch (internal_f
->f_target_id
)
2170 arch
= TICOFF_TARGET_ARCH
;
2171 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2175 arch
= bfd_arch_obscure
;
2176 (*_bfd_error_handler
)
2177 (_("Unrecognized TI COFF target id '0x%x'"),
2178 internal_f
->f_target_id
);
2184 #ifdef TIC80_ARCH_MAGIC
2185 case TIC80_ARCH_MAGIC
:
2186 arch
= bfd_arch_tic80
;
2192 arch
= bfd_arch_mcore
;
2198 arch
= bfd_arch_w65
;
2202 default: /* Unreadable input file type. */
2203 arch
= bfd_arch_obscure
;
2207 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2211 #ifdef SYMNAME_IN_DEBUG
2213 static bfd_boolean symname_in_debug_hook
2214 PARAMS ((bfd
*, struct internal_syment
*));
2217 symname_in_debug_hook (abfd
, sym
)
2218 bfd
* abfd ATTRIBUTE_UNUSED
;
2219 struct internal_syment
*sym
;
2221 return SYMNAME_IN_DEBUG (sym
) != 0;
2226 #define symname_in_debug_hook \
2227 (bfd_boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
2234 #define FORCE_SYMNAMES_IN_STRINGS
2237 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
2239 static bfd_boolean coff_pointerize_aux_hook
2240 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
2241 unsigned int, combined_entry_type
*));
2244 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
2245 bfd
*abfd ATTRIBUTE_UNUSED
;
2246 combined_entry_type
*table_base
;
2247 combined_entry_type
*symbol
;
2248 unsigned int indaux
;
2249 combined_entry_type
*aux
;
2251 int class = symbol
->u
.syment
.n_sclass
;
2253 if ((class == C_EXT
|| class == C_HIDEXT
)
2254 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2256 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2258 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2259 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2260 aux
->fix_scnlen
= 1;
2263 /* Return TRUE to indicate that the caller should not do any
2264 further work on this auxent. */
2268 /* Return FALSE to indicate that this auxent should be handled by
2276 /* We don't want to pointerize bal entries. */
2278 static bfd_boolean coff_pointerize_aux_hook
2279 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
2280 unsigned int, combined_entry_type
*));
2283 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
2284 bfd
*abfd ATTRIBUTE_UNUSED
;
2285 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
2286 combined_entry_type
*symbol
;
2287 unsigned int indaux
;
2288 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
2290 /* Return TRUE if we don't want to pointerize this aux entry, which
2291 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2293 && (symbol
->u
.syment
.n_sclass
== C_LEAFPROC
2294 || symbol
->u
.syment
.n_sclass
== C_LEAFSTAT
2295 || symbol
->u
.syment
.n_sclass
== C_LEAFEXT
));
2300 #define coff_pointerize_aux_hook 0
2303 #endif /* ! RS6000COFF_C */
2305 /* Print an aux entry. This returns TRUE if it has printed it. */
2307 static bfd_boolean coff_print_aux
2308 PARAMS ((bfd
*, FILE *, combined_entry_type
*, combined_entry_type
*,
2309 combined_entry_type
*, unsigned int));
2312 coff_print_aux (abfd
, file
, table_base
, symbol
, aux
, indaux
)
2313 bfd
*abfd ATTRIBUTE_UNUSED
;
2314 FILE *file ATTRIBUTE_UNUSED
;
2315 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
2316 combined_entry_type
*symbol ATTRIBUTE_UNUSED
;
2317 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
2318 unsigned int indaux ATTRIBUTE_UNUSED
;
2321 if ((symbol
->u
.syment
.n_sclass
== C_EXT
2322 || symbol
->u
.syment
.n_sclass
== C_HIDEXT
)
2323 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2325 /* This is a csect entry. */
2326 fprintf (file
, "AUX ");
2327 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2329 BFD_ASSERT (! aux
->fix_scnlen
);
2331 fprintf (file
, "val %5lld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2333 fprintf (file
, "val %5ld", (long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2338 fprintf (file
, "indx ");
2339 if (! aux
->fix_scnlen
)
2341 fprintf (file
, "%4lld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2343 fprintf (file
, "%4ld", (long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2346 fprintf (file
, "%4ld",
2347 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2350 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2351 aux
->u
.auxent
.x_csect
.x_parmhash
,
2352 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2353 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2354 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2355 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2356 aux
->u
.auxent
.x_csect
.x_stab
,
2357 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2362 /* Return FALSE to indicate that no special action was taken. */
2370 To write relocations, the back end steps though the
2371 canonical relocation table and create an
2372 @code{internal_reloc}. The symbol index to use is removed from
2373 the @code{offset} field in the symbol table supplied. The
2374 address comes directly from the sum of the section base
2375 address and the relocation offset; the type is dug directly
2376 from the howto field. Then the @code{internal_reloc} is
2377 swapped into the shape of an @code{external_reloc} and written
2384 static int compare_arelent_ptr
PARAMS ((const PTR
, const PTR
));
2386 /* AUX's ld wants relocations to be sorted. */
2388 compare_arelent_ptr (x
, y
)
2392 const arelent
**a
= (const arelent
**) x
;
2393 const arelent
**b
= (const arelent
**) y
;
2394 bfd_size_type aadr
= (*a
)->address
;
2395 bfd_size_type badr
= (*b
)->address
;
2397 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2400 #endif /* TARG_AUX */
2403 coff_write_relocs (abfd
, first_undef
)
2409 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
2412 struct external_reloc dst
;
2419 /* Sort relocations before we write them out. */
2422 amt
= s
->reloc_count
;
2423 amt
*= sizeof (arelent
*);
2424 p
= (arelent
**) bfd_malloc (amt
);
2425 if (p
== NULL
&& s
->reloc_count
> 0)
2427 memcpy (p
, s
->orelocation
, (size_t) amt
);
2428 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2432 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2436 if (obj_pe (abfd
) && s
->reloc_count
>= 0xffff)
2438 /* Encode real count here as first reloc. */
2439 struct internal_reloc n
;
2441 memset ((PTR
) & n
, 0, sizeof (n
));
2442 /* Add one to count *this* reloc (grr). */
2443 n
.r_vaddr
= s
->reloc_count
+ 1;
2444 coff_swap_reloc_out (abfd
, &n
, &dst
);
2445 if (bfd_bwrite ((PTR
) & dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2446 abfd
) != bfd_coff_relsz (abfd
))
2451 for (i
= 0; i
< s
->reloc_count
; i
++)
2453 struct internal_reloc n
;
2456 memset ((PTR
) & n
, 0, sizeof (n
));
2458 /* Now we've renumbered the symbols we know where the
2459 undefined symbols live in the table. Check the reloc
2460 entries for symbols who's output bfd isn't the right one.
2461 This is because the symbol was undefined (which means
2462 that all the pointers are never made to point to the same
2463 place). This is a bad thing,'cause the symbols attached
2464 to the output bfd are indexed, so that the relocation
2465 entries know which symbol index they point to. So we
2466 have to look up the output symbol here. */
2468 if (q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2471 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2472 asymbol
**outsyms
= abfd
->outsymbols
;
2474 for (j
= first_undef
; outsyms
[j
]; j
++)
2476 const char *intable
= outsyms
[j
]->name
;
2478 if (strcmp (intable
, sname
) == 0) {
2479 /* Got a hit, so repoint the reloc. */
2480 q
->sym_ptr_ptr
= outsyms
+ j
;
2486 n
.r_vaddr
= q
->address
+ s
->vma
;
2489 /* The 29k const/consth reloc pair is a real kludge. The consth
2490 part doesn't have a symbol; it has an offset. So rebuilt
2492 if (q
->howto
->type
== R_IHCONST
)
2493 n
.r_symndx
= q
->addend
;
2498 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2499 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
,s
))
2501 if ((*q
->sym_ptr_ptr
)->section
== bfd_abs_section_ptr
2502 && ((*q
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) != 0)
2504 /* This is a relocation relative to the absolute symbol. */
2508 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2509 /* Take notice if the symbol reloc points to a symbol
2510 we don't have in our symbol table. What should we
2512 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2517 #ifdef SWAP_OUT_RELOC_OFFSET
2518 n
.r_offset
= q
->addend
;
2522 /* Work out reloc type from what is required. */
2523 SELECT_RELOC (n
, q
->howto
);
2525 n
.r_type
= q
->howto
->type
;
2527 coff_swap_reloc_out (abfd
, &n
, &dst
);
2529 if (bfd_bwrite ((PTR
) & dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2530 abfd
) != bfd_coff_relsz (abfd
))
2543 /* Set flags and magic number of a coff file from architecture and machine
2544 type. Result is TRUE if we can represent the arch&type, FALSE if not. */
2547 coff_set_flags (abfd
, magicp
, flagsp
)
2549 unsigned int *magicp ATTRIBUTE_UNUSED
;
2550 unsigned short *flagsp ATTRIBUTE_UNUSED
;
2552 switch (bfd_get_arch (abfd
))
2557 switch (bfd_get_mach (abfd
))
2559 case bfd_mach_z8001
:
2562 case bfd_mach_z8002
:
2576 *magicp
= I960ROMAGIC
;
2578 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2579 I960RWMAGIC); FIXME???
2581 switch (bfd_get_mach (abfd
))
2583 case bfd_mach_i960_core
:
2586 case bfd_mach_i960_kb_sb
:
2589 case bfd_mach_i960_mc
:
2592 case bfd_mach_i960_xa
:
2595 case bfd_mach_i960_ca
:
2598 case bfd_mach_i960_ka_sa
:
2601 case bfd_mach_i960_jx
:
2604 case bfd_mach_i960_hx
:
2617 case bfd_arch_tic30
:
2618 *magicp
= TIC30MAGIC
;
2622 #ifdef TICOFF_DEFAULT_MAGIC
2623 case TICOFF_TARGET_ARCH
:
2624 /* If there's no indication of which version we want, use the default. */
2626 *magicp
= TICOFF_DEFAULT_MAGIC
;
2629 /* We may want to output in a different COFF version. */
2630 switch (abfd
->xvec
->name
[4])
2633 *magicp
= TICOFF0MAGIC
;
2636 *magicp
= TICOFF1MAGIC
;
2639 *magicp
= TICOFF2MAGIC
;
2645 TICOFF_TARGET_MACHINE_SET (flagsp
, bfd_get_mach (abfd
));
2649 #ifdef TIC80_ARCH_MAGIC
2650 case bfd_arch_tic80
:
2651 *magicp
= TIC80_ARCH_MAGIC
;
2657 * magicp
= ARMPEMAGIC
;
2659 * magicp
= ARMMAGIC
;
2662 if (APCS_SET (abfd
))
2664 if (APCS_26_FLAG (abfd
))
2665 * flagsp
|= F_APCS26
;
2667 if (APCS_FLOAT_FLAG (abfd
))
2668 * flagsp
|= F_APCS_FLOAT
;
2670 if (PIC_FLAG (abfd
))
2673 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2674 * flagsp
|= F_INTERWORK
;
2675 switch (bfd_get_mach (abfd
))
2677 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2678 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2679 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2680 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2681 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2682 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2683 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2684 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2685 See also the comment in coff_set_arch_mach_hook(). */
2686 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break;
2687 case bfd_mach_arm_5TE
: * flagsp
|= F_ARM_5
; break;
2688 case bfd_mach_arm_XScale
: * flagsp
|= F_ARM_5
; break;
2693 case bfd_arch_powerpc
:
2700 *magicp
= I386MAGIC
;
2702 /* Just overwrite the usual value if we're doing Lynx. */
2703 *magicp
= LYNXCOFFMAGIC
;
2710 *magicp
= I860MAGIC
;
2716 *magicp
= IA64MAGIC
;
2722 #ifdef APOLLOM68KMAGIC
2723 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
2725 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2726 #ifdef NAMES_HAVE_UNDERSCORE
2727 *magicp
= MC68KBCSMAGIC
;
2729 *magicp
= MC68MAGIC
;
2733 /* Just overwrite the usual value if we're doing Lynx. */
2734 *magicp
= LYNXCOFFMAGIC
;
2742 *magicp
= MC88OMAGIC
;
2747 case bfd_arch_h8300
:
2748 switch (bfd_get_mach (abfd
))
2750 case bfd_mach_h8300
:
2751 *magicp
= H8300MAGIC
;
2753 case bfd_mach_h8300h
:
2754 *magicp
= H8300HMAGIC
;
2756 case bfd_mach_h8300s
:
2757 *magicp
= H8300SMAGIC
;
2763 #ifdef SH_ARCH_MAGIC_BIG
2765 #ifdef COFF_IMAGE_WITH_PE
2766 *magicp
= SH_ARCH_MAGIC_WINCE
;
2768 if (bfd_big_endian (abfd
))
2769 *magicp
= SH_ARCH_MAGIC_BIG
;
2771 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2777 #ifdef MIPS_ARCH_MAGIC_WINCE
2779 *magicp
= MIPS_ARCH_MAGIC_WINCE
;
2785 case bfd_arch_sparc
:
2786 *magicp
= SPARCMAGIC
;
2788 /* Just overwrite the usual value if we're doing Lynx. */
2789 *magicp
= LYNXCOFFMAGIC
;
2796 case bfd_arch_h8500
:
2797 *magicp
= H8500MAGIC
;
2801 #ifdef A29K_MAGIC_BIG
2803 if (bfd_big_endian (abfd
))
2804 *magicp
= A29K_MAGIC_BIG
;
2806 *magicp
= A29K_MAGIC_LITTLE
;
2812 case bfd_arch_we32k
:
2813 *magicp
= WE32KMAGIC
;
2819 case bfd_arch_rs6000
:
2821 case bfd_arch_powerpc
:
2823 BFD_ASSERT (bfd_get_flavour (abfd
) == bfd_target_xcoff_flavour
);
2824 *magicp
= bfd_xcoff_magic_number (abfd
);
2830 case bfd_arch_mcore
:
2831 * magicp
= MCOREMAGIC
;
2841 #ifdef OR32_MAGIC_BIG
2843 if (bfd_big_endian (abfd
))
2844 * magicp
= OR32_MAGIC_BIG
;
2846 * magicp
= OR32_MAGIC_LITTLE
;
2850 default: /* Unknown architecture. */
2851 /* Fall through to "return FALSE" below, to avoid
2852 "statement never reached" errors on the one below. */
2860 coff_set_arch_mach (abfd
, arch
, machine
)
2862 enum bfd_architecture arch
;
2863 unsigned long machine
;
2866 unsigned short dummy2
;
2868 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
2871 if (arch
!= bfd_arch_unknown
2872 && ! coff_set_flags (abfd
, &dummy1
, &dummy2
))
2873 return FALSE
; /* We can't represent this type */
2875 return TRUE
; /* We're easy ... */
2878 #ifdef COFF_IMAGE_WITH_PE
2880 /* This is used to sort sections by VMA, as required by PE image
2883 static int sort_by_secaddr
PARAMS ((const PTR
, const PTR
));
2886 sort_by_secaddr (arg1
, arg2
)
2890 const asection
*a
= *(const asection
**) arg1
;
2891 const asection
*b
= *(const asection
**) arg2
;
2893 if (a
->vma
< b
->vma
)
2895 else if (a
->vma
> b
->vma
)
2901 #endif /* COFF_IMAGE_WITH_PE */
2903 /* Calculate the file position for each section. */
2906 #define ALIGN_SECTIONS_IN_FILE
2908 #if defined(TIC80COFF) || defined(TICOFF)
2909 #undef ALIGN_SECTIONS_IN_FILE
2913 coff_compute_section_file_positions (abfd
)
2917 asection
*previous
= (asection
*) NULL
;
2918 file_ptr sofar
= bfd_coff_filhsz (abfd
);
2919 bfd_boolean align_adjust
;
2920 #ifdef ALIGN_SECTIONS_IN_FILE
2925 /* On XCOFF, if we have symbols, set up the .debug section. */
2926 if (bfd_get_symcount (abfd
) > 0)
2929 bfd_size_type i
, symcount
;
2933 symcount
= bfd_get_symcount (abfd
);
2934 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
2936 coff_symbol_type
*cf
;
2938 cf
= coff_symbol_from (abfd
, *symp
);
2940 && cf
->native
!= NULL
2941 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
2945 len
= strlen (bfd_asymbol_name (*symp
));
2946 if (len
> SYMNMLEN
|| bfd_coff_force_symnames_in_strings (abfd
))
2947 sz
+= len
+ 1 + bfd_coff_debug_string_prefix_length (abfd
);
2954 dsec
= bfd_make_section_old_way (abfd
, ".debug");
2957 dsec
->_raw_size
= sz
;
2958 dsec
->flags
|= SEC_HAS_CONTENTS
;
2963 #ifdef COFF_IMAGE_WITH_PE
2965 if (coff_data (abfd
)->link_info
)
2967 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
2970 page_size
= PE_DEF_FILE_ALIGNMENT
;
2972 #ifdef COFF_PAGE_SIZE
2973 int page_size
= COFF_PAGE_SIZE
;
2977 if (bfd_get_start_address (abfd
))
2979 /* A start address may have been added to the original file. In this
2980 case it will need an optional header to record it. */
2981 abfd
->flags
|= EXEC_P
;
2984 if (abfd
->flags
& EXEC_P
)
2985 sofar
+= bfd_coff_aoutsz (abfd
);
2987 else if (xcoff_data (abfd
)->full_aouthdr
)
2988 sofar
+= bfd_coff_aoutsz (abfd
);
2990 sofar
+= SMALL_AOUTSZ
;
2993 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2996 /* XCOFF handles overflows in the reloc and line number count fields
2997 by allocating a new section header to hold the correct counts. */
2998 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2999 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3000 sofar
+= bfd_coff_scnhsz (abfd
);
3003 #ifdef COFF_IMAGE_WITH_PE
3005 /* PE requires the sections to be in memory order when listed in
3006 the section headers. It also does not like empty loadable
3007 sections. The sections apparently do not have to be in the
3008 right order in the image file itself, but we do need to get the
3009 target_index values right. */
3012 asection
**section_list
;
3018 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3021 /* We allocate an extra cell to simplify the final loop. */
3022 amt
= sizeof (struct asection
*) * (count
+ 1);
3023 section_list
= bfd_malloc (amt
);
3024 if (section_list
== NULL
)
3028 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3030 section_list
[i
] = current
;
3033 section_list
[i
] = NULL
;
3035 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
3037 /* Rethread the linked list into sorted order; at the same time,
3038 assign target_index values. */
3040 abfd
->sections
= section_list
[0];
3041 for (i
= 0; i
< count
; i
++)
3043 current
= section_list
[i
];
3044 current
->next
= section_list
[i
+ 1];
3046 /* Later, if the section has zero size, we'll be throwing it
3047 away, so we don't want to number it now. Note that having
3048 a zero size and having real contents are different
3049 concepts: .bss has no contents, but (usually) non-zero
3051 if (current
->_raw_size
== 0)
3053 /* Discard. However, it still might have (valid) symbols
3054 in it, so arbitrarily set it to section 1 (indexing is
3055 1-based here; usually .text). __end__ and other
3056 contents of .endsection really have this happen.
3057 FIXME: This seems somewhat dubious. */
3058 current
->target_index
= 1;
3061 current
->target_index
= target_index
++;
3063 abfd
->section_tail
= ¤t
->next
;
3065 free (section_list
);
3067 #else /* ! COFF_IMAGE_WITH_PE */
3069 /* Set the target_index field. */
3073 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3074 current
->target_index
= target_index
++;
3076 #endif /* ! COFF_IMAGE_WITH_PE */
3078 align_adjust
= FALSE
;
3079 for (current
= abfd
->sections
;
3080 current
!= (asection
*) NULL
;
3081 current
= current
->next
)
3083 #ifdef COFF_IMAGE_WITH_PE
3084 /* With PE we have to pad each section to be a multiple of its
3085 page size too, and remember both sizes. */
3086 if (coff_section_data (abfd
, current
) == NULL
)
3088 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
3089 current
->used_by_bfd
= (PTR
) bfd_zalloc (abfd
, amt
);
3090 if (current
->used_by_bfd
== NULL
)
3093 if (pei_section_data (abfd
, current
) == NULL
)
3095 bfd_size_type amt
= sizeof (struct pei_section_tdata
);
3096 coff_section_data (abfd
, current
)->tdata
3097 = (PTR
) bfd_zalloc (abfd
, amt
);
3098 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
3101 if (pei_section_data (abfd
, current
)->virt_size
== 0)
3102 pei_section_data (abfd
, current
)->virt_size
= current
->_raw_size
;
3105 /* Only deal with sections which have contents. */
3106 if (!(current
->flags
& SEC_HAS_CONTENTS
))
3109 #ifdef COFF_IMAGE_WITH_PE
3110 /* Make sure we skip empty sections in a PE image. */
3111 if (current
->_raw_size
== 0)
3115 /* Align the sections in the file to the same boundary on
3116 which they are aligned in virtual memory. I960 doesn't
3117 do this (FIXME) so we can stay in sync with Intel. 960
3118 doesn't yet page from files... */
3119 #ifdef ALIGN_SECTIONS_IN_FILE
3120 if ((abfd
->flags
& EXEC_P
) != 0)
3122 /* Make sure this section is aligned on the right boundary - by
3123 padding the previous section up if necessary. */
3127 /* AIX loader checks the text section alignment of (vma - filepos)
3128 So even though the filepos may be aligned wrt the o_algntext, for
3129 AIX executables, this check fails. This shows up when a native
3130 AIX executable is stripped with gnu strip because the default vma
3131 of native is 0x10000150 but default for gnu is 0x10000140. Gnu
3132 stripped gnu excutable passes this check because the filepos is
3133 0x0140. This problem also show up with 64 bit shared objects. The
3134 data section must also be aligned. */
3135 if (!strcmp (current
->name
, _TEXT
)
3136 || !strcmp (current
->name
, _DATA
))
3141 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3143 align
= 1 << current
->alignment_power
;
3144 pad
= abs (current
->vma
- sofar
) % align
;
3155 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3158 if (previous
!= (asection
*) NULL
)
3159 previous
->_raw_size
+= sofar
- old_sofar
;
3164 /* In demand paged files the low order bits of the file offset
3165 must match the low order bits of the virtual address. */
3166 #ifdef COFF_PAGE_SIZE
3167 if ((abfd
->flags
& D_PAGED
) != 0
3168 && (current
->flags
& SEC_ALLOC
) != 0)
3169 sofar
+= (current
->vma
- sofar
) % page_size
;
3171 current
->filepos
= sofar
;
3173 #ifdef COFF_IMAGE_WITH_PE
3174 /* Set the padded size. */
3175 current
->_raw_size
= (current
->_raw_size
+ page_size
-1) & -page_size
;
3178 sofar
+= current
->_raw_size
;
3180 #ifdef ALIGN_SECTIONS_IN_FILE
3181 /* Make sure that this section is of the right size too. */
3182 if ((abfd
->flags
& EXEC_P
) == 0)
3184 bfd_size_type old_size
;
3186 old_size
= current
->_raw_size
;
3187 current
->_raw_size
= BFD_ALIGN (current
->_raw_size
,
3188 1 << current
->alignment_power
);
3189 align_adjust
= current
->_raw_size
!= old_size
;
3190 sofar
+= current
->_raw_size
- old_size
;
3195 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3196 align_adjust
= sofar
!= old_sofar
;
3197 current
->_raw_size
+= sofar
- old_sofar
;
3201 #ifdef COFF_IMAGE_WITH_PE
3202 /* For PE we need to make sure we pad out to the aligned
3203 _raw_size, in case the caller only writes out data to the
3204 unaligned _raw_size. */
3205 if (pei_section_data (abfd
, current
)->virt_size
< current
->_raw_size
)
3206 align_adjust
= TRUE
;
3210 /* Force .lib sections to start at zero. The vma is then
3211 incremented in coff_set_section_contents. This is right for
3213 if (strcmp (current
->name
, _LIB
) == 0)
3214 bfd_set_section_vma (abfd
, current
, 0);
3220 /* It is now safe to write to the output file. If we needed an
3221 alignment adjustment for the last section, then make sure that
3222 there is a byte at offset sofar. If there are no symbols and no
3223 relocs, then nothing follows the last section. If we don't force
3224 the last byte out, then the file may appear to be truncated. */
3230 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
3231 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3235 /* Make sure the relocations are aligned. We don't need to make
3236 sure that this byte exists, because it will only matter if there
3237 really are relocs. */
3238 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
3240 obj_relocbase (abfd
) = sofar
;
3241 abfd
->output_has_begun
= TRUE
;
3248 /* This can never work, because it is called too late--after the
3249 section positions have been set. I can't figure out what it is
3250 for, so I am going to disable it--Ian Taylor 20 March 1996. */
3252 /* If .file, .text, .data, .bss symbols are missing, add them. */
3253 /* @@ Should we only be adding missing symbols, or overriding the aux
3254 values for existing section symbols? */
3256 coff_add_missing_symbols (abfd
)
3259 unsigned int nsyms
= bfd_get_symcount (abfd
);
3260 asymbol
**sympp
= abfd
->outsymbols
;
3263 int need_text
= 1, need_data
= 1, need_bss
= 1, need_file
= 1;
3266 for (i
= 0; i
< nsyms
; i
++)
3268 coff_symbol_type
*csym
= coff_symbol_from (abfd
, sympp
[i
]);
3273 /* Only do this if there is a coff representation of the input
3275 if (csym
->native
&& csym
->native
->u
.syment
.n_sclass
== C_FILE
)
3280 name
= csym
->symbol
.name
;
3283 if (!strcmp (name
, _TEXT
))
3286 else if (!strcmp (name
, ".wtext"))
3289 else if (!strcmp (name
, _DATA
))
3291 else if (!strcmp (name
, _BSS
))
3295 /* Now i == bfd_get_symcount (abfd). */
3296 /* @@ For now, don't deal with .file symbol. */
3299 if (!need_text
&& !need_data
&& !need_bss
&& !need_file
)
3301 nsyms
+= need_text
+ need_data
+ need_bss
+ need_file
;
3303 amt
*= sizeof (asymbol
*);
3304 sympp2
= (asymbol
**) bfd_alloc (abfd
, amt
);
3307 memcpy (sympp2
, sympp
, i
* sizeof (asymbol
*));
3310 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
3314 sympp2
[i
++] = coff_section_symbol (abfd
, _TEXT
);
3316 sympp2
[i
++] = coff_section_symbol (abfd
, _DATA
);
3318 sympp2
[i
++] = coff_section_symbol (abfd
, _BSS
);
3319 BFD_ASSERT (i
== nsyms
);
3320 bfd_set_symtab (abfd
, sympp2
, nsyms
);
3326 #ifdef COFF_IMAGE_WITH_PE
3328 static unsigned int pelength
;
3329 static unsigned int peheader
;
3332 coff_read_word (abfd
, value
)
3334 unsigned int *value
;
3339 status
= bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3347 *value
= (unsigned int) b
[0];
3349 *value
= (unsigned int) (b
[0] + (b
[1] << 8));
3351 pelength
+= (unsigned int) status
;
3357 coff_compute_checksum (abfd
)
3360 bfd_boolean more_data
;
3367 filepos
= (file_ptr
) 0;
3371 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
3374 more_data
= coff_read_word (abfd
, &value
);
3376 total
= 0xffff & (total
+ (total
>> 0x10));
3381 return (0xffff & (total
+ (total
>> 0x10)));
3385 coff_apply_checksum (abfd
)
3388 unsigned int computed
;
3389 unsigned int checksum
= 0;
3391 if (bfd_seek (abfd
, 0x3c, SEEK_SET
) != 0)
3394 if (!coff_read_word (abfd
, &peheader
))
3397 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3401 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3403 if (bfd_seek (abfd
, peheader
, SEEK_SET
) != 0)
3406 computed
= coff_compute_checksum (abfd
);
3408 checksum
= computed
+ pelength
;
3410 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3413 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3418 #endif /* COFF_IMAGE_WITH_PE */
3423 coff_write_object_contents (abfd
)
3427 bfd_boolean hasrelocs
= FALSE
;
3428 bfd_boolean haslinno
= FALSE
;
3429 bfd_boolean hasdebug
= FALSE
;
3431 file_ptr reloc_base
;
3432 file_ptr lineno_base
;
3434 unsigned long reloc_size
= 0, reloc_count
= 0;
3435 unsigned long lnno_size
= 0;
3436 bfd_boolean long_section_names
;
3437 asection
*text_sec
= NULL
;
3438 asection
*data_sec
= NULL
;
3439 asection
*bss_sec
= NULL
;
3440 struct internal_filehdr internal_f
;
3441 struct internal_aouthdr internal_a
;
3442 #ifdef COFF_LONG_SECTION_NAMES
3443 size_t string_size
= STRING_SIZE_SIZE
;
3446 bfd_set_error (bfd_error_system_call
);
3448 /* Make a pass through the symbol table to count line number entries and
3449 put them into the correct asections. */
3451 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3453 if (! abfd
->output_has_begun
)
3455 if (! coff_compute_section_file_positions (abfd
))
3459 reloc_base
= obj_relocbase (abfd
);
3461 /* Work out the size of the reloc and linno areas. */
3463 for (current
= abfd
->sections
; current
!= NULL
; current
=
3467 /* We store the actual reloc count in the first reloc's addr. */
3468 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3471 reloc_count
+= current
->reloc_count
;
3474 reloc_size
= reloc_count
* bfd_coff_relsz (abfd
);
3476 lineno_base
= reloc_base
+ reloc_size
;
3477 sym_base
= lineno_base
+ lnno_size
;
3479 /* Indicate in each section->line_filepos its actual file address. */
3480 for (current
= abfd
->sections
; current
!= NULL
; current
=
3483 if (current
->lineno_count
)
3485 current
->line_filepos
= lineno_base
;
3486 current
->moving_line_filepos
= lineno_base
;
3487 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3491 current
->line_filepos
= 0;
3493 if (current
->reloc_count
)
3495 current
->rel_filepos
= reloc_base
;
3496 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3498 /* Extra reloc to hold real count. */
3499 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3500 reloc_base
+= bfd_coff_relsz (abfd
);
3505 current
->rel_filepos
= 0;
3509 /* Write section headers to the file. */
3510 internal_f
.f_nscns
= 0;
3512 if ((abfd
->flags
& EXEC_P
) != 0)
3513 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3516 scn_base
= bfd_coff_filhsz (abfd
);
3519 if (xcoff_data (abfd
)->full_aouthdr
)
3520 scn_base
+= bfd_coff_aoutsz (abfd
);
3522 scn_base
+= SMALL_AOUTSZ
;
3527 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3530 long_section_names
= FALSE
;
3531 for (current
= abfd
->sections
;
3533 current
= current
->next
)
3535 struct internal_scnhdr section
;
3536 bfd_boolean is_reloc_section
= FALSE
;
3538 #ifdef COFF_IMAGE_WITH_PE
3539 if (strcmp (current
->name
, ".reloc") == 0)
3541 is_reloc_section
= TRUE
;
3543 pe_data (abfd
)->has_reloc_section
= 1;
3547 internal_f
.f_nscns
++;
3549 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3551 #ifdef COFF_LONG_SECTION_NAMES
3552 /* Handle long section names as in PE. This must be compatible
3553 with the code in coff_write_symbols and _bfd_coff_final_link. */
3557 len
= strlen (current
->name
);
3560 memset (section
.s_name
, 0, SCNNMLEN
);
3561 sprintf (section
.s_name
, "/%lu", (unsigned long) string_size
);
3562 string_size
+= len
+ 1;
3563 long_section_names
= TRUE
;
3569 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3570 Ian Taylor <ian@cygnus.com>. */
3571 if (strcmp (current
->name
, _LIB
) == 0)
3572 section
.s_vaddr
= 0;
3575 section
.s_vaddr
= current
->vma
;
3576 section
.s_paddr
= current
->lma
;
3577 section
.s_size
= current
->_raw_size
;
3578 #ifdef coff_get_section_load_page
3579 section
.s_page
= coff_get_section_load_page (current
);
3583 section
.s_paddr
= 0;
3585 #ifdef COFF_IMAGE_WITH_PE
3586 /* Reminder: s_paddr holds the virtual size of the section. */
3587 if (coff_section_data (abfd
, current
) != NULL
3588 && pei_section_data (abfd
, current
) != NULL
)
3589 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3591 section
.s_paddr
= 0;
3594 /* If this section has no size or is unloadable then the scnptr
3596 if (current
->_raw_size
== 0 ||
3597 (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3598 section
.s_scnptr
= 0;
3600 section
.s_scnptr
= current
->filepos
;
3602 section
.s_relptr
= current
->rel_filepos
;
3603 section
.s_lnnoptr
= current
->line_filepos
;
3604 section
.s_nreloc
= current
->reloc_count
;
3605 section
.s_nlnno
= current
->lineno_count
;
3606 #ifndef COFF_IMAGE_WITH_PE
3607 /* In PEI, relocs come in the .reloc section. */
3608 if (current
->reloc_count
!= 0)
3611 if (current
->lineno_count
!= 0)
3613 if ((current
->flags
& SEC_DEBUGGING
) != 0
3614 && ! is_reloc_section
)
3619 /* Indicate the use of an XCOFF overflow section header. */
3620 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3622 section
.s_nreloc
= 0xffff;
3623 section
.s_nlnno
= 0xffff;
3628 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3630 if (!strcmp (current
->name
, _TEXT
))
3632 else if (!strcmp (current
->name
, _DATA
))
3634 else if (!strcmp (current
->name
, _BSS
))
3638 section
.s_align
= (current
->alignment_power
3639 ? 1 << current
->alignment_power
3643 /* TI COFF puts the alignment power in bits 8-11 of the flags. */
3644 section
.s_flags
|= (current
->alignment_power
& 0xF) << 8;
3646 #ifdef COFF_ENCODE_ALIGNMENT
3647 COFF_ENCODE_ALIGNMENT(section
, current
->alignment_power
);
3650 #ifdef COFF_IMAGE_WITH_PE
3651 /* Suppress output of the sections if they are null. ld
3652 includes the bss and data sections even if there is no size
3653 assigned to them. NT loader doesn't like it if these section
3654 headers are included if the sections themselves are not
3655 needed. See also coff_compute_section_file_positions. */
3656 if (section
.s_size
== 0)
3657 internal_f
.f_nscns
--;
3662 bfd_size_type amt
= bfd_coff_scnhsz (abfd
);
3664 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3665 || bfd_bwrite ((PTR
) &buff
, amt
, abfd
) != amt
)
3670 /* PE stores COMDAT section information in the symbol table. If
3671 this section is supposed to have some COMDAT info, track down
3672 the symbol in the symbol table and modify it. */
3673 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3675 unsigned int i
, count
;
3677 coff_symbol_type
*csym
= NULL
;
3681 count
= bfd_get_symcount (abfd
);
3682 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3684 if ((*psym
)->section
!= current
)
3687 /* Remember the location of the first symbol in this
3689 if (psymsec
== NULL
)
3692 /* See if this is the section symbol. */
3693 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3695 csym
= coff_symbol_from (abfd
, *psym
);
3697 || csym
->native
== NULL
3698 || csym
->native
->u
.syment
.n_numaux
< 1
3699 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3700 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3703 /* Here *PSYM is the section symbol for CURRENT. */
3710 Note that we might not if we're converting the file from
3711 some other object file format. */
3714 combined_entry_type
*aux
;
3716 /* We don't touch the x_checksum field. The
3717 x_associated field is not currently supported. */
3719 aux
= csym
->native
+ 1;
3720 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3722 case SEC_LINK_DUPLICATES_DISCARD
:
3723 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3726 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3727 aux
->u
.auxent
.x_scn
.x_comdat
=
3728 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3731 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3732 aux
->u
.auxent
.x_scn
.x_comdat
=
3733 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3736 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3737 aux
->u
.auxent
.x_scn
.x_comdat
=
3738 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3742 /* The COMDAT symbol must be the first symbol from this
3743 section in the symbol table. In order to make this
3744 work, we move the COMDAT symbol before the first
3745 symbol we found in the search above. It's OK to
3746 rearrange the symbol table at this point, because
3747 coff_renumber_symbols is going to rearrange it
3748 further and fix up all the aux entries. */
3749 if (psym
!= psymsec
)
3755 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3756 pcopy
[0] = pcopy
[-1];
3761 #endif /* COFF_WITH_PE */
3766 /* XCOFF handles overflows in the reloc and line number count fields
3767 by creating a new section header to hold the correct values. */
3768 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3770 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3772 struct internal_scnhdr scnhdr
;
3776 internal_f
.f_nscns
++;
3777 strncpy (&(scnhdr
.s_name
[0]), current
->name
, 8);
3778 scnhdr
.s_paddr
= current
->reloc_count
;
3779 scnhdr
.s_vaddr
= current
->lineno_count
;
3781 scnhdr
.s_scnptr
= 0;
3782 scnhdr
.s_relptr
= current
->rel_filepos
;
3783 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3784 scnhdr
.s_nreloc
= current
->target_index
;
3785 scnhdr
.s_nlnno
= current
->target_index
;
3786 scnhdr
.s_flags
= STYP_OVRFLO
;
3787 amt
= bfd_coff_scnhsz (abfd
);
3788 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3789 || bfd_bwrite ((PTR
) &buff
, amt
, abfd
) != amt
)
3796 /* OK, now set up the filehdr... */
3798 /* Don't include the internal abs section in the section count */
3800 /* We will NOT put a fucking timestamp in the header here. Every time you
3801 put it back, I will come in and take it out again. I'm sorry. This
3802 field does not belong here. We fill it with a 0 so it compares the
3803 same but is not a reasonable time. -- gnu@cygnus.com */
3804 internal_f
.f_timdat
= 0;
3805 internal_f
.f_flags
= 0;
3807 if (abfd
->flags
& EXEC_P
)
3808 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3811 internal_f
.f_opthdr
= 0;
3814 if (xcoff_data (abfd
)->full_aouthdr
)
3815 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3817 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
3823 internal_f
.f_flags
|= F_RELFLG
;
3825 internal_f
.f_flags
|= F_LNNO
;
3826 if (abfd
->flags
& EXEC_P
)
3827 internal_f
.f_flags
|= F_EXEC
;
3828 #ifdef COFF_IMAGE_WITH_PE
3830 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
3833 #ifndef COFF_WITH_PE
3834 if (bfd_little_endian (abfd
))
3835 internal_f
.f_flags
|= F_AR32WR
;
3837 internal_f
.f_flags
|= F_AR32W
;
3841 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
3842 but it doesn't hurt to set it internally. */
3843 internal_f
.f_target_id
= TI_TARGET_ID
;
3845 #ifdef TIC80_TARGET_ID
3846 internal_f
.f_target_id
= TIC80_TARGET_ID
;
3849 /* FIXME, should do something about the other byte orders and
3853 if ((abfd
->flags
& DYNAMIC
) != 0)
3854 internal_f
.f_flags
|= F_SHROBJ
;
3855 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
3856 internal_f
.f_flags
|= F_DYNLOAD
;
3859 memset (&internal_a
, 0, sizeof internal_a
);
3861 /* Set up architecture-dependent stuff. */
3863 unsigned int magic
= 0;
3864 unsigned short flags
= 0;
3866 coff_set_flags (abfd
, &magic
, &flags
);
3867 internal_f
.f_magic
= magic
;
3868 internal_f
.f_flags
|= flags
;
3869 /* ...and the "opt"hdr... */
3872 #ifdef ULTRA3 /* NYU's machine */
3873 /* FIXME: This is a bogus check. I really want to see if there
3874 is a .shbss or a .shdata section, if so then set the magic
3875 number to indicate a shared data executable. */
3876 if (internal_f
.f_nscns
>= 7)
3877 internal_a
.magic
= SHMAGIC
; /* Shared magic. */
3880 internal_a
.magic
= NMAGIC
; /* Assume separate i/d. */
3881 #define __A_MAGIC_SET__
3883 #ifdef TICOFF_AOUT_MAGIC
3884 internal_a
.magic
= TICOFF_AOUT_MAGIC
;
3885 #define __A_MAGIC_SET__
3888 internal_a
.magic
= TIC80_ARCH_MAGIC
;
3889 #define __A_MAGIC_SET__
3892 /* FIXME: What are the a.out magic numbers for the i860? */
3893 internal_a
.magic
= 0;
3894 #define __A_MAGIC_SET__
3897 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
3898 #define __A_MAGIC_SET__
3901 #define __A_MAGIC_SET__
3902 internal_a
.magic
= PAGEMAGICBCS
;
3906 #define __A_MAGIC_SET__
3907 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
3910 #if defined(M68) || defined(WE32K) || defined(M68K)
3911 #define __A_MAGIC_SET__
3913 internal_a
.magic
= LYNXCOFFMAGIC
;
3915 #if defined(TARG_AUX)
3916 internal_a
.magic
= (abfd
->flags
& D_PAGED
? PAGEMAGICPEXECPAGED
:
3917 abfd
->flags
& WP_TEXT
? PAGEMAGICPEXECSWAPPED
:
3918 PAGEMAGICEXECSWAPPED
);
3920 #if defined (PAGEMAGICPEXECPAGED)
3921 internal_a
.magic
= PAGEMAGICPEXECPAGED
;
3923 #endif /* TARG_AUX */
3925 #endif /* M68 || WE32K || M68K */
3928 #define __A_MAGIC_SET__
3929 internal_a
.magic
= ZMAGIC
;
3933 #define __A_MAGIC_SET__
3934 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3937 #if defined MCORE_PE
3938 #define __A_MAGIC_SET__
3939 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3943 #define __A_MAGIC_SET__
3945 internal_a
.magic
= LYNXCOFFMAGIC
;
3947 internal_a
.magic
= ZMAGIC
;
3952 #define __A_MAGIC_SET__
3953 internal_a
.magic
= ZMAGIC
;
3957 #define __A_MAGIC_SET__
3959 internal_a
.magic
= LYNXCOFFMAGIC
;
3964 #define __A_MAGIC_SET__
3965 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
3966 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
3967 RS6K_AOUTHDR_OMAGIC
;
3970 #if defined(SH) && defined(COFF_WITH_PE)
3971 #define __A_MAGIC_SET__
3972 internal_a
.magic
= SH_PE_MAGIC
;
3975 #if defined(MIPS) && defined(COFF_WITH_PE)
3976 #define __A_MAGIC_SET__
3977 internal_a
.magic
= MIPS_PE_MAGIC
;
3981 #define __A_MAGIC_SET__
3982 internal_a
.magic
= NMAGIC
; /* Assume separate i/d. */
3985 #ifndef __A_MAGIC_SET__
3986 #include "Your aouthdr magic number is not being set!"
3988 #undef __A_MAGIC_SET__
3992 /* FIXME: Does anybody ever set this to another value? */
3993 internal_a
.vstamp
= 0;
3995 /* Now should write relocs, strings, syms. */
3996 obj_sym_filepos (abfd
) = sym_base
;
3998 if (bfd_get_symcount (abfd
) != 0)
4002 if (!coff_add_missing_symbols (abfd
))
4005 if (!coff_renumber_symbols (abfd
, &firstundef
))
4007 coff_mangle_symbols (abfd
);
4008 if (! coff_write_symbols (abfd
))
4010 if (! coff_write_linenumbers (abfd
))
4012 if (! coff_write_relocs (abfd
, firstundef
))
4015 #ifdef COFF_LONG_SECTION_NAMES
4016 else if (long_section_names
&& ! obj_coff_strings_written (abfd
))
4018 /* If we have long section names we have to write out the string
4019 table even if there are no symbols. */
4020 if (! coff_write_symbols (abfd
))
4024 #ifdef COFF_IMAGE_WITH_PE
4026 else if ((abfd
->flags
& EXEC_P
) != 0)
4030 /* PowerPC PE appears to require that all executable files be
4031 rounded up to the page size. */
4034 (file_ptr
) BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
4036 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
4042 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
4043 backend linker, and obj_raw_syment_count is not valid until after
4044 coff_write_symbols is called. */
4045 if (obj_raw_syment_count (abfd
) != 0)
4047 internal_f
.f_symptr
= sym_base
;
4049 /* AIX appears to require that F_RELFLG not be set if there are
4050 local symbols but no relocations. */
4051 internal_f
.f_flags
&=~ F_RELFLG
;
4056 if (long_section_names
)
4057 internal_f
.f_symptr
= sym_base
;
4059 internal_f
.f_symptr
= 0;
4060 internal_f
.f_flags
|= F_LSYMS
;
4065 internal_a
.tsize
= bfd_get_section_size_before_reloc (text_sec
);
4066 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
4070 internal_a
.dsize
= bfd_get_section_size_before_reloc (data_sec
);
4071 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
4075 internal_a
.bsize
= bfd_get_section_size_before_reloc (bss_sec
);
4076 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
4077 internal_a
.data_start
= bss_sec
->vma
;
4080 internal_a
.entry
= bfd_get_start_address (abfd
);
4081 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
4084 if (xcoff_data (abfd
)->full_aouthdr
)
4087 asection
*loader_sec
;
4089 internal_a
.vstamp
= 1;
4091 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
4092 if (internal_a
.o_snentry
== 0)
4093 internal_a
.entry
= (bfd_vma
) -1;
4095 if (text_sec
!= NULL
)
4097 internal_a
.o_sntext
= text_sec
->target_index
;
4098 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
4102 internal_a
.o_sntext
= 0;
4103 internal_a
.o_algntext
= 0;
4105 if (data_sec
!= NULL
)
4107 internal_a
.o_sndata
= data_sec
->target_index
;
4108 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
4112 internal_a
.o_sndata
= 0;
4113 internal_a
.o_algndata
= 0;
4115 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
4116 if (loader_sec
!= NULL
)
4117 internal_a
.o_snloader
= loader_sec
->target_index
;
4119 internal_a
.o_snloader
= 0;
4120 if (bss_sec
!= NULL
)
4121 internal_a
.o_snbss
= bss_sec
->target_index
;
4123 internal_a
.o_snbss
= 0;
4125 toc
= xcoff_data (abfd
)->toc
;
4126 internal_a
.o_toc
= toc
;
4127 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
4129 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
4130 if (xcoff_data (abfd
)->cputype
!= -1)
4131 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
4134 switch (bfd_get_arch (abfd
))
4136 case bfd_arch_rs6000
:
4137 internal_a
.o_cputype
= 4;
4139 case bfd_arch_powerpc
:
4140 if (bfd_get_mach (abfd
) == bfd_mach_ppc
)
4141 internal_a
.o_cputype
= 3;
4143 internal_a
.o_cputype
= 1;
4149 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
4150 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
4154 /* now write them */
4155 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
4160 bfd_size_type amount
= bfd_coff_filhsz (abfd
);
4162 buff
= bfd_malloc (amount
);
4166 bfd_coff_swap_filehdr_out (abfd
, (PTR
) &internal_f
, (PTR
) buff
);
4167 amount
= bfd_bwrite ((PTR
) buff
, amount
, abfd
);
4171 if (amount
!= bfd_coff_filhsz (abfd
))
4175 if (abfd
->flags
& EXEC_P
)
4177 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4178 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4180 bfd_size_type amount
= bfd_coff_aoutsz (abfd
);
4182 buff
= bfd_malloc (amount
);
4186 coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, (PTR
) buff
);
4187 amount
= bfd_bwrite ((PTR
) buff
, amount
, abfd
);
4191 if (amount
!= bfd_coff_aoutsz (abfd
))
4194 #ifdef COFF_IMAGE_WITH_PE
4195 if (! coff_apply_checksum (abfd
))
4205 /* XCOFF seems to always write at least a small a.out header. */
4206 coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, (PTR
) &buff
);
4207 if (xcoff_data (abfd
)->full_aouthdr
)
4208 size
= bfd_coff_aoutsz (abfd
);
4210 size
= SMALL_AOUTSZ
;
4211 if (bfd_bwrite ((PTR
) &buff
, (bfd_size_type
) size
, abfd
) != size
)
4220 coff_set_section_contents (abfd
, section
, location
, offset
, count
)
4225 bfd_size_type count
;
4227 if (! abfd
->output_has_begun
) /* Set by bfd.c handler. */
4229 if (! coff_compute_section_file_positions (abfd
))
4233 #if defined(_LIB) && !defined(TARG_AUX)
4235 /* The physical address field of a .lib section is used to hold the
4236 number of shared libraries in the section. This code counts the
4237 number of sections being written, and increments the lma field
4240 I have found no documentation on the contents of this section.
4241 Experimentation indicates that the section contains zero or more
4242 records, each of which has the following structure:
4244 - a (four byte) word holding the length of this record, in words,
4245 - a word that always seems to be set to "2",
4246 - the path to a shared library, null-terminated and then padded
4247 to a whole word boundary.
4249 bfd_assert calls have been added to alert if an attempt is made
4250 to write a section which doesn't follow these assumptions. The
4251 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4252 <robertl@arnet.com> (Thanks!).
4254 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4256 if (strcmp (section
->name
, _LIB
) == 0)
4258 bfd_byte
*rec
, *recend
;
4260 rec
= (bfd_byte
*) location
;
4261 recend
= rec
+ count
;
4262 while (rec
< recend
)
4265 rec
+= bfd_get_32 (abfd
, rec
) * 4;
4268 BFD_ASSERT (rec
== recend
);
4273 /* Don't write out bss sections - one way to do this is to
4274 see if the filepos has not been set. */
4275 if (section
->filepos
== 0)
4278 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0)
4284 return bfd_bwrite (location
, count
, abfd
) == count
;
4288 coff_close_and_cleanup (abfd
)
4291 if (!bfd_read_p (abfd
))
4292 switch (abfd
->format
)
4295 if (!_bfd_write_archive_contents (abfd
))
4299 if (!coff_write_object_contents (abfd
))
4303 bfd_set_error (bfd_error_invalid_operation
);
4307 /* We depend on bfd_close to free all the memory on the objalloc. */
4314 buy_and_read (abfd
, where
, size
)
4319 PTR area
= (PTR
) bfd_alloc (abfd
, size
);
4322 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0
4323 || bfd_bread (area
, size
, abfd
) != size
)
4326 } /* buy_and_read() */
4332 Creating the linenumber table is done by reading in the entire
4333 coff linenumber table, and creating another table for internal use.
4335 A coff linenumber table is structured so that each function
4336 is marked as having a line number of 0. Each line within the
4337 function is an offset from the first line in the function. The
4338 base of the line number information for the table is stored in
4339 the symbol associated with the function.
4341 Note: The PE format uses line number 0 for a flag indicating a
4344 The information is copied from the external to the internal
4345 table, and each symbol which marks a function is marked by
4348 How does this work ?
4353 coff_slurp_line_table (abfd
, asect
)
4357 LINENO
*native_lineno
;
4358 alent
*lineno_cache
;
4361 BFD_ASSERT (asect
->lineno
== (alent
*) NULL
);
4363 amt
= (bfd_size_type
) bfd_coff_linesz (abfd
) * asect
->lineno_count
;
4364 native_lineno
= (LINENO
*) buy_and_read (abfd
, asect
->line_filepos
, amt
);
4365 amt
= ((bfd_size_type
) asect
->lineno_count
+ 1) * sizeof (alent
);
4366 lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
);
4367 if (lineno_cache
== NULL
)
4371 unsigned int counter
= 0;
4372 alent
*cache_ptr
= lineno_cache
;
4373 LINENO
*src
= native_lineno
;
4375 while (counter
< asect
->lineno_count
)
4377 struct internal_lineno dst
;
4379 bfd_coff_swap_lineno_in (abfd
, src
, &dst
);
4380 cache_ptr
->line_number
= dst
.l_lnno
;
4382 if (cache_ptr
->line_number
== 0)
4385 bfd_signed_vma symndx
;
4386 coff_symbol_type
*sym
;
4389 symndx
= dst
.l_addr
.l_symndx
;
4391 || (bfd_vma
) symndx
>= obj_raw_syment_count (abfd
))
4393 (*_bfd_error_handler
)
4394 (_("%s: warning: illegal symbol index %ld in line numbers"),
4395 bfd_archive_filename (abfd
), dst
.l_addr
.l_symndx
);
4399 /* FIXME: We should not be casting between ints and
4400 pointers like this. */
4401 sym
= ((coff_symbol_type
*)
4402 ((symndx
+ obj_raw_syments (abfd
))
4403 ->u
.syment
._n
._n_n
._n_zeroes
));
4404 cache_ptr
->u
.sym
= (asymbol
*) sym
;
4405 if (sym
->lineno
!= NULL
&& ! warned
)
4407 (*_bfd_error_handler
)
4408 (_("%s: warning: duplicate line number information for `%s'"),
4409 bfd_archive_filename (abfd
),
4410 bfd_asymbol_name (&sym
->symbol
));
4412 sym
->lineno
= cache_ptr
;
4416 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
4417 - bfd_section_vma (abfd
, asect
);
4418 } /* If no linenumber expect a symbol index */
4424 cache_ptr
->line_number
= 0;
4427 asect
->lineno
= lineno_cache
;
4428 /* FIXME, free native_lineno here, or use alloca or something. */
4432 /* Slurp in the symbol table, converting it to generic form. Note
4433 that if coff_relocate_section is defined, the linker will read
4434 symbols via coff_link_add_symbols, rather than via this routine. */
4437 coff_slurp_symbol_table (abfd
)
4440 combined_entry_type
*native_symbols
;
4441 coff_symbol_type
*cached_area
;
4442 unsigned int *table_ptr
;
4444 unsigned int number_of_symbols
= 0;
4446 if (obj_symbols (abfd
))
4449 /* Read in the symbol table. */
4450 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4453 /* Allocate enough room for all the symbols in cached form. */
4454 amt
= obj_raw_syment_count (abfd
);
4455 amt
*= sizeof (coff_symbol_type
);
4456 cached_area
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
4457 if (cached_area
== NULL
)
4460 amt
= obj_raw_syment_count (abfd
);
4461 amt
*= sizeof (unsigned int);
4462 table_ptr
= (unsigned int *) bfd_alloc (abfd
, amt
);
4464 if (table_ptr
== NULL
)
4468 coff_symbol_type
*dst
= cached_area
;
4469 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4470 unsigned int this_index
= 0;
4472 while (this_index
< last_native_index
)
4474 combined_entry_type
*src
= native_symbols
+ this_index
;
4475 table_ptr
[this_index
] = number_of_symbols
;
4476 dst
->symbol
.the_bfd
= abfd
;
4478 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4479 /* We use the native name field to point to the cached field. */
4480 src
->u
.syment
._n
._n_n
._n_zeroes
= (long) dst
;
4481 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4482 src
->u
.syment
.n_scnum
);
4483 dst
->symbol
.flags
= 0;
4484 dst
->done_lineno
= FALSE
;
4486 switch (src
->u
.syment
.n_sclass
)
4491 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
4492 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4493 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4495 /* Fall through to next case. */
4502 case C_THUMBEXTFUNC
:
4508 case C_SYSTEM
: /* System Wide variable. */
4511 /* In PE, 0x68 (104) denotes a section symbol. */
4513 /* In PE, 0x69 (105) denotes a weak external symbol. */
4516 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4518 case COFF_SYMBOL_GLOBAL
:
4519 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4520 #if defined COFF_WITH_PE
4521 /* PE sets the symbol to a value relative to the
4522 start of the section. */
4523 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4525 dst
->symbol
.value
= (src
->u
.syment
.n_value
4526 - dst
->symbol
.section
->vma
);
4528 if (ISFCN ((src
->u
.syment
.n_type
)))
4530 /* A function ext does not go at the end of a
4532 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4536 case COFF_SYMBOL_COMMON
:
4537 dst
->symbol
.section
= bfd_com_section_ptr
;
4538 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4541 case COFF_SYMBOL_UNDEFINED
:
4542 dst
->symbol
.section
= bfd_und_section_ptr
;
4543 dst
->symbol
.value
= 0;
4546 case COFF_SYMBOL_PE_SECTION
:
4547 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4548 dst
->symbol
.value
= 0;
4551 case COFF_SYMBOL_LOCAL
:
4552 dst
->symbol
.flags
= BSF_LOCAL
;
4553 #if defined COFF_WITH_PE
4554 /* PE sets the symbol to a value relative to the
4555 start of the section. */
4556 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4558 dst
->symbol
.value
= (src
->u
.syment
.n_value
4559 - dst
->symbol
.section
->vma
);
4561 if (ISFCN ((src
->u
.syment
.n_type
)))
4562 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4567 /* A symbol with a csect entry should not go at the end. */
4568 if (src
->u
.syment
.n_numaux
> 0)
4569 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4573 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4574 dst
->symbol
.flags
|= BSF_WEAK
;
4576 if (src
->u
.syment
.n_sclass
== C_SECTION
4577 && src
->u
.syment
.n_scnum
> 0)
4578 dst
->symbol
.flags
= BSF_LOCAL
;
4580 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
)
4581 dst
->symbol
.flags
|= BSF_WEAK
;
4585 case C_STAT
: /* Static. */
4587 case C_LEAFSTAT
: /* Static leaf procedure. */
4590 case C_THUMBSTAT
: /* Thumb static. */
4591 case C_THUMBLABEL
: /* Thumb label. */
4592 case C_THUMBSTATFUNC
:/* Thumb static function. */
4594 case C_LABEL
: /* Label. */
4595 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4596 dst
->symbol
.flags
= BSF_DEBUGGING
;
4598 dst
->symbol
.flags
= BSF_LOCAL
;
4600 /* Base the value as an index from the base of the
4601 section, if there is one. */
4602 if (dst
->symbol
.section
)
4604 #if defined COFF_WITH_PE
4605 /* PE sets the symbol to a value relative to the
4606 start of the section. */
4607 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4609 dst
->symbol
.value
= (src
->u
.syment
.n_value
4610 - dst
->symbol
.section
->vma
);
4614 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4617 case C_MOS
: /* Member of structure. */
4618 case C_EOS
: /* End of structure. */
4619 #ifdef NOTDEF /* C_AUTOARG has the same value. */
4621 case C_GLBLREG
: /* A29k-specific storage class. */
4624 case C_REGPARM
: /* Register parameter. */
4625 case C_REG
: /* register variable. */
4626 /* C_AUTOARG conflictes with TI COFF C_UEXT. */
4627 #if !defined (TIC80COFF) && !defined (TICOFF)
4629 case C_AUTOARG
: /* 960-specific storage class. */
4632 case C_TPDEF
: /* Type definition. */
4634 case C_AUTO
: /* Automatic variable. */
4635 case C_FIELD
: /* Bit field. */
4636 case C_ENTAG
: /* Enumeration tag. */
4637 case C_MOE
: /* Member of enumeration. */
4638 case C_MOU
: /* Member of union. */
4639 case C_UNTAG
: /* Union tag. */
4640 dst
->symbol
.flags
= BSF_DEBUGGING
;
4641 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4644 case C_FILE
: /* File name. */
4645 case C_STRTAG
: /* Structure tag. */
4660 dst
->symbol
.flags
= BSF_DEBUGGING
;
4661 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4665 case C_BINCL
: /* Beginning of include file. */
4666 case C_EINCL
: /* Ending of include file. */
4667 /* The value is actually a pointer into the line numbers
4668 of the file. We locate the line number entry, and
4669 set the section to the section which contains it, and
4670 the value to the index in that section. */
4674 dst
->symbol
.flags
= BSF_DEBUGGING
;
4675 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4676 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4677 && ((file_ptr
) (sec
->line_filepos
4678 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4679 > (file_ptr
) src
->u
.syment
.n_value
))
4682 dst
->symbol
.value
= 0;
4685 dst
->symbol
.section
= sec
;
4686 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4687 - sec
->line_filepos
)
4688 / bfd_coff_linesz (abfd
));
4695 dst
->symbol
.flags
= BSF_DEBUGGING
;
4697 /* The value is actually a symbol index. Save a pointer
4698 to the symbol instead of the index. FIXME: This
4699 should use a union. */
4700 src
->u
.syment
.n_value
=
4701 (long) (native_symbols
+ src
->u
.syment
.n_value
);
4702 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4707 case C_BLOCK
: /* ".bb" or ".eb". */
4708 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf"). */
4709 case C_EFCN
: /* Physical end of function. */
4710 #if defined COFF_WITH_PE
4711 /* PE sets the symbol to a value relative to the start
4713 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4714 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4716 /* PE uses funny values for .ef and .lf; don't
4718 dst
->symbol
.flags
= BSF_DEBUGGING
;
4721 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4723 /* Base the value as an index from the base of the
4725 dst
->symbol
.flags
= BSF_LOCAL
;
4726 dst
->symbol
.value
= (src
->u
.syment
.n_value
4727 - dst
->symbol
.section
->vma
);
4731 case C_STATLAB
: /* Static load time label. */
4732 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4733 dst
->symbol
.flags
= BSF_GLOBAL
;
4737 /* PE DLLs sometimes have zeroed out symbols for some
4738 reason. Just ignore them without a warning. */
4739 if (src
->u
.syment
.n_type
== 0
4740 && src
->u
.syment
.n_value
== 0
4741 && src
->u
.syment
.n_scnum
== 0)
4744 case C_EXTDEF
: /* External definition. */
4745 case C_ULABEL
: /* Undefined label. */
4746 case C_USTATIC
: /* Undefined static. */
4747 #ifndef COFF_WITH_PE
4748 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4749 class to represent a section symbol. */
4750 case C_LINE
: /* line # reformatted as symbol table entry. */
4751 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4752 case C_ALIAS
: /* Duplicate tag. */
4754 /* New storage classes for TI COFF. */
4755 #if defined(TIC80COFF) || defined(TICOFF)
4756 case C_UEXT
: /* Tentative external definition. */
4758 case C_EXTLAB
: /* External load time label. */
4759 case C_HIDDEN
: /* Ext symbol in dmert public lib. */
4761 (*_bfd_error_handler
)
4762 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
4763 bfd_archive_filename (abfd
), src
->u
.syment
.n_sclass
,
4764 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4765 dst
->symbol
.flags
= BSF_DEBUGGING
;
4766 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4770 /* BFD_ASSERT(dst->symbol.flags != 0);*/
4774 dst
->symbol
.udata
.i
= 0;
4775 dst
->lineno
= (alent
*) NULL
;
4776 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
4778 number_of_symbols
++;
4782 obj_symbols (abfd
) = cached_area
;
4783 obj_raw_syments (abfd
) = native_symbols
;
4785 bfd_get_symcount (abfd
) = number_of_symbols
;
4786 obj_convert (abfd
) = table_ptr
;
4787 /* Slurp the line tables for each section too. */
4794 coff_slurp_line_table (abfd
, p
);
4800 } /* coff_slurp_symbol_table() */
4802 /* Classify a COFF symbol. A couple of targets have globally visible
4803 symbols which are not class C_EXT, and this handles those. It also
4804 recognizes some special PE cases. */
4806 static enum coff_symbol_classification
4807 coff_classify_symbol (abfd
, syment
)
4809 struct internal_syment
*syment
;
4811 /* FIXME: This partially duplicates the switch in
4812 coff_slurp_symbol_table. */
4813 switch (syment
->n_sclass
)
4822 case C_THUMBEXTFUNC
:
4830 if (syment
->n_scnum
== 0)
4832 if (syment
->n_value
== 0)
4833 return COFF_SYMBOL_UNDEFINED
;
4835 return COFF_SYMBOL_COMMON
;
4837 return COFF_SYMBOL_GLOBAL
;
4844 if (syment
->n_sclass
== C_STAT
)
4846 if (syment
->n_scnum
== 0)
4848 /* The Microsoft compiler sometimes generates these if a
4849 small static function is inlined every time it is used.
4850 The function is discarded, but the symbol table entry
4852 return COFF_SYMBOL_LOCAL
;
4855 #ifdef STRICT_PE_FORMAT
4856 /* This is correct for Microsoft generated objects, but it
4857 breaks gas generated objects. */
4859 if (syment
->n_value
== 0)
4862 char buf
[SYMNMLEN
+ 1];
4864 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
4866 && (strcmp (bfd_get_section_name (abfd
, sec
),
4867 _bfd_coff_internal_syment_name (abfd
, syment
, buf
))
4869 return COFF_SYMBOL_PE_SECTION
;
4873 return COFF_SYMBOL_LOCAL
;
4876 if (syment
->n_sclass
== C_SECTION
)
4878 /* In some cases in a DLL generated by the Microsoft linker, the
4879 n_value field will contain garbage. FIXME: This should
4880 probably be handled by the swapping function instead. */
4881 syment
->n_value
= 0;
4882 if (syment
->n_scnum
== 0)
4883 return COFF_SYMBOL_UNDEFINED
;
4884 return COFF_SYMBOL_PE_SECTION
;
4886 #endif /* COFF_WITH_PE */
4888 /* If it is not a global symbol, we presume it is a local symbol. */
4890 if (syment
->n_scnum
== 0)
4892 char buf
[SYMNMLEN
+ 1];
4894 (*_bfd_error_handler
)
4895 (_("warning: %s: local symbol `%s' has no section"),
4896 bfd_archive_filename (abfd
),
4897 _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
4900 return COFF_SYMBOL_LOCAL
;
4907 Coff relocations are easily transformed into the internal BFD form
4910 Reading a coff relocation table is done in the following stages:
4912 o Read the entire coff relocation table into memory.
4914 o Process each relocation in turn; first swap it from the
4915 external to the internal form.
4917 o Turn the symbol referenced in the relocation's symbol index
4918 into a pointer into the canonical symbol table.
4919 This table is the same as the one returned by a call to
4920 @code{bfd_canonicalize_symtab}. The back end will call that
4921 routine and save the result if a canonicalization hasn't been done.
4923 o The reloc index is turned into a pointer to a howto
4924 structure, in a back end specific way. For instance, the 386
4925 and 960 use the @code{r_type} to directly produce an index
4926 into a howto table vector; the 88k subtracts a number from the
4927 @code{r_type} field and creates an addend field.
4932 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
4934 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
4935 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
4936 coffsym = (obj_symbols (abfd) \
4937 + (cache_ptr->sym_ptr_ptr - symbols)); \
4939 coffsym = coff_symbol_from (abfd, ptr); \
4940 if (coffsym != (coff_symbol_type *) NULL \
4941 && coffsym->native->u.syment.n_scnum == 0) \
4942 cache_ptr->addend = 0; \
4943 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
4944 && ptr->section != (asection *) NULL) \
4945 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
4947 cache_ptr->addend = 0; \
4952 coff_slurp_reloc_table (abfd
, asect
, symbols
)
4957 RELOC
*native_relocs
;
4958 arelent
*reloc_cache
;
4963 if (asect
->relocation
)
4965 if (asect
->reloc_count
== 0)
4967 if (asect
->flags
& SEC_CONSTRUCTOR
)
4969 if (!coff_slurp_symbol_table (abfd
))
4971 amt
= (bfd_size_type
) bfd_coff_relsz (abfd
) * asect
->reloc_count
;
4972 native_relocs
= (RELOC
*) buy_and_read (abfd
, asect
->rel_filepos
, amt
);
4973 amt
= (bfd_size_type
) asect
->reloc_count
* sizeof (arelent
);
4974 reloc_cache
= (arelent
*) bfd_alloc (abfd
, amt
);
4976 if (reloc_cache
== NULL
)
4979 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
4981 struct internal_reloc dst
;
4982 struct external_reloc
*src
;
4983 #ifndef RELOC_PROCESSING
4987 cache_ptr
= reloc_cache
+ idx
;
4988 src
= native_relocs
+ idx
;
4990 coff_swap_reloc_in (abfd
, src
, &dst
);
4992 #ifdef RELOC_PROCESSING
4993 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
4995 cache_ptr
->address
= dst
.r_vaddr
;
4997 if (dst
.r_symndx
!= -1)
4999 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
5001 (*_bfd_error_handler
)
5002 (_("%s: warning: illegal symbol index %ld in relocs"),
5003 bfd_archive_filename (abfd
), dst
.r_symndx
);
5004 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5009 cache_ptr
->sym_ptr_ptr
= (symbols
5010 + obj_convert (abfd
)[dst
.r_symndx
]);
5011 ptr
= *(cache_ptr
->sym_ptr_ptr
);
5016 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5020 /* The symbols definitions that we have read in have been
5021 relocated as if their sections started at 0. But the offsets
5022 refering to the symbols in the raw data have not been
5023 modified, so we have to have a negative addend to compensate.
5025 Note that symbols which used to be common must be left alone. */
5027 /* Calculate any reloc addend by looking at the symbol. */
5028 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
5030 cache_ptr
->address
-= asect
->vma
;
5031 /* !! cache_ptr->section = (asection *) NULL;*/
5033 /* Fill in the cache_ptr->howto field from dst.r_type. */
5034 RTYPE2HOWTO (cache_ptr
, &dst
);
5035 #endif /* RELOC_PROCESSING */
5037 if (cache_ptr
->howto
== NULL
)
5039 (*_bfd_error_handler
)
5040 (_("%s: illegal relocation type %d at address 0x%lx"),
5041 bfd_archive_filename (abfd
), dst
.r_type
, (long) dst
.r_vaddr
);
5042 bfd_set_error (bfd_error_bad_value
);
5047 asect
->relocation
= reloc_cache
;
5051 #ifndef coff_rtype_to_howto
5054 /* Get the howto structure for a reloc. This is only used if the file
5055 including this one defines coff_relocate_section to be
5056 _bfd_coff_generic_relocate_section, so it is OK if it does not
5057 always work. It is the responsibility of the including file to
5058 make sure it is reasonable if it is needed. */
5060 static reloc_howto_type
*coff_rtype_to_howto
5061 PARAMS ((bfd
*, asection
*, struct internal_reloc
*,
5062 struct coff_link_hash_entry
*, struct internal_syment
*,
5066 static reloc_howto_type
*
5067 coff_rtype_to_howto (abfd
, sec
, rel
, h
, sym
, addendp
)
5068 bfd
*abfd ATTRIBUTE_UNUSED
;
5069 asection
*sec ATTRIBUTE_UNUSED
;
5070 struct internal_reloc
*rel
;
5071 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
;
5072 struct internal_syment
*sym ATTRIBUTE_UNUSED
;
5073 bfd_vma
*addendp ATTRIBUTE_UNUSED
;
5077 RTYPE2HOWTO (&genrel
, rel
);
5078 return genrel
.howto
;
5081 #else /* ! defined (RTYPE2HOWTO) */
5083 #define coff_rtype_to_howto NULL
5085 #endif /* ! defined (RTYPE2HOWTO) */
5086 #endif /* ! defined (coff_rtype_to_howto) */
5088 /* This is stupid. This function should be a boolean predicate. */
5090 coff_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
5096 arelent
*tblptr
= section
->relocation
;
5097 unsigned int count
= 0;
5099 if (section
->flags
& SEC_CONSTRUCTOR
)
5101 /* This section has relocs made up by us, they are not in the
5102 file, so take them out of their chain and place them into
5103 the data area provided. */
5104 arelent_chain
*chain
= section
->constructor_chain
;
5106 for (count
= 0; count
< section
->reloc_count
; count
++)
5108 *relptr
++ = &chain
->relent
;
5109 chain
= chain
->next
;
5114 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
5117 tblptr
= section
->relocation
;
5119 for (; count
++ < section
->reloc_count
;)
5120 *relptr
++ = tblptr
++;
5123 return section
->reloc_count
;
5128 coff_sym_filepos (abfd
)
5131 return obj_sym_filepos (abfd
);
5135 #ifndef coff_reloc16_estimate
5136 #define coff_reloc16_estimate dummy_reloc16_estimate
5138 static int dummy_reloc16_estimate
5139 PARAMS ((bfd
*, asection
*, arelent
*, unsigned int,
5140 struct bfd_link_info
*));
5143 dummy_reloc16_estimate (abfd
, input_section
, reloc
, shrink
, link_info
)
5144 bfd
*abfd ATTRIBUTE_UNUSED
;
5145 asection
*input_section ATTRIBUTE_UNUSED
;
5146 arelent
*reloc ATTRIBUTE_UNUSED
;
5147 unsigned int shrink ATTRIBUTE_UNUSED
;
5148 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
5156 #ifndef coff_reloc16_extra_cases
5158 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5160 /* This works even if abort is not declared in any header file. */
5162 static void dummy_reloc16_extra_cases
5163 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*, arelent
*,
5164 bfd_byte
*, unsigned int *, unsigned int *));
5167 dummy_reloc16_extra_cases (abfd
, link_info
, link_order
, reloc
, data
, src_ptr
,
5169 bfd
*abfd ATTRIBUTE_UNUSED
;
5170 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
5171 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
;
5172 arelent
*reloc ATTRIBUTE_UNUSED
;
5173 bfd_byte
*data ATTRIBUTE_UNUSED
;
5174 unsigned int *src_ptr ATTRIBUTE_UNUSED
;
5175 unsigned int *dst_ptr ATTRIBUTE_UNUSED
;
5181 #ifndef coff_bfd_link_hash_table_free
5182 #define coff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
5185 /* If coff_relocate_section is defined, we can use the optimized COFF
5186 backend linker. Otherwise we must continue to use the old linker. */
5187 #ifdef coff_relocate_section
5188 #ifndef coff_bfd_link_hash_table_create
5189 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5191 #ifndef coff_bfd_link_add_symbols
5192 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5194 #ifndef coff_bfd_final_link
5195 #define coff_bfd_final_link _bfd_coff_final_link
5197 #else /* ! defined (coff_relocate_section) */
5198 #define coff_relocate_section NULL
5199 #ifndef coff_bfd_link_hash_table_create
5200 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5202 #ifndef coff_bfd_link_add_symbols
5203 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5205 #define coff_bfd_final_link _bfd_generic_final_link
5206 #endif /* ! defined (coff_relocate_section) */
5208 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5209 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5211 #ifndef coff_start_final_link
5212 #define coff_start_final_link NULL
5215 #ifndef coff_adjust_symndx
5216 #define coff_adjust_symndx NULL
5219 #ifndef coff_link_add_one_symbol
5220 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5223 #ifndef coff_link_output_has_begun
5225 static bfd_boolean coff_link_output_has_begun
5226 PARAMS ((bfd
*, struct coff_final_link_info
*));
5229 coff_link_output_has_begun (abfd
, info
)
5231 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
;
5233 return abfd
->output_has_begun
;
5237 #ifndef coff_final_link_postscript
5239 static bfd_boolean coff_final_link_postscript
5240 PARAMS ((bfd
*, struct coff_final_link_info
*));
5243 coff_final_link_postscript (abfd
, pfinfo
)
5244 bfd
* abfd ATTRIBUTE_UNUSED
;
5245 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
;
5251 #ifndef coff_SWAP_aux_in
5252 #define coff_SWAP_aux_in coff_swap_aux_in
5254 #ifndef coff_SWAP_sym_in
5255 #define coff_SWAP_sym_in coff_swap_sym_in
5257 #ifndef coff_SWAP_lineno_in
5258 #define coff_SWAP_lineno_in coff_swap_lineno_in
5260 #ifndef coff_SWAP_aux_out
5261 #define coff_SWAP_aux_out coff_swap_aux_out
5263 #ifndef coff_SWAP_sym_out
5264 #define coff_SWAP_sym_out coff_swap_sym_out
5266 #ifndef coff_SWAP_lineno_out
5267 #define coff_SWAP_lineno_out coff_swap_lineno_out
5269 #ifndef coff_SWAP_reloc_out
5270 #define coff_SWAP_reloc_out coff_swap_reloc_out
5272 #ifndef coff_SWAP_filehdr_out
5273 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5275 #ifndef coff_SWAP_aouthdr_out
5276 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5278 #ifndef coff_SWAP_scnhdr_out
5279 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5281 #ifndef coff_SWAP_reloc_in
5282 #define coff_SWAP_reloc_in coff_swap_reloc_in
5284 #ifndef coff_SWAP_filehdr_in
5285 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5287 #ifndef coff_SWAP_aouthdr_in
5288 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5290 #ifndef coff_SWAP_scnhdr_in
5291 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5294 static const bfd_coff_backend_data bfd_coff_std_swap_table
=
5296 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5297 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5298 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5299 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5300 coff_SWAP_scnhdr_out
,
5301 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5302 #ifdef COFF_LONG_FILENAMES
5307 #ifdef COFF_LONG_SECTION_NAMES
5312 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5313 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5318 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5323 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5324 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5325 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5326 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5327 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5328 coff_classify_symbol
, coff_compute_section_file_positions
,
5329 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5330 coff_adjust_symndx
, coff_link_add_one_symbol
,
5331 coff_link_output_has_begun
, coff_final_link_postscript
5334 #ifndef coff_close_and_cleanup
5335 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5338 #ifndef coff_bfd_free_cached_info
5339 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5342 #ifndef coff_get_section_contents
5343 #define coff_get_section_contents _bfd_generic_get_section_contents
5346 #ifndef coff_bfd_copy_private_symbol_data
5347 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5350 #ifndef coff_bfd_copy_private_section_data
5351 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5354 #ifndef coff_bfd_copy_private_bfd_data
5355 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5358 #ifndef coff_bfd_merge_private_bfd_data
5359 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5362 #ifndef coff_bfd_set_private_flags
5363 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5366 #ifndef coff_bfd_print_private_bfd_data
5367 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5370 #ifndef coff_bfd_is_local_label_name
5371 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5374 #ifndef coff_read_minisymbols
5375 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5378 #ifndef coff_minisymbol_to_symbol
5379 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5382 /* The reloc lookup routine must be supplied by each individual COFF
5384 #ifndef coff_bfd_reloc_type_lookup
5385 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5388 #ifndef coff_bfd_get_relocated_section_contents
5389 #define coff_bfd_get_relocated_section_contents \
5390 bfd_generic_get_relocated_section_contents
5393 #ifndef coff_bfd_relax_section
5394 #define coff_bfd_relax_section bfd_generic_relax_section
5397 #ifndef coff_bfd_gc_sections
5398 #define coff_bfd_gc_sections bfd_generic_gc_sections
5401 #ifndef coff_bfd_merge_sections
5402 #define coff_bfd_merge_sections bfd_generic_merge_sections
5405 #ifndef coff_bfd_discard_group
5406 #define coff_bfd_discard_group bfd_generic_discard_group
5409 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
5410 const bfd_target VAR = \
5413 bfd_target_coff_flavour, \
5414 BFD_ENDIAN_BIG, /* data byte order is big */ \
5415 BFD_ENDIAN_BIG, /* header byte order is big */ \
5416 /* object flags */ \
5417 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5418 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5419 /* section flags */ \
5420 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5421 UNDER, /* leading symbol underscore */ \
5422 '/', /* ar_pad_char */ \
5423 15, /* ar_max_namelen */ \
5425 /* Data conversion functions. */ \
5426 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5427 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5428 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5430 /* Header conversion functions. */ \
5431 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5432 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5433 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5435 /* bfd_check_format */ \
5436 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5437 _bfd_dummy_target }, \
5438 /* bfd_set_format */ \
5439 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5440 /* bfd_write_contents */ \
5441 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5444 BFD_JUMP_TABLE_GENERIC (coff), \
5445 BFD_JUMP_TABLE_COPY (coff), \
5446 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5447 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5448 BFD_JUMP_TABLE_SYMBOLS (coff), \
5449 BFD_JUMP_TABLE_RELOCS (coff), \
5450 BFD_JUMP_TABLE_WRITE (coff), \
5451 BFD_JUMP_TABLE_LINK (coff), \
5452 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5459 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
5460 const bfd_target VAR = \
5463 bfd_target_coff_flavour, \
5464 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
5465 BFD_ENDIAN_LITTLE, /* header byte order is little */ \
5466 /* object flags */ \
5467 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5468 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5469 /* section flags */ \
5470 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5471 UNDER, /* leading symbol underscore */ \
5472 '/', /* ar_pad_char */ \
5473 15, /* ar_max_namelen */ \
5475 /* Data conversion functions. */ \
5476 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5477 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5478 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5479 /* Header conversion functions. */ \
5480 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5481 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5482 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5483 /* bfd_check_format */ \
5484 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5485 _bfd_dummy_target }, \
5486 /* bfd_set_format */ \
5487 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5488 /* bfd_write_contents */ \
5489 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5492 BFD_JUMP_TABLE_GENERIC (coff), \
5493 BFD_JUMP_TABLE_COPY (coff), \
5494 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5495 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5496 BFD_JUMP_TABLE_SYMBOLS (coff), \
5497 BFD_JUMP_TABLE_RELOCS (coff), \
5498 BFD_JUMP_TABLE_WRITE (coff), \
5499 BFD_JUMP_TABLE_LINK (coff), \
5500 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \