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
*, const 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 static bfd_boolean ticoff0_bad_format_hook
367 PARAMS ((bfd
*, PTR
));
368 static bfd_boolean ticoff1_bad_format_hook
369 PARAMS ((bfd
*, PTR
));
372 /* void warning(); */
374 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
375 the incoming SEC_* flags. The inverse of this function is
376 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
377 should probably mirror the changes in styp_to_sec_flags(). */
381 /* Macros for setting debugging flags. */
383 #define STYP_XCOFF_DEBUG STYP_DEBUG
385 #define STYP_XCOFF_DEBUG STYP_INFO
388 #ifdef COFF_ALIGN_IN_S_FLAGS
389 #define STYP_DEBUG_INFO STYP_DSECT
391 #define STYP_DEBUG_INFO STYP_INFO
395 sec_to_styp_flags (sec_name
, sec_flags
)
396 const char *sec_name
;
401 if (!strcmp (sec_name
, _TEXT
))
403 styp_flags
= STYP_TEXT
;
405 else if (!strcmp (sec_name
, _DATA
))
407 styp_flags
= STYP_DATA
;
409 else if (!strcmp (sec_name
, _BSS
))
411 styp_flags
= STYP_BSS
;
414 else if (!strcmp (sec_name
, _COMMENT
))
416 styp_flags
= STYP_INFO
;
417 #endif /* _COMMENT */
420 else if (!strcmp (sec_name
, _LIB
))
422 styp_flags
= STYP_LIB
;
426 else if (!strcmp (sec_name
, _LIT
))
428 styp_flags
= STYP_LIT
;
431 else if (!strncmp (sec_name
, ".debug", 6))
433 /* Handle the XCOFF debug section and DWARF2 debug sections. */
435 styp_flags
= STYP_XCOFF_DEBUG
;
437 styp_flags
= STYP_DEBUG_INFO
;
439 else if (!strncmp (sec_name
, ".stab", 5))
441 styp_flags
= STYP_DEBUG_INFO
;
443 #ifdef COFF_LONG_SECTION_NAMES
444 else if (!strncmp (sec_name
, ".gnu.linkonce.wi.", 17))
446 styp_flags
= STYP_DEBUG_INFO
;
450 else if (!strcmp (sec_name
, _PAD
))
452 styp_flags
= STYP_PAD
;
454 else if (!strcmp (sec_name
, _LOADER
))
456 styp_flags
= STYP_LOADER
;
458 else if (!strcmp (sec_name
, _EXCEPT
))
460 styp_flags
= STYP_EXCEPT
;
462 else if (!strcmp (sec_name
, _TYPCHK
))
464 styp_flags
= STYP_TYPCHK
;
467 /* Try and figure out what it should be */
468 else if (sec_flags
& SEC_CODE
)
470 styp_flags
= STYP_TEXT
;
472 else if (sec_flags
& SEC_DATA
)
474 styp_flags
= STYP_DATA
;
476 else if (sec_flags
& SEC_READONLY
)
478 #ifdef STYP_LIT /* 29k readonly text/data section */
479 styp_flags
= STYP_LIT
;
481 styp_flags
= STYP_TEXT
;
482 #endif /* STYP_LIT */
484 else if (sec_flags
& SEC_LOAD
)
486 styp_flags
= STYP_TEXT
;
488 else if (sec_flags
& SEC_ALLOC
)
490 styp_flags
= STYP_BSS
;
494 if (sec_flags
& SEC_CLINK
)
495 styp_flags
|= STYP_CLINK
;
499 if (sec_flags
& SEC_BLOCK
)
500 styp_flags
|= STYP_BLOCK
;
504 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
505 styp_flags
|= STYP_NOLOAD
;
511 #else /* COFF_WITH_PE */
513 /* The PE version; see above for the general comments. The non-PE
514 case seems to be more guessing, and breaks PE format; specifically,
515 .rdata is readonly, but it sure ain't text. Really, all this
516 should be set up properly in gas (or whatever assembler is in use),
517 and honor whatever objcopy/strip, etc. sent us as input. */
520 sec_to_styp_flags (sec_name
, sec_flags
)
521 const char *sec_name ATTRIBUTE_UNUSED
;
526 /* caution: there are at least three groups of symbols that have
527 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
528 SEC_* are the BFD internal flags, used for generic BFD
529 information. STYP_* are the COFF section flags which appear in
530 COFF files. IMAGE_SCN_* are the PE section flags which appear in
531 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
532 but there are more IMAGE_SCN_* flags. */
537 if ((sec_flags
& SEC_CODE
) != 0)
538 styp_flags
|= IMAGE_SCN_CNT_CODE
;
539 if ((sec_flags
& SEC_DATA
) != 0)
540 styp_flags
|= IMAGE_SCN_CNT_INITIALIZED_DATA
;
541 if ((sec_flags
& SEC_ALLOC
) != 0 && (sec_flags
& SEC_LOAD
) == 0)
542 styp_flags
|= IMAGE_SCN_CNT_UNINITIALIZED_DATA
; /* ==STYP_BSS */
544 /* skip constRUCTOR */
547 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
548 styp_flags
|= STYP_NOLOAD
;
550 if ((sec_flags
& SEC_IS_COMMON
) != 0)
551 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
552 if ((sec_flags
& SEC_DEBUGGING
) != 0)
553 styp_flags
|= IMAGE_SCN_MEM_DISCARDABLE
;
554 if ((sec_flags
& SEC_EXCLUDE
) != 0)
555 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
556 if ((sec_flags
& SEC_NEVER_LOAD
) != 0)
557 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
560 if (sec_flags
& SEC_LINK_ONCE
)
561 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
562 /* skip LINK_DUPLICATES */
563 /* skip LINKER_CREATED */
565 /* For now, the read/write bits are mapped onto SEC_READONLY, even
566 though the semantics don't quite match. The bits from the input
567 are retained in pei_section_data(abfd, section)->pe_flags. */
569 styp_flags
|= IMAGE_SCN_MEM_READ
; /* Always readable. */
570 if ((sec_flags
& SEC_READONLY
) == 0)
571 styp_flags
|= IMAGE_SCN_MEM_WRITE
; /* Invert READONLY for write. */
572 if (sec_flags
& SEC_CODE
)
573 styp_flags
|= IMAGE_SCN_MEM_EXECUTE
; /* CODE->EXECUTE. */
574 if (sec_flags
& SEC_SHARED
)
575 styp_flags
|= IMAGE_SCN_MEM_SHARED
; /* Shared remains meaningful. */
580 #endif /* COFF_WITH_PE */
582 /* Return a word with SEC_* flags set to represent the incoming STYP_*
583 flags (from scnhdr.s_flags). The inverse of this function is
584 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
585 should probably mirror the changes in sec_to_styp_flags(). */
590 styp_to_sec_flags (abfd
, hdr
, name
, section
, flags_ptr
)
591 bfd
*abfd ATTRIBUTE_UNUSED
;
594 asection
*section ATTRIBUTE_UNUSED
;
597 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
598 long styp_flags
= internal_s
->s_flags
;
599 flagword sec_flags
= 0;
602 if (styp_flags
& STYP_BLOCK
)
603 sec_flags
|= SEC_BLOCK
;
607 if (styp_flags
& STYP_CLINK
)
608 sec_flags
|= SEC_CLINK
;
612 if (styp_flags
& STYP_NOLOAD
)
613 sec_flags
|= SEC_NEVER_LOAD
;
614 #endif /* STYP_NOLOAD */
616 /* For 386 COFF, at least, an unloadable text or data section is
617 actually a shared library section. */
618 if (styp_flags
& STYP_TEXT
)
620 if (sec_flags
& SEC_NEVER_LOAD
)
621 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
623 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
625 else if (styp_flags
& STYP_DATA
)
627 if (sec_flags
& SEC_NEVER_LOAD
)
628 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
630 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
632 else if (styp_flags
& STYP_BSS
)
634 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
635 if (sec_flags
& SEC_NEVER_LOAD
)
636 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
639 sec_flags
|= SEC_ALLOC
;
641 else if (styp_flags
& STYP_INFO
)
643 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
644 defined. coff_compute_section_file_positions uses
645 COFF_PAGE_SIZE to ensure that the low order bits of the
646 section VMA and the file offset match. If we don't know
647 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
648 and demand page loading of the file will fail. */
649 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
650 sec_flags
|= SEC_DEBUGGING
;
653 else if (styp_flags
& STYP_PAD
)
655 else if (strcmp (name
, _TEXT
) == 0)
657 if (sec_flags
& SEC_NEVER_LOAD
)
658 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
660 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
662 else if (strcmp (name
, _DATA
) == 0)
664 if (sec_flags
& SEC_NEVER_LOAD
)
665 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
667 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
669 else if (strcmp (name
, _BSS
) == 0)
671 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
672 if (sec_flags
& SEC_NEVER_LOAD
)
673 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
676 sec_flags
|= SEC_ALLOC
;
678 else if (strncmp (name
, ".debug", 6) == 0
680 || strcmp (name
, _COMMENT
) == 0
682 #ifdef COFF_LONG_SECTION_NAMES
683 || strncmp (name
, ".gnu.linkonce.wi.", 17) == 0
685 || strncmp (name
, ".stab", 5) == 0)
687 #ifdef COFF_PAGE_SIZE
688 sec_flags
|= SEC_DEBUGGING
;
692 else if (strcmp (name
, _LIB
) == 0)
696 else if (strcmp (name
, _LIT
) == 0)
697 sec_flags
= SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
700 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
702 #ifdef STYP_LIT /* A29k readonly text/data section type. */
703 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
704 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
705 #endif /* STYP_LIT */
707 #ifdef STYP_OTHER_LOAD /* Other loaded sections. */
708 if (styp_flags
& STYP_OTHER_LOAD
)
709 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
710 #endif /* STYP_SDATA */
712 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
713 /* As a GNU extension, if the name begins with .gnu.linkonce, we
714 only link a single copy of the section. This is used to support
715 g++. g++ will emit each template expansion in its own section.
716 The symbols will be defined as weak, so that multiple definitions
717 are permitted. The GNU linker extension is to actually discard
718 all but one of the sections. */
719 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
720 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
723 if (flags_ptr
== NULL
)
726 * flags_ptr
= sec_flags
;
730 #else /* COFF_WITH_PE */
733 handle_COMDAT (abfd
, sec_flags
, hdr
, name
, section
)
740 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
741 bfd_byte
*esymstart
, *esym
, *esymend
;
743 char *target_name
= NULL
;
745 sec_flags
|= SEC_LINK_ONCE
;
747 /* Unfortunately, the PE format stores essential information in
748 the symbol table, of all places. We need to extract that
749 information now, so that objdump and the linker will know how
750 to handle the section without worrying about the symbols. We
751 can't call slurp_symtab, because the linker doesn't want the
754 /* COMDAT sections are special. The first symbol is the section
755 symbol, which tells what kind of COMDAT section it is. The
756 second symbol is the "comdat symbol" - the one with the
757 unique name. GNU uses the section symbol for the unique
758 name; MS uses ".text" for every comdat section. Sigh. - DJ */
760 /* This is not mirrored in sec_to_styp_flags(), but there
761 doesn't seem to be a need to, either, and it would at best be
764 if (! _bfd_coff_get_external_symbols (abfd
))
767 esymstart
= esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
768 esymend
= esym
+ obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
770 while (esym
< esymend
)
772 struct internal_syment isym
;
773 char buf
[SYMNMLEN
+ 1];
776 bfd_coff_swap_sym_in (abfd
, (PTR
) esym
, (PTR
) &isym
);
778 if (sizeof (internal_s
->s_name
) > SYMNMLEN
)
780 /* This case implies that the matching
781 symbol name will be in the string table. */
785 if (isym
.n_scnum
== section
->target_index
)
787 /* According to the MSVC documentation, the first
788 TWO entries with the section # are both of
789 interest to us. The first one is the "section
790 symbol" (section name). The second is the comdat
791 symbol name. Here, we've found the first
792 qualifying entry; we distinguish it from the
793 second with a state flag.
795 In the case of gas-generated (at least until that
796 is fixed) .o files, it isn't necessarily the
797 second one. It may be some other later symbol.
799 Since gas also doesn't follow MS conventions and
800 emits the section similar to .text$<name>, where
801 <something> is the name we're looking for, we
802 distinguish the two as follows:
804 If the section name is simply a section name (no
805 $) we presume it's MS-generated, and look at
806 precisely the second symbol for the comdat name.
807 If the section name has a $, we assume it's
808 gas-generated, and look for <something> (whatever
809 follows the $) as the comdat symbol. */
811 /* All 3 branches use this. */
812 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
, buf
);
821 /* The first time we've seen the symbol. */
822 union internal_auxent aux
;
826 /* If it isn't the stuff we're expecting, die;
827 The MS documentation is vague, but it
828 appears that the second entry serves BOTH
829 as the comdat symbol and the defining
830 symbol record (either C_STAT or C_EXT,
831 possibly with an aux entry with debug
832 information if it's a function.) It
833 appears the only way to find the second one
834 is to count. (On Intel, they appear to be
835 adjacent, but on Alpha, they have been
838 Here, we think we've found the first one,
839 but there's some checking we can do to be
842 if (! (isym
.n_sclass
== C_STAT
843 && isym
.n_type
== T_NULL
844 && isym
.n_value
== 0))
847 /* FIXME LATER: MSVC generates section names
848 like .text for comdats. Gas generates
849 names like .text$foo__Fv (in the case of a
850 function). See comment above for more. */
852 if (strcmp (name
, symname
) != 0)
855 /* This is the section symbol. */
856 bfd_coff_swap_aux_in (abfd
, (PTR
) (esym
+ bfd_coff_symesz (abfd
)),
857 isym
.n_type
, isym
.n_sclass
,
858 0, isym
.n_numaux
, (PTR
) &aux
);
860 target_name
= strchr (name
, '$');
861 if (target_name
!= NULL
)
869 /* FIXME: Microsoft uses NODUPLICATES and
870 ASSOCIATIVE, but gnu uses ANY and
871 SAME_SIZE. Unfortunately, gnu doesn't do
872 the comdat symbols right. So, until we can
873 fix it to do the right thing, we are
874 temporarily disabling comdats for the MS
875 types (they're used in DLLs and C++, but we
876 don't support *their* C++ libraries anyway
879 /* Cygwin does not follow the MS style, and
880 uses ANY and SAME_SIZE where NODUPLICATES
881 and ASSOCIATIVE should be used. For
882 Interix, we just do the right thing up
885 switch (aux
.x_scn
.x_comdat
)
887 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
888 #ifdef STRICT_PE_FORMAT
889 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
891 sec_flags
&= ~SEC_LINK_ONCE
;
895 case IMAGE_COMDAT_SELECT_ANY
:
896 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
899 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
900 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
903 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
904 /* Not yet fully implemented ??? */
905 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
908 /* debug$S gets this case; other
911 /* There may be no symbol... we'll search
912 the whole table... Is this the right
913 place to play this game? Or should we do
914 it when reading it in. */
915 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
916 #ifdef STRICT_PE_FORMAT
917 /* FIXME: This is not currently implemented. */
918 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
920 sec_flags
&= ~SEC_LINK_ONCE
;
924 default: /* 0 means "no symbol" */
925 /* debug$F gets this case; other
927 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
934 /* Gas mode: the first matching on partial name. */
936 #ifndef TARGET_UNDERSCORE
937 #define TARGET_UNDERSCORE 0
939 /* Is this the name we're looking for ? */
940 if (strcmp (target_name
,
941 symname
+ (TARGET_UNDERSCORE
? 1 : 0)) != 0)
943 /* Not the name we're looking for */
944 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
949 /* MSVC mode: the lexically second symbol (or
950 drop through from the above). */
955 /* This must the second symbol with the
956 section #. It is the actual symbol name.
957 Intel puts the two adjacent, but Alpha (at
958 least) spreads them out. */
960 amt
= sizeof (struct bfd_comdat_info
);
961 section
->comdat
= bfd_alloc (abfd
, amt
);
962 if (section
->comdat
== NULL
)
965 section
->comdat
->symbol
=
966 (esym
- esymstart
) / bfd_coff_symesz (abfd
);
968 amt
= strlen (symname
) + 1;
969 newname
= bfd_alloc (abfd
, amt
);
973 strcpy (newname
, symname
);
974 section
->comdat
->name
= newname
;
981 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
989 /* The PE version; see above for the general comments.
991 Since to set the SEC_LINK_ONCE and associated flags, we have to
992 look at the symbol table anyway, we return the symbol table index
993 of the symbol being used as the COMDAT symbol. This is admittedly
994 ugly, but there's really nowhere else that we have access to the
995 required information. FIXME: Is the COMDAT symbol index used for
996 any purpose other than objdump? */
999 styp_to_sec_flags (abfd
, hdr
, name
, section
, flags_ptr
)
1004 flagword
*flags_ptr
;
1006 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
1007 long styp_flags
= internal_s
->s_flags
;
1009 bfd_boolean result
= TRUE
;
1011 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
1012 sec_flags
= SEC_READONLY
;
1014 /* Process each flag bit in styp_flags in turn. */
1017 long flag
= styp_flags
& - styp_flags
;
1018 char * unhandled
= NULL
;
1020 styp_flags
&= ~ flag
;
1022 /* We infer from the distinct read/write/execute bits the settings
1023 of some of the bfd flags; the actual values, should we need them,
1024 are also in pei_section_data (abfd, section)->pe_flags. */
1029 unhandled
= "STYP_DSECT";
1032 unhandled
= "STYP_GROUP";
1035 unhandled
= "STYP_COPY";
1038 unhandled
= "STYP_OVER";
1040 #ifdef SEC_NEVER_LOAD
1042 sec_flags
|= SEC_NEVER_LOAD
;
1045 case IMAGE_SCN_MEM_READ
:
1046 /* Ignored, assume it always to be true. */
1048 case IMAGE_SCN_TYPE_NO_PAD
:
1051 case IMAGE_SCN_LNK_OTHER
:
1052 unhandled
= "IMAGE_SCN_LNK_OTHER";
1054 case IMAGE_SCN_MEM_NOT_CACHED
:
1055 unhandled
= "IMAGE_SCN_MEM_NOT_CACHED";
1057 case IMAGE_SCN_MEM_NOT_PAGED
:
1058 unhandled
= "IMAGE_SCN_MEM_NOT_PAGED";
1060 case IMAGE_SCN_MEM_EXECUTE
:
1061 sec_flags
|= SEC_CODE
;
1063 case IMAGE_SCN_MEM_WRITE
:
1064 sec_flags
&= ~ SEC_READONLY
;
1066 case IMAGE_SCN_MEM_DISCARDABLE
:
1067 sec_flags
|= SEC_DEBUGGING
;
1069 case IMAGE_SCN_MEM_SHARED
:
1070 sec_flags
|= SEC_SHARED
;
1072 case IMAGE_SCN_LNK_REMOVE
:
1073 sec_flags
|= SEC_EXCLUDE
;
1075 case IMAGE_SCN_CNT_CODE
:
1076 sec_flags
|= SEC_CODE
| SEC_ALLOC
| SEC_LOAD
;
1078 case IMAGE_SCN_CNT_INITIALIZED_DATA
:
1079 sec_flags
|= SEC_DATA
| SEC_ALLOC
| SEC_LOAD
;
1081 case IMAGE_SCN_CNT_UNINITIALIZED_DATA
:
1082 sec_flags
|= SEC_ALLOC
;
1084 case IMAGE_SCN_LNK_INFO
:
1085 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1086 defined. coff_compute_section_file_positions uses
1087 COFF_PAGE_SIZE to ensure that the low order bits of the
1088 section VMA and the file offset match. If we don't know
1089 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1090 and demand page loading of the file will fail. */
1091 #ifdef COFF_PAGE_SIZE
1092 sec_flags
|= SEC_DEBUGGING
;
1095 case IMAGE_SCN_LNK_COMDAT
:
1096 /* COMDAT gets very special treatment. */
1097 sec_flags
= handle_COMDAT (abfd
, sec_flags
, hdr
, name
, section
);
1100 /* Silently ignore for now. */
1104 /* If the section flag was not handled, report it here. */
1105 if (unhandled
!= NULL
)
1107 (*_bfd_error_handler
)
1108 (_("%s (%s): Section flag %s (0x%x) ignored"),
1109 bfd_archive_filename (abfd
), name
, unhandled
, flag
);
1114 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1115 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1116 only link a single copy of the section. This is used to support
1117 g++. g++ will emit each template expansion in its own section.
1118 The symbols will be defined as weak, so that multiple definitions
1119 are permitted. The GNU linker extension is to actually discard
1120 all but one of the sections. */
1121 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
1122 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1126 * flags_ptr
= sec_flags
;
1131 #endif /* COFF_WITH_PE */
1133 #define get_index(symbol) ((symbol)->udata.i)
1137 bfd_coff_backend_data
1141 .{* COFF symbol classifications. *}
1143 .enum coff_symbol_classification
1145 . {* Global symbol. *}
1146 . COFF_SYMBOL_GLOBAL,
1147 . {* Common symbol. *}
1148 . COFF_SYMBOL_COMMON,
1149 . {* Undefined symbol. *}
1150 . COFF_SYMBOL_UNDEFINED,
1151 . {* Local symbol. *}
1152 . COFF_SYMBOL_LOCAL,
1153 . {* PE section symbol. *}
1154 . COFF_SYMBOL_PE_SECTION
1157 Special entry points for gdb to swap in coff symbol table parts:
1160 . void (*_bfd_coff_swap_aux_in)
1161 . PARAMS ((bfd *, PTR, int, int, int, int, PTR));
1163 . void (*_bfd_coff_swap_sym_in)
1164 . PARAMS ((bfd *, PTR, PTR));
1166 . void (*_bfd_coff_swap_lineno_in)
1167 . PARAMS ((bfd *, PTR, PTR));
1169 . unsigned int (*_bfd_coff_swap_aux_out)
1170 . PARAMS ((bfd *, PTR, int, int, int, int, PTR));
1172 . unsigned int (*_bfd_coff_swap_sym_out)
1173 . PARAMS ((bfd *, PTR, PTR));
1175 . unsigned int (*_bfd_coff_swap_lineno_out)
1176 . PARAMS ((bfd *, PTR, PTR));
1178 . unsigned int (*_bfd_coff_swap_reloc_out)
1179 . PARAMS ((bfd *, PTR, PTR));
1181 . unsigned int (*_bfd_coff_swap_filehdr_out)
1182 . PARAMS ((bfd *, PTR, PTR));
1184 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1185 . PARAMS ((bfd *, PTR, PTR));
1187 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1188 . PARAMS ((bfd *, PTR, PTR));
1190 . unsigned int _bfd_filhsz;
1191 . unsigned int _bfd_aoutsz;
1192 . unsigned int _bfd_scnhsz;
1193 . unsigned int _bfd_symesz;
1194 . unsigned int _bfd_auxesz;
1195 . unsigned int _bfd_relsz;
1196 . unsigned int _bfd_linesz;
1197 . unsigned int _bfd_filnmlen;
1198 . bfd_boolean _bfd_coff_long_filenames;
1199 . bfd_boolean _bfd_coff_long_section_names;
1200 . unsigned int _bfd_coff_default_section_alignment_power;
1201 . bfd_boolean _bfd_coff_force_symnames_in_strings;
1202 . unsigned int _bfd_coff_debug_string_prefix_length;
1204 . void (*_bfd_coff_swap_filehdr_in)
1205 . PARAMS ((bfd *, PTR, PTR));
1207 . void (*_bfd_coff_swap_aouthdr_in)
1208 . PARAMS ((bfd *, PTR, PTR));
1210 . void (*_bfd_coff_swap_scnhdr_in)
1211 . PARAMS ((bfd *, PTR, PTR));
1213 . void (*_bfd_coff_swap_reloc_in)
1214 . PARAMS ((bfd *abfd, PTR, PTR));
1216 . bfd_boolean (*_bfd_coff_bad_format_hook)
1217 . PARAMS ((bfd *, PTR));
1219 . bfd_boolean (*_bfd_coff_set_arch_mach_hook)
1220 . PARAMS ((bfd *, PTR));
1222 . PTR (*_bfd_coff_mkobject_hook)
1223 . PARAMS ((bfd *, PTR, PTR));
1225 . bfd_boolean (*_bfd_styp_to_sec_flags_hook)
1226 . PARAMS ((bfd *, PTR, const char *, asection *, flagword *));
1228 . void (*_bfd_set_alignment_hook)
1229 . PARAMS ((bfd *, asection *, PTR));
1231 . bfd_boolean (*_bfd_coff_slurp_symbol_table)
1234 . bfd_boolean (*_bfd_coff_symname_in_debug)
1235 . PARAMS ((bfd *, struct internal_syment *));
1237 . bfd_boolean (*_bfd_coff_pointerize_aux_hook)
1238 . PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
1239 . unsigned int, combined_entry_type *));
1241 . bfd_boolean (*_bfd_coff_print_aux)
1242 . PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1243 . combined_entry_type *, unsigned int));
1245 . void (*_bfd_coff_reloc16_extra_cases)
1246 . PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1247 . bfd_byte *, unsigned int *, unsigned int *));
1249 . int (*_bfd_coff_reloc16_estimate)
1250 . PARAMS ((bfd *, asection *, arelent *, unsigned int,
1251 . struct bfd_link_info *));
1253 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1254 . PARAMS ((bfd *, struct internal_syment *));
1256 . bfd_boolean (*_bfd_coff_compute_section_file_positions)
1259 . bfd_boolean (*_bfd_coff_start_final_link)
1260 . PARAMS ((bfd *, struct bfd_link_info *));
1262 . bfd_boolean (*_bfd_coff_relocate_section)
1263 . PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1264 . struct internal_reloc *, struct internal_syment *, asection **));
1266 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1267 . PARAMS ((bfd *, asection *, struct internal_reloc *,
1268 . struct coff_link_hash_entry *, struct internal_syment *,
1271 . bfd_boolean (*_bfd_coff_adjust_symndx)
1272 . PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
1273 . struct internal_reloc *, bfd_boolean *));
1275 . bfd_boolean (*_bfd_coff_link_add_one_symbol)
1276 . PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword,
1277 . asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
1278 . struct bfd_link_hash_entry **));
1280 . bfd_boolean (*_bfd_coff_link_output_has_begun)
1281 . PARAMS ((bfd *, struct coff_final_link_info *));
1283 . bfd_boolean (*_bfd_coff_final_link_postscript)
1284 . PARAMS ((bfd *, struct coff_final_link_info *));
1286 .} bfd_coff_backend_data;
1288 .#define coff_backend_info(abfd) \
1289 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1291 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1292 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1294 .#define bfd_coff_swap_sym_in(a,e,i) \
1295 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1297 .#define bfd_coff_swap_lineno_in(a,e,i) \
1298 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1300 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1301 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1303 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1304 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1306 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1307 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1309 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1310 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1312 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1313 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1315 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1316 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1318 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1319 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1321 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1322 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1323 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1324 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1325 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1326 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1327 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1328 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1329 .#define bfd_coff_long_filenames(abfd) \
1330 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1331 .#define bfd_coff_long_section_names(abfd) \
1332 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1333 .#define bfd_coff_default_section_alignment_power(abfd) \
1334 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1335 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1336 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1338 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1339 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1341 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1342 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1344 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1345 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1347 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1348 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1350 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1351 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1352 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1353 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1354 . (abfd, filehdr, aouthdr))
1356 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1357 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1358 . (abfd, scnhdr, name, section, flags_ptr))
1360 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1361 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1363 .#define bfd_coff_slurp_symbol_table(abfd)\
1364 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1366 .#define bfd_coff_symname_in_debug(abfd, sym)\
1367 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1369 .#define bfd_coff_force_symnames_in_strings(abfd)\
1370 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1372 .#define bfd_coff_debug_string_prefix_length(abfd)\
1373 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1375 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1376 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1377 . (abfd, file, base, symbol, aux, indaux))
1379 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1380 . reloc, data, src_ptr, dst_ptr)\
1381 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1382 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1384 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1385 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1386 . (abfd, section, reloc, shrink, link_info))
1388 .#define bfd_coff_classify_symbol(abfd, sym)\
1389 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1392 .#define bfd_coff_compute_section_file_positions(abfd)\
1393 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1396 .#define bfd_coff_start_final_link(obfd, info)\
1397 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1399 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1400 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1401 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1402 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1403 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1404 . (abfd, sec, rel, h, sym, addendp))
1405 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1406 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1407 . (obfd, info, ibfd, sec, rel, adjustedp))
1408 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1409 . value, string, cp, coll, hashp)\
1410 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1411 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1413 .#define bfd_coff_link_output_has_begun(a,p) \
1414 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p))
1415 .#define bfd_coff_final_link_postscript(a,p) \
1416 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
1420 /* See whether the magic number matches. */
1423 coff_bad_format_hook (abfd
, filehdr
)
1424 bfd
* abfd ATTRIBUTE_UNUSED
;
1427 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1429 if (BADMAG (*internal_f
))
1432 /* If the optional header is NULL or not the correct size then
1433 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1434 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1435 optional header is of a different size.
1437 But the mips keeps extra stuff in it's opthdr, so dont check
1440 #if defined(M88) || defined(I960)
1441 if (internal_f
->f_opthdr
!= 0 && bfd_coff_aoutsz (abfd
) != internal_f
->f_opthdr
)
1450 ticoff0_bad_format_hook (abfd
, filehdr
)
1451 bfd
*abfd ATTRIBUTE_UNUSED
;
1454 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1456 if (COFF0_BADMAG (*internal_f
))
1465 ticoff1_bad_format_hook (abfd
, filehdr
)
1466 bfd
*abfd ATTRIBUTE_UNUSED
;
1469 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1471 if (COFF1_BADMAG (*internal_f
))
1478 /* Check whether this section uses an alignment other than the
1482 coff_set_custom_section_alignment (abfd
, section
, alignment_table
, table_size
)
1483 bfd
*abfd ATTRIBUTE_UNUSED
;
1485 const struct coff_section_alignment_entry
*alignment_table
;
1486 const unsigned int table_size
;
1488 const unsigned int default_alignment
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1491 for (i
= 0; i
< table_size
; ++i
)
1493 const char *secname
= bfd_get_section_name (abfd
, section
);
1495 if (alignment_table
[i
].comparison_length
== (unsigned int) -1
1496 ? strcmp (alignment_table
[i
].name
, secname
) == 0
1497 : strncmp (alignment_table
[i
].name
, secname
,
1498 alignment_table
[i
].comparison_length
) == 0)
1501 if (i
>= table_size
)
1504 if (alignment_table
[i
].default_alignment_min
!= COFF_ALIGNMENT_FIELD_EMPTY
1505 && default_alignment
< alignment_table
[i
].default_alignment_min
)
1508 if (alignment_table
[i
].default_alignment_max
!= COFF_ALIGNMENT_FIELD_EMPTY
1509 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1510 && default_alignment
> alignment_table
[i
].default_alignment_max
1515 section
->alignment_power
= alignment_table
[i
].alignment_power
;
1518 /* Custom section alignment records. */
1520 static const struct coff_section_alignment_entry
1521 coff_section_alignment_table
[] =
1523 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1524 COFF_SECTION_ALIGNMENT_ENTRIES
,
1526 /* There must not be any gaps between .stabstr sections. */
1527 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1528 1, COFF_ALIGNMENT_FIELD_EMPTY
, 0 },
1529 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1530 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1531 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1532 /* Similarly for the .ctors and .dtors sections. */
1533 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1534 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1535 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1536 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 }
1539 static const unsigned int coff_section_alignment_table_size
=
1540 sizeof coff_section_alignment_table
/ sizeof coff_section_alignment_table
[0];
1542 /* Initialize a section structure with information peculiar to this
1543 particular implementation of COFF. */
1546 coff_new_section_hook (abfd
, section
)
1550 combined_entry_type
*native
;
1553 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1556 if (bfd_xcoff_text_align_power (abfd
) != 0
1557 && strcmp (bfd_get_section_name (abfd
, section
), ".text") == 0)
1558 section
->alignment_power
= bfd_xcoff_text_align_power (abfd
);
1559 if (bfd_xcoff_data_align_power (abfd
) != 0
1560 && strcmp (bfd_get_section_name (abfd
, section
), ".data") == 0)
1561 section
->alignment_power
= bfd_xcoff_data_align_power (abfd
);
1564 /* Allocate aux records for section symbols, to store size and
1567 @@ The 10 is a guess at a plausible maximum number of aux entries
1568 (but shouldn't be a constant). */
1569 amt
= sizeof (combined_entry_type
) * 10;
1570 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
1574 /* We don't need to set up n_name, n_value, or n_scnum in the native
1575 symbol information, since they'll be overridden by the BFD symbol
1576 anyhow. However, we do need to set the type and storage class,
1577 in case this symbol winds up getting written out. The value 0
1578 for n_numaux is already correct. */
1580 native
->u
.syment
.n_type
= T_NULL
;
1581 native
->u
.syment
.n_sclass
= C_STAT
;
1583 coffsymbol (section
->symbol
)->native
= native
;
1585 coff_set_custom_section_alignment (abfd
, section
,
1586 coff_section_alignment_table
,
1587 coff_section_alignment_table_size
);
1592 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1594 /* Set the alignment of a BFD section. */
1596 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1599 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1600 bfd
* abfd ATTRIBUTE_UNUSED
;
1604 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1608 /* Extract ALIGN from 2**ALIGN stored in section header. */
1609 for (i
= 0; i
< 32; i
++)
1610 if ((1 << i
) >= hdr
->s_align
)
1614 /* TI tools puts the alignment power in bits 8-11. */
1615 i
= (hdr
->s_flags
>> 8) & 0xF ;
1617 #ifdef COFF_DECODE_ALIGNMENT
1618 i
= COFF_DECODE_ALIGNMENT(hdr
->s_flags
);
1620 section
->alignment_power
= i
;
1622 #ifdef coff_set_section_load_page
1623 coff_set_section_load_page (section
, hdr
->s_page
);
1627 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1630 /* A couple of macros to help setting the alignment power field. */
1631 #define ALIGN_SET(field,x,y) \
1632 if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1634 section->alignment_power = y;\
1637 #define ELIFALIGN_SET(field,x,y) \
1638 else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1640 section->alignment_power = y;\
1643 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1646 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1647 bfd
* abfd ATTRIBUTE_UNUSED
;
1651 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1654 ALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_64BYTES
, 6)
1655 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_32BYTES
, 5)
1656 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_16BYTES
, 4)
1657 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_8BYTES
, 3)
1658 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_4BYTES
, 2)
1659 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_2BYTES
, 1)
1660 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_1BYTES
, 0)
1662 /* In a PE image file, the s_paddr field holds the virtual size of a
1663 section, while the s_size field holds the raw size. We also keep
1664 the original section flag value, since not every bit can be
1665 mapped onto a generic BFD section bit. */
1666 if (coff_section_data (abfd
, section
) == NULL
)
1668 amt
= sizeof (struct coff_section_tdata
);
1669 section
->used_by_bfd
= (PTR
) bfd_zalloc (abfd
, amt
);
1670 if (section
->used_by_bfd
== NULL
)
1672 /* FIXME: Return error. */
1676 if (pei_section_data (abfd
, section
) == NULL
)
1678 amt
= sizeof (struct pei_section_tdata
);
1679 coff_section_data (abfd
, section
)->tdata
= (PTR
) bfd_zalloc (abfd
, amt
);
1680 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1682 /* FIXME: Return error. */
1686 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1687 pei_section_data (abfd
, section
)->pe_flags
= hdr
->s_flags
;
1689 section
->lma
= hdr
->s_vaddr
;
1691 /* Check for extended relocs. */
1692 if (hdr
->s_flags
& IMAGE_SCN_LNK_NRELOC_OVFL
)
1694 struct external_reloc dst
;
1695 struct internal_reloc n
;
1696 file_ptr oldpos
= bfd_tell (abfd
);
1697 bfd_size_type relsz
= bfd_coff_relsz (abfd
);
1699 bfd_seek (abfd
, (file_ptr
) hdr
->s_relptr
, 0);
1700 if (bfd_bread ((PTR
) &dst
, relsz
, abfd
) != relsz
)
1703 coff_swap_reloc_in (abfd
, &dst
, &n
);
1704 bfd_seek (abfd
, oldpos
, 0);
1705 section
->reloc_count
= hdr
->s_nreloc
= n
.r_vaddr
- 1;
1706 section
->rel_filepos
+= relsz
;
1708 else if (hdr
->s_nreloc
== 0xffff)
1709 (*_bfd_error_handler
)
1710 ("%s: warning: claims to have 0xffff relocs, without overflow",
1711 bfd_get_filename (abfd
));
1714 #undef ELIFALIGN_SET
1716 #else /* ! COFF_WITH_PE */
1719 /* We grossly abuse this function to handle XCOFF overflow headers.
1720 When we see one, we correct the reloc and line number counts in the
1721 real header, and remove the section we just created. */
1723 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1726 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1731 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1735 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1738 real_sec
= coff_section_from_bfd_index (abfd
, (int) hdr
->s_nreloc
);
1739 if (real_sec
== NULL
)
1742 real_sec
->reloc_count
= hdr
->s_paddr
;
1743 real_sec
->lineno_count
= hdr
->s_vaddr
;
1745 for (ps
= &abfd
->sections
; *ps
!= NULL
; ps
= &(*ps
)->next
)
1749 bfd_section_list_remove (abfd
, ps
);
1750 --abfd
->section_count
;
1756 #else /* ! RS6000COFF_C */
1758 #define coff_set_alignment_hook \
1759 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1761 #endif /* ! RS6000COFF_C */
1762 #endif /* ! COFF_WITH_PE */
1763 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1765 #ifndef coff_mkobject
1767 static bfd_boolean coff_mkobject
PARAMS ((bfd
*));
1770 coff_mkobject (abfd
)
1773 coff_data_type
*coff
;
1774 bfd_size_type amt
= sizeof (coff_data_type
);
1776 abfd
->tdata
.coff_obj_data
= (struct coff_tdata
*) bfd_zalloc (abfd
, amt
);
1777 if (abfd
->tdata
.coff_obj_data
== 0)
1779 coff
= coff_data (abfd
);
1780 coff
->symbols
= (coff_symbol_type
*) NULL
;
1781 coff
->conversion_table
= (unsigned int *) NULL
;
1782 coff
->raw_syments
= (struct coff_ptr_struct
*) NULL
;
1783 coff
->relocbase
= 0;
1784 coff
->local_toc_sym_map
= 0;
1786 /* make_abs_section(abfd);*/
1792 /* Create the COFF backend specific information. */
1794 #ifndef coff_mkobject_hook
1796 coff_mkobject_hook (abfd
, filehdr
, aouthdr
)
1799 PTR aouthdr ATTRIBUTE_UNUSED
;
1801 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1802 coff_data_type
*coff
;
1804 if (! coff_mkobject (abfd
))
1807 coff
= coff_data (abfd
);
1809 coff
->sym_filepos
= internal_f
->f_symptr
;
1811 /* These members communicate important constants about the symbol
1812 table to GDB's symbol-reading code. These `constants'
1813 unfortunately vary among coff implementations... */
1814 coff
->local_n_btmask
= N_BTMASK
;
1815 coff
->local_n_btshft
= N_BTSHFT
;
1816 coff
->local_n_tmask
= N_TMASK
;
1817 coff
->local_n_tshift
= N_TSHIFT
;
1818 coff
->local_symesz
= bfd_coff_symesz (abfd
);
1819 coff
->local_auxesz
= bfd_coff_auxesz (abfd
);
1820 coff
->local_linesz
= bfd_coff_linesz (abfd
);
1822 coff
->timestamp
= internal_f
->f_timdat
;
1824 obj_raw_syment_count (abfd
) =
1825 obj_conv_table_size (abfd
) =
1826 internal_f
->f_nsyms
;
1829 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
1830 abfd
->flags
|= DYNAMIC
;
1831 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= bfd_coff_aoutsz (abfd
))
1833 struct internal_aouthdr
*internal_a
=
1834 (struct internal_aouthdr
*) aouthdr
;
1835 struct xcoff_tdata
*xcoff
;
1837 xcoff
= xcoff_data (abfd
);
1838 # ifdef U803XTOCMAGIC
1839 xcoff
->xcoff64
= internal_f
->f_magic
== U803XTOCMAGIC
;
1843 xcoff
->full_aouthdr
= TRUE
;
1844 xcoff
->toc
= internal_a
->o_toc
;
1845 xcoff
->sntoc
= internal_a
->o_sntoc
;
1846 xcoff
->snentry
= internal_a
->o_snentry
;
1847 bfd_xcoff_text_align_power (abfd
) = internal_a
->o_algntext
;
1848 bfd_xcoff_data_align_power (abfd
) = internal_a
->o_algndata
;
1849 xcoff
->modtype
= internal_a
->o_modtype
;
1850 xcoff
->cputype
= internal_a
->o_cputype
;
1851 xcoff
->maxdata
= internal_a
->o_maxdata
;
1852 xcoff
->maxstack
= internal_a
->o_maxstack
;
1857 /* Set the flags field from the COFF header read in. */
1858 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
1863 /* FIXME: I'm not sure this is ever executed, since peicode.h
1864 defines coff_mkobject_hook. */
1865 if ((internal_f
->f_flags
& IMAGE_FILE_DEBUG_STRIPPED
) == 0)
1866 abfd
->flags
|= HAS_DEBUG
;
1873 /* Determine the machine architecture and type. FIXME: This is target
1874 dependent because the magic numbers are defined in the target
1875 dependent header files. But there is no particular need for this.
1876 If the magic numbers were moved to a separate file, this function
1877 would be target independent and would also be much more successful
1878 at linking together COFF files for different architectures. */
1881 coff_set_arch_mach_hook (abfd
, filehdr
)
1885 unsigned long machine
;
1886 enum bfd_architecture arch
;
1887 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1889 /* Zero selects the default machine for an arch. */
1891 switch (internal_f
->f_magic
)
1893 #ifdef OR32_MAGIC_BIG
1894 case OR32_MAGIC_BIG
:
1895 case OR32_MAGIC_LITTLE
:
1896 arch
= bfd_arch_or32
;
1901 arch
= bfd_arch_powerpc
;
1907 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler */
1908 case LYNXCOFFMAGIC
: /* shadows the m68k Lynx number below, sigh */
1909 arch
= bfd_arch_i386
;
1914 arch
= bfd_arch_ia64
;
1917 #ifdef A29K_MAGIC_BIG
1918 case A29K_MAGIC_BIG
:
1919 case A29K_MAGIC_LITTLE
:
1920 arch
= bfd_arch_a29k
;
1927 arch
= bfd_arch_arm
;
1928 machine
= bfd_arm_get_mach_from_notes (abfd
, ARM_NOTE_SECTION
);
1929 if (machine
== bfd_mach_arm_unknown
)
1931 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
1933 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
1934 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
1935 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
1937 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
1938 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
1939 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
1940 /* The COFF header does not have enough bits available
1941 to cover all the different ARM architectures. So
1942 we interpret F_ARM_5, the highest flag value to mean
1943 "the highest ARM architecture known to BFD" which is
1944 currently the XScale. */
1945 case F_ARM_5
: machine
= bfd_mach_arm_XScale
; break;
1953 #ifdef MC68KBCSMAGIC
1956 #ifdef APOLLOM68KMAGIC
1957 case APOLLOM68KMAGIC
:
1959 #ifdef LYNXCOFFMAGIC
1962 arch
= bfd_arch_m68k
;
1963 machine
= bfd_mach_m68020
;
1970 arch
= bfd_arch_m88k
;
1976 arch
= bfd_arch_z8k
;
1977 switch (internal_f
->f_flags
& F_MACHMASK
)
1980 machine
= bfd_mach_z8001
;
1983 machine
= bfd_mach_z8002
;
1992 arch
= bfd_arch_i860
;
1999 arch
= bfd_arch_i960
;
2000 switch (F_I960TYPE
& internal_f
->f_flags
)
2004 machine
= bfd_mach_i960_core
;
2007 machine
= bfd_mach_i960_kb_sb
;
2010 machine
= bfd_mach_i960_mc
;
2013 machine
= bfd_mach_i960_xa
;
2016 machine
= bfd_mach_i960_ca
;
2019 machine
= bfd_mach_i960_ka_sa
;
2022 machine
= bfd_mach_i960_jx
;
2025 machine
= bfd_mach_i960_hx
;
2044 if (xcoff_data (abfd
)->cputype
!= -1)
2045 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
2048 /* We did not get a value from the a.out header. If the
2049 file has not been stripped, we may be able to get the
2050 architecture information from the first symbol, if it
2051 is a .file symbol. */
2052 if (obj_raw_syment_count (abfd
) == 0)
2057 struct internal_syment sym
;
2058 bfd_size_type amt
= bfd_coff_symesz (abfd
);
2060 buf
= (bfd_byte
*) bfd_malloc (amt
);
2061 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
2062 || bfd_bread (buf
, amt
, abfd
) != amt
)
2067 bfd_coff_swap_sym_in (abfd
, (PTR
) buf
, (PTR
) &sym
);
2068 if (sym
.n_sclass
== C_FILE
)
2069 cputype
= sym
.n_type
& 0xff;
2076 /* FIXME: We don't handle all cases here. */
2081 arch
= bfd_xcoff_architecture (abfd
);
2082 machine
= bfd_xcoff_machine (abfd
);
2086 arch
= bfd_arch_powerpc
;
2087 machine
= bfd_mach_ppc_601
;
2089 case 2: /* 64 bit PowerPC */
2090 arch
= bfd_arch_powerpc
;
2091 machine
= bfd_mach_ppc_620
;
2094 arch
= bfd_arch_powerpc
;
2095 machine
= bfd_mach_ppc
;
2098 arch
= bfd_arch_rs6000
;
2099 machine
= bfd_mach_rs6k
;
2108 arch
= bfd_arch_we32k
;
2114 arch
= bfd_arch_h8300
;
2115 machine
= bfd_mach_h8300
;
2116 /* !! FIXME this probably isn't the right place for this. */
2117 abfd
->flags
|= BFD_IS_RELAXABLE
;
2123 arch
= bfd_arch_h8300
;
2124 machine
= bfd_mach_h8300h
;
2125 /* !! FIXME this probably isn't the right place for this. */
2126 abfd
->flags
|= BFD_IS_RELAXABLE
;
2132 arch
= bfd_arch_h8300
;
2133 machine
= bfd_mach_h8300s
;
2134 /* !! FIXME this probably isn't the right place for this. */
2135 abfd
->flags
|= BFD_IS_RELAXABLE
;
2141 arch
= bfd_arch_h8300
;
2142 machine
= bfd_mach_h8300hn
;
2143 /* !! FIXME this probably isn't the right place for this. */
2144 abfd
->flags
|= BFD_IS_RELAXABLE
;
2150 arch
= bfd_arch_h8300
;
2151 machine
= bfd_mach_h8300sn
;
2152 /* !! FIXME this probably isn't the right place for this. */
2153 abfd
->flags
|= BFD_IS_RELAXABLE
;
2157 #ifdef SH_ARCH_MAGIC_BIG
2158 case SH_ARCH_MAGIC_BIG
:
2159 case SH_ARCH_MAGIC_LITTLE
:
2161 case SH_ARCH_MAGIC_WINCE
:
2167 #ifdef MIPS_ARCH_MAGIC_WINCE
2168 case MIPS_ARCH_MAGIC_WINCE
:
2169 arch
= bfd_arch_mips
;
2175 arch
= bfd_arch_h8500
;
2181 #ifdef LYNXCOFFMAGIC
2184 arch
= bfd_arch_sparc
;
2190 arch
= bfd_arch_tic30
;
2195 #ifdef TICOFF_TARGET_ARCH
2196 /* This TI COFF section should be used by all new TI COFF v0 targets. */
2198 arch
= TICOFF_TARGET_ARCH
;
2199 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2205 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */
2206 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */
2209 switch (internal_f
->f_target_id
)
2213 arch
= TICOFF_TARGET_ARCH
;
2214 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2218 arch
= bfd_arch_obscure
;
2219 (*_bfd_error_handler
)
2220 (_("Unrecognized TI COFF target id '0x%x'"),
2221 internal_f
->f_target_id
);
2227 #ifdef TIC80_ARCH_MAGIC
2228 case TIC80_ARCH_MAGIC
:
2229 arch
= bfd_arch_tic80
;
2235 arch
= bfd_arch_mcore
;
2241 arch
= bfd_arch_w65
;
2245 default: /* Unreadable input file type. */
2246 arch
= bfd_arch_obscure
;
2250 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2254 #ifdef SYMNAME_IN_DEBUG
2256 static bfd_boolean symname_in_debug_hook
2257 PARAMS ((bfd
*, struct internal_syment
*));
2260 symname_in_debug_hook (abfd
, sym
)
2261 bfd
* abfd ATTRIBUTE_UNUSED
;
2262 struct internal_syment
*sym
;
2264 return SYMNAME_IN_DEBUG (sym
) != 0;
2269 #define symname_in_debug_hook \
2270 (bfd_boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
2277 #define FORCE_SYMNAMES_IN_STRINGS
2280 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
2282 static bfd_boolean coff_pointerize_aux_hook
2283 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
2284 unsigned int, combined_entry_type
*));
2287 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
2288 bfd
*abfd ATTRIBUTE_UNUSED
;
2289 combined_entry_type
*table_base
;
2290 combined_entry_type
*symbol
;
2291 unsigned int indaux
;
2292 combined_entry_type
*aux
;
2294 int class = symbol
->u
.syment
.n_sclass
;
2296 if ((class == C_EXT
|| class == C_HIDEXT
)
2297 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2299 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2301 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2302 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2303 aux
->fix_scnlen
= 1;
2306 /* Return TRUE to indicate that the caller should not do any
2307 further work on this auxent. */
2311 /* Return FALSE to indicate that this auxent should be handled by
2319 /* We don't want to pointerize bal entries. */
2321 static bfd_boolean coff_pointerize_aux_hook
2322 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
2323 unsigned int, combined_entry_type
*));
2326 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
2327 bfd
*abfd ATTRIBUTE_UNUSED
;
2328 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
2329 combined_entry_type
*symbol
;
2330 unsigned int indaux
;
2331 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
2333 /* Return TRUE if we don't want to pointerize this aux entry, which
2334 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2336 && (symbol
->u
.syment
.n_sclass
== C_LEAFPROC
2337 || symbol
->u
.syment
.n_sclass
== C_LEAFSTAT
2338 || symbol
->u
.syment
.n_sclass
== C_LEAFEXT
));
2343 #define coff_pointerize_aux_hook 0
2346 #endif /* ! RS6000COFF_C */
2348 /* Print an aux entry. This returns TRUE if it has printed it. */
2350 static bfd_boolean coff_print_aux
2351 PARAMS ((bfd
*, FILE *, combined_entry_type
*, combined_entry_type
*,
2352 combined_entry_type
*, unsigned int));
2355 coff_print_aux (abfd
, file
, table_base
, symbol
, aux
, indaux
)
2356 bfd
*abfd ATTRIBUTE_UNUSED
;
2357 FILE *file ATTRIBUTE_UNUSED
;
2358 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
2359 combined_entry_type
*symbol ATTRIBUTE_UNUSED
;
2360 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
2361 unsigned int indaux ATTRIBUTE_UNUSED
;
2364 if ((symbol
->u
.syment
.n_sclass
== C_EXT
2365 || symbol
->u
.syment
.n_sclass
== C_HIDEXT
)
2366 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2368 /* This is a csect entry. */
2369 fprintf (file
, "AUX ");
2370 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2372 BFD_ASSERT (! aux
->fix_scnlen
);
2374 fprintf (file
, "val %5lld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2376 fprintf (file
, "val %5ld", (long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2381 fprintf (file
, "indx ");
2382 if (! aux
->fix_scnlen
)
2384 fprintf (file
, "%4lld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2386 fprintf (file
, "%4ld", (long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2389 fprintf (file
, "%4ld",
2390 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2393 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2394 aux
->u
.auxent
.x_csect
.x_parmhash
,
2395 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2396 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2397 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2398 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2399 aux
->u
.auxent
.x_csect
.x_stab
,
2400 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2405 /* Return FALSE to indicate that no special action was taken. */
2413 To write relocations, the back end steps though the
2414 canonical relocation table and create an
2415 @code{internal_reloc}. The symbol index to use is removed from
2416 the @code{offset} field in the symbol table supplied. The
2417 address comes directly from the sum of the section base
2418 address and the relocation offset; the type is dug directly
2419 from the howto field. Then the @code{internal_reloc} is
2420 swapped into the shape of an @code{external_reloc} and written
2427 static int compare_arelent_ptr
PARAMS ((const PTR
, const PTR
));
2429 /* AUX's ld wants relocations to be sorted. */
2431 compare_arelent_ptr (x
, y
)
2435 const arelent
**a
= (const arelent
**) x
;
2436 const arelent
**b
= (const arelent
**) y
;
2437 bfd_size_type aadr
= (*a
)->address
;
2438 bfd_size_type badr
= (*b
)->address
;
2440 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2443 #endif /* TARG_AUX */
2446 coff_write_relocs (abfd
, first_undef
)
2452 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
2455 struct external_reloc dst
;
2462 /* Sort relocations before we write them out. */
2465 amt
= s
->reloc_count
;
2466 amt
*= sizeof (arelent
*);
2467 p
= (arelent
**) bfd_malloc (amt
);
2468 if (p
== NULL
&& s
->reloc_count
> 0)
2470 memcpy (p
, s
->orelocation
, (size_t) amt
);
2471 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2475 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2479 if (obj_pe (abfd
) && s
->reloc_count
>= 0xffff)
2481 /* Encode real count here as first reloc. */
2482 struct internal_reloc n
;
2484 memset ((PTR
) & n
, 0, sizeof (n
));
2485 /* Add one to count *this* reloc (grr). */
2486 n
.r_vaddr
= s
->reloc_count
+ 1;
2487 coff_swap_reloc_out (abfd
, &n
, &dst
);
2488 if (bfd_bwrite ((PTR
) & dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2489 abfd
) != bfd_coff_relsz (abfd
))
2494 for (i
= 0; i
< s
->reloc_count
; i
++)
2496 struct internal_reloc n
;
2499 memset ((PTR
) & n
, 0, sizeof (n
));
2501 /* Now we've renumbered the symbols we know where the
2502 undefined symbols live in the table. Check the reloc
2503 entries for symbols who's output bfd isn't the right one.
2504 This is because the symbol was undefined (which means
2505 that all the pointers are never made to point to the same
2506 place). This is a bad thing,'cause the symbols attached
2507 to the output bfd are indexed, so that the relocation
2508 entries know which symbol index they point to. So we
2509 have to look up the output symbol here. */
2511 if (q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2514 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2515 asymbol
**outsyms
= abfd
->outsymbols
;
2517 for (j
= first_undef
; outsyms
[j
]; j
++)
2519 const char *intable
= outsyms
[j
]->name
;
2521 if (strcmp (intable
, sname
) == 0) {
2522 /* Got a hit, so repoint the reloc. */
2523 q
->sym_ptr_ptr
= outsyms
+ j
;
2529 n
.r_vaddr
= q
->address
+ s
->vma
;
2532 /* The 29k const/consth reloc pair is a real kludge. The consth
2533 part doesn't have a symbol; it has an offset. So rebuilt
2535 if (q
->howto
->type
== R_IHCONST
)
2536 n
.r_symndx
= q
->addend
;
2541 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2542 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
,s
))
2544 if ((*q
->sym_ptr_ptr
)->section
== bfd_abs_section_ptr
2545 && ((*q
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) != 0)
2547 /* This is a relocation relative to the absolute symbol. */
2551 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2552 /* Take notice if the symbol reloc points to a symbol
2553 we don't have in our symbol table. What should we
2555 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2560 #ifdef SWAP_OUT_RELOC_OFFSET
2561 n
.r_offset
= q
->addend
;
2565 /* Work out reloc type from what is required. */
2566 SELECT_RELOC (n
, q
->howto
);
2568 n
.r_type
= q
->howto
->type
;
2570 coff_swap_reloc_out (abfd
, &n
, &dst
);
2572 if (bfd_bwrite ((PTR
) & dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2573 abfd
) != bfd_coff_relsz (abfd
))
2586 /* Set flags and magic number of a coff file from architecture and machine
2587 type. Result is TRUE if we can represent the arch&type, FALSE if not. */
2590 coff_set_flags (abfd
, magicp
, flagsp
)
2592 unsigned int *magicp ATTRIBUTE_UNUSED
;
2593 unsigned short *flagsp ATTRIBUTE_UNUSED
;
2595 switch (bfd_get_arch (abfd
))
2600 switch (bfd_get_mach (abfd
))
2602 case bfd_mach_z8001
:
2605 case bfd_mach_z8002
:
2619 *magicp
= I960ROMAGIC
;
2621 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2622 I960RWMAGIC); FIXME???
2624 switch (bfd_get_mach (abfd
))
2626 case bfd_mach_i960_core
:
2629 case bfd_mach_i960_kb_sb
:
2632 case bfd_mach_i960_mc
:
2635 case bfd_mach_i960_xa
:
2638 case bfd_mach_i960_ca
:
2641 case bfd_mach_i960_ka_sa
:
2644 case bfd_mach_i960_jx
:
2647 case bfd_mach_i960_hx
:
2660 case bfd_arch_tic30
:
2661 *magicp
= TIC30MAGIC
;
2665 #ifdef TICOFF_DEFAULT_MAGIC
2666 case TICOFF_TARGET_ARCH
:
2667 /* If there's no indication of which version we want, use the default. */
2669 *magicp
= TICOFF_DEFAULT_MAGIC
;
2672 /* We may want to output in a different COFF version. */
2673 switch (abfd
->xvec
->name
[4])
2676 *magicp
= TICOFF0MAGIC
;
2679 *magicp
= TICOFF1MAGIC
;
2682 *magicp
= TICOFF2MAGIC
;
2688 TICOFF_TARGET_MACHINE_SET (flagsp
, bfd_get_mach (abfd
));
2692 #ifdef TIC80_ARCH_MAGIC
2693 case bfd_arch_tic80
:
2694 *magicp
= TIC80_ARCH_MAGIC
;
2700 * magicp
= ARMPEMAGIC
;
2702 * magicp
= ARMMAGIC
;
2705 if (APCS_SET (abfd
))
2707 if (APCS_26_FLAG (abfd
))
2708 * flagsp
|= F_APCS26
;
2710 if (APCS_FLOAT_FLAG (abfd
))
2711 * flagsp
|= F_APCS_FLOAT
;
2713 if (PIC_FLAG (abfd
))
2716 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2717 * flagsp
|= F_INTERWORK
;
2718 switch (bfd_get_mach (abfd
))
2720 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2721 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2722 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2723 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2724 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2725 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2726 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2727 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2728 See also the comment in coff_set_arch_mach_hook(). */
2729 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break;
2730 case bfd_mach_arm_5TE
: * flagsp
|= F_ARM_5
; break;
2731 case bfd_mach_arm_XScale
: * flagsp
|= F_ARM_5
; break;
2736 case bfd_arch_powerpc
:
2743 *magicp
= I386MAGIC
;
2745 /* Just overwrite the usual value if we're doing Lynx. */
2746 *magicp
= LYNXCOFFMAGIC
;
2753 *magicp
= I860MAGIC
;
2759 *magicp
= IA64MAGIC
;
2765 #ifdef APOLLOM68KMAGIC
2766 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
2768 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2769 #ifdef NAMES_HAVE_UNDERSCORE
2770 *magicp
= MC68KBCSMAGIC
;
2772 *magicp
= MC68MAGIC
;
2776 /* Just overwrite the usual value if we're doing Lynx. */
2777 *magicp
= LYNXCOFFMAGIC
;
2785 *magicp
= MC88OMAGIC
;
2790 case bfd_arch_h8300
:
2791 switch (bfd_get_mach (abfd
))
2793 case bfd_mach_h8300
:
2794 *magicp
= H8300MAGIC
;
2796 case bfd_mach_h8300h
:
2797 *magicp
= H8300HMAGIC
;
2799 case bfd_mach_h8300s
:
2800 *magicp
= H8300SMAGIC
;
2802 case bfd_mach_h8300hn
:
2803 *magicp
= H8300HNMAGIC
;
2805 case bfd_mach_h8300sn
:
2806 *magicp
= H8300SNMAGIC
;
2812 #ifdef SH_ARCH_MAGIC_BIG
2814 #ifdef COFF_IMAGE_WITH_PE
2815 *magicp
= SH_ARCH_MAGIC_WINCE
;
2817 if (bfd_big_endian (abfd
))
2818 *magicp
= SH_ARCH_MAGIC_BIG
;
2820 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2826 #ifdef MIPS_ARCH_MAGIC_WINCE
2828 *magicp
= MIPS_ARCH_MAGIC_WINCE
;
2834 case bfd_arch_sparc
:
2835 *magicp
= SPARCMAGIC
;
2837 /* Just overwrite the usual value if we're doing Lynx. */
2838 *magicp
= LYNXCOFFMAGIC
;
2845 case bfd_arch_h8500
:
2846 *magicp
= H8500MAGIC
;
2850 #ifdef A29K_MAGIC_BIG
2852 if (bfd_big_endian (abfd
))
2853 *magicp
= A29K_MAGIC_BIG
;
2855 *magicp
= A29K_MAGIC_LITTLE
;
2861 case bfd_arch_we32k
:
2862 *magicp
= WE32KMAGIC
;
2868 case bfd_arch_rs6000
:
2870 case bfd_arch_powerpc
:
2872 BFD_ASSERT (bfd_get_flavour (abfd
) == bfd_target_xcoff_flavour
);
2873 *magicp
= bfd_xcoff_magic_number (abfd
);
2879 case bfd_arch_mcore
:
2880 * magicp
= MCOREMAGIC
;
2890 #ifdef OR32_MAGIC_BIG
2892 if (bfd_big_endian (abfd
))
2893 * magicp
= OR32_MAGIC_BIG
;
2895 * magicp
= OR32_MAGIC_LITTLE
;
2899 default: /* Unknown architecture. */
2900 /* Fall through to "return FALSE" below, to avoid
2901 "statement never reached" errors on the one below. */
2909 coff_set_arch_mach (abfd
, arch
, machine
)
2911 enum bfd_architecture arch
;
2912 unsigned long machine
;
2915 unsigned short dummy2
;
2917 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
2920 if (arch
!= bfd_arch_unknown
2921 && ! coff_set_flags (abfd
, &dummy1
, &dummy2
))
2922 return FALSE
; /* We can't represent this type */
2924 return TRUE
; /* We're easy ... */
2927 #ifdef COFF_IMAGE_WITH_PE
2929 /* This is used to sort sections by VMA, as required by PE image
2932 static int sort_by_secaddr
PARAMS ((const PTR
, const PTR
));
2935 sort_by_secaddr (arg1
, arg2
)
2939 const asection
*a
= *(const asection
**) arg1
;
2940 const asection
*b
= *(const asection
**) arg2
;
2942 if (a
->vma
< b
->vma
)
2944 else if (a
->vma
> b
->vma
)
2950 #endif /* COFF_IMAGE_WITH_PE */
2952 /* Calculate the file position for each section. */
2955 #define ALIGN_SECTIONS_IN_FILE
2957 #if defined(TIC80COFF) || defined(TICOFF)
2958 #undef ALIGN_SECTIONS_IN_FILE
2962 coff_compute_section_file_positions (abfd
)
2966 asection
*previous
= (asection
*) NULL
;
2967 file_ptr sofar
= bfd_coff_filhsz (abfd
);
2968 bfd_boolean align_adjust
;
2969 #ifdef ALIGN_SECTIONS_IN_FILE
2974 /* On XCOFF, if we have symbols, set up the .debug section. */
2975 if (bfd_get_symcount (abfd
) > 0)
2978 bfd_size_type i
, symcount
;
2982 symcount
= bfd_get_symcount (abfd
);
2983 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
2985 coff_symbol_type
*cf
;
2987 cf
= coff_symbol_from (abfd
, *symp
);
2989 && cf
->native
!= NULL
2990 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
2994 len
= strlen (bfd_asymbol_name (*symp
));
2995 if (len
> SYMNMLEN
|| bfd_coff_force_symnames_in_strings (abfd
))
2996 sz
+= len
+ 1 + bfd_coff_debug_string_prefix_length (abfd
);
3003 dsec
= bfd_make_section_old_way (abfd
, ".debug");
3006 dsec
->_raw_size
= sz
;
3007 dsec
->flags
|= SEC_HAS_CONTENTS
;
3012 #ifdef COFF_IMAGE_WITH_PE
3014 if (coff_data (abfd
)->link_info
)
3016 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
3018 /* If no file alignment has been set, default to one.
3019 This repairs 'ld -r' for arm-wince-pe target. */
3024 page_size
= PE_DEF_FILE_ALIGNMENT
;
3026 #ifdef COFF_PAGE_SIZE
3027 int page_size
= COFF_PAGE_SIZE
;
3031 if (bfd_get_start_address (abfd
))
3033 /* A start address may have been added to the original file. In this
3034 case it will need an optional header to record it. */
3035 abfd
->flags
|= EXEC_P
;
3038 if (abfd
->flags
& EXEC_P
)
3039 sofar
+= bfd_coff_aoutsz (abfd
);
3041 else if (xcoff_data (abfd
)->full_aouthdr
)
3042 sofar
+= bfd_coff_aoutsz (abfd
);
3044 sofar
+= SMALL_AOUTSZ
;
3047 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
3050 /* XCOFF handles overflows in the reloc and line number count fields
3051 by allocating a new section header to hold the correct counts. */
3052 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3053 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3054 sofar
+= bfd_coff_scnhsz (abfd
);
3057 #ifdef COFF_IMAGE_WITH_PE
3059 /* PE requires the sections to be in memory order when listed in
3060 the section headers. It also does not like empty loadable
3061 sections. The sections apparently do not have to be in the
3062 right order in the image file itself, but we do need to get the
3063 target_index values right. */
3066 asection
**section_list
;
3072 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3075 /* We allocate an extra cell to simplify the final loop. */
3076 amt
= sizeof (struct asection
*) * (count
+ 1);
3077 section_list
= bfd_malloc (amt
);
3078 if (section_list
== NULL
)
3082 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3084 section_list
[i
] = current
;
3087 section_list
[i
] = NULL
;
3089 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
3091 /* Rethread the linked list into sorted order; at the same time,
3092 assign target_index values. */
3094 abfd
->sections
= section_list
[0];
3095 for (i
= 0; i
< count
; i
++)
3097 current
= section_list
[i
];
3098 current
->next
= section_list
[i
+ 1];
3100 /* Later, if the section has zero size, we'll be throwing it
3101 away, so we don't want to number it now. Note that having
3102 a zero size and having real contents are different
3103 concepts: .bss has no contents, but (usually) non-zero
3105 if (current
->_raw_size
== 0)
3107 /* Discard. However, it still might have (valid) symbols
3108 in it, so arbitrarily set it to section 1 (indexing is
3109 1-based here; usually .text). __end__ and other
3110 contents of .endsection really have this happen.
3111 FIXME: This seems somewhat dubious. */
3112 current
->target_index
= 1;
3115 current
->target_index
= target_index
++;
3117 abfd
->section_tail
= ¤t
->next
;
3119 free (section_list
);
3121 #else /* ! COFF_IMAGE_WITH_PE */
3123 /* Set the target_index field. */
3127 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3128 current
->target_index
= target_index
++;
3130 #endif /* ! COFF_IMAGE_WITH_PE */
3132 align_adjust
= FALSE
;
3133 for (current
= abfd
->sections
;
3134 current
!= (asection
*) NULL
;
3135 current
= current
->next
)
3137 #ifdef COFF_IMAGE_WITH_PE
3138 /* With PE we have to pad each section to be a multiple of its
3139 page size too, and remember both sizes. */
3140 if (coff_section_data (abfd
, current
) == NULL
)
3142 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
3143 current
->used_by_bfd
= (PTR
) bfd_zalloc (abfd
, amt
);
3144 if (current
->used_by_bfd
== NULL
)
3147 if (pei_section_data (abfd
, current
) == NULL
)
3149 bfd_size_type amt
= sizeof (struct pei_section_tdata
);
3150 coff_section_data (abfd
, current
)->tdata
3151 = (PTR
) bfd_zalloc (abfd
, amt
);
3152 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
3155 if (pei_section_data (abfd
, current
)->virt_size
== 0)
3156 pei_section_data (abfd
, current
)->virt_size
= current
->_raw_size
;
3159 /* Only deal with sections which have contents. */
3160 if (!(current
->flags
& SEC_HAS_CONTENTS
))
3163 #ifdef COFF_IMAGE_WITH_PE
3164 /* Make sure we skip empty sections in a PE image. */
3165 if (current
->_raw_size
== 0)
3169 /* Align the sections in the file to the same boundary on
3170 which they are aligned in virtual memory. I960 doesn't
3171 do this (FIXME) so we can stay in sync with Intel. 960
3172 doesn't yet page from files... */
3173 #ifdef ALIGN_SECTIONS_IN_FILE
3174 if ((abfd
->flags
& EXEC_P
) != 0)
3176 /* Make sure this section is aligned on the right boundary - by
3177 padding the previous section up if necessary. */
3181 /* AIX loader checks the text section alignment of (vma - filepos)
3182 So even though the filepos may be aligned wrt the o_algntext, for
3183 AIX executables, this check fails. This shows up when a native
3184 AIX executable is stripped with gnu strip because the default vma
3185 of native is 0x10000150 but default for gnu is 0x10000140. Gnu
3186 stripped gnu excutable passes this check because the filepos is
3187 0x0140. This problem also show up with 64 bit shared objects. The
3188 data section must also be aligned. */
3189 if (!strcmp (current
->name
, _TEXT
)
3190 || !strcmp (current
->name
, _DATA
))
3195 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3197 align
= 1 << current
->alignment_power
;
3198 pad
= abs (current
->vma
- sofar
) % align
;
3209 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3212 if (previous
!= (asection
*) NULL
)
3213 previous
->_raw_size
+= sofar
- old_sofar
;
3218 /* In demand paged files the low order bits of the file offset
3219 must match the low order bits of the virtual address. */
3220 #ifdef COFF_PAGE_SIZE
3221 if ((abfd
->flags
& D_PAGED
) != 0
3222 && (current
->flags
& SEC_ALLOC
) != 0)
3223 sofar
+= (current
->vma
- sofar
) % page_size
;
3225 current
->filepos
= sofar
;
3227 #ifdef COFF_IMAGE_WITH_PE
3228 /* Set the padded size. */
3229 current
->_raw_size
= (current
->_raw_size
+ page_size
-1) & -page_size
;
3232 sofar
+= current
->_raw_size
;
3234 #ifdef ALIGN_SECTIONS_IN_FILE
3235 /* Make sure that this section is of the right size too. */
3236 if ((abfd
->flags
& EXEC_P
) == 0)
3238 bfd_size_type old_size
;
3240 old_size
= current
->_raw_size
;
3241 current
->_raw_size
= BFD_ALIGN (current
->_raw_size
,
3242 1 << current
->alignment_power
);
3243 align_adjust
= current
->_raw_size
!= old_size
;
3244 sofar
+= current
->_raw_size
- old_size
;
3249 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3250 align_adjust
= sofar
!= old_sofar
;
3251 current
->_raw_size
+= sofar
- old_sofar
;
3255 #ifdef COFF_IMAGE_WITH_PE
3256 /* For PE we need to make sure we pad out to the aligned
3257 _raw_size, in case the caller only writes out data to the
3258 unaligned _raw_size. */
3259 if (pei_section_data (abfd
, current
)->virt_size
< current
->_raw_size
)
3260 align_adjust
= TRUE
;
3264 /* Force .lib sections to start at zero. The vma is then
3265 incremented in coff_set_section_contents. This is right for
3267 if (strcmp (current
->name
, _LIB
) == 0)
3268 bfd_set_section_vma (abfd
, current
, 0);
3274 /* It is now safe to write to the output file. If we needed an
3275 alignment adjustment for the last section, then make sure that
3276 there is a byte at offset sofar. If there are no symbols and no
3277 relocs, then nothing follows the last section. If we don't force
3278 the last byte out, then the file may appear to be truncated. */
3284 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
3285 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3289 /* Make sure the relocations are aligned. We don't need to make
3290 sure that this byte exists, because it will only matter if there
3291 really are relocs. */
3292 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
3294 obj_relocbase (abfd
) = sofar
;
3295 abfd
->output_has_begun
= TRUE
;
3302 /* This can never work, because it is called too late--after the
3303 section positions have been set. I can't figure out what it is
3304 for, so I am going to disable it--Ian Taylor 20 March 1996. */
3306 /* If .file, .text, .data, .bss symbols are missing, add them. */
3307 /* @@ Should we only be adding missing symbols, or overriding the aux
3308 values for existing section symbols? */
3310 coff_add_missing_symbols (abfd
)
3313 unsigned int nsyms
= bfd_get_symcount (abfd
);
3314 asymbol
**sympp
= abfd
->outsymbols
;
3317 int need_text
= 1, need_data
= 1, need_bss
= 1, need_file
= 1;
3320 for (i
= 0; i
< nsyms
; i
++)
3322 coff_symbol_type
*csym
= coff_symbol_from (abfd
, sympp
[i
]);
3327 /* Only do this if there is a coff representation of the input
3329 if (csym
->native
&& csym
->native
->u
.syment
.n_sclass
== C_FILE
)
3334 name
= csym
->symbol
.name
;
3337 if (!strcmp (name
, _TEXT
))
3340 else if (!strcmp (name
, ".wtext"))
3343 else if (!strcmp (name
, _DATA
))
3345 else if (!strcmp (name
, _BSS
))
3349 /* Now i == bfd_get_symcount (abfd). */
3350 /* @@ For now, don't deal with .file symbol. */
3353 if (!need_text
&& !need_data
&& !need_bss
&& !need_file
)
3355 nsyms
+= need_text
+ need_data
+ need_bss
+ need_file
;
3357 amt
*= sizeof (asymbol
*);
3358 sympp2
= (asymbol
**) bfd_alloc (abfd
, amt
);
3361 memcpy (sympp2
, sympp
, i
* sizeof (asymbol
*));
3364 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
3368 sympp2
[i
++] = coff_section_symbol (abfd
, _TEXT
);
3370 sympp2
[i
++] = coff_section_symbol (abfd
, _DATA
);
3372 sympp2
[i
++] = coff_section_symbol (abfd
, _BSS
);
3373 BFD_ASSERT (i
== nsyms
);
3374 bfd_set_symtab (abfd
, sympp2
, nsyms
);
3380 #ifdef COFF_IMAGE_WITH_PE
3382 static unsigned int pelength
;
3383 static unsigned int peheader
;
3386 coff_read_word (abfd
, value
)
3388 unsigned int *value
;
3393 status
= bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3401 *value
= (unsigned int) b
[0];
3403 *value
= (unsigned int) (b
[0] + (b
[1] << 8));
3405 pelength
+= (unsigned int) status
;
3411 coff_compute_checksum (abfd
)
3414 bfd_boolean more_data
;
3421 filepos
= (file_ptr
) 0;
3425 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
3428 more_data
= coff_read_word (abfd
, &value
);
3430 total
= 0xffff & (total
+ (total
>> 0x10));
3435 return (0xffff & (total
+ (total
>> 0x10)));
3439 coff_apply_checksum (abfd
)
3442 unsigned int computed
;
3443 unsigned int checksum
= 0;
3445 if (bfd_seek (abfd
, 0x3c, SEEK_SET
) != 0)
3448 if (!coff_read_word (abfd
, &peheader
))
3451 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3455 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3457 if (bfd_seek (abfd
, peheader
, SEEK_SET
) != 0)
3460 computed
= coff_compute_checksum (abfd
);
3462 checksum
= computed
+ pelength
;
3464 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3467 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3472 #endif /* COFF_IMAGE_WITH_PE */
3477 coff_write_object_contents (abfd
)
3481 bfd_boolean hasrelocs
= FALSE
;
3482 bfd_boolean haslinno
= FALSE
;
3483 bfd_boolean hasdebug
= FALSE
;
3485 file_ptr reloc_base
;
3486 file_ptr lineno_base
;
3488 unsigned long reloc_size
= 0, reloc_count
= 0;
3489 unsigned long lnno_size
= 0;
3490 bfd_boolean long_section_names
;
3491 asection
*text_sec
= NULL
;
3492 asection
*data_sec
= NULL
;
3493 asection
*bss_sec
= NULL
;
3494 struct internal_filehdr internal_f
;
3495 struct internal_aouthdr internal_a
;
3496 #ifdef COFF_LONG_SECTION_NAMES
3497 size_t string_size
= STRING_SIZE_SIZE
;
3500 bfd_set_error (bfd_error_system_call
);
3502 /* Make a pass through the symbol table to count line number entries and
3503 put them into the correct asections. */
3505 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3507 if (! abfd
->output_has_begun
)
3509 if (! coff_compute_section_file_positions (abfd
))
3513 reloc_base
= obj_relocbase (abfd
);
3515 /* Work out the size of the reloc and linno areas. */
3517 for (current
= abfd
->sections
; current
!= NULL
; current
=
3521 /* We store the actual reloc count in the first reloc's addr. */
3522 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3525 reloc_count
+= current
->reloc_count
;
3528 reloc_size
= reloc_count
* bfd_coff_relsz (abfd
);
3530 lineno_base
= reloc_base
+ reloc_size
;
3531 sym_base
= lineno_base
+ lnno_size
;
3533 /* Indicate in each section->line_filepos its actual file address. */
3534 for (current
= abfd
->sections
; current
!= NULL
; current
=
3537 if (current
->lineno_count
)
3539 current
->line_filepos
= lineno_base
;
3540 current
->moving_line_filepos
= lineno_base
;
3541 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3545 current
->line_filepos
= 0;
3547 if (current
->reloc_count
)
3549 current
->rel_filepos
= reloc_base
;
3550 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3552 /* Extra reloc to hold real count. */
3553 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3554 reloc_base
+= bfd_coff_relsz (abfd
);
3559 current
->rel_filepos
= 0;
3563 /* Write section headers to the file. */
3564 internal_f
.f_nscns
= 0;
3566 if ((abfd
->flags
& EXEC_P
) != 0)
3567 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3570 scn_base
= bfd_coff_filhsz (abfd
);
3573 if (xcoff_data (abfd
)->full_aouthdr
)
3574 scn_base
+= bfd_coff_aoutsz (abfd
);
3576 scn_base
+= SMALL_AOUTSZ
;
3581 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3584 long_section_names
= FALSE
;
3585 for (current
= abfd
->sections
;
3587 current
= current
->next
)
3589 struct internal_scnhdr section
;
3590 bfd_boolean is_reloc_section
= FALSE
;
3592 #ifdef COFF_IMAGE_WITH_PE
3593 if (strcmp (current
->name
, ".reloc") == 0)
3595 is_reloc_section
= TRUE
;
3597 pe_data (abfd
)->has_reloc_section
= 1;
3601 internal_f
.f_nscns
++;
3603 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3605 #ifdef COFF_LONG_SECTION_NAMES
3606 /* Handle long section names as in PE. This must be compatible
3607 with the code in coff_write_symbols and _bfd_coff_final_link. */
3611 len
= strlen (current
->name
);
3614 memset (section
.s_name
, 0, SCNNMLEN
);
3615 sprintf (section
.s_name
, "/%lu", (unsigned long) string_size
);
3616 string_size
+= len
+ 1;
3617 long_section_names
= TRUE
;
3623 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3624 Ian Taylor <ian@cygnus.com>. */
3625 if (strcmp (current
->name
, _LIB
) == 0)
3626 section
.s_vaddr
= 0;
3629 section
.s_vaddr
= current
->vma
;
3630 section
.s_paddr
= current
->lma
;
3631 section
.s_size
= current
->_raw_size
;
3632 #ifdef coff_get_section_load_page
3633 section
.s_page
= coff_get_section_load_page (current
);
3637 section
.s_paddr
= 0;
3639 #ifdef COFF_IMAGE_WITH_PE
3640 /* Reminder: s_paddr holds the virtual size of the section. */
3641 if (coff_section_data (abfd
, current
) != NULL
3642 && pei_section_data (abfd
, current
) != NULL
)
3643 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3645 section
.s_paddr
= 0;
3648 /* If this section has no size or is unloadable then the scnptr
3650 if (current
->_raw_size
== 0 ||
3651 (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3652 section
.s_scnptr
= 0;
3654 section
.s_scnptr
= current
->filepos
;
3656 section
.s_relptr
= current
->rel_filepos
;
3657 section
.s_lnnoptr
= current
->line_filepos
;
3658 section
.s_nreloc
= current
->reloc_count
;
3659 section
.s_nlnno
= current
->lineno_count
;
3660 #ifndef COFF_IMAGE_WITH_PE
3661 /* In PEI, relocs come in the .reloc section. */
3662 if (current
->reloc_count
!= 0)
3665 if (current
->lineno_count
!= 0)
3667 if ((current
->flags
& SEC_DEBUGGING
) != 0
3668 && ! is_reloc_section
)
3673 /* Indicate the use of an XCOFF overflow section header. */
3674 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3676 section
.s_nreloc
= 0xffff;
3677 section
.s_nlnno
= 0xffff;
3682 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3684 if (!strcmp (current
->name
, _TEXT
))
3686 else if (!strcmp (current
->name
, _DATA
))
3688 else if (!strcmp (current
->name
, _BSS
))
3692 section
.s_align
= (current
->alignment_power
3693 ? 1 << current
->alignment_power
3697 /* TI COFF puts the alignment power in bits 8-11 of the flags. */
3698 section
.s_flags
|= (current
->alignment_power
& 0xF) << 8;
3700 #ifdef COFF_ENCODE_ALIGNMENT
3701 COFF_ENCODE_ALIGNMENT(section
, current
->alignment_power
);
3704 #ifdef COFF_IMAGE_WITH_PE
3705 /* Suppress output of the sections if they are null. ld
3706 includes the bss and data sections even if there is no size
3707 assigned to them. NT loader doesn't like it if these section
3708 headers are included if the sections themselves are not
3709 needed. See also coff_compute_section_file_positions. */
3710 if (section
.s_size
== 0)
3711 internal_f
.f_nscns
--;
3716 bfd_size_type amt
= bfd_coff_scnhsz (abfd
);
3718 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3719 || bfd_bwrite ((PTR
) &buff
, amt
, abfd
) != amt
)
3724 /* PE stores COMDAT section information in the symbol table. If
3725 this section is supposed to have some COMDAT info, track down
3726 the symbol in the symbol table and modify it. */
3727 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3729 unsigned int i
, count
;
3731 coff_symbol_type
*csym
= NULL
;
3735 count
= bfd_get_symcount (abfd
);
3736 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3738 if ((*psym
)->section
!= current
)
3741 /* Remember the location of the first symbol in this
3743 if (psymsec
== NULL
)
3746 /* See if this is the section symbol. */
3747 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3749 csym
= coff_symbol_from (abfd
, *psym
);
3751 || csym
->native
== NULL
3752 || csym
->native
->u
.syment
.n_numaux
< 1
3753 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3754 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3757 /* Here *PSYM is the section symbol for CURRENT. */
3764 Note that we might not if we're converting the file from
3765 some other object file format. */
3768 combined_entry_type
*aux
;
3770 /* We don't touch the x_checksum field. The
3771 x_associated field is not currently supported. */
3773 aux
= csym
->native
+ 1;
3774 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3776 case SEC_LINK_DUPLICATES_DISCARD
:
3777 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3780 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3781 aux
->u
.auxent
.x_scn
.x_comdat
=
3782 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3785 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3786 aux
->u
.auxent
.x_scn
.x_comdat
=
3787 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3790 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3791 aux
->u
.auxent
.x_scn
.x_comdat
=
3792 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3796 /* The COMDAT symbol must be the first symbol from this
3797 section in the symbol table. In order to make this
3798 work, we move the COMDAT symbol before the first
3799 symbol we found in the search above. It's OK to
3800 rearrange the symbol table at this point, because
3801 coff_renumber_symbols is going to rearrange it
3802 further and fix up all the aux entries. */
3803 if (psym
!= psymsec
)
3809 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3810 pcopy
[0] = pcopy
[-1];
3815 #endif /* COFF_WITH_PE */
3820 /* XCOFF handles overflows in the reloc and line number count fields
3821 by creating a new section header to hold the correct values. */
3822 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3824 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3826 struct internal_scnhdr scnhdr
;
3830 internal_f
.f_nscns
++;
3831 strncpy (&(scnhdr
.s_name
[0]), current
->name
, 8);
3832 scnhdr
.s_paddr
= current
->reloc_count
;
3833 scnhdr
.s_vaddr
= current
->lineno_count
;
3835 scnhdr
.s_scnptr
= 0;
3836 scnhdr
.s_relptr
= current
->rel_filepos
;
3837 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3838 scnhdr
.s_nreloc
= current
->target_index
;
3839 scnhdr
.s_nlnno
= current
->target_index
;
3840 scnhdr
.s_flags
= STYP_OVRFLO
;
3841 amt
= bfd_coff_scnhsz (abfd
);
3842 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3843 || bfd_bwrite ((PTR
) &buff
, amt
, abfd
) != amt
)
3850 /* OK, now set up the filehdr... */
3852 /* Don't include the internal abs section in the section count */
3854 /* We will NOT put a fucking timestamp in the header here. Every time you
3855 put it back, I will come in and take it out again. I'm sorry. This
3856 field does not belong here. We fill it with a 0 so it compares the
3857 same but is not a reasonable time. -- gnu@cygnus.com */
3858 internal_f
.f_timdat
= 0;
3859 internal_f
.f_flags
= 0;
3861 if (abfd
->flags
& EXEC_P
)
3862 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3865 internal_f
.f_opthdr
= 0;
3868 if (xcoff_data (abfd
)->full_aouthdr
)
3869 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3871 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
3877 internal_f
.f_flags
|= F_RELFLG
;
3879 internal_f
.f_flags
|= F_LNNO
;
3880 if (abfd
->flags
& EXEC_P
)
3881 internal_f
.f_flags
|= F_EXEC
;
3882 #ifdef COFF_IMAGE_WITH_PE
3884 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
3888 internal_f
.f_flags
|= IMAGE_FILE_32BIT_MACHINE
;
3890 if (bfd_little_endian (abfd
))
3891 internal_f
.f_flags
|= F_AR32WR
;
3893 internal_f
.f_flags
|= F_AR32W
;
3897 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
3898 but it doesn't hurt to set it internally. */
3899 internal_f
.f_target_id
= TI_TARGET_ID
;
3901 #ifdef TIC80_TARGET_ID
3902 internal_f
.f_target_id
= TIC80_TARGET_ID
;
3905 /* FIXME, should do something about the other byte orders and
3909 if ((abfd
->flags
& DYNAMIC
) != 0)
3910 internal_f
.f_flags
|= F_SHROBJ
;
3911 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
3912 internal_f
.f_flags
|= F_DYNLOAD
;
3915 memset (&internal_a
, 0, sizeof internal_a
);
3917 /* Set up architecture-dependent stuff. */
3919 unsigned int magic
= 0;
3920 unsigned short flags
= 0;
3922 coff_set_flags (abfd
, &magic
, &flags
);
3923 internal_f
.f_magic
= magic
;
3924 internal_f
.f_flags
|= flags
;
3925 /* ...and the "opt"hdr... */
3928 #ifdef ULTRA3 /* NYU's machine */
3929 /* FIXME: This is a bogus check. I really want to see if there
3930 is a .shbss or a .shdata section, if so then set the magic
3931 number to indicate a shared data executable. */
3932 if (internal_f
.f_nscns
>= 7)
3933 internal_a
.magic
= SHMAGIC
; /* Shared magic. */
3936 internal_a
.magic
= NMAGIC
; /* Assume separate i/d. */
3937 #define __A_MAGIC_SET__
3939 #ifdef TICOFF_AOUT_MAGIC
3940 internal_a
.magic
= TICOFF_AOUT_MAGIC
;
3941 #define __A_MAGIC_SET__
3944 internal_a
.magic
= TIC80_ARCH_MAGIC
;
3945 #define __A_MAGIC_SET__
3948 /* FIXME: What are the a.out magic numbers for the i860? */
3949 internal_a
.magic
= 0;
3950 #define __A_MAGIC_SET__
3953 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
3954 #define __A_MAGIC_SET__
3957 #define __A_MAGIC_SET__
3958 internal_a
.magic
= PAGEMAGICBCS
;
3962 #define __A_MAGIC_SET__
3963 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
3966 #if defined(M68) || defined(WE32K) || defined(M68K)
3967 #define __A_MAGIC_SET__
3969 internal_a
.magic
= LYNXCOFFMAGIC
;
3971 #if defined(TARG_AUX)
3972 internal_a
.magic
= (abfd
->flags
& D_PAGED
? PAGEMAGICPEXECPAGED
:
3973 abfd
->flags
& WP_TEXT
? PAGEMAGICPEXECSWAPPED
:
3974 PAGEMAGICEXECSWAPPED
);
3976 #if defined (PAGEMAGICPEXECPAGED)
3977 internal_a
.magic
= PAGEMAGICPEXECPAGED
;
3979 #endif /* TARG_AUX */
3981 #endif /* M68 || WE32K || M68K */
3984 #define __A_MAGIC_SET__
3985 internal_a
.magic
= ZMAGIC
;
3989 #define __A_MAGIC_SET__
3990 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3993 #if defined MCORE_PE
3994 #define __A_MAGIC_SET__
3995 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3999 #define __A_MAGIC_SET__
4001 internal_a
.magic
= LYNXCOFFMAGIC
;
4003 internal_a
.magic
= ZMAGIC
;
4008 #define __A_MAGIC_SET__
4009 internal_a
.magic
= ZMAGIC
;
4013 #define __A_MAGIC_SET__
4015 internal_a
.magic
= LYNXCOFFMAGIC
;
4020 #define __A_MAGIC_SET__
4021 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
4022 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
4023 RS6K_AOUTHDR_OMAGIC
;
4026 #if defined(SH) && defined(COFF_WITH_PE)
4027 #define __A_MAGIC_SET__
4028 internal_a
.magic
= SH_PE_MAGIC
;
4031 #if defined(MIPS) && defined(COFF_WITH_PE)
4032 #define __A_MAGIC_SET__
4033 internal_a
.magic
= MIPS_PE_MAGIC
;
4037 #define __A_MAGIC_SET__
4038 internal_a
.magic
= NMAGIC
; /* Assume separate i/d. */
4041 #ifndef __A_MAGIC_SET__
4042 #include "Your aouthdr magic number is not being set!"
4044 #undef __A_MAGIC_SET__
4048 /* FIXME: Does anybody ever set this to another value? */
4049 internal_a
.vstamp
= 0;
4051 /* Now should write relocs, strings, syms. */
4052 obj_sym_filepos (abfd
) = sym_base
;
4054 if (bfd_get_symcount (abfd
) != 0)
4058 if (!coff_add_missing_symbols (abfd
))
4061 if (!coff_renumber_symbols (abfd
, &firstundef
))
4063 coff_mangle_symbols (abfd
);
4064 if (! coff_write_symbols (abfd
))
4066 if (! coff_write_linenumbers (abfd
))
4068 if (! coff_write_relocs (abfd
, firstundef
))
4071 #ifdef COFF_LONG_SECTION_NAMES
4072 else if (long_section_names
&& ! obj_coff_strings_written (abfd
))
4074 /* If we have long section names we have to write out the string
4075 table even if there are no symbols. */
4076 if (! coff_write_symbols (abfd
))
4080 #ifdef COFF_IMAGE_WITH_PE
4082 else if ((abfd
->flags
& EXEC_P
) != 0)
4086 /* PowerPC PE appears to require that all executable files be
4087 rounded up to the page size. */
4090 (file_ptr
) BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
4092 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
4098 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
4099 backend linker, and obj_raw_syment_count is not valid until after
4100 coff_write_symbols is called. */
4101 if (obj_raw_syment_count (abfd
) != 0)
4103 internal_f
.f_symptr
= sym_base
;
4105 /* AIX appears to require that F_RELFLG not be set if there are
4106 local symbols but no relocations. */
4107 internal_f
.f_flags
&=~ F_RELFLG
;
4112 if (long_section_names
)
4113 internal_f
.f_symptr
= sym_base
;
4115 internal_f
.f_symptr
= 0;
4116 internal_f
.f_flags
|= F_LSYMS
;
4121 internal_a
.tsize
= bfd_get_section_size_before_reloc (text_sec
);
4122 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
4126 internal_a
.dsize
= bfd_get_section_size_before_reloc (data_sec
);
4127 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
4131 internal_a
.bsize
= bfd_get_section_size_before_reloc (bss_sec
);
4132 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
4133 internal_a
.data_start
= bss_sec
->vma
;
4136 internal_a
.entry
= bfd_get_start_address (abfd
);
4137 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
4140 if (xcoff_data (abfd
)->full_aouthdr
)
4143 asection
*loader_sec
;
4145 internal_a
.vstamp
= 1;
4147 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
4148 if (internal_a
.o_snentry
== 0)
4149 internal_a
.entry
= (bfd_vma
) -1;
4151 if (text_sec
!= NULL
)
4153 internal_a
.o_sntext
= text_sec
->target_index
;
4154 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
4158 internal_a
.o_sntext
= 0;
4159 internal_a
.o_algntext
= 0;
4161 if (data_sec
!= NULL
)
4163 internal_a
.o_sndata
= data_sec
->target_index
;
4164 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
4168 internal_a
.o_sndata
= 0;
4169 internal_a
.o_algndata
= 0;
4171 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
4172 if (loader_sec
!= NULL
)
4173 internal_a
.o_snloader
= loader_sec
->target_index
;
4175 internal_a
.o_snloader
= 0;
4176 if (bss_sec
!= NULL
)
4177 internal_a
.o_snbss
= bss_sec
->target_index
;
4179 internal_a
.o_snbss
= 0;
4181 toc
= xcoff_data (abfd
)->toc
;
4182 internal_a
.o_toc
= toc
;
4183 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
4185 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
4186 if (xcoff_data (abfd
)->cputype
!= -1)
4187 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
4190 switch (bfd_get_arch (abfd
))
4192 case bfd_arch_rs6000
:
4193 internal_a
.o_cputype
= 4;
4195 case bfd_arch_powerpc
:
4196 if (bfd_get_mach (abfd
) == bfd_mach_ppc
)
4197 internal_a
.o_cputype
= 3;
4199 internal_a
.o_cputype
= 1;
4205 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
4206 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
4210 /* now write them */
4211 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
4216 bfd_size_type amount
= bfd_coff_filhsz (abfd
);
4218 buff
= bfd_malloc (amount
);
4222 bfd_coff_swap_filehdr_out (abfd
, (PTR
) &internal_f
, (PTR
) buff
);
4223 amount
= bfd_bwrite ((PTR
) buff
, amount
, abfd
);
4227 if (amount
!= bfd_coff_filhsz (abfd
))
4231 if (abfd
->flags
& EXEC_P
)
4233 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4234 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4236 bfd_size_type amount
= bfd_coff_aoutsz (abfd
);
4238 buff
= bfd_malloc (amount
);
4242 coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, (PTR
) buff
);
4243 amount
= bfd_bwrite ((PTR
) buff
, amount
, abfd
);
4247 if (amount
!= bfd_coff_aoutsz (abfd
))
4250 #ifdef COFF_IMAGE_WITH_PE
4251 if (! coff_apply_checksum (abfd
))
4261 /* XCOFF seems to always write at least a small a.out header. */
4262 coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, (PTR
) &buff
);
4263 if (xcoff_data (abfd
)->full_aouthdr
)
4264 size
= bfd_coff_aoutsz (abfd
);
4266 size
= SMALL_AOUTSZ
;
4267 if (bfd_bwrite ((PTR
) &buff
, (bfd_size_type
) size
, abfd
) != size
)
4276 coff_set_section_contents (abfd
, section
, location
, offset
, count
)
4281 bfd_size_type count
;
4283 if (! abfd
->output_has_begun
) /* Set by bfd.c handler. */
4285 if (! coff_compute_section_file_positions (abfd
))
4289 #if defined(_LIB) && !defined(TARG_AUX)
4291 /* The physical address field of a .lib section is used to hold the
4292 number of shared libraries in the section. This code counts the
4293 number of sections being written, and increments the lma field
4296 I have found no documentation on the contents of this section.
4297 Experimentation indicates that the section contains zero or more
4298 records, each of which has the following structure:
4300 - a (four byte) word holding the length of this record, in words,
4301 - a word that always seems to be set to "2",
4302 - the path to a shared library, null-terminated and then padded
4303 to a whole word boundary.
4305 bfd_assert calls have been added to alert if an attempt is made
4306 to write a section which doesn't follow these assumptions. The
4307 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4308 <robertl@arnet.com> (Thanks!).
4310 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4312 if (strcmp (section
->name
, _LIB
) == 0)
4314 bfd_byte
*rec
, *recend
;
4316 rec
= (bfd_byte
*) location
;
4317 recend
= rec
+ count
;
4318 while (rec
< recend
)
4321 rec
+= bfd_get_32 (abfd
, rec
) * 4;
4324 BFD_ASSERT (rec
== recend
);
4329 /* Don't write out bss sections - one way to do this is to
4330 see if the filepos has not been set. */
4331 if (section
->filepos
== 0)
4334 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0)
4340 return bfd_bwrite (location
, count
, abfd
) == count
;
4344 coff_close_and_cleanup (abfd
)
4347 if (!bfd_read_p (abfd
))
4348 switch (abfd
->format
)
4351 if (!_bfd_write_archive_contents (abfd
))
4355 if (!coff_write_object_contents (abfd
))
4359 bfd_set_error (bfd_error_invalid_operation
);
4363 /* We depend on bfd_close to free all the memory on the objalloc. */
4370 buy_and_read (abfd
, where
, size
)
4375 PTR area
= (PTR
) bfd_alloc (abfd
, size
);
4378 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0
4379 || bfd_bread (area
, size
, abfd
) != size
)
4382 } /* buy_and_read() */
4388 Creating the linenumber table is done by reading in the entire
4389 coff linenumber table, and creating another table for internal use.
4391 A coff linenumber table is structured so that each function
4392 is marked as having a line number of 0. Each line within the
4393 function is an offset from the first line in the function. The
4394 base of the line number information for the table is stored in
4395 the symbol associated with the function.
4397 Note: The PE format uses line number 0 for a flag indicating a
4400 The information is copied from the external to the internal
4401 table, and each symbol which marks a function is marked by
4404 How does this work ?
4409 coff_slurp_line_table (abfd
, asect
)
4413 LINENO
*native_lineno
;
4414 alent
*lineno_cache
;
4417 BFD_ASSERT (asect
->lineno
== (alent
*) NULL
);
4419 amt
= (bfd_size_type
) bfd_coff_linesz (abfd
) * asect
->lineno_count
;
4420 native_lineno
= (LINENO
*) buy_and_read (abfd
, asect
->line_filepos
, amt
);
4421 if (native_lineno
== NULL
)
4423 (*_bfd_error_handler
)
4424 (_("%s: warning: line number table read failed"),
4425 bfd_archive_filename (abfd
));
4428 amt
= ((bfd_size_type
) asect
->lineno_count
+ 1) * sizeof (alent
);
4429 lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
);
4430 if (lineno_cache
== NULL
)
4434 unsigned int counter
= 0;
4435 alent
*cache_ptr
= lineno_cache
;
4436 LINENO
*src
= native_lineno
;
4438 while (counter
< asect
->lineno_count
)
4440 struct internal_lineno dst
;
4442 bfd_coff_swap_lineno_in (abfd
, src
, &dst
);
4443 cache_ptr
->line_number
= dst
.l_lnno
;
4445 if (cache_ptr
->line_number
== 0)
4448 bfd_signed_vma symndx
;
4449 coff_symbol_type
*sym
;
4452 symndx
= dst
.l_addr
.l_symndx
;
4454 || (bfd_vma
) symndx
>= obj_raw_syment_count (abfd
))
4456 (*_bfd_error_handler
)
4457 (_("%s: warning: illegal symbol index %ld in line numbers"),
4458 bfd_archive_filename (abfd
), dst
.l_addr
.l_symndx
);
4462 /* FIXME: We should not be casting between ints and
4463 pointers like this. */
4464 sym
= ((coff_symbol_type
*)
4465 ((symndx
+ obj_raw_syments (abfd
))
4466 ->u
.syment
._n
._n_n
._n_zeroes
));
4467 cache_ptr
->u
.sym
= (asymbol
*) sym
;
4468 if (sym
->lineno
!= NULL
&& ! warned
)
4470 (*_bfd_error_handler
)
4471 (_("%s: warning: duplicate line number information for `%s'"),
4472 bfd_archive_filename (abfd
),
4473 bfd_asymbol_name (&sym
->symbol
));
4475 sym
->lineno
= cache_ptr
;
4479 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
4480 - bfd_section_vma (abfd
, asect
);
4481 } /* If no linenumber expect a symbol index */
4487 cache_ptr
->line_number
= 0;
4490 asect
->lineno
= lineno_cache
;
4491 /* FIXME, free native_lineno here, or use alloca or something. */
4495 /* Slurp in the symbol table, converting it to generic form. Note
4496 that if coff_relocate_section is defined, the linker will read
4497 symbols via coff_link_add_symbols, rather than via this routine. */
4500 coff_slurp_symbol_table (abfd
)
4503 combined_entry_type
*native_symbols
;
4504 coff_symbol_type
*cached_area
;
4505 unsigned int *table_ptr
;
4507 unsigned int number_of_symbols
= 0;
4509 if (obj_symbols (abfd
))
4512 /* Read in the symbol table. */
4513 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4516 /* Allocate enough room for all the symbols in cached form. */
4517 amt
= obj_raw_syment_count (abfd
);
4518 amt
*= sizeof (coff_symbol_type
);
4519 cached_area
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
4520 if (cached_area
== NULL
)
4523 amt
= obj_raw_syment_count (abfd
);
4524 amt
*= sizeof (unsigned int);
4525 table_ptr
= (unsigned int *) bfd_alloc (abfd
, amt
);
4527 if (table_ptr
== NULL
)
4531 coff_symbol_type
*dst
= cached_area
;
4532 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4533 unsigned int this_index
= 0;
4535 while (this_index
< last_native_index
)
4537 combined_entry_type
*src
= native_symbols
+ this_index
;
4538 table_ptr
[this_index
] = number_of_symbols
;
4539 dst
->symbol
.the_bfd
= abfd
;
4541 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4542 /* We use the native name field to point to the cached field. */
4543 src
->u
.syment
._n
._n_n
._n_zeroes
= (long) dst
;
4544 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4545 src
->u
.syment
.n_scnum
);
4546 dst
->symbol
.flags
= 0;
4547 dst
->done_lineno
= FALSE
;
4549 switch (src
->u
.syment
.n_sclass
)
4554 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
4555 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4556 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4558 /* Fall through to next case. */
4565 case C_THUMBEXTFUNC
:
4571 case C_SYSTEM
: /* System Wide variable. */
4574 /* In PE, 0x68 (104) denotes a section symbol. */
4576 /* In PE, 0x69 (105) denotes a weak external symbol. */
4579 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4581 case COFF_SYMBOL_GLOBAL
:
4582 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4583 #if defined COFF_WITH_PE
4584 /* PE sets the symbol to a value relative to the
4585 start of the section. */
4586 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4588 dst
->symbol
.value
= (src
->u
.syment
.n_value
4589 - dst
->symbol
.section
->vma
);
4591 if (ISFCN ((src
->u
.syment
.n_type
)))
4593 /* A function ext does not go at the end of a
4595 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4599 case COFF_SYMBOL_COMMON
:
4600 dst
->symbol
.section
= bfd_com_section_ptr
;
4601 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4604 case COFF_SYMBOL_UNDEFINED
:
4605 dst
->symbol
.section
= bfd_und_section_ptr
;
4606 dst
->symbol
.value
= 0;
4609 case COFF_SYMBOL_PE_SECTION
:
4610 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4611 dst
->symbol
.value
= 0;
4614 case COFF_SYMBOL_LOCAL
:
4615 dst
->symbol
.flags
= BSF_LOCAL
;
4616 #if defined COFF_WITH_PE
4617 /* PE sets the symbol to a value relative to the
4618 start of the section. */
4619 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4621 dst
->symbol
.value
= (src
->u
.syment
.n_value
4622 - dst
->symbol
.section
->vma
);
4624 if (ISFCN ((src
->u
.syment
.n_type
)))
4625 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4630 /* A symbol with a csect entry should not go at the end. */
4631 if (src
->u
.syment
.n_numaux
> 0)
4632 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4636 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4637 dst
->symbol
.flags
|= BSF_WEAK
;
4639 if (src
->u
.syment
.n_sclass
== C_SECTION
4640 && src
->u
.syment
.n_scnum
> 0)
4641 dst
->symbol
.flags
= BSF_LOCAL
;
4643 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
)
4644 dst
->symbol
.flags
|= BSF_WEAK
;
4648 case C_STAT
: /* Static. */
4650 case C_LEAFSTAT
: /* Static leaf procedure. */
4653 case C_THUMBSTAT
: /* Thumb static. */
4654 case C_THUMBLABEL
: /* Thumb label. */
4655 case C_THUMBSTATFUNC
:/* Thumb static function. */
4657 case C_LABEL
: /* Label. */
4658 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4659 dst
->symbol
.flags
= BSF_DEBUGGING
;
4661 dst
->symbol
.flags
= BSF_LOCAL
;
4663 /* Base the value as an index from the base of the
4664 section, if there is one. */
4665 if (dst
->symbol
.section
)
4667 #if defined COFF_WITH_PE
4668 /* PE sets the symbol to a value relative to the
4669 start of the section. */
4670 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4672 dst
->symbol
.value
= (src
->u
.syment
.n_value
4673 - dst
->symbol
.section
->vma
);
4677 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4680 case C_MOS
: /* Member of structure. */
4681 case C_EOS
: /* End of structure. */
4682 #ifdef NOTDEF /* C_AUTOARG has the same value. */
4684 case C_GLBLREG
: /* A29k-specific storage class. */
4687 case C_REGPARM
: /* Register parameter. */
4688 case C_REG
: /* register variable. */
4689 /* C_AUTOARG conflicts with TI COFF C_UEXT. */
4690 #if !defined (TIC80COFF) && !defined (TICOFF)
4692 case C_AUTOARG
: /* 960-specific storage class. */
4695 case C_TPDEF
: /* Type definition. */
4697 case C_AUTO
: /* Automatic variable. */
4698 case C_FIELD
: /* Bit field. */
4699 case C_ENTAG
: /* Enumeration tag. */
4700 case C_MOE
: /* Member of enumeration. */
4701 case C_MOU
: /* Member of union. */
4702 case C_UNTAG
: /* Union tag. */
4703 dst
->symbol
.flags
= BSF_DEBUGGING
;
4704 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4707 case C_FILE
: /* File name. */
4708 case C_STRTAG
: /* Structure tag. */
4725 dst
->symbol
.flags
= BSF_DEBUGGING
;
4726 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4730 case C_BINCL
: /* Beginning of include file. */
4731 case C_EINCL
: /* Ending of include file. */
4732 /* The value is actually a pointer into the line numbers
4733 of the file. We locate the line number entry, and
4734 set the section to the section which contains it, and
4735 the value to the index in that section. */
4739 dst
->symbol
.flags
= BSF_DEBUGGING
;
4740 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4741 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4742 && ((file_ptr
) (sec
->line_filepos
4743 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4744 > (file_ptr
) src
->u
.syment
.n_value
))
4747 dst
->symbol
.value
= 0;
4750 dst
->symbol
.section
= sec
;
4751 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4752 - sec
->line_filepos
)
4753 / bfd_coff_linesz (abfd
));
4760 dst
->symbol
.flags
= BSF_DEBUGGING
;
4762 /* The value is actually a symbol index. Save a pointer
4763 to the symbol instead of the index. FIXME: This
4764 should use a union. */
4765 src
->u
.syment
.n_value
=
4766 (long) (native_symbols
+ src
->u
.syment
.n_value
);
4767 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4772 case C_BLOCK
: /* ".bb" or ".eb". */
4773 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf"). */
4774 case C_EFCN
: /* Physical end of function. */
4775 #if defined COFF_WITH_PE
4776 /* PE sets the symbol to a value relative to the start
4778 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4779 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4781 /* PE uses funny values for .ef and .lf; don't
4783 dst
->symbol
.flags
= BSF_DEBUGGING
;
4786 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4788 /* Base the value as an index from the base of the
4790 dst
->symbol
.flags
= BSF_LOCAL
;
4791 dst
->symbol
.value
= (src
->u
.syment
.n_value
4792 - dst
->symbol
.section
->vma
);
4796 case C_STATLAB
: /* Static load time label. */
4797 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4798 dst
->symbol
.flags
= BSF_GLOBAL
;
4802 /* PE DLLs sometimes have zeroed out symbols for some
4803 reason. Just ignore them without a warning. */
4804 if (src
->u
.syment
.n_type
== 0
4805 && src
->u
.syment
.n_value
== 0
4806 && src
->u
.syment
.n_scnum
== 0)
4809 case C_EXTDEF
: /* External definition. */
4810 case C_ULABEL
: /* Undefined label. */
4811 case C_USTATIC
: /* Undefined static. */
4812 #ifndef COFF_WITH_PE
4813 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4814 class to represent a section symbol. */
4815 case C_LINE
: /* line # reformatted as symbol table entry. */
4816 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4817 case C_ALIAS
: /* Duplicate tag. */
4819 /* New storage classes for TI COFF. */
4820 #if defined(TIC80COFF) || defined(TICOFF)
4821 case C_UEXT
: /* Tentative external definition. */
4823 case C_EXTLAB
: /* External load time label. */
4824 case C_HIDDEN
: /* Ext symbol in dmert public lib. */
4826 (*_bfd_error_handler
)
4827 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
4828 bfd_archive_filename (abfd
), src
->u
.syment
.n_sclass
,
4829 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4830 dst
->symbol
.flags
= BSF_DEBUGGING
;
4831 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4835 /* BFD_ASSERT(dst->symbol.flags != 0);*/
4839 dst
->symbol
.udata
.i
= 0;
4840 dst
->lineno
= (alent
*) NULL
;
4841 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
4843 number_of_symbols
++;
4847 obj_symbols (abfd
) = cached_area
;
4848 obj_raw_syments (abfd
) = native_symbols
;
4850 bfd_get_symcount (abfd
) = number_of_symbols
;
4851 obj_convert (abfd
) = table_ptr
;
4852 /* Slurp the line tables for each section too. */
4859 coff_slurp_line_table (abfd
, p
);
4865 } /* coff_slurp_symbol_table() */
4867 /* Classify a COFF symbol. A couple of targets have globally visible
4868 symbols which are not class C_EXT, and this handles those. It also
4869 recognizes some special PE cases. */
4871 static enum coff_symbol_classification
4872 coff_classify_symbol (abfd
, syment
)
4874 struct internal_syment
*syment
;
4876 /* FIXME: This partially duplicates the switch in
4877 coff_slurp_symbol_table. */
4878 switch (syment
->n_sclass
)
4887 case C_THUMBEXTFUNC
:
4895 if (syment
->n_scnum
== 0)
4897 if (syment
->n_value
== 0)
4898 return COFF_SYMBOL_UNDEFINED
;
4900 return COFF_SYMBOL_COMMON
;
4902 return COFF_SYMBOL_GLOBAL
;
4909 if (syment
->n_sclass
== C_STAT
)
4911 if (syment
->n_scnum
== 0)
4913 /* The Microsoft compiler sometimes generates these if a
4914 small static function is inlined every time it is used.
4915 The function is discarded, but the symbol table entry
4917 return COFF_SYMBOL_LOCAL
;
4920 #ifdef STRICT_PE_FORMAT
4921 /* This is correct for Microsoft generated objects, but it
4922 breaks gas generated objects. */
4924 if (syment
->n_value
== 0)
4927 char buf
[SYMNMLEN
+ 1];
4929 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
4931 && (strcmp (bfd_get_section_name (abfd
, sec
),
4932 _bfd_coff_internal_syment_name (abfd
, syment
, buf
))
4934 return COFF_SYMBOL_PE_SECTION
;
4938 return COFF_SYMBOL_LOCAL
;
4941 if (syment
->n_sclass
== C_SECTION
)
4943 /* In some cases in a DLL generated by the Microsoft linker, the
4944 n_value field will contain garbage. FIXME: This should
4945 probably be handled by the swapping function instead. */
4946 syment
->n_value
= 0;
4947 if (syment
->n_scnum
== 0)
4948 return COFF_SYMBOL_UNDEFINED
;
4949 return COFF_SYMBOL_PE_SECTION
;
4951 #endif /* COFF_WITH_PE */
4953 /* If it is not a global symbol, we presume it is a local symbol. */
4955 if (syment
->n_scnum
== 0)
4957 char buf
[SYMNMLEN
+ 1];
4959 (*_bfd_error_handler
)
4960 (_("warning: %s: local symbol `%s' has no section"),
4961 bfd_archive_filename (abfd
),
4962 _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
4965 return COFF_SYMBOL_LOCAL
;
4972 Coff relocations are easily transformed into the internal BFD form
4975 Reading a coff relocation table is done in the following stages:
4977 o Read the entire coff relocation table into memory.
4979 o Process each relocation in turn; first swap it from the
4980 external to the internal form.
4982 o Turn the symbol referenced in the relocation's symbol index
4983 into a pointer into the canonical symbol table.
4984 This table is the same as the one returned by a call to
4985 @code{bfd_canonicalize_symtab}. The back end will call that
4986 routine and save the result if a canonicalization hasn't been done.
4988 o The reloc index is turned into a pointer to a howto
4989 structure, in a back end specific way. For instance, the 386
4990 and 960 use the @code{r_type} to directly produce an index
4991 into a howto table vector; the 88k subtracts a number from the
4992 @code{r_type} field and creates an addend field.
4997 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
4999 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
5000 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
5001 coffsym = (obj_symbols (abfd) \
5002 + (cache_ptr->sym_ptr_ptr - symbols)); \
5004 coffsym = coff_symbol_from (abfd, ptr); \
5005 if (coffsym != (coff_symbol_type *) NULL \
5006 && coffsym->native->u.syment.n_scnum == 0) \
5007 cache_ptr->addend = 0; \
5008 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
5009 && ptr->section != (asection *) NULL) \
5010 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
5012 cache_ptr->addend = 0; \
5017 coff_slurp_reloc_table (abfd
, asect
, symbols
)
5022 RELOC
*native_relocs
;
5023 arelent
*reloc_cache
;
5028 if (asect
->relocation
)
5030 if (asect
->reloc_count
== 0)
5032 if (asect
->flags
& SEC_CONSTRUCTOR
)
5034 if (!coff_slurp_symbol_table (abfd
))
5036 amt
= (bfd_size_type
) bfd_coff_relsz (abfd
) * asect
->reloc_count
;
5037 native_relocs
= (RELOC
*) buy_and_read (abfd
, asect
->rel_filepos
, amt
);
5038 amt
= (bfd_size_type
) asect
->reloc_count
* sizeof (arelent
);
5039 reloc_cache
= (arelent
*) bfd_alloc (abfd
, amt
);
5041 if (reloc_cache
== NULL
)
5044 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
5046 struct internal_reloc dst
;
5047 struct external_reloc
*src
;
5048 #ifndef RELOC_PROCESSING
5052 cache_ptr
= reloc_cache
+ idx
;
5053 src
= native_relocs
+ idx
;
5055 coff_swap_reloc_in (abfd
, src
, &dst
);
5057 #ifdef RELOC_PROCESSING
5058 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
5060 cache_ptr
->address
= dst
.r_vaddr
;
5062 if (dst
.r_symndx
!= -1)
5064 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
5066 (*_bfd_error_handler
)
5067 (_("%s: warning: illegal symbol index %ld in relocs"),
5068 bfd_archive_filename (abfd
), dst
.r_symndx
);
5069 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5074 cache_ptr
->sym_ptr_ptr
= (symbols
5075 + obj_convert (abfd
)[dst
.r_symndx
]);
5076 ptr
= *(cache_ptr
->sym_ptr_ptr
);
5081 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5085 /* The symbols definitions that we have read in have been
5086 relocated as if their sections started at 0. But the offsets
5087 refering to the symbols in the raw data have not been
5088 modified, so we have to have a negative addend to compensate.
5090 Note that symbols which used to be common must be left alone. */
5092 /* Calculate any reloc addend by looking at the symbol. */
5093 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
5095 cache_ptr
->address
-= asect
->vma
;
5096 /* !! cache_ptr->section = (asection *) NULL;*/
5098 /* Fill in the cache_ptr->howto field from dst.r_type. */
5099 RTYPE2HOWTO (cache_ptr
, &dst
);
5100 #endif /* RELOC_PROCESSING */
5102 if (cache_ptr
->howto
== NULL
)
5104 (*_bfd_error_handler
)
5105 (_("%s: illegal relocation type %d at address 0x%lx"),
5106 bfd_archive_filename (abfd
), dst
.r_type
, (long) dst
.r_vaddr
);
5107 bfd_set_error (bfd_error_bad_value
);
5112 asect
->relocation
= reloc_cache
;
5116 #ifndef coff_rtype_to_howto
5119 /* Get the howto structure for a reloc. This is only used if the file
5120 including this one defines coff_relocate_section to be
5121 _bfd_coff_generic_relocate_section, so it is OK if it does not
5122 always work. It is the responsibility of the including file to
5123 make sure it is reasonable if it is needed. */
5125 static reloc_howto_type
*coff_rtype_to_howto
5126 PARAMS ((bfd
*, asection
*, struct internal_reloc
*,
5127 struct coff_link_hash_entry
*, struct internal_syment
*,
5130 static reloc_howto_type
*
5131 coff_rtype_to_howto (abfd
, sec
, rel
, h
, sym
, addendp
)
5132 bfd
*abfd ATTRIBUTE_UNUSED
;
5133 asection
*sec ATTRIBUTE_UNUSED
;
5134 struct internal_reloc
*rel
;
5135 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
;
5136 struct internal_syment
*sym ATTRIBUTE_UNUSED
;
5137 bfd_vma
*addendp ATTRIBUTE_UNUSED
;
5141 RTYPE2HOWTO (&genrel
, rel
);
5142 return genrel
.howto
;
5145 #else /* ! defined (RTYPE2HOWTO) */
5147 #define coff_rtype_to_howto NULL
5149 #endif /* ! defined (RTYPE2HOWTO) */
5150 #endif /* ! defined (coff_rtype_to_howto) */
5152 /* This is stupid. This function should be a boolean predicate. */
5154 coff_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
5160 arelent
*tblptr
= section
->relocation
;
5161 unsigned int count
= 0;
5163 if (section
->flags
& SEC_CONSTRUCTOR
)
5165 /* This section has relocs made up by us, they are not in the
5166 file, so take them out of their chain and place them into
5167 the data area provided. */
5168 arelent_chain
*chain
= section
->constructor_chain
;
5170 for (count
= 0; count
< section
->reloc_count
; count
++)
5172 *relptr
++ = &chain
->relent
;
5173 chain
= chain
->next
;
5178 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
5181 tblptr
= section
->relocation
;
5183 for (; count
++ < section
->reloc_count
;)
5184 *relptr
++ = tblptr
++;
5187 return section
->reloc_count
;
5192 coff_sym_filepos (abfd
)
5195 return obj_sym_filepos (abfd
);
5199 #ifndef coff_reloc16_estimate
5200 #define coff_reloc16_estimate dummy_reloc16_estimate
5202 static int dummy_reloc16_estimate
5203 PARAMS ((bfd
*, asection
*, arelent
*, unsigned int,
5204 struct bfd_link_info
*));
5207 dummy_reloc16_estimate (abfd
, input_section
, reloc
, shrink
, link_info
)
5208 bfd
*abfd ATTRIBUTE_UNUSED
;
5209 asection
*input_section ATTRIBUTE_UNUSED
;
5210 arelent
*reloc ATTRIBUTE_UNUSED
;
5211 unsigned int shrink ATTRIBUTE_UNUSED
;
5212 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
5220 #ifndef coff_reloc16_extra_cases
5222 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5224 /* This works even if abort is not declared in any header file. */
5226 static void dummy_reloc16_extra_cases
5227 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*, arelent
*,
5228 bfd_byte
*, unsigned int *, unsigned int *));
5231 dummy_reloc16_extra_cases (abfd
, link_info
, link_order
, reloc
, data
, src_ptr
,
5233 bfd
*abfd ATTRIBUTE_UNUSED
;
5234 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
5235 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
;
5236 arelent
*reloc ATTRIBUTE_UNUSED
;
5237 bfd_byte
*data ATTRIBUTE_UNUSED
;
5238 unsigned int *src_ptr ATTRIBUTE_UNUSED
;
5239 unsigned int *dst_ptr ATTRIBUTE_UNUSED
;
5245 #ifndef coff_bfd_link_hash_table_free
5246 #define coff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
5249 /* If coff_relocate_section is defined, we can use the optimized COFF
5250 backend linker. Otherwise we must continue to use the old linker. */
5251 #ifdef coff_relocate_section
5252 #ifndef coff_bfd_link_hash_table_create
5253 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5255 #ifndef coff_bfd_link_add_symbols
5256 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5258 #ifndef coff_bfd_final_link
5259 #define coff_bfd_final_link _bfd_coff_final_link
5261 #else /* ! defined (coff_relocate_section) */
5262 #define coff_relocate_section NULL
5263 #ifndef coff_bfd_link_hash_table_create
5264 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5266 #ifndef coff_bfd_link_add_symbols
5267 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5269 #define coff_bfd_final_link _bfd_generic_final_link
5270 #endif /* ! defined (coff_relocate_section) */
5272 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5273 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5275 #ifndef coff_start_final_link
5276 #define coff_start_final_link NULL
5279 #ifndef coff_adjust_symndx
5280 #define coff_adjust_symndx NULL
5283 #ifndef coff_link_add_one_symbol
5284 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5287 #ifndef coff_link_output_has_begun
5289 static bfd_boolean coff_link_output_has_begun
5290 PARAMS ((bfd
*, struct coff_final_link_info
*));
5293 coff_link_output_has_begun (abfd
, info
)
5295 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
;
5297 return abfd
->output_has_begun
;
5301 #ifndef coff_final_link_postscript
5303 static bfd_boolean coff_final_link_postscript
5304 PARAMS ((bfd
*, struct coff_final_link_info
*));
5307 coff_final_link_postscript (abfd
, pfinfo
)
5308 bfd
* abfd ATTRIBUTE_UNUSED
;
5309 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
;
5315 #ifndef coff_SWAP_aux_in
5316 #define coff_SWAP_aux_in coff_swap_aux_in
5318 #ifndef coff_SWAP_sym_in
5319 #define coff_SWAP_sym_in coff_swap_sym_in
5321 #ifndef coff_SWAP_lineno_in
5322 #define coff_SWAP_lineno_in coff_swap_lineno_in
5324 #ifndef coff_SWAP_aux_out
5325 #define coff_SWAP_aux_out coff_swap_aux_out
5327 #ifndef coff_SWAP_sym_out
5328 #define coff_SWAP_sym_out coff_swap_sym_out
5330 #ifndef coff_SWAP_lineno_out
5331 #define coff_SWAP_lineno_out coff_swap_lineno_out
5333 #ifndef coff_SWAP_reloc_out
5334 #define coff_SWAP_reloc_out coff_swap_reloc_out
5336 #ifndef coff_SWAP_filehdr_out
5337 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5339 #ifndef coff_SWAP_aouthdr_out
5340 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5342 #ifndef coff_SWAP_scnhdr_out
5343 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5345 #ifndef coff_SWAP_reloc_in
5346 #define coff_SWAP_reloc_in coff_swap_reloc_in
5348 #ifndef coff_SWAP_filehdr_in
5349 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5351 #ifndef coff_SWAP_aouthdr_in
5352 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5354 #ifndef coff_SWAP_scnhdr_in
5355 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5358 static const bfd_coff_backend_data bfd_coff_std_swap_table
=
5360 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5361 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5362 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5363 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5364 coff_SWAP_scnhdr_out
,
5365 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5366 #ifdef COFF_LONG_FILENAMES
5371 #ifdef COFF_LONG_SECTION_NAMES
5376 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5377 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5382 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5387 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5388 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5389 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5390 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5391 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5392 coff_classify_symbol
, coff_compute_section_file_positions
,
5393 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5394 coff_adjust_symndx
, coff_link_add_one_symbol
,
5395 coff_link_output_has_begun
, coff_final_link_postscript
5399 /* COFF0 differs in file/section header size and relocation entry size. */
5400 static const bfd_coff_backend_data ticoff0_swap_table
=
5402 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5403 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5404 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5405 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5406 coff_SWAP_scnhdr_out
,
5407 FILHSZ_V0
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ_V0
, LINESZ
, FILNMLEN
,
5408 #ifdef COFF_LONG_FILENAMES
5413 #ifdef COFF_LONG_SECTION_NAMES
5418 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5419 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5424 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5429 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5430 coff_SWAP_reloc_in
, ticoff0_bad_format_hook
, coff_set_arch_mach_hook
,
5431 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5432 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5433 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5434 coff_classify_symbol
, coff_compute_section_file_positions
,
5435 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5436 coff_adjust_symndx
, coff_link_add_one_symbol
,
5437 coff_link_output_has_begun
, coff_final_link_postscript
5442 /* COFF1 differs in section header size. */
5443 static const bfd_coff_backend_data ticoff1_swap_table
=
5445 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5446 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5447 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5448 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5449 coff_SWAP_scnhdr_out
,
5450 FILHSZ
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5451 #ifdef COFF_LONG_FILENAMES
5456 #ifdef COFF_LONG_SECTION_NAMES
5461 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5462 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5467 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5472 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5473 coff_SWAP_reloc_in
, ticoff1_bad_format_hook
, coff_set_arch_mach_hook
,
5474 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5475 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5476 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5477 coff_classify_symbol
, coff_compute_section_file_positions
,
5478 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5479 coff_adjust_symndx
, coff_link_add_one_symbol
,
5480 coff_link_output_has_begun
, coff_final_link_postscript
5484 #ifndef coff_close_and_cleanup
5485 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5488 #ifndef coff_bfd_free_cached_info
5489 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5492 #ifndef coff_get_section_contents
5493 #define coff_get_section_contents _bfd_generic_get_section_contents
5496 #ifndef coff_bfd_copy_private_symbol_data
5497 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5500 #ifndef coff_bfd_copy_private_section_data
5501 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5504 #ifndef coff_bfd_copy_private_bfd_data
5505 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5508 #ifndef coff_bfd_merge_private_bfd_data
5509 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5512 #ifndef coff_bfd_set_private_flags
5513 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5516 #ifndef coff_bfd_print_private_bfd_data
5517 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5520 #ifndef coff_bfd_is_local_label_name
5521 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5524 #ifndef coff_read_minisymbols
5525 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5528 #ifndef coff_minisymbol_to_symbol
5529 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5532 /* The reloc lookup routine must be supplied by each individual COFF
5534 #ifndef coff_bfd_reloc_type_lookup
5535 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5538 #ifndef coff_bfd_get_relocated_section_contents
5539 #define coff_bfd_get_relocated_section_contents \
5540 bfd_generic_get_relocated_section_contents
5543 #ifndef coff_bfd_relax_section
5544 #define coff_bfd_relax_section bfd_generic_relax_section
5547 #ifndef coff_bfd_gc_sections
5548 #define coff_bfd_gc_sections bfd_generic_gc_sections
5551 #ifndef coff_bfd_merge_sections
5552 #define coff_bfd_merge_sections bfd_generic_merge_sections
5555 #ifndef coff_bfd_discard_group
5556 #define coff_bfd_discard_group bfd_generic_discard_group
5559 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5560 const bfd_target VAR = \
5563 bfd_target_coff_flavour, \
5564 BFD_ENDIAN_BIG, /* data byte order is big */ \
5565 BFD_ENDIAN_BIG, /* header byte order is big */ \
5566 /* object flags */ \
5567 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5568 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5569 /* section flags */ \
5570 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5571 UNDER, /* leading symbol underscore */ \
5572 '/', /* ar_pad_char */ \
5573 15, /* ar_max_namelen */ \
5575 /* Data conversion functions. */ \
5576 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5577 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5578 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5580 /* Header conversion functions. */ \
5581 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5582 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5583 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5585 /* bfd_check_format */ \
5586 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5587 _bfd_dummy_target }, \
5588 /* bfd_set_format */ \
5589 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5590 /* bfd_write_contents */ \
5591 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5594 BFD_JUMP_TABLE_GENERIC (coff), \
5595 BFD_JUMP_TABLE_COPY (coff), \
5596 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5597 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5598 BFD_JUMP_TABLE_SYMBOLS (coff), \
5599 BFD_JUMP_TABLE_RELOCS (coff), \
5600 BFD_JUMP_TABLE_WRITE (coff), \
5601 BFD_JUMP_TABLE_LINK (coff), \
5602 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5609 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5610 const bfd_target VAR = \
5613 bfd_target_coff_flavour, \
5614 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
5615 BFD_ENDIAN_BIG, /* header byte order is big */ \
5616 /* object flags */ \
5617 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5618 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5619 /* section flags */ \
5620 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5621 UNDER, /* leading symbol underscore */ \
5622 '/', /* ar_pad_char */ \
5623 15, /* ar_max_namelen */ \
5625 /* Data conversion functions. */ \
5626 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5627 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5628 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5630 /* Header conversion functions. */ \
5631 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5632 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5633 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5635 /* bfd_check_format */ \
5636 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5637 _bfd_dummy_target }, \
5638 /* bfd_set_format */ \
5639 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5640 /* bfd_write_contents */ \
5641 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5644 BFD_JUMP_TABLE_GENERIC (coff), \
5645 BFD_JUMP_TABLE_COPY (coff), \
5646 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5647 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5648 BFD_JUMP_TABLE_SYMBOLS (coff), \
5649 BFD_JUMP_TABLE_RELOCS (coff), \
5650 BFD_JUMP_TABLE_WRITE (coff), \
5651 BFD_JUMP_TABLE_LINK (coff), \
5652 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5659 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5660 const bfd_target VAR = \
5663 bfd_target_coff_flavour, \
5664 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
5665 BFD_ENDIAN_LITTLE, /* header byte order is little */ \
5666 /* object flags */ \
5667 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5668 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5669 /* section flags */ \
5670 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5671 UNDER, /* leading symbol underscore */ \
5672 '/', /* ar_pad_char */ \
5673 15, /* ar_max_namelen */ \
5675 /* Data conversion functions. */ \
5676 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5677 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5678 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5679 /* Header conversion functions. */ \
5680 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5681 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5682 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5683 /* bfd_check_format */ \
5684 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5685 _bfd_dummy_target }, \
5686 /* bfd_set_format */ \
5687 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5688 /* bfd_write_contents */ \
5689 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5692 BFD_JUMP_TABLE_GENERIC (coff), \
5693 BFD_JUMP_TABLE_COPY (coff), \
5694 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5695 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5696 BFD_JUMP_TABLE_SYMBOLS (coff), \
5697 BFD_JUMP_TABLE_RELOCS (coff), \
5698 BFD_JUMP_TABLE_WRITE (coff), \
5699 BFD_JUMP_TABLE_LINK (coff), \
5700 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \