1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006
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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
23 /* Most of this hacked by Steve Chamberlain,
29 BFD supports a number of different flavours of coff format.
30 The major differences between formats are the sizes and
31 alignments of fields in structures on disk, and the occasional
34 Coff in all its varieties is implemented with a few common
35 files and a number of implementation specific files. For
36 example, The 88k bcs coff format is implemented in the file
37 @file{coff-m88k.c}. This file @code{#include}s
38 @file{coff/m88k.h} which defines the external structure of the
39 coff format for the 88k, and @file{coff/internal.h} which
40 defines the internal structure. @file{coff-m88k.c} also
41 defines the relocations used by the 88k format
44 The Intel i960 processor version of coff is implemented in
45 @file{coff-i960.c}. This file has the same structure as
46 @file{coff-m88k.c}, except that it includes @file{coff/i960.h}
47 rather than @file{coff-m88k.h}.
50 Porting to a new version of coff
52 The recommended method is to select from the existing
53 implementations the version of coff which is most like the one
54 you want to use. For example, we'll say that i386 coff is
55 the one you select, and that your coff flavour is called foo.
56 Copy @file{i386coff.c} to @file{foocoff.c}, copy
57 @file{../include/coff/i386.h} to @file{../include/coff/foo.h},
58 and add the lines to @file{targets.c} and @file{Makefile.in}
59 so that your new back end is used. Alter the shapes of the
60 structures in @file{../include/coff/foo.h} so that they match
61 what you need. You will probably also have to add
62 @code{#ifdef}s to the code in @file{coff/internal.h} and
63 @file{coffcode.h} if your version of coff is too wild.
65 You can verify that your new BFD backend works quite simply by
66 building @file{objdump} from the @file{binutils} directory,
67 and making sure that its version of what's going on and your
68 host system's idea (assuming it has the pretty standard coff
69 dump utility, usually called @code{att-dump} or just
70 @code{dump}) are the same. Then clean up your code, and send
71 what you've done to Cygnus. Then your stuff will be in the
72 next release, and you won't have to keep integrating it.
75 How the coff backend works
80 The Coff backend is split into generic routines that are
81 applicable to any Coff target and routines that are specific
82 to a particular target. The target-specific routines are
83 further split into ones which are basically the same for all
84 Coff targets except that they use the external symbol format
85 or use different values for certain constants.
87 The generic routines are in @file{coffgen.c}. These routines
88 work for any Coff target. They use some hooks into the target
89 specific code; the hooks are in a @code{bfd_coff_backend_data}
90 structure, one of which exists for each target.
92 The essentially similar target-specific routines are in
93 @file{coffcode.h}. This header file includes executable C code.
94 The various Coff targets first include the appropriate Coff
95 header file, make any special defines that are needed, and
96 then include @file{coffcode.h}.
98 Some of the Coff targets then also have additional routines in
99 the target source file itself.
101 For example, @file{coff-i960.c} includes
102 @file{coff/internal.h} and @file{coff/i960.h}. It then
103 defines a few constants, such as @code{I960}, and includes
104 @file{coffcode.h}. Since the i960 has complex relocation
105 types, @file{coff-i960.c} also includes some code to
106 manipulate the i960 relocs. This code is not in
107 @file{coffcode.h} because it would not be used by any other
113 Each flavour of coff supported in BFD has its own header file
114 describing the external layout of the structures. There is also
115 an internal description of the coff layout, in
116 @file{coff/internal.h}. A major function of the
117 coff backend is swapping the bytes and twiddling the bits to
118 translate the external form of the structures into the normal
119 internal form. This is all performed in the
120 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
121 elements are different sizes between different versions of
122 coff; it is the duty of the coff version specific include file
123 to override the definitions of various packing routines in
124 @file{coffcode.h}. E.g., the size of line number entry in coff is
125 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
126 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
127 correct one. No doubt, some day someone will find a version of
128 coff which has a varying field size not catered to at the
129 moment. To port BFD, that person will have to add more @code{#defines}.
130 Three of the bit twiddling routines are exported to
131 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
132 and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol
133 table on its own, but uses BFD to fix things up. More of the
134 bit twiddlers are exported for @code{gas};
135 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
136 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
137 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
138 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
139 of all the symbol table and reloc drudgery itself, thereby
140 saving the internal BFD overhead, but uses BFD to swap things
141 on the way out, making cross ports much safer. Doing so also
142 allows BFD (and thus the linker) to use the same header files
143 as @code{gas}, which makes one avenue to disaster disappear.
148 The simple canonical form for symbols used by BFD is not rich
149 enough to keep all the information available in a coff symbol
150 table. The back end gets around this problem by keeping the original
151 symbol table around, "behind the scenes".
153 When a symbol table is requested (through a call to
154 @code{bfd_canonicalize_symtab}), a request gets through to
155 @code{coff_get_normalized_symtab}. This reads the symbol table from
156 the coff file and swaps all the structures inside into the
157 internal form. It also fixes up all the pointers in the table
158 (represented in the file by offsets from the first symbol in
159 the table) into physical pointers to elements in the new
160 internal table. This involves some work since the meanings of
161 fields change depending upon context: a field that is a
162 pointer to another structure in the symbol table at one moment
163 may be the size in bytes of a structure at the next. Another
164 pass is made over the table. All symbols which mark file names
165 (<<C_FILE>> symbols) are modified so that the internal
166 string points to the value in the auxent (the real filename)
167 rather than the normal text associated with the symbol
170 At this time the symbol names are moved around. Coff stores
171 all symbols less than nine characters long physically
172 within the symbol table; longer strings are kept at the end of
173 the file in the string table. This pass moves all strings
174 into memory and replaces them with pointers to the strings.
176 The symbol table is massaged once again, this time to create
177 the canonical table used by the BFD application. Each symbol
178 is inspected in turn, and a decision made (using the
179 @code{sclass} field) about the various flags to set in the
180 @code{asymbol}. @xref{Symbols}. The generated canonical table
181 shares strings with the hidden internal symbol table.
183 Any linenumbers are read from the coff file too, and attached
184 to the symbols which own the functions the linenumbers belong to.
189 Writing a symbol to a coff file which didn't come from a coff
190 file will lose any debugging information. The @code{asymbol}
191 structure remembers the BFD from which the symbol was taken, and on
192 output the back end makes sure that the same destination target as
193 source target is present.
195 When the symbols have come from a coff file then all the
196 debugging information is preserved.
198 Symbol tables are provided for writing to the back end in a
199 vector of pointers to pointers. This allows applications like
200 the linker to accumulate and output large symbol tables
201 without having to do too much byte copying.
203 This function runs through the provided symbol table and
204 patches each symbol marked as a file place holder
205 (@code{C_FILE}) to point to the next file place holder in the
206 list. It also marks each @code{offset} field in the list with
207 the offset from the first symbol of the current symbol.
209 Another function of this procedure is to turn the canonical
210 value form of BFD into the form used by coff. Internally, BFD
211 expects symbol values to be offsets from a section base; so a
212 symbol physically at 0x120, but in a section starting at
213 0x100, would have the value 0x20. Coff expects symbols to
214 contain their final value, so symbols have their values
215 changed at this point to reflect their sum with their owning
216 section. This transformation uses the
217 <<output_section>> field of the @code{asymbol}'s
218 @code{asection} @xref{Sections}.
220 o <<coff_mangle_symbols>>
222 This routine runs though the provided symbol table and uses
223 the offsets generated by the previous pass and the pointers
224 generated when the symbol table was read in to create the
225 structured hierarchy required by coff. It changes each pointer
226 to a symbol into the index into the symbol table of the asymbol.
228 o <<coff_write_symbols>>
230 This routine runs through the symbol table and patches up the
231 symbols from their internal form into the coff way, calls the
232 bit twiddlers, and writes out the table to the file.
241 The hidden information for an <<asymbol>> is described in a
242 <<combined_entry_type>>:
246 .typedef struct coff_ptr_struct
248 . {* Remembers the offset from the first symbol in the file for
249 . this symbol. Generated by coff_renumber_symbols. *}
250 . unsigned int offset;
252 . {* Should the value of this symbol be renumbered. Used for
253 . XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
254 . unsigned int fix_value : 1;
256 . {* Should the tag field of this symbol be renumbered.
257 . Created by coff_pointerize_aux. *}
258 . unsigned int fix_tag : 1;
260 . {* Should the endidx field of this symbol be renumbered.
261 . Created by coff_pointerize_aux. *}
262 . unsigned int fix_end : 1;
264 . {* Should the x_csect.x_scnlen field be renumbered.
265 . Created by coff_pointerize_aux. *}
266 . unsigned int fix_scnlen : 1;
268 . {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
269 . index into the line number entries. Set by coff_slurp_symbol_table. *}
270 . unsigned int fix_line : 1;
272 . {* The container for the symbol structure as read and translated
276 . union internal_auxent auxent;
277 . struct internal_syment syment;
279 .} combined_entry_type;
282 .{* Each canonical asymbol really looks like this: *}
284 .typedef struct coff_symbol_struct
286 . {* The actual symbol which the rest of BFD works with *}
289 . {* A pointer to the hidden information for this symbol *}
290 . combined_entry_type *native;
292 . {* A pointer to the linenumber information for this symbol *}
293 . struct lineno_cache_entry *lineno;
295 . {* Have the line numbers been relocated yet ? *}
296 . bfd_boolean done_lineno;
304 #include "coffswap.h"
307 #define STRING_SIZE_SIZE 4
309 #define DOT_DEBUG ".debug"
310 #define GNU_LINKONCE_WI ".gnu.linkonce.wi."
312 static long sec_to_styp_flags
313 (const char *, flagword
);
314 static bfd_boolean styp_to_sec_flags
315 (bfd
*, void *, const char *, asection
*, flagword
*);
316 static bfd_boolean coff_bad_format_hook
318 static void coff_set_custom_section_alignment
319 (bfd
*, asection
*, const struct coff_section_alignment_entry
*,
321 static bfd_boolean coff_new_section_hook
323 static bfd_boolean coff_set_arch_mach_hook
325 static bfd_boolean coff_write_relocs
327 static bfd_boolean coff_set_flags
328 (bfd
*, unsigned int *, unsigned short *);
329 static bfd_boolean coff_set_arch_mach
330 (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 (bfd
*) ATTRIBUTE_UNUSED
;
335 static bfd_boolean coff_set_section_contents
336 (bfd
*, asection
*, const void *, file_ptr
, bfd_size_type
);
337 static void * buy_and_read
338 (bfd
*, file_ptr
, bfd_size_type
);
339 static bfd_boolean coff_slurp_line_table
341 static bfd_boolean coff_slurp_symbol_table
343 static enum coff_symbol_classification coff_classify_symbol
344 (bfd
*, struct internal_syment
*);
345 static bfd_boolean coff_slurp_reloc_table
346 (bfd
*, asection
*, asymbol
**);
347 static long coff_canonicalize_reloc
348 (bfd
*, asection
*, arelent
**, asymbol
**);
349 #ifndef coff_mkobject_hook
350 static void * coff_mkobject_hook
351 (bfd
*, void *, void *);
354 static flagword handle_COMDAT
355 (bfd
*, flagword
, void *, const char *, asection
*);
357 #ifdef COFF_IMAGE_WITH_PE
358 static bfd_boolean coff_read_word
359 (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
368 static bfd_boolean ticoff1_bad_format_hook
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. */
384 #define STYP_XCOFF_DEBUG STYP_DEBUG
386 #define STYP_XCOFF_DEBUG STYP_INFO
389 #ifdef COFF_ALIGN_IN_S_FLAGS
390 #define STYP_DEBUG_INFO STYP_DSECT
392 #define STYP_DEBUG_INFO STYP_INFO
396 sec_to_styp_flags (const char *sec_name
, flagword sec_flags
)
400 if (!strcmp (sec_name
, _TEXT
))
402 styp_flags
= STYP_TEXT
;
404 else if (!strcmp (sec_name
, _DATA
))
406 styp_flags
= STYP_DATA
;
408 else if (!strcmp (sec_name
, _BSS
))
410 styp_flags
= STYP_BSS
;
413 else if (!strcmp (sec_name
, _COMMENT
))
415 styp_flags
= STYP_INFO
;
416 #endif /* _COMMENT */
419 else if (!strcmp (sec_name
, _LIB
))
421 styp_flags
= STYP_LIB
;
425 else if (!strcmp (sec_name
, _LIT
))
427 styp_flags
= STYP_LIT
;
430 else if (!strncmp (sec_name
, DOT_DEBUG
, sizeof (DOT_DEBUG
) - 1))
432 /* Handle the XCOFF debug section and DWARF2 debug sections. */
434 styp_flags
= STYP_XCOFF_DEBUG
;
436 styp_flags
= STYP_DEBUG_INFO
;
438 else if (!strncmp (sec_name
, ".stab", 5))
440 styp_flags
= STYP_DEBUG_INFO
;
442 #ifdef COFF_LONG_SECTION_NAMES
443 else if (!strncmp (sec_name
, GNU_LINKONCE_WI
, sizeof (GNU_LINKONCE_WI
) - 1))
445 styp_flags
= STYP_DEBUG_INFO
;
449 else if (!strcmp (sec_name
, _PAD
))
451 styp_flags
= STYP_PAD
;
453 else if (!strcmp (sec_name
, _LOADER
))
455 styp_flags
= STYP_LOADER
;
457 else if (!strcmp (sec_name
, _EXCEPT
))
459 styp_flags
= STYP_EXCEPT
;
461 else if (!strcmp (sec_name
, _TYPCHK
))
463 styp_flags
= STYP_TYPCHK
;
466 /* Try and figure out what it should be */
467 else if (sec_flags
& SEC_CODE
)
469 styp_flags
= STYP_TEXT
;
471 else if (sec_flags
& SEC_DATA
)
473 styp_flags
= STYP_DATA
;
475 else if (sec_flags
& SEC_READONLY
)
477 #ifdef STYP_LIT /* 29k readonly text/data section */
478 styp_flags
= STYP_LIT
;
480 styp_flags
= STYP_TEXT
;
481 #endif /* STYP_LIT */
483 else if (sec_flags
& SEC_LOAD
)
485 styp_flags
= STYP_TEXT
;
487 else if (sec_flags
& SEC_ALLOC
)
489 styp_flags
= STYP_BSS
;
493 if (sec_flags
& SEC_TIC54X_CLINK
)
494 styp_flags
|= STYP_CLINK
;
498 if (sec_flags
& SEC_TIC54X_BLOCK
)
499 styp_flags
|= STYP_BLOCK
;
503 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
504 styp_flags
|= STYP_NOLOAD
;
510 #else /* COFF_WITH_PE */
512 /* The PE version; see above for the general comments. The non-PE
513 case seems to be more guessing, and breaks PE format; specifically,
514 .rdata is readonly, but it sure ain't text. Really, all this
515 should be set up properly in gas (or whatever assembler is in use),
516 and honor whatever objcopy/strip, etc. sent us as input. */
519 sec_to_styp_flags (const char *sec_name
, flagword sec_flags
)
523 /* caution: there are at least three groups of symbols that have
524 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
525 SEC_* are the BFD internal flags, used for generic BFD
526 information. STYP_* are the COFF section flags which appear in
527 COFF files. IMAGE_SCN_* are the PE section flags which appear in
528 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
529 but there are more IMAGE_SCN_* flags. */
531 /* FIXME: There is no gas syntax to specify the debug section flag. */
532 if (strncmp (sec_name
, DOT_DEBUG
, sizeof (DOT_DEBUG
) - 1) == 0
533 || strncmp (sec_name
, GNU_LINKONCE_WI
, sizeof (GNU_LINKONCE_WI
) - 1) == 0)
534 sec_flags
= SEC_DEBUGGING
;
539 if ((sec_flags
& SEC_CODE
) != 0)
540 styp_flags
|= IMAGE_SCN_CNT_CODE
;
541 if ((sec_flags
& SEC_DATA
) != 0)
542 styp_flags
|= IMAGE_SCN_CNT_INITIALIZED_DATA
;
543 if ((sec_flags
& SEC_ALLOC
) != 0 && (sec_flags
& SEC_LOAD
) == 0)
544 styp_flags
|= IMAGE_SCN_CNT_UNINITIALIZED_DATA
; /* ==STYP_BSS */
546 /* skip constRUCTOR */
548 if ((sec_flags
& SEC_IS_COMMON
) != 0)
549 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
550 if ((sec_flags
& SEC_DEBUGGING
) != 0)
551 styp_flags
|= IMAGE_SCN_MEM_DISCARDABLE
;
552 if ((sec_flags
& SEC_EXCLUDE
) != 0)
553 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
554 if ((sec_flags
& SEC_NEVER_LOAD
) != 0)
555 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
558 if (sec_flags
& SEC_LINK_ONCE
)
559 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
560 /* skip LINK_DUPLICATES */
561 /* skip LINKER_CREATED */
563 if (sec_flags
& (SEC_ALLOC
| SEC_LOAD
))
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. */
568 styp_flags
|= IMAGE_SCN_MEM_READ
; /* Always readable. */
569 if ((sec_flags
& SEC_READONLY
) == 0)
570 styp_flags
|= IMAGE_SCN_MEM_WRITE
; /* Invert READONLY for write. */
571 if (sec_flags
& SEC_CODE
)
572 styp_flags
|= IMAGE_SCN_MEM_EXECUTE
; /* CODE->EXECUTE. */
573 if (sec_flags
& SEC_COFF_SHARED
)
574 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 (bfd
*abfd ATTRIBUTE_UNUSED
,
593 asection
*section ATTRIBUTE_UNUSED
,
596 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
597 long styp_flags
= internal_s
->s_flags
;
598 flagword sec_flags
= 0;
601 if (styp_flags
& STYP_BLOCK
)
602 sec_flags
|= SEC_TIC54X_BLOCK
;
606 if (styp_flags
& STYP_CLINK
)
607 sec_flags
|= SEC_TIC54X_CLINK
;
611 if (styp_flags
& STYP_NOLOAD
)
612 sec_flags
|= SEC_NEVER_LOAD
;
613 #endif /* STYP_NOLOAD */
615 /* For 386 COFF, at least, an unloadable text or data section is
616 actually a shared library section. */
617 if (styp_flags
& STYP_TEXT
)
619 if (sec_flags
& SEC_NEVER_LOAD
)
620 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
622 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
624 else if (styp_flags
& STYP_DATA
)
626 if (sec_flags
& SEC_NEVER_LOAD
)
627 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
629 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
631 else if (styp_flags
& STYP_BSS
)
633 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
634 if (sec_flags
& SEC_NEVER_LOAD
)
635 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
638 sec_flags
|= SEC_ALLOC
;
640 else if (styp_flags
& STYP_INFO
)
642 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
643 defined. coff_compute_section_file_positions uses
644 COFF_PAGE_SIZE to ensure that the low order bits of the
645 section VMA and the file offset match. If we don't know
646 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
647 and demand page loading of the file will fail. */
648 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
649 sec_flags
|= SEC_DEBUGGING
;
652 else if (styp_flags
& STYP_PAD
)
654 else if (strcmp (name
, _TEXT
) == 0)
656 if (sec_flags
& SEC_NEVER_LOAD
)
657 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
659 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
661 else if (strcmp (name
, _DATA
) == 0)
663 if (sec_flags
& SEC_NEVER_LOAD
)
664 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
666 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
668 else if (strcmp (name
, _BSS
) == 0)
670 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
671 if (sec_flags
& SEC_NEVER_LOAD
)
672 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
675 sec_flags
|= SEC_ALLOC
;
677 else if (strncmp (name
, DOT_DEBUG
, sizeof (DOT_DEBUG
) - 1) == 0
679 || strcmp (name
, _COMMENT
) == 0
681 #ifdef COFF_LONG_SECTION_NAMES
682 || strncmp (name
, GNU_LINKONCE_WI
, sizeof (GNU_LINKONCE_WI
) - 1) == 0
684 || strncmp (name
, ".stab", 5) == 0)
686 #ifdef COFF_PAGE_SIZE
687 sec_flags
|= SEC_DEBUGGING
;
691 else if (strcmp (name
, _LIB
) == 0)
695 else if (strcmp (name
, _LIT
) == 0)
696 sec_flags
= SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
699 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
701 #ifdef STYP_LIT /* A29k readonly text/data section type. */
702 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
703 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
704 #endif /* STYP_LIT */
706 #ifdef STYP_OTHER_LOAD /* Other loaded sections. */
707 if (styp_flags
& STYP_OTHER_LOAD
)
708 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
709 #endif /* STYP_SDATA */
711 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
712 /* As a GNU extension, if the name begins with .gnu.linkonce, we
713 only link a single copy of the section. This is used to support
714 g++. g++ will emit each template expansion in its own section.
715 The symbols will be defined as weak, so that multiple definitions
716 are permitted. The GNU linker extension is to actually discard
717 all but one of the sections. */
718 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
719 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
722 if (flags_ptr
== NULL
)
725 * flags_ptr
= sec_flags
;
729 #else /* COFF_WITH_PE */
732 handle_COMDAT (bfd
* abfd
,
738 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
739 bfd_byte
*esymstart
, *esym
, *esymend
;
741 char *target_name
= NULL
;
743 sec_flags
|= SEC_LINK_ONCE
;
745 /* Unfortunately, the PE format stores essential information in
746 the symbol table, of all places. We need to extract that
747 information now, so that objdump and the linker will know how
748 to handle the section without worrying about the symbols. We
749 can't call slurp_symtab, because the linker doesn't want the
752 /* COMDAT sections are special. The first symbol is the section
753 symbol, which tells what kind of COMDAT section it is. The
754 second symbol is the "comdat symbol" - the one with the
755 unique name. GNU uses the section symbol for the unique
756 name; MS uses ".text" for every comdat section. Sigh. - DJ */
758 /* This is not mirrored in sec_to_styp_flags(), but there
759 doesn't seem to be a need to, either, and it would at best be
762 if (! _bfd_coff_get_external_symbols (abfd
))
765 esymstart
= esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
766 esymend
= esym
+ obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
768 while (esym
< esymend
)
770 struct internal_syment isym
;
771 char buf
[SYMNMLEN
+ 1];
774 bfd_coff_swap_sym_in (abfd
, esym
, & isym
);
776 if (sizeof (internal_s
->s_name
) > SYMNMLEN
)
778 /* This case implies that the matching
779 symbol name will be in the string table. */
783 if (isym
.n_scnum
== section
->target_index
)
785 /* According to the MSVC documentation, the first
786 TWO entries with the section # are both of
787 interest to us. The first one is the "section
788 symbol" (section name). The second is the comdat
789 symbol name. Here, we've found the first
790 qualifying entry; we distinguish it from the
791 second with a state flag.
793 In the case of gas-generated (at least until that
794 is fixed) .o files, it isn't necessarily the
795 second one. It may be some other later symbol.
797 Since gas also doesn't follow MS conventions and
798 emits the section similar to .text$<name>, where
799 <something> is the name we're looking for, we
800 distinguish the two as follows:
802 If the section name is simply a section name (no
803 $) we presume it's MS-generated, and look at
804 precisely the second symbol for the comdat name.
805 If the section name has a $, we assume it's
806 gas-generated, and look for <something> (whatever
807 follows the $) as the comdat symbol. */
809 /* All 3 branches use this. */
810 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
, buf
);
819 /* The first time we've seen the symbol. */
820 union internal_auxent aux
;
822 /* If it isn't the stuff we're expecting, die;
823 The MS documentation is vague, but it
824 appears that the second entry serves BOTH
825 as the comdat symbol and the defining
826 symbol record (either C_STAT or C_EXT,
827 possibly with an aux entry with debug
828 information if it's a function.) It
829 appears the only way to find the second one
830 is to count. (On Intel, they appear to be
831 adjacent, but on Alpha, they have been
834 Here, we think we've found the first one,
835 but there's some checking we can do to be
838 if (! (isym
.n_sclass
== C_STAT
839 && isym
.n_type
== T_NULL
840 && isym
.n_value
== 0))
843 /* FIXME LATER: MSVC generates section names
844 like .text for comdats. Gas generates
845 names like .text$foo__Fv (in the case of a
846 function). See comment above for more. */
848 if (strcmp (name
, symname
) != 0)
849 _bfd_error_handler (_("%B: warning: COMDAT symbol '%s' does not match section name '%s'"),
850 abfd
, symname
, name
);
854 /* This is the section symbol. */
855 bfd_coff_swap_aux_in (abfd
, (esym
+ bfd_coff_symesz (abfd
)),
856 isym
.n_type
, isym
.n_sclass
,
857 0, isym
.n_numaux
, & aux
);
859 target_name
= strchr (name
, '$');
860 if (target_name
!= NULL
)
868 /* FIXME: Microsoft uses NODUPLICATES and
869 ASSOCIATIVE, but gnu uses ANY and
870 SAME_SIZE. Unfortunately, gnu doesn't do
871 the comdat symbols right. So, until we can
872 fix it to do the right thing, we are
873 temporarily disabling comdats for the MS
874 types (they're used in DLLs and C++, but we
875 don't support *their* C++ libraries anyway
878 /* Cygwin does not follow the MS style, and
879 uses ANY and SAME_SIZE where NODUPLICATES
880 and ASSOCIATIVE should be used. For
881 Interix, we just do the right thing up
884 switch (aux
.x_scn
.x_comdat
)
886 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
887 #ifdef STRICT_PE_FORMAT
888 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
890 sec_flags
&= ~SEC_LINK_ONCE
;
894 case IMAGE_COMDAT_SELECT_ANY
:
895 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
898 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
899 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
902 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
903 /* Not yet fully implemented ??? */
904 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
907 /* debug$S gets this case; other
910 /* There may be no symbol... we'll search
911 the whole table... Is this the right
912 place to play this game? Or should we do
913 it when reading it in. */
914 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
915 #ifdef STRICT_PE_FORMAT
916 /* FIXME: This is not currently implemented. */
917 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
919 sec_flags
&= ~SEC_LINK_ONCE
;
923 default: /* 0 means "no symbol" */
924 /* debug$F gets this case; other
926 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
933 /* Gas mode: the first matching on partial name. */
935 #ifndef TARGET_UNDERSCORE
936 #define TARGET_UNDERSCORE 0
938 /* Is this the name we're looking for ? */
939 if (strcmp (target_name
,
940 symname
+ (TARGET_UNDERSCORE
? 1 : 0)) != 0)
942 /* Not the name we're looking for */
943 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
948 /* MSVC mode: the lexically second symbol (or
949 drop through from the above). */
954 /* This must the second symbol with the
955 section #. It is the actual symbol name.
956 Intel puts the two adjacent, but Alpha (at
957 least) spreads them out. */
959 amt
= sizeof (struct coff_comdat_info
);
960 coff_section_data (abfd
, section
)->comdat
961 = bfd_alloc (abfd
, amt
);
962 if (coff_section_data (abfd
, section
)->comdat
== NULL
)
965 coff_section_data (abfd
, 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 coff_section_data (abfd
, section
)->comdat
->name
982 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
990 /* The PE version; see above for the general comments.
992 Since to set the SEC_LINK_ONCE and associated flags, we have to
993 look at the symbol table anyway, we return the symbol table index
994 of the symbol being used as the COMDAT symbol. This is admittedly
995 ugly, but there's really nowhere else that we have access to the
996 required information. FIXME: Is the COMDAT symbol index used for
997 any purpose other than objdump? */
1000 styp_to_sec_flags (bfd
*abfd
,
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 /* Generate a warning message rather using the 'unhandled'
1059 variable as this will allow some .sys files generate by
1060 other toolchains to be processed. See bugzilla issue 196. */
1061 _bfd_error_handler (_("%B: Warning: Ignoring section flag IMAGE_SCN_MEM_NOT_PAGED in section %s"),
1064 case IMAGE_SCN_MEM_EXECUTE
:
1065 sec_flags
|= SEC_CODE
;
1067 case IMAGE_SCN_MEM_WRITE
:
1068 sec_flags
&= ~ SEC_READONLY
;
1070 case IMAGE_SCN_MEM_DISCARDABLE
:
1071 /* The MS PE spec sets the DISCARDABLE flag on .reloc sections
1072 but we do not want them to be labelled as debug section, since
1073 then strip would remove them. */
1074 if (strncmp (name
, ".reloc", sizeof ".reloc" - 1) != 0)
1075 sec_flags
|= SEC_DEBUGGING
;
1077 case IMAGE_SCN_MEM_SHARED
:
1078 sec_flags
|= SEC_COFF_SHARED
;
1080 case IMAGE_SCN_LNK_REMOVE
:
1081 sec_flags
|= SEC_EXCLUDE
;
1083 case IMAGE_SCN_CNT_CODE
:
1084 sec_flags
|= SEC_CODE
| SEC_ALLOC
| SEC_LOAD
;
1086 case IMAGE_SCN_CNT_INITIALIZED_DATA
:
1087 sec_flags
|= SEC_DATA
| SEC_ALLOC
| SEC_LOAD
;
1089 case IMAGE_SCN_CNT_UNINITIALIZED_DATA
:
1090 sec_flags
|= SEC_ALLOC
;
1092 case IMAGE_SCN_LNK_INFO
:
1093 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1094 defined. coff_compute_section_file_positions uses
1095 COFF_PAGE_SIZE to ensure that the low order bits of the
1096 section VMA and the file offset match. If we don't know
1097 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1098 and demand page loading of the file will fail. */
1099 #ifdef COFF_PAGE_SIZE
1100 sec_flags
|= SEC_DEBUGGING
;
1103 case IMAGE_SCN_LNK_COMDAT
:
1104 /* COMDAT gets very special treatment. */
1105 sec_flags
= handle_COMDAT (abfd
, sec_flags
, hdr
, name
, section
);
1108 /* Silently ignore for now. */
1112 /* If the section flag was not handled, report it here. */
1113 if (unhandled
!= NULL
)
1115 (*_bfd_error_handler
)
1116 (_("%B (%s): Section flag %s (0x%x) ignored"),
1117 abfd
, name
, unhandled
, flag
);
1122 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1123 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1124 only link a single copy of the section. This is used to support
1125 g++. g++ will emit each template expansion in its own section.
1126 The symbols will be defined as weak, so that multiple definitions
1127 are permitted. The GNU linker extension is to actually discard
1128 all but one of the sections. */
1129 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
1130 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1134 * flags_ptr
= sec_flags
;
1139 #endif /* COFF_WITH_PE */
1141 #define get_index(symbol) ((symbol)->udata.i)
1145 bfd_coff_backend_data
1149 .{* COFF symbol classifications. *}
1151 .enum coff_symbol_classification
1153 . {* Global symbol. *}
1154 . COFF_SYMBOL_GLOBAL,
1155 . {* Common symbol. *}
1156 . COFF_SYMBOL_COMMON,
1157 . {* Undefined symbol. *}
1158 . COFF_SYMBOL_UNDEFINED,
1159 . {* Local symbol. *}
1160 . COFF_SYMBOL_LOCAL,
1161 . {* PE section symbol. *}
1162 . COFF_SYMBOL_PE_SECTION
1165 Special entry points for gdb to swap in coff symbol table parts:
1168 . void (*_bfd_coff_swap_aux_in)
1169 . (bfd *, void *, int, int, int, int, void *);
1171 . void (*_bfd_coff_swap_sym_in)
1172 . (bfd *, void *, void *);
1174 . void (*_bfd_coff_swap_lineno_in)
1175 . (bfd *, void *, void *);
1177 . unsigned int (*_bfd_coff_swap_aux_out)
1178 . (bfd *, void *, int, int, int, int, void *);
1180 . unsigned int (*_bfd_coff_swap_sym_out)
1181 . (bfd *, void *, void *);
1183 . unsigned int (*_bfd_coff_swap_lineno_out)
1184 . (bfd *, void *, void *);
1186 . unsigned int (*_bfd_coff_swap_reloc_out)
1187 . (bfd *, void *, void *);
1189 . unsigned int (*_bfd_coff_swap_filehdr_out)
1190 . (bfd *, void *, void *);
1192 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1193 . (bfd *, void *, void *);
1195 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1196 . (bfd *, void *, void *);
1198 . unsigned int _bfd_filhsz;
1199 . unsigned int _bfd_aoutsz;
1200 . unsigned int _bfd_scnhsz;
1201 . unsigned int _bfd_symesz;
1202 . unsigned int _bfd_auxesz;
1203 . unsigned int _bfd_relsz;
1204 . unsigned int _bfd_linesz;
1205 . unsigned int _bfd_filnmlen;
1206 . bfd_boolean _bfd_coff_long_filenames;
1207 . bfd_boolean _bfd_coff_long_section_names;
1208 . unsigned int _bfd_coff_default_section_alignment_power;
1209 . bfd_boolean _bfd_coff_force_symnames_in_strings;
1210 . unsigned int _bfd_coff_debug_string_prefix_length;
1212 . void (*_bfd_coff_swap_filehdr_in)
1213 . (bfd *, void *, void *);
1215 . void (*_bfd_coff_swap_aouthdr_in)
1216 . (bfd *, void *, void *);
1218 . void (*_bfd_coff_swap_scnhdr_in)
1219 . (bfd *, void *, void *);
1221 . void (*_bfd_coff_swap_reloc_in)
1222 . (bfd *abfd, void *, void *);
1224 . bfd_boolean (*_bfd_coff_bad_format_hook)
1227 . bfd_boolean (*_bfd_coff_set_arch_mach_hook)
1230 . void * (*_bfd_coff_mkobject_hook)
1231 . (bfd *, void *, void *);
1233 . bfd_boolean (*_bfd_styp_to_sec_flags_hook)
1234 . (bfd *, void *, const char *, asection *, flagword *);
1236 . void (*_bfd_set_alignment_hook)
1237 . (bfd *, asection *, void *);
1239 . bfd_boolean (*_bfd_coff_slurp_symbol_table)
1242 . bfd_boolean (*_bfd_coff_symname_in_debug)
1243 . (bfd *, struct internal_syment *);
1245 . bfd_boolean (*_bfd_coff_pointerize_aux_hook)
1246 . (bfd *, combined_entry_type *, combined_entry_type *,
1247 . unsigned int, combined_entry_type *);
1249 . bfd_boolean (*_bfd_coff_print_aux)
1250 . (bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1251 . combined_entry_type *, unsigned int);
1253 . void (*_bfd_coff_reloc16_extra_cases)
1254 . (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1255 . bfd_byte *, unsigned int *, unsigned int *);
1257 . int (*_bfd_coff_reloc16_estimate)
1258 . (bfd *, asection *, arelent *, unsigned int,
1259 . struct bfd_link_info *);
1261 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1262 . (bfd *, struct internal_syment *);
1264 . bfd_boolean (*_bfd_coff_compute_section_file_positions)
1267 . bfd_boolean (*_bfd_coff_start_final_link)
1268 . (bfd *, struct bfd_link_info *);
1270 . bfd_boolean (*_bfd_coff_relocate_section)
1271 . (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1272 . struct internal_reloc *, struct internal_syment *, asection **);
1274 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1275 . (bfd *, asection *, struct internal_reloc *,
1276 . struct coff_link_hash_entry *, struct internal_syment *,
1279 . bfd_boolean (*_bfd_coff_adjust_symndx)
1280 . (bfd *, struct bfd_link_info *, bfd *, asection *,
1281 . struct internal_reloc *, bfd_boolean *);
1283 . bfd_boolean (*_bfd_coff_link_add_one_symbol)
1284 . (struct bfd_link_info *, bfd *, const char *, flagword,
1285 . asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
1286 . struct bfd_link_hash_entry **);
1288 . bfd_boolean (*_bfd_coff_link_output_has_begun)
1289 . (bfd *, struct coff_final_link_info *);
1291 . bfd_boolean (*_bfd_coff_final_link_postscript)
1292 . (bfd *, struct coff_final_link_info *);
1294 .} bfd_coff_backend_data;
1296 .#define coff_backend_info(abfd) \
1297 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1299 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1300 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1302 .#define bfd_coff_swap_sym_in(a,e,i) \
1303 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1305 .#define bfd_coff_swap_lineno_in(a,e,i) \
1306 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1308 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1309 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1311 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1312 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1314 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1315 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1317 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1318 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1320 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1321 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1323 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1324 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1326 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1327 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1329 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1330 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1331 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1332 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1333 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1334 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1335 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1336 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1337 .#define bfd_coff_long_filenames(abfd) \
1338 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1339 .#define bfd_coff_long_section_names(abfd) \
1340 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1341 .#define bfd_coff_default_section_alignment_power(abfd) \
1342 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1343 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1344 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1346 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1347 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1349 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1350 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1352 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1353 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1355 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1356 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1358 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1359 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1360 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1361 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1362 . (abfd, filehdr, aouthdr))
1364 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1365 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1366 . (abfd, scnhdr, name, section, flags_ptr))
1368 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1369 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1371 .#define bfd_coff_slurp_symbol_table(abfd)\
1372 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1374 .#define bfd_coff_symname_in_debug(abfd, sym)\
1375 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1377 .#define bfd_coff_force_symnames_in_strings(abfd)\
1378 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1380 .#define bfd_coff_debug_string_prefix_length(abfd)\
1381 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1383 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1384 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1385 . (abfd, file, base, symbol, aux, indaux))
1387 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1388 . reloc, data, src_ptr, dst_ptr)\
1389 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1390 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1392 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1393 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1394 . (abfd, section, reloc, shrink, link_info))
1396 .#define bfd_coff_classify_symbol(abfd, sym)\
1397 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1400 .#define bfd_coff_compute_section_file_positions(abfd)\
1401 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1404 .#define bfd_coff_start_final_link(obfd, info)\
1405 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1407 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1408 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1409 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1410 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1411 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1412 . (abfd, sec, rel, h, sym, addendp))
1413 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1414 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1415 . (obfd, info, ibfd, sec, rel, adjustedp))
1416 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1417 . value, string, cp, coll, hashp)\
1418 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1419 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1421 .#define bfd_coff_link_output_has_begun(a,p) \
1422 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p))
1423 .#define bfd_coff_final_link_postscript(a,p) \
1424 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p))
1428 /* See whether the magic number matches. */
1431 coff_bad_format_hook (bfd
* abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1433 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1435 if (BADMAG (*internal_f
))
1438 /* If the optional header is NULL or not the correct size then
1439 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1440 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1441 optional header is of a different size.
1443 But the mips keeps extra stuff in it's opthdr, so dont check
1446 #if defined(M88) || defined(I960)
1447 if (internal_f
->f_opthdr
!= 0 && bfd_coff_aoutsz (abfd
) != internal_f
->f_opthdr
)
1456 ticoff0_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1458 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1460 if (COFF0_BADMAG (*internal_f
))
1469 ticoff1_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1471 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1473 if (COFF1_BADMAG (*internal_f
))
1480 /* Check whether this section uses an alignment other than the
1484 coff_set_custom_section_alignment (bfd
*abfd ATTRIBUTE_UNUSED
,
1486 const struct coff_section_alignment_entry
*alignment_table
,
1487 const unsigned int table_size
)
1489 const unsigned int default_alignment
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1492 for (i
= 0; i
< table_size
; ++i
)
1494 const char *secname
= bfd_get_section_name (abfd
, section
);
1496 if (alignment_table
[i
].comparison_length
== (unsigned int) -1
1497 ? strcmp (alignment_table
[i
].name
, secname
) == 0
1498 : strncmp (alignment_table
[i
].name
, secname
,
1499 alignment_table
[i
].comparison_length
) == 0)
1502 if (i
>= table_size
)
1505 if (alignment_table
[i
].default_alignment_min
!= COFF_ALIGNMENT_FIELD_EMPTY
1506 && default_alignment
< alignment_table
[i
].default_alignment_min
)
1509 if (alignment_table
[i
].default_alignment_max
!= COFF_ALIGNMENT_FIELD_EMPTY
1510 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1511 && default_alignment
> alignment_table
[i
].default_alignment_max
1516 section
->alignment_power
= alignment_table
[i
].alignment_power
;
1519 /* Custom section alignment records. */
1521 static const struct coff_section_alignment_entry
1522 coff_section_alignment_table
[] =
1524 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1525 COFF_SECTION_ALIGNMENT_ENTRIES
,
1527 /* There must not be any gaps between .stabstr sections. */
1528 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1529 1, COFF_ALIGNMENT_FIELD_EMPTY
, 0 },
1530 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1531 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1532 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1533 /* Similarly for the .ctors and .dtors sections. */
1534 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1535 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1536 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1537 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 }
1540 static const unsigned int coff_section_alignment_table_size
=
1541 sizeof coff_section_alignment_table
/ sizeof coff_section_alignment_table
[0];
1543 /* Initialize a section structure with information peculiar to this
1544 particular implementation of COFF. */
1547 coff_new_section_hook (bfd
* abfd
, asection
* section
)
1549 combined_entry_type
*native
;
1552 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1555 if (bfd_xcoff_text_align_power (abfd
) != 0
1556 && strcmp (bfd_get_section_name (abfd
, section
), ".text") == 0)
1557 section
->alignment_power
= bfd_xcoff_text_align_power (abfd
);
1558 if (bfd_xcoff_data_align_power (abfd
) != 0
1559 && strcmp (bfd_get_section_name (abfd
, section
), ".data") == 0)
1560 section
->alignment_power
= bfd_xcoff_data_align_power (abfd
);
1563 /* Set up the section symbol. */
1564 if (!_bfd_generic_new_section_hook (abfd
, section
))
1567 /* Allocate aux records for section symbols, to store size and
1570 @@ The 10 is a guess at a plausible maximum number of aux entries
1571 (but shouldn't be a constant). */
1572 amt
= sizeof (combined_entry_type
) * 10;
1573 native
= bfd_zalloc (abfd
, amt
);
1577 /* We don't need to set up n_name, n_value, or n_scnum in the native
1578 symbol information, since they'll be overridden by the BFD symbol
1579 anyhow. However, we do need to set the type and storage class,
1580 in case this symbol winds up getting written out. The value 0
1581 for n_numaux is already correct. */
1583 native
->u
.syment
.n_type
= T_NULL
;
1584 native
->u
.syment
.n_sclass
= C_STAT
;
1586 coffsymbol (section
->symbol
)->native
= native
;
1588 coff_set_custom_section_alignment (abfd
, section
,
1589 coff_section_alignment_table
,
1590 coff_section_alignment_table_size
);
1595 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1597 /* Set the alignment of a BFD section. */
1600 coff_set_alignment_hook (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;\
1644 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1648 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1651 ALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_64BYTES
, 6)
1652 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_32BYTES
, 5)
1653 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_16BYTES
, 4)
1654 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_8BYTES
, 3)
1655 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_4BYTES
, 2)
1656 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_2BYTES
, 1)
1657 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_1BYTES
, 0)
1659 /* In a PE image file, the s_paddr field holds the virtual size of a
1660 section, while the s_size field holds the raw size. We also keep
1661 the original section flag value, since not every bit can be
1662 mapped onto a generic BFD section bit. */
1663 if (coff_section_data (abfd
, section
) == NULL
)
1665 amt
= sizeof (struct coff_section_tdata
);
1666 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
1667 if (section
->used_by_bfd
== NULL
)
1668 /* FIXME: Return error. */
1672 if (pei_section_data (abfd
, section
) == NULL
)
1674 amt
= sizeof (struct pei_section_tdata
);
1675 coff_section_data (abfd
, section
)->tdata
= bfd_zalloc (abfd
, amt
);
1676 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1677 /* FIXME: Return error. */
1680 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1681 pei_section_data (abfd
, section
)->pe_flags
= hdr
->s_flags
;
1683 section
->lma
= hdr
->s_vaddr
;
1685 /* Check for extended relocs. */
1686 if (hdr
->s_flags
& IMAGE_SCN_LNK_NRELOC_OVFL
)
1688 struct external_reloc dst
;
1689 struct internal_reloc n
;
1690 file_ptr oldpos
= bfd_tell (abfd
);
1691 bfd_size_type relsz
= bfd_coff_relsz (abfd
);
1693 bfd_seek (abfd
, (file_ptr
) hdr
->s_relptr
, 0);
1694 if (bfd_bread (& dst
, relsz
, abfd
) != relsz
)
1697 coff_swap_reloc_in (abfd
, &dst
, &n
);
1698 bfd_seek (abfd
, oldpos
, 0);
1699 section
->reloc_count
= hdr
->s_nreloc
= n
.r_vaddr
- 1;
1700 section
->rel_filepos
+= relsz
;
1702 else if (hdr
->s_nreloc
== 0xffff)
1703 (*_bfd_error_handler
)
1704 ("%s: warning: claims to have 0xffff relocs, without overflow",
1705 bfd_get_filename (abfd
));
1708 #undef ELIFALIGN_SET
1710 #else /* ! COFF_WITH_PE */
1713 /* We grossly abuse this function to handle XCOFF overflow headers.
1714 When we see one, we correct the reloc and line number counts in the
1715 real header, and remove the section we just created. */
1718 coff_set_alignment_hook (bfd
*abfd
, asection
*section
, void * scnhdr
)
1720 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1723 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1726 real_sec
= coff_section_from_bfd_index (abfd
, (int) hdr
->s_nreloc
);
1727 if (real_sec
== NULL
)
1730 real_sec
->reloc_count
= hdr
->s_paddr
;
1731 real_sec
->lineno_count
= hdr
->s_vaddr
;
1733 if (!bfd_section_removed_from_list (abfd
, section
))
1735 bfd_section_list_remove (abfd
, section
);
1736 --abfd
->section_count
;
1740 #else /* ! RS6000COFF_C */
1742 #define coff_set_alignment_hook \
1743 ((void (*) (bfd *, asection *, void *)) bfd_void)
1745 #endif /* ! RS6000COFF_C */
1746 #endif /* ! COFF_WITH_PE */
1747 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1749 #ifndef coff_mkobject
1752 coff_mkobject (bfd
* abfd
)
1754 coff_data_type
*coff
;
1755 bfd_size_type amt
= sizeof (coff_data_type
);
1757 abfd
->tdata
.coff_obj_data
= bfd_zalloc (abfd
, amt
);
1758 if (abfd
->tdata
.coff_obj_data
== NULL
)
1760 coff
= coff_data (abfd
);
1761 coff
->symbols
= NULL
;
1762 coff
->conversion_table
= NULL
;
1763 coff
->raw_syments
= NULL
;
1764 coff
->relocbase
= 0;
1765 coff
->local_toc_sym_map
= 0;
1767 /* make_abs_section(abfd);*/
1773 /* Create the COFF backend specific information. */
1775 #ifndef coff_mkobject_hook
1777 coff_mkobject_hook (bfd
* abfd
,
1779 void * aouthdr ATTRIBUTE_UNUSED
)
1781 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1782 coff_data_type
*coff
;
1784 if (! coff_mkobject (abfd
))
1787 coff
= coff_data (abfd
);
1789 coff
->sym_filepos
= internal_f
->f_symptr
;
1791 /* These members communicate important constants about the symbol
1792 table to GDB's symbol-reading code. These `constants'
1793 unfortunately vary among coff implementations... */
1794 coff
->local_n_btmask
= N_BTMASK
;
1795 coff
->local_n_btshft
= N_BTSHFT
;
1796 coff
->local_n_tmask
= N_TMASK
;
1797 coff
->local_n_tshift
= N_TSHIFT
;
1798 coff
->local_symesz
= bfd_coff_symesz (abfd
);
1799 coff
->local_auxesz
= bfd_coff_auxesz (abfd
);
1800 coff
->local_linesz
= bfd_coff_linesz (abfd
);
1802 coff
->timestamp
= internal_f
->f_timdat
;
1804 obj_raw_syment_count (abfd
) =
1805 obj_conv_table_size (abfd
) =
1806 internal_f
->f_nsyms
;
1809 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
1810 abfd
->flags
|= DYNAMIC
;
1811 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= bfd_coff_aoutsz (abfd
))
1813 struct internal_aouthdr
*internal_a
=
1814 (struct internal_aouthdr
*) aouthdr
;
1815 struct xcoff_tdata
*xcoff
;
1817 xcoff
= xcoff_data (abfd
);
1818 # ifdef U803XTOCMAGIC
1819 xcoff
->xcoff64
= internal_f
->f_magic
== U803XTOCMAGIC
;
1823 xcoff
->full_aouthdr
= TRUE
;
1824 xcoff
->toc
= internal_a
->o_toc
;
1825 xcoff
->sntoc
= internal_a
->o_sntoc
;
1826 xcoff
->snentry
= internal_a
->o_snentry
;
1827 bfd_xcoff_text_align_power (abfd
) = internal_a
->o_algntext
;
1828 bfd_xcoff_data_align_power (abfd
) = internal_a
->o_algndata
;
1829 xcoff
->modtype
= internal_a
->o_modtype
;
1830 xcoff
->cputype
= internal_a
->o_cputype
;
1831 xcoff
->maxdata
= internal_a
->o_maxdata
;
1832 xcoff
->maxstack
= internal_a
->o_maxstack
;
1837 /* Set the flags field from the COFF header read in. */
1838 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
1843 /* FIXME: I'm not sure this is ever executed, since peicode.h
1844 defines coff_mkobject_hook. */
1845 if ((internal_f
->f_flags
& IMAGE_FILE_DEBUG_STRIPPED
) == 0)
1846 abfd
->flags
|= HAS_DEBUG
;
1853 /* Determine the machine architecture and type. FIXME: This is target
1854 dependent because the magic numbers are defined in the target
1855 dependent header files. But there is no particular need for this.
1856 If the magic numbers were moved to a separate file, this function
1857 would be target independent and would also be much more successful
1858 at linking together COFF files for different architectures. */
1861 coff_set_arch_mach_hook (bfd
*abfd
, void * filehdr
)
1863 unsigned long machine
;
1864 enum bfd_architecture arch
;
1865 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1867 /* Zero selects the default machine for an arch. */
1869 switch (internal_f
->f_magic
)
1871 #ifdef OR32_MAGIC_BIG
1872 case OR32_MAGIC_BIG
:
1873 case OR32_MAGIC_LITTLE
:
1874 arch
= bfd_arch_or32
;
1879 arch
= bfd_arch_powerpc
;
1885 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler */
1886 case LYNXCOFFMAGIC
: /* shadows the m68k Lynx number below, sigh */
1887 arch
= bfd_arch_i386
;
1892 arch
= bfd_arch_ia64
;
1899 arch
= bfd_arch_arm
;
1900 machine
= bfd_arm_get_mach_from_notes (abfd
, ARM_NOTE_SECTION
);
1901 if (machine
== bfd_mach_arm_unknown
)
1903 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
1905 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
1906 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
1907 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
1909 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
1910 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
1911 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
1912 /* The COFF header does not have enough bits available
1913 to cover all the different ARM architectures. So
1914 we interpret F_ARM_5, the highest flag value to mean
1915 "the highest ARM architecture known to BFD" which is
1916 currently the XScale. */
1917 case F_ARM_5
: machine
= bfd_mach_arm_XScale
; break;
1925 #ifdef MC68KBCSMAGIC
1928 #ifdef APOLLOM68KMAGIC
1929 case APOLLOM68KMAGIC
:
1931 #ifdef LYNXCOFFMAGIC
1934 arch
= bfd_arch_m68k
;
1935 machine
= bfd_mach_m68020
;
1940 arch
= bfd_arch_maxq
;
1941 switch (internal_f
->f_flags
& F_MACHMASK
)
1944 machine
= bfd_mach_maxq10
;
1947 machine
= bfd_mach_maxq20
;
1958 arch
= bfd_arch_m88k
;
1964 arch
= bfd_arch_z80
;
1965 switch (internal_f
->f_flags
& F_MACHMASK
)
1968 case bfd_mach_z80strict
<< 12:
1969 case bfd_mach_z80
<< 12:
1970 case bfd_mach_z80full
<< 12:
1971 case bfd_mach_r800
<< 12:
1972 machine
= ((unsigned)internal_f
->f_flags
& F_MACHMASK
) >> 12;
1981 arch
= bfd_arch_z8k
;
1982 switch (internal_f
->f_flags
& F_MACHMASK
)
1985 machine
= bfd_mach_z8001
;
1988 machine
= bfd_mach_z8002
;
1997 arch
= bfd_arch_i860
;
2004 arch
= bfd_arch_i960
;
2005 switch (F_I960TYPE
& internal_f
->f_flags
)
2009 machine
= bfd_mach_i960_core
;
2012 machine
= bfd_mach_i960_kb_sb
;
2015 machine
= bfd_mach_i960_mc
;
2018 machine
= bfd_mach_i960_xa
;
2021 machine
= bfd_mach_i960_ca
;
2024 machine
= bfd_mach_i960_ka_sa
;
2027 machine
= bfd_mach_i960_jx
;
2030 machine
= bfd_mach_i960_hx
;
2049 if (xcoff_data (abfd
)->cputype
!= -1)
2050 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
2053 /* We did not get a value from the a.out header. If the
2054 file has not been stripped, we may be able to get the
2055 architecture information from the first symbol, if it
2056 is a .file symbol. */
2057 if (obj_raw_syment_count (abfd
) == 0)
2062 struct internal_syment sym
;
2063 bfd_size_type amt
= bfd_coff_symesz (abfd
);
2065 buf
= bfd_malloc (amt
);
2066 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
2067 || bfd_bread (buf
, amt
, abfd
) != amt
)
2072 bfd_coff_swap_sym_in (abfd
, buf
, & sym
);
2073 if (sym
.n_sclass
== C_FILE
)
2074 cputype
= sym
.n_type
& 0xff;
2081 /* FIXME: We don't handle all cases here. */
2086 arch
= bfd_xcoff_architecture (abfd
);
2087 machine
= bfd_xcoff_machine (abfd
);
2091 arch
= bfd_arch_powerpc
;
2092 machine
= bfd_mach_ppc_601
;
2094 case 2: /* 64 bit PowerPC */
2095 arch
= bfd_arch_powerpc
;
2096 machine
= bfd_mach_ppc_620
;
2099 arch
= bfd_arch_powerpc
;
2100 machine
= bfd_mach_ppc
;
2103 arch
= bfd_arch_rs6000
;
2104 machine
= bfd_mach_rs6k
;
2113 arch
= bfd_arch_we32k
;
2119 arch
= bfd_arch_h8300
;
2120 machine
= bfd_mach_h8300
;
2121 /* !! FIXME this probably isn't the right place for this. */
2122 abfd
->flags
|= BFD_IS_RELAXABLE
;
2128 arch
= bfd_arch_h8300
;
2129 machine
= bfd_mach_h8300h
;
2130 /* !! FIXME this probably isn't the right place for this. */
2131 abfd
->flags
|= BFD_IS_RELAXABLE
;
2137 arch
= bfd_arch_h8300
;
2138 machine
= bfd_mach_h8300s
;
2139 /* !! FIXME this probably isn't the right place for this. */
2140 abfd
->flags
|= BFD_IS_RELAXABLE
;
2146 arch
= bfd_arch_h8300
;
2147 machine
= bfd_mach_h8300hn
;
2148 /* !! FIXME this probably isn't the right place for this. */
2149 abfd
->flags
|= BFD_IS_RELAXABLE
;
2155 arch
= bfd_arch_h8300
;
2156 machine
= bfd_mach_h8300sn
;
2157 /* !! FIXME this probably isn't the right place for this. */
2158 abfd
->flags
|= BFD_IS_RELAXABLE
;
2162 #ifdef SH_ARCH_MAGIC_BIG
2163 case SH_ARCH_MAGIC_BIG
:
2164 case SH_ARCH_MAGIC_LITTLE
:
2166 case SH_ARCH_MAGIC_WINCE
:
2172 #ifdef MIPS_ARCH_MAGIC_WINCE
2173 case MIPS_ARCH_MAGIC_WINCE
:
2174 arch
= bfd_arch_mips
;
2180 arch
= bfd_arch_h8500
;
2186 #ifdef LYNXCOFFMAGIC
2189 arch
= bfd_arch_sparc
;
2195 arch
= bfd_arch_tic30
;
2200 #ifdef TICOFF_TARGET_ARCH
2201 /* This TI COFF section should be used by all new TI COFF v0 targets. */
2203 arch
= TICOFF_TARGET_ARCH
;
2204 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2210 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */
2211 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */
2214 switch (internal_f
->f_target_id
)
2218 arch
= TICOFF_TARGET_ARCH
;
2219 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2223 arch
= bfd_arch_obscure
;
2224 (*_bfd_error_handler
)
2225 (_("Unrecognized TI COFF target id '0x%x'"),
2226 internal_f
->f_target_id
);
2232 #ifdef TIC80_ARCH_MAGIC
2233 case TIC80_ARCH_MAGIC
:
2234 arch
= bfd_arch_tic80
;
2240 arch
= bfd_arch_mcore
;
2246 arch
= bfd_arch_w65
;
2250 default: /* Unreadable input file type. */
2251 arch
= bfd_arch_obscure
;
2255 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2259 #ifdef SYMNAME_IN_DEBUG
2262 symname_in_debug_hook (bfd
* abfd ATTRIBUTE_UNUSED
, struct internal_syment
*sym
)
2264 return SYMNAME_IN_DEBUG (sym
) != 0;
2269 #define symname_in_debug_hook \
2270 (bfd_boolean (*) (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. */
2283 coff_pointerize_aux_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2284 combined_entry_type
*table_base
,
2285 combined_entry_type
*symbol
,
2286 unsigned int indaux
,
2287 combined_entry_type
*aux
)
2289 int class = symbol
->u
.syment
.n_sclass
;
2291 if ((class == C_EXT
|| class == C_HIDEXT
)
2292 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2294 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2296 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2297 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2298 aux
->fix_scnlen
= 1;
2301 /* Return TRUE to indicate that the caller should not do any
2302 further work on this auxent. */
2306 /* Return FALSE to indicate that this auxent should be handled by
2314 /* We don't want to pointerize bal entries. */
2317 coff_pointerize_aux_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2318 combined_entry_type
*table_base ATTRIBUTE_UNUSED
,
2319 combined_entry_type
*symbol
,
2320 unsigned int indaux
,
2321 combined_entry_type
*aux ATTRIBUTE_UNUSED
)
2323 /* Return TRUE if we don't want to pointerize this aux entry, which
2324 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2326 && (symbol
->u
.syment
.n_sclass
== C_LEAFPROC
2327 || symbol
->u
.syment
.n_sclass
== C_LEAFSTAT
2328 || symbol
->u
.syment
.n_sclass
== C_LEAFEXT
));
2333 #define coff_pointerize_aux_hook 0
2336 #endif /* ! RS6000COFF_C */
2338 /* Print an aux entry. This returns TRUE if it has printed it. */
2341 coff_print_aux (bfd
*abfd ATTRIBUTE_UNUSED
,
2342 FILE *file ATTRIBUTE_UNUSED
,
2343 combined_entry_type
*table_base ATTRIBUTE_UNUSED
,
2344 combined_entry_type
*symbol ATTRIBUTE_UNUSED
,
2345 combined_entry_type
*aux ATTRIBUTE_UNUSED
,
2346 unsigned int indaux ATTRIBUTE_UNUSED
)
2349 if ((symbol
->u
.syment
.n_sclass
== C_EXT
2350 || symbol
->u
.syment
.n_sclass
== C_HIDEXT
)
2351 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2353 /* This is a csect entry. */
2354 fprintf (file
, "AUX ");
2355 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2357 BFD_ASSERT (! aux
->fix_scnlen
);
2359 fprintf (file
, "val %5lld",
2360 (long long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2362 fprintf (file
, "val %5ld", (long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2367 fprintf (file
, "indx ");
2368 if (! aux
->fix_scnlen
)
2370 fprintf (file
, "%4lld",
2371 (long long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2373 fprintf (file
, "%4ld", (long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2376 fprintf (file
, "%4ld",
2377 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2380 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2381 aux
->u
.auxent
.x_csect
.x_parmhash
,
2382 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2383 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2384 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2385 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2386 aux
->u
.auxent
.x_csect
.x_stab
,
2387 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2392 /* Return FALSE to indicate that no special action was taken. */
2400 To write relocations, the back end steps though the
2401 canonical relocation table and create an
2402 @code{internal_reloc}. The symbol index to use is removed from
2403 the @code{offset} field in the symbol table supplied. The
2404 address comes directly from the sum of the section base
2405 address and the relocation offset; the type is dug directly
2406 from the howto field. Then the @code{internal_reloc} is
2407 swapped into the shape of an @code{external_reloc} and written
2415 /* AUX's ld wants relocations to be sorted. */
2417 compare_arelent_ptr (const void * x
, const void * y
)
2419 const arelent
**a
= (const arelent
**) x
;
2420 const arelent
**b
= (const arelent
**) y
;
2421 bfd_size_type aadr
= (*a
)->address
;
2422 bfd_size_type badr
= (*b
)->address
;
2424 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2427 #endif /* TARG_AUX */
2430 coff_write_relocs (bfd
* abfd
, int first_undef
)
2434 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2437 struct external_reloc dst
;
2444 /* Sort relocations before we write them out. */
2447 amt
= s
->reloc_count
;
2448 amt
*= sizeof (arelent
*);
2449 p
= bfd_malloc (amt
);
2450 if (p
== NULL
&& s
->reloc_count
> 0)
2452 memcpy (p
, s
->orelocation
, (size_t) amt
);
2453 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2457 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2461 if (obj_pe (abfd
) && s
->reloc_count
>= 0xffff)
2463 /* Encode real count here as first reloc. */
2464 struct internal_reloc n
;
2466 memset (& n
, 0, sizeof (n
));
2467 /* Add one to count *this* reloc (grr). */
2468 n
.r_vaddr
= s
->reloc_count
+ 1;
2469 coff_swap_reloc_out (abfd
, &n
, &dst
);
2470 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2471 abfd
) != bfd_coff_relsz (abfd
))
2476 for (i
= 0; i
< s
->reloc_count
; i
++)
2478 struct internal_reloc n
;
2481 memset (& n
, 0, sizeof (n
));
2483 /* Now we've renumbered the symbols we know where the
2484 undefined symbols live in the table. Check the reloc
2485 entries for symbols who's output bfd isn't the right one.
2486 This is because the symbol was undefined (which means
2487 that all the pointers are never made to point to the same
2488 place). This is a bad thing,'cause the symbols attached
2489 to the output bfd are indexed, so that the relocation
2490 entries know which symbol index they point to. So we
2491 have to look up the output symbol here. */
2493 if (q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2496 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2497 asymbol
**outsyms
= abfd
->outsymbols
;
2499 for (j
= first_undef
; outsyms
[j
]; j
++)
2501 const char *intable
= outsyms
[j
]->name
;
2503 if (strcmp (intable
, sname
) == 0)
2505 /* Got a hit, so repoint the reloc. */
2506 q
->sym_ptr_ptr
= outsyms
+ j
;
2512 n
.r_vaddr
= q
->address
+ s
->vma
;
2515 /* The 29k const/consth reloc pair is a real kludge. The consth
2516 part doesn't have a symbol; it has an offset. So rebuilt
2518 if (q
->howto
->type
== R_IHCONST
)
2519 n
.r_symndx
= q
->addend
;
2524 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2525 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
, s
))
2527 if ((*q
->sym_ptr_ptr
)->section
== bfd_abs_section_ptr
2528 && ((*q
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) != 0)
2530 /* This is a relocation relative to the absolute symbol. */
2534 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2535 /* Take notice if the symbol reloc points to a symbol
2536 we don't have in our symbol table. What should we
2538 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2543 #ifdef SWAP_OUT_RELOC_OFFSET
2544 n
.r_offset
= q
->addend
;
2548 /* Work out reloc type from what is required. */
2549 SELECT_RELOC (n
, q
->howto
);
2551 n
.r_type
= q
->howto
->type
;
2553 coff_swap_reloc_out (abfd
, &n
, &dst
);
2555 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2556 abfd
) != bfd_coff_relsz (abfd
))
2569 /* Set flags and magic number of a coff file from architecture and machine
2570 type. Result is TRUE if we can represent the arch&type, FALSE if not. */
2573 coff_set_flags (bfd
* abfd
,
2574 unsigned int *magicp ATTRIBUTE_UNUSED
,
2575 unsigned short *flagsp ATTRIBUTE_UNUSED
)
2577 switch (bfd_get_arch (abfd
))
2582 switch (bfd_get_mach (abfd
))
2585 case bfd_mach_z80strict
:
2587 case bfd_mach_z80full
:
2589 *flagsp
= bfd_get_mach (abfd
) << 12;
2601 switch (bfd_get_mach (abfd
))
2603 case bfd_mach_z8001
: *flagsp
= F_Z8001
; break;
2604 case bfd_mach_z8002
: *flagsp
= F_Z8002
; break;
2605 default: return FALSE
;
2616 *magicp
= I960ROMAGIC
;
2618 switch (bfd_get_mach (abfd
))
2620 case bfd_mach_i960_core
: flags
= F_I960CORE
; break;
2621 case bfd_mach_i960_kb_sb
: flags
= F_I960KB
; break;
2622 case bfd_mach_i960_mc
: flags
= F_I960MC
; break;
2623 case bfd_mach_i960_xa
: flags
= F_I960XA
; break;
2624 case bfd_mach_i960_ca
: flags
= F_I960CA
; break;
2625 case bfd_mach_i960_ka_sa
: flags
= F_I960KA
; break;
2626 case bfd_mach_i960_jx
: flags
= F_I960JX
; break;
2627 case bfd_mach_i960_hx
: flags
= F_I960HX
; break;
2628 default: return FALSE
;
2637 case bfd_arch_tic30
:
2638 *magicp
= TIC30MAGIC
;
2642 #ifdef TICOFF_DEFAULT_MAGIC
2643 case TICOFF_TARGET_ARCH
:
2644 /* If there's no indication of which version we want, use the default. */
2646 *magicp
= TICOFF_DEFAULT_MAGIC
;
2649 /* We may want to output in a different COFF version. */
2650 switch (abfd
->xvec
->name
[4])
2653 *magicp
= TICOFF0MAGIC
;
2656 *magicp
= TICOFF1MAGIC
;
2659 *magicp
= TICOFF2MAGIC
;
2665 TICOFF_TARGET_MACHINE_SET (flagsp
, bfd_get_mach (abfd
));
2669 #ifdef TIC80_ARCH_MAGIC
2670 case bfd_arch_tic80
:
2671 *magicp
= TIC80_ARCH_MAGIC
;
2678 * magicp
= ARMPEMAGIC
;
2680 * magicp
= ARMMAGIC
;
2683 if (APCS_SET (abfd
))
2685 if (APCS_26_FLAG (abfd
))
2686 * flagsp
|= F_APCS26
;
2688 if (APCS_FLOAT_FLAG (abfd
))
2689 * flagsp
|= F_APCS_FLOAT
;
2691 if (PIC_FLAG (abfd
))
2694 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2695 * flagsp
|= F_INTERWORK
;
2696 switch (bfd_get_mach (abfd
))
2698 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2699 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2700 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2701 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2702 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2703 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2704 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2705 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2706 See also the comment in coff_set_arch_mach_hook(). */
2707 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break;
2708 case bfd_mach_arm_5TE
: * flagsp
|= F_ARM_5
; break;
2709 case bfd_mach_arm_XScale
: * flagsp
|= F_ARM_5
; break;
2715 case bfd_arch_powerpc
:
2722 *magicp
= I386MAGIC
;
2724 /* Just overwrite the usual value if we're doing Lynx. */
2725 *magicp
= LYNXCOFFMAGIC
;
2732 *magicp
= I860MAGIC
;
2738 *magicp
= IA64MAGIC
;
2744 #ifdef APOLLOM68KMAGIC
2745 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
2747 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2748 #ifdef NAMES_HAVE_UNDERSCORE
2749 *magicp
= MC68KBCSMAGIC
;
2751 *magicp
= MC68MAGIC
;
2755 /* Just overwrite the usual value if we're doing Lynx. */
2756 *magicp
= LYNXCOFFMAGIC
;
2763 *magicp
= MC88OMAGIC
;
2768 case bfd_arch_h8300
:
2769 switch (bfd_get_mach (abfd
))
2771 case bfd_mach_h8300
: *magicp
= H8300MAGIC
; return TRUE
;
2772 case bfd_mach_h8300h
: *magicp
= H8300HMAGIC
; return TRUE
;
2773 case bfd_mach_h8300s
: *magicp
= H8300SMAGIC
; return TRUE
;
2774 case bfd_mach_h8300hn
: *magicp
= H8300HNMAGIC
; return TRUE
;
2775 case bfd_mach_h8300sn
: *magicp
= H8300SNMAGIC
; return TRUE
;
2781 #ifdef SH_ARCH_MAGIC_BIG
2783 #ifdef COFF_IMAGE_WITH_PE
2784 *magicp
= SH_ARCH_MAGIC_WINCE
;
2786 if (bfd_big_endian (abfd
))
2787 *magicp
= SH_ARCH_MAGIC_BIG
;
2789 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2794 #ifdef MIPS_ARCH_MAGIC_WINCE
2796 *magicp
= MIPS_ARCH_MAGIC_WINCE
;
2801 case bfd_arch_sparc
:
2802 *magicp
= SPARCMAGIC
;
2804 /* Just overwrite the usual value if we're doing Lynx. */
2805 *magicp
= LYNXCOFFMAGIC
;
2811 case bfd_arch_h8500
:
2812 *magicp
= H8500MAGIC
;
2818 case bfd_arch_we32k
:
2819 *magicp
= WE32KMAGIC
;
2824 case bfd_arch_rs6000
:
2826 case bfd_arch_powerpc
:
2828 BFD_ASSERT (bfd_get_flavour (abfd
) == bfd_target_xcoff_flavour
);
2829 *magicp
= bfd_xcoff_magic_number (abfd
);
2834 case bfd_arch_mcore
:
2835 * magicp
= MCOREMAGIC
;
2845 #ifdef OR32_MAGIC_BIG
2847 if (bfd_big_endian (abfd
))
2848 * magicp
= OR32_MAGIC_BIG
;
2850 * magicp
= OR32_MAGIC_LITTLE
;
2856 * magicp
= MAXQ20MAGIC
;
2857 switch (bfd_get_mach (abfd
))
2859 case bfd_mach_maxq10
: * flagsp
= F_MAXQ10
; return TRUE
;
2860 case bfd_mach_maxq20
: * flagsp
= F_MAXQ20
; return TRUE
;
2861 default: return FALSE
;
2865 default: /* Unknown architecture. */
2866 /* Fall through to "return FALSE" below, to avoid
2867 "statement never reached" errors on the one below. */
2875 coff_set_arch_mach (bfd
* abfd
,
2876 enum bfd_architecture arch
,
2877 unsigned long machine
)
2880 unsigned short dummy2
;
2882 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
2885 if (arch
!= bfd_arch_unknown
2886 && ! coff_set_flags (abfd
, &dummy1
, &dummy2
))
2887 return FALSE
; /* We can't represent this type. */
2889 return TRUE
; /* We're easy... */
2892 #ifdef COFF_IMAGE_WITH_PE
2894 /* This is used to sort sections by VMA, as required by PE image
2898 sort_by_secaddr (const void * arg1
, const void * arg2
)
2900 const asection
*a
= *(const asection
**) arg1
;
2901 const asection
*b
= *(const asection
**) arg2
;
2903 if (a
->vma
< b
->vma
)
2905 else if (a
->vma
> b
->vma
)
2911 #endif /* COFF_IMAGE_WITH_PE */
2913 /* Calculate the file position for each section. */
2916 #define ALIGN_SECTIONS_IN_FILE
2918 #if defined(TIC80COFF) || defined(TICOFF)
2919 #undef ALIGN_SECTIONS_IN_FILE
2923 coff_compute_section_file_positions (bfd
* abfd
)
2926 asection
*previous
= NULL
;
2927 file_ptr sofar
= bfd_coff_filhsz (abfd
);
2928 bfd_boolean align_adjust
;
2929 #ifdef ALIGN_SECTIONS_IN_FILE
2934 /* On XCOFF, if we have symbols, set up the .debug section. */
2935 if (bfd_get_symcount (abfd
) > 0)
2938 bfd_size_type i
, symcount
;
2942 symcount
= bfd_get_symcount (abfd
);
2943 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
2945 coff_symbol_type
*cf
;
2947 cf
= coff_symbol_from (abfd
, *symp
);
2949 && cf
->native
!= NULL
2950 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
2954 len
= strlen (bfd_asymbol_name (*symp
));
2955 if (len
> SYMNMLEN
|| bfd_coff_force_symnames_in_strings (abfd
))
2956 sz
+= len
+ 1 + bfd_coff_debug_string_prefix_length (abfd
);
2963 dsec
= bfd_make_section_old_way (abfd
, DOT_DEBUG
);
2967 dsec
->flags
|= SEC_HAS_CONTENTS
;
2972 #ifdef COFF_IMAGE_WITH_PE
2975 if (coff_data (abfd
)->link_info
)
2977 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
2979 /* If no file alignment has been set, default to one.
2980 This repairs 'ld -r' for arm-wince-pe target. */
2985 page_size
= PE_DEF_FILE_ALIGNMENT
;
2987 #ifdef COFF_PAGE_SIZE
2988 int page_size
= COFF_PAGE_SIZE
;
2992 if (bfd_get_start_address (abfd
))
2993 /* A start address may have been added to the original file. In this
2994 case it will need an optional header to record it. */
2995 abfd
->flags
|= EXEC_P
;
2997 if (abfd
->flags
& EXEC_P
)
2998 sofar
+= bfd_coff_aoutsz (abfd
);
3000 else if (xcoff_data (abfd
)->full_aouthdr
)
3001 sofar
+= bfd_coff_aoutsz (abfd
);
3003 sofar
+= SMALL_AOUTSZ
;
3006 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
3009 /* XCOFF handles overflows in the reloc and line number count fields
3010 by allocating a new section header to hold the correct counts. */
3011 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3012 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3013 sofar
+= bfd_coff_scnhsz (abfd
);
3016 #ifdef COFF_IMAGE_WITH_PE
3018 /* PE requires the sections to be in memory order when listed in
3019 the section headers. It also does not like empty loadable
3020 sections. The sections apparently do not have to be in the
3021 right order in the image file itself, but we do need to get the
3022 target_index values right. */
3025 asection
**section_list
;
3031 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3034 /* We allocate an extra cell to simplify the final loop. */
3035 amt
= sizeof (struct asection
*) * (count
+ 1);
3036 section_list
= bfd_malloc (amt
);
3037 if (section_list
== NULL
)
3041 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3043 section_list
[i
] = current
;
3046 section_list
[i
] = NULL
;
3048 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
3050 /* Rethread the linked list into sorted order; at the same time,
3051 assign target_index values. */
3053 abfd
->sections
= NULL
;
3054 abfd
->section_last
= NULL
;
3055 for (i
= 0; i
< count
; i
++)
3057 current
= section_list
[i
];
3058 bfd_section_list_append (abfd
, current
);
3060 /* Later, if the section has zero size, we'll be throwing it
3061 away, so we don't want to number it now. Note that having
3062 a zero size and having real contents are different
3063 concepts: .bss has no contents, but (usually) non-zero
3065 if (current
->size
== 0)
3067 /* Discard. However, it still might have (valid) symbols
3068 in it, so arbitrarily set it to section 1 (indexing is
3069 1-based here; usually .text). __end__ and other
3070 contents of .endsection really have this happen.
3071 FIXME: This seems somewhat dubious. */
3072 current
->target_index
= 1;
3075 current
->target_index
= target_index
++;
3078 free (section_list
);
3080 #else /* ! COFF_IMAGE_WITH_PE */
3082 /* Set the target_index field. */
3086 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3087 current
->target_index
= target_index
++;
3089 #endif /* ! COFF_IMAGE_WITH_PE */
3091 align_adjust
= FALSE
;
3092 for (current
= abfd
->sections
;
3094 current
= current
->next
)
3096 #ifdef COFF_IMAGE_WITH_PE
3097 /* With PE we have to pad each section to be a multiple of its
3098 page size too, and remember both sizes. */
3099 if (coff_section_data (abfd
, current
) == NULL
)
3101 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
3103 current
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
3104 if (current
->used_by_bfd
== NULL
)
3107 if (pei_section_data (abfd
, current
) == NULL
)
3109 bfd_size_type amt
= sizeof (struct pei_section_tdata
);
3111 coff_section_data (abfd
, current
)->tdata
= bfd_zalloc (abfd
, amt
);
3112 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
3115 if (pei_section_data (abfd
, current
)->virt_size
== 0)
3116 pei_section_data (abfd
, current
)->virt_size
= current
->size
;
3119 /* Only deal with sections which have contents. */
3120 if (!(current
->flags
& SEC_HAS_CONTENTS
))
3123 #ifdef COFF_IMAGE_WITH_PE
3124 /* Make sure we skip empty sections in a PE image. */
3125 if (current
->size
== 0)
3129 /* Align the sections in the file to the same boundary on
3130 which they are aligned in virtual memory. I960 doesn't
3131 do this (FIXME) so we can stay in sync with Intel. 960
3132 doesn't yet page from files... */
3133 #ifdef ALIGN_SECTIONS_IN_FILE
3134 if ((abfd
->flags
& EXEC_P
) != 0)
3136 /* Make sure this section is aligned on the right boundary - by
3137 padding the previous section up if necessary. */
3141 /* AIX loader checks the text section alignment of (vma - filepos)
3142 So even though the filepos may be aligned wrt the o_algntext, for
3143 AIX executables, this check fails. This shows up when a native
3144 AIX executable is stripped with gnu strip because the default vma
3145 of native is 0x10000150 but default for gnu is 0x10000140. Gnu
3146 stripped gnu excutable passes this check because the filepos is
3147 0x0140. This problem also show up with 64 bit shared objects. The
3148 data section must also be aligned. */
3149 if (!strcmp (current
->name
, _TEXT
)
3150 || !strcmp (current
->name
, _DATA
))
3155 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3157 align
= 1 << current
->alignment_power
;
3158 pad
= abs (current
->vma
- sofar
) % align
;
3169 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3172 if (previous
!= NULL
)
3173 previous
->size
+= sofar
- old_sofar
;
3178 /* In demand paged files the low order bits of the file offset
3179 must match the low order bits of the virtual address. */
3180 #ifdef COFF_PAGE_SIZE
3181 if ((abfd
->flags
& D_PAGED
) != 0
3182 && (current
->flags
& SEC_ALLOC
) != 0)
3183 sofar
+= (current
->vma
- (bfd_vma
) sofar
) % page_size
;
3185 current
->filepos
= sofar
;
3187 #ifdef COFF_IMAGE_WITH_PE
3188 /* Set the padded size. */
3189 current
->size
= (current
->size
+ page_size
-1) & -page_size
;
3192 sofar
+= current
->size
;
3194 #ifdef ALIGN_SECTIONS_IN_FILE
3195 /* Make sure that this section is of the right size too. */
3196 if ((abfd
->flags
& EXEC_P
) == 0)
3198 bfd_size_type old_size
;
3200 old_size
= current
->size
;
3201 current
->size
= BFD_ALIGN (current
->size
,
3202 1 << current
->alignment_power
);
3203 align_adjust
= current
->size
!= old_size
;
3204 sofar
+= current
->size
- old_size
;
3209 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3210 align_adjust
= sofar
!= old_sofar
;
3211 current
->size
+= sofar
- old_sofar
;
3215 #ifdef COFF_IMAGE_WITH_PE
3216 /* For PE we need to make sure we pad out to the aligned
3217 size, in case the caller only writes out data to the
3219 if (pei_section_data (abfd
, current
)->virt_size
< current
->size
)
3220 align_adjust
= TRUE
;
3224 /* Force .lib sections to start at zero. The vma is then
3225 incremented in coff_set_section_contents. This is right for
3227 if (strcmp (current
->name
, _LIB
) == 0)
3228 bfd_set_section_vma (abfd
, current
, 0);
3234 /* It is now safe to write to the output file. If we needed an
3235 alignment adjustment for the last section, then make sure that
3236 there is a byte at offset sofar. If there are no symbols and no
3237 relocs, then nothing follows the last section. If we don't force
3238 the last byte out, then the file may appear to be truncated. */
3244 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
3245 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3249 /* Make sure the relocations are aligned. We don't need to make
3250 sure that this byte exists, because it will only matter if there
3251 really are relocs. */
3252 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
3254 obj_relocbase (abfd
) = sofar
;
3255 abfd
->output_has_begun
= TRUE
;
3260 #ifdef COFF_IMAGE_WITH_PE
3262 static unsigned int pelength
;
3263 static unsigned int peheader
;
3266 coff_read_word (bfd
*abfd
, unsigned int *value
)
3271 status
= bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3279 *value
= (unsigned int) b
[0];
3281 *value
= (unsigned int) (b
[0] + (b
[1] << 8));
3283 pelength
+= (unsigned int) status
;
3289 coff_compute_checksum (bfd
*abfd
)
3291 bfd_boolean more_data
;
3298 filepos
= (file_ptr
) 0;
3302 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
3305 more_data
= coff_read_word (abfd
, &value
);
3307 total
= 0xffff & (total
+ (total
>> 0x10));
3312 return (0xffff & (total
+ (total
>> 0x10)));
3316 coff_apply_checksum (bfd
*abfd
)
3318 unsigned int computed
;
3319 unsigned int checksum
= 0;
3321 if (bfd_seek (abfd
, 0x3c, SEEK_SET
) != 0)
3324 if (!coff_read_word (abfd
, &peheader
))
3327 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3331 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3333 if (bfd_seek (abfd
, peheader
, SEEK_SET
) != 0)
3336 computed
= coff_compute_checksum (abfd
);
3338 checksum
= computed
+ pelength
;
3340 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3343 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3348 #endif /* COFF_IMAGE_WITH_PE */
3351 coff_write_object_contents (bfd
* abfd
)
3354 bfd_boolean hasrelocs
= FALSE
;
3355 bfd_boolean haslinno
= FALSE
;
3356 bfd_boolean hasdebug
= FALSE
;
3358 file_ptr reloc_base
;
3359 file_ptr lineno_base
;
3361 unsigned long reloc_size
= 0, reloc_count
= 0;
3362 unsigned long lnno_size
= 0;
3363 bfd_boolean long_section_names
;
3364 asection
*text_sec
= NULL
;
3365 asection
*data_sec
= NULL
;
3366 asection
*bss_sec
= NULL
;
3367 struct internal_filehdr internal_f
;
3368 struct internal_aouthdr internal_a
;
3369 #ifdef COFF_LONG_SECTION_NAMES
3370 size_t string_size
= STRING_SIZE_SIZE
;
3373 bfd_set_error (bfd_error_system_call
);
3375 /* Make a pass through the symbol table to count line number entries and
3376 put them into the correct asections. */
3377 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3379 if (! abfd
->output_has_begun
)
3381 if (! coff_compute_section_file_positions (abfd
))
3385 reloc_base
= obj_relocbase (abfd
);
3387 /* Work out the size of the reloc and linno areas. */
3389 for (current
= abfd
->sections
; current
!= NULL
; current
=
3393 /* We store the actual reloc count in the first reloc's addr. */
3394 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3397 reloc_count
+= current
->reloc_count
;
3400 reloc_size
= reloc_count
* bfd_coff_relsz (abfd
);
3402 lineno_base
= reloc_base
+ reloc_size
;
3403 sym_base
= lineno_base
+ lnno_size
;
3405 /* Indicate in each section->line_filepos its actual file address. */
3406 for (current
= abfd
->sections
; current
!= NULL
; current
=
3409 if (current
->lineno_count
)
3411 current
->line_filepos
= lineno_base
;
3412 current
->moving_line_filepos
= lineno_base
;
3413 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3416 current
->line_filepos
= 0;
3418 if (current
->reloc_count
)
3420 current
->rel_filepos
= reloc_base
;
3421 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3423 /* Extra reloc to hold real count. */
3424 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3425 reloc_base
+= bfd_coff_relsz (abfd
);
3429 current
->rel_filepos
= 0;
3432 /* Write section headers to the file. */
3433 internal_f
.f_nscns
= 0;
3435 if ((abfd
->flags
& EXEC_P
) != 0)
3436 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3439 scn_base
= bfd_coff_filhsz (abfd
);
3442 if (xcoff_data (abfd
)->full_aouthdr
)
3443 scn_base
+= bfd_coff_aoutsz (abfd
);
3445 scn_base
+= SMALL_AOUTSZ
;
3450 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3453 long_section_names
= FALSE
;
3454 for (current
= abfd
->sections
;
3456 current
= current
->next
)
3458 struct internal_scnhdr section
;
3459 bfd_boolean is_reloc_section
= FALSE
;
3461 #ifdef COFF_IMAGE_WITH_PE
3462 if (strcmp (current
->name
, ".reloc") == 0)
3464 is_reloc_section
= TRUE
;
3466 pe_data (abfd
)->has_reloc_section
= 1;
3470 internal_f
.f_nscns
++;
3472 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3474 #ifdef COFF_LONG_SECTION_NAMES
3475 /* Handle long section names as in PE. This must be compatible
3476 with the code in coff_write_symbols and _bfd_coff_final_link. */
3480 len
= strlen (current
->name
);
3483 memset (section
.s_name
, 0, SCNNMLEN
);
3484 sprintf (section
.s_name
, "/%lu", (unsigned long) string_size
);
3485 string_size
+= len
+ 1;
3486 long_section_names
= TRUE
;
3492 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3493 Ian Taylor <ian@cygnus.com>. */
3494 if (strcmp (current
->name
, _LIB
) == 0)
3495 section
.s_vaddr
= 0;
3498 section
.s_vaddr
= current
->vma
;
3499 section
.s_paddr
= current
->lma
;
3500 section
.s_size
= current
->size
;
3501 #ifdef coff_get_section_load_page
3502 section
.s_page
= coff_get_section_load_page (current
);
3506 section
.s_paddr
= 0;
3508 #ifdef COFF_IMAGE_WITH_PE
3509 /* Reminder: s_paddr holds the virtual size of the section. */
3510 if (coff_section_data (abfd
, current
) != NULL
3511 && pei_section_data (abfd
, current
) != NULL
)
3512 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3514 section
.s_paddr
= 0;
3517 /* If this section has no size or is unloadable then the scnptr
3519 if (current
->size
== 0
3520 || (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3521 section
.s_scnptr
= 0;
3523 section
.s_scnptr
= current
->filepos
;
3525 section
.s_relptr
= current
->rel_filepos
;
3526 section
.s_lnnoptr
= current
->line_filepos
;
3527 section
.s_nreloc
= current
->reloc_count
;
3528 section
.s_nlnno
= current
->lineno_count
;
3529 #ifndef COFF_IMAGE_WITH_PE
3530 /* In PEI, relocs come in the .reloc section. */
3531 if (current
->reloc_count
!= 0)
3534 if (current
->lineno_count
!= 0)
3536 if ((current
->flags
& SEC_DEBUGGING
) != 0
3537 && ! is_reloc_section
)
3542 /* Indicate the use of an XCOFF overflow section header. */
3543 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3545 section
.s_nreloc
= 0xffff;
3546 section
.s_nlnno
= 0xffff;
3551 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3553 if (!strcmp (current
->name
, _TEXT
))
3555 else if (!strcmp (current
->name
, _DATA
))
3557 else if (!strcmp (current
->name
, _BSS
))
3561 section
.s_align
= (current
->alignment_power
3562 ? 1 << current
->alignment_power
3566 /* TI COFF puts the alignment power in bits 8-11 of the flags. */
3567 section
.s_flags
|= (current
->alignment_power
& 0xF) << 8;
3569 #ifdef COFF_ENCODE_ALIGNMENT
3570 COFF_ENCODE_ALIGNMENT(section
, current
->alignment_power
);
3573 #ifdef COFF_IMAGE_WITH_PE
3574 /* Suppress output of the sections if they are null. ld
3575 includes the bss and data sections even if there is no size
3576 assigned to them. NT loader doesn't like it if these section
3577 headers are included if the sections themselves are not
3578 needed. See also coff_compute_section_file_positions. */
3579 if (section
.s_size
== 0)
3580 internal_f
.f_nscns
--;
3585 bfd_size_type amt
= bfd_coff_scnhsz (abfd
);
3587 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3588 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3593 /* PE stores COMDAT section information in the symbol table. If
3594 this section is supposed to have some COMDAT info, track down
3595 the symbol in the symbol table and modify it. */
3596 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3598 unsigned int i
, count
;
3600 coff_symbol_type
*csym
= NULL
;
3604 count
= bfd_get_symcount (abfd
);
3605 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3607 if ((*psym
)->section
!= current
)
3610 /* Remember the location of the first symbol in this
3612 if (psymsec
== NULL
)
3615 /* See if this is the section symbol. */
3616 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3618 csym
= coff_symbol_from (abfd
, *psym
);
3620 || csym
->native
== NULL
3621 || csym
->native
->u
.syment
.n_numaux
< 1
3622 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3623 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3626 /* Here *PSYM is the section symbol for CURRENT. */
3633 Note that we might not if we're converting the file from
3634 some other object file format. */
3637 combined_entry_type
*aux
;
3639 /* We don't touch the x_checksum field. The
3640 x_associated field is not currently supported. */
3642 aux
= csym
->native
+ 1;
3643 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3645 case SEC_LINK_DUPLICATES_DISCARD
:
3646 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3649 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3650 aux
->u
.auxent
.x_scn
.x_comdat
=
3651 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3654 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3655 aux
->u
.auxent
.x_scn
.x_comdat
=
3656 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3659 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3660 aux
->u
.auxent
.x_scn
.x_comdat
=
3661 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3665 /* The COMDAT symbol must be the first symbol from this
3666 section in the symbol table. In order to make this
3667 work, we move the COMDAT symbol before the first
3668 symbol we found in the search above. It's OK to
3669 rearrange the symbol table at this point, because
3670 coff_renumber_symbols is going to rearrange it
3671 further and fix up all the aux entries. */
3672 if (psym
!= psymsec
)
3678 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3679 pcopy
[0] = pcopy
[-1];
3684 #endif /* COFF_WITH_PE */
3689 /* XCOFF handles overflows in the reloc and line number count fields
3690 by creating a new section header to hold the correct values. */
3691 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3693 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3695 struct internal_scnhdr scnhdr
;
3699 internal_f
.f_nscns
++;
3700 strncpy (&(scnhdr
.s_name
[0]), current
->name
, 8);
3701 scnhdr
.s_paddr
= current
->reloc_count
;
3702 scnhdr
.s_vaddr
= current
->lineno_count
;
3704 scnhdr
.s_scnptr
= 0;
3705 scnhdr
.s_relptr
= current
->rel_filepos
;
3706 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3707 scnhdr
.s_nreloc
= current
->target_index
;
3708 scnhdr
.s_nlnno
= current
->target_index
;
3709 scnhdr
.s_flags
= STYP_OVRFLO
;
3710 amt
= bfd_coff_scnhsz (abfd
);
3711 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3712 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3719 /* OK, now set up the filehdr... */
3721 /* Don't include the internal abs section in the section count */
3723 /* We will NOT put a fucking timestamp in the header here. Every time you
3724 put it back, I will come in and take it out again. I'm sorry. This
3725 field does not belong here. We fill it with a 0 so it compares the
3726 same but is not a reasonable time. -- gnu@cygnus.com */
3727 internal_f
.f_timdat
= 0;
3728 internal_f
.f_flags
= 0;
3730 if (abfd
->flags
& EXEC_P
)
3731 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3734 internal_f
.f_opthdr
= 0;
3737 if (xcoff_data (abfd
)->full_aouthdr
)
3738 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3740 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
3746 internal_f
.f_flags
|= F_RELFLG
;
3748 internal_f
.f_flags
|= F_LNNO
;
3749 if (abfd
->flags
& EXEC_P
)
3750 internal_f
.f_flags
|= F_EXEC
;
3751 #ifdef COFF_IMAGE_WITH_PE
3753 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
3754 if (pe_data (abfd
)->real_flags
& IMAGE_FILE_LARGE_ADDRESS_AWARE
)
3755 internal_f
.f_flags
|= IMAGE_FILE_LARGE_ADDRESS_AWARE
;
3759 internal_f
.f_flags
|= IMAGE_FILE_32BIT_MACHINE
;
3761 if (bfd_little_endian (abfd
))
3762 internal_f
.f_flags
|= F_AR32WR
;
3764 internal_f
.f_flags
|= F_AR32W
;
3768 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
3769 but it doesn't hurt to set it internally. */
3770 internal_f
.f_target_id
= TI_TARGET_ID
;
3772 #ifdef TIC80_TARGET_ID
3773 internal_f
.f_target_id
= TIC80_TARGET_ID
;
3776 /* FIXME, should do something about the other byte orders and
3780 if ((abfd
->flags
& DYNAMIC
) != 0)
3781 internal_f
.f_flags
|= F_SHROBJ
;
3782 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
3783 internal_f
.f_flags
|= F_DYNLOAD
;
3786 memset (&internal_a
, 0, sizeof internal_a
);
3788 /* Set up architecture-dependent stuff. */
3790 unsigned int magic
= 0;
3791 unsigned short flags
= 0;
3793 coff_set_flags (abfd
, &magic
, &flags
);
3794 internal_f
.f_magic
= magic
;
3795 internal_f
.f_flags
|= flags
;
3796 /* ...and the "opt"hdr... */
3798 #ifdef TICOFF_AOUT_MAGIC
3799 internal_a
.magic
= TICOFF_AOUT_MAGIC
;
3800 #define __A_MAGIC_SET__
3803 internal_a
.magic
= TIC80_ARCH_MAGIC
;
3804 #define __A_MAGIC_SET__
3807 /* FIXME: What are the a.out magic numbers for the i860? */
3808 internal_a
.magic
= 0;
3809 #define __A_MAGIC_SET__
3812 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
3813 #define __A_MAGIC_SET__
3816 #define __A_MAGIC_SET__
3817 internal_a
.magic
= PAGEMAGICBCS
;
3821 #define __A_MAGIC_SET__
3822 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
3825 #if defined(M68) || defined(WE32K) || defined(M68K)
3826 #define __A_MAGIC_SET__
3828 internal_a
.magic
= LYNXCOFFMAGIC
;
3830 #if defined(TARG_AUX)
3831 internal_a
.magic
= (abfd
->flags
& D_PAGED
? PAGEMAGICPEXECPAGED
:
3832 abfd
->flags
& WP_TEXT
? PAGEMAGICPEXECSWAPPED
:
3833 PAGEMAGICEXECSWAPPED
);
3835 #if defined (PAGEMAGICPEXECPAGED)
3836 internal_a
.magic
= PAGEMAGICPEXECPAGED
;
3838 #endif /* TARG_AUX */
3840 #endif /* M68 || WE32K || M68K */
3843 #define __A_MAGIC_SET__
3844 internal_a
.magic
= ZMAGIC
;
3848 #define __A_MAGIC_SET__
3849 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3852 #if defined MCORE_PE
3853 #define __A_MAGIC_SET__
3854 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3858 #define __A_MAGIC_SET__
3860 internal_a
.magic
= LYNXCOFFMAGIC
;
3862 internal_a
.magic
= ZMAGIC
;
3867 #define __A_MAGIC_SET__
3868 internal_a
.magic
= ZMAGIC
;
3872 #define __A_MAGIC_SET__
3874 internal_a
.magic
= LYNXCOFFMAGIC
;
3879 #define __A_MAGIC_SET__
3880 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
3881 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
3882 RS6K_AOUTHDR_OMAGIC
;
3885 #if defined(SH) && defined(COFF_WITH_PE)
3886 #define __A_MAGIC_SET__
3887 internal_a
.magic
= SH_PE_MAGIC
;
3890 #if defined(MIPS) && defined(COFF_WITH_PE)
3891 #define __A_MAGIC_SET__
3892 internal_a
.magic
= MIPS_PE_MAGIC
;
3896 #define __A_MAGIC_SET__
3897 internal_a
.magic
= NMAGIC
; /* Assume separate i/d. */
3901 #define __A_MAGIC_SET__
3902 internal_a
.magic
= MAXQ20MAGIC
;
3905 #ifndef __A_MAGIC_SET__
3906 #include "Your aouthdr magic number is not being set!"
3908 #undef __A_MAGIC_SET__
3912 /* FIXME: Does anybody ever set this to another value? */
3913 internal_a
.vstamp
= 0;
3915 /* Now should write relocs, strings, syms. */
3916 obj_sym_filepos (abfd
) = sym_base
;
3918 if (bfd_get_symcount (abfd
) != 0)
3922 if (!coff_renumber_symbols (abfd
, &firstundef
))
3924 coff_mangle_symbols (abfd
);
3925 if (! coff_write_symbols (abfd
))
3927 if (! coff_write_linenumbers (abfd
))
3929 if (! coff_write_relocs (abfd
, firstundef
))
3932 #ifdef COFF_LONG_SECTION_NAMES
3933 else if (long_section_names
&& ! obj_coff_strings_written (abfd
))
3935 /* If we have long section names we have to write out the string
3936 table even if there are no symbols. */
3937 if (! coff_write_symbols (abfd
))
3941 #ifdef COFF_IMAGE_WITH_PE
3943 else if ((abfd
->flags
& EXEC_P
) != 0)
3947 /* PowerPC PE appears to require that all executable files be
3948 rounded up to the page size. */
3951 (file_ptr
) BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
3953 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3959 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3960 backend linker, and obj_raw_syment_count is not valid until after
3961 coff_write_symbols is called. */
3962 if (obj_raw_syment_count (abfd
) != 0)
3964 internal_f
.f_symptr
= sym_base
;
3966 /* AIX appears to require that F_RELFLG not be set if there are
3967 local symbols but no relocations. */
3968 internal_f
.f_flags
&=~ F_RELFLG
;
3973 if (long_section_names
)
3974 internal_f
.f_symptr
= sym_base
;
3976 internal_f
.f_symptr
= 0;
3977 internal_f
.f_flags
|= F_LSYMS
;
3982 internal_a
.tsize
= text_sec
->size
;
3983 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
3987 internal_a
.dsize
= data_sec
->size
;
3988 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
3992 internal_a
.bsize
= bss_sec
->size
;
3993 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
3994 internal_a
.data_start
= bss_sec
->vma
;
3997 internal_a
.entry
= bfd_get_start_address (abfd
);
3998 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
4001 if (xcoff_data (abfd
)->full_aouthdr
)
4004 asection
*loader_sec
;
4006 internal_a
.vstamp
= 1;
4008 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
4009 if (internal_a
.o_snentry
== 0)
4010 internal_a
.entry
= (bfd_vma
) -1;
4012 if (text_sec
!= NULL
)
4014 internal_a
.o_sntext
= text_sec
->target_index
;
4015 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
4019 internal_a
.o_sntext
= 0;
4020 internal_a
.o_algntext
= 0;
4022 if (data_sec
!= NULL
)
4024 internal_a
.o_sndata
= data_sec
->target_index
;
4025 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
4029 internal_a
.o_sndata
= 0;
4030 internal_a
.o_algndata
= 0;
4032 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
4033 if (loader_sec
!= NULL
)
4034 internal_a
.o_snloader
= loader_sec
->target_index
;
4036 internal_a
.o_snloader
= 0;
4037 if (bss_sec
!= NULL
)
4038 internal_a
.o_snbss
= bss_sec
->target_index
;
4040 internal_a
.o_snbss
= 0;
4042 toc
= xcoff_data (abfd
)->toc
;
4043 internal_a
.o_toc
= toc
;
4044 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
4046 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
4047 if (xcoff_data (abfd
)->cputype
!= -1)
4048 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
4051 switch (bfd_get_arch (abfd
))
4053 case bfd_arch_rs6000
:
4054 internal_a
.o_cputype
= 4;
4056 case bfd_arch_powerpc
:
4057 if (bfd_get_mach (abfd
) == bfd_mach_ppc
)
4058 internal_a
.o_cputype
= 3;
4060 internal_a
.o_cputype
= 1;
4066 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
4067 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
4071 /* Now write them. */
4072 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
4077 bfd_size_type amount
= bfd_coff_filhsz (abfd
);
4079 buff
= bfd_malloc (amount
);
4083 bfd_coff_swap_filehdr_out (abfd
, & internal_f
, buff
);
4084 amount
= bfd_bwrite (buff
, amount
, abfd
);
4088 if (amount
!= bfd_coff_filhsz (abfd
))
4092 if (abfd
->flags
& EXEC_P
)
4094 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4095 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4097 bfd_size_type amount
= bfd_coff_aoutsz (abfd
);
4099 buff
= bfd_malloc (amount
);
4103 coff_swap_aouthdr_out (abfd
, & internal_a
, buff
);
4104 amount
= bfd_bwrite (buff
, amount
, abfd
);
4108 if (amount
!= bfd_coff_aoutsz (abfd
))
4111 #ifdef COFF_IMAGE_WITH_PE
4112 if (! coff_apply_checksum (abfd
))
4122 /* XCOFF seems to always write at least a small a.out header. */
4123 coff_swap_aouthdr_out (abfd
, & internal_a
, & buff
);
4124 if (xcoff_data (abfd
)->full_aouthdr
)
4125 size
= bfd_coff_aoutsz (abfd
);
4127 size
= SMALL_AOUTSZ
;
4128 if (bfd_bwrite (& buff
, (bfd_size_type
) size
, abfd
) != size
)
4137 coff_set_section_contents (bfd
* abfd
,
4139 const void * location
,
4141 bfd_size_type count
)
4143 if (! abfd
->output_has_begun
) /* Set by bfd.c handler. */
4145 if (! coff_compute_section_file_positions (abfd
))
4149 #if defined(_LIB) && !defined(TARG_AUX)
4150 /* The physical address field of a .lib section is used to hold the
4151 number of shared libraries in the section. This code counts the
4152 number of sections being written, and increments the lma field
4155 I have found no documentation on the contents of this section.
4156 Experimentation indicates that the section contains zero or more
4157 records, each of which has the following structure:
4159 - a (four byte) word holding the length of this record, in words,
4160 - a word that always seems to be set to "2",
4161 - the path to a shared library, null-terminated and then padded
4162 to a whole word boundary.
4164 bfd_assert calls have been added to alert if an attempt is made
4165 to write a section which doesn't follow these assumptions. The
4166 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4167 <robertl@arnet.com> (Thanks!).
4169 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4170 if (strcmp (section
->name
, _LIB
) == 0)
4172 bfd_byte
*rec
, *recend
;
4174 rec
= (bfd_byte
*) location
;
4175 recend
= rec
+ count
;
4176 while (rec
< recend
)
4179 rec
+= bfd_get_32 (abfd
, rec
) * 4;
4182 BFD_ASSERT (rec
== recend
);
4186 /* Don't write out bss sections - one way to do this is to
4187 see if the filepos has not been set. */
4188 if (section
->filepos
== 0)
4191 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0)
4197 return bfd_bwrite (location
, count
, abfd
) == count
;
4201 buy_and_read (bfd
*abfd
, file_ptr where
, bfd_size_type size
)
4203 void * area
= bfd_alloc (abfd
, size
);
4207 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0
4208 || bfd_bread (area
, size
, abfd
) != size
)
4217 Creating the linenumber table is done by reading in the entire
4218 coff linenumber table, and creating another table for internal use.
4220 A coff linenumber table is structured so that each function
4221 is marked as having a line number of 0. Each line within the
4222 function is an offset from the first line in the function. The
4223 base of the line number information for the table is stored in
4224 the symbol associated with the function.
4226 Note: The PE format uses line number 0 for a flag indicating a
4229 The information is copied from the external to the internal
4230 table, and each symbol which marks a function is marked by
4233 How does this work ?
4237 coff_slurp_line_table (bfd
*abfd
, asection
*asect
)
4239 LINENO
*native_lineno
;
4240 alent
*lineno_cache
;
4243 BFD_ASSERT (asect
->lineno
== NULL
);
4245 amt
= (bfd_size_type
) bfd_coff_linesz (abfd
) * asect
->lineno_count
;
4246 native_lineno
= (LINENO
*) buy_and_read (abfd
, asect
->line_filepos
, amt
);
4247 if (native_lineno
== NULL
)
4249 (*_bfd_error_handler
)
4250 (_("%B: warning: line number table read failed"), abfd
);
4253 amt
= ((bfd_size_type
) asect
->lineno_count
+ 1) * sizeof (alent
);
4254 lineno_cache
= bfd_alloc (abfd
, amt
);
4255 if (lineno_cache
== NULL
)
4259 unsigned int counter
= 0;
4260 alent
*cache_ptr
= lineno_cache
;
4261 LINENO
*src
= native_lineno
;
4263 while (counter
< asect
->lineno_count
)
4265 struct internal_lineno dst
;
4267 bfd_coff_swap_lineno_in (abfd
, src
, &dst
);
4268 cache_ptr
->line_number
= dst
.l_lnno
;
4270 if (cache_ptr
->line_number
== 0)
4273 bfd_signed_vma symndx
;
4274 coff_symbol_type
*sym
;
4277 symndx
= dst
.l_addr
.l_symndx
;
4279 || (bfd_vma
) symndx
>= obj_raw_syment_count (abfd
))
4281 (*_bfd_error_handler
)
4282 (_("%B: warning: illegal symbol index %ld in line numbers"),
4283 abfd
, dst
.l_addr
.l_symndx
);
4287 /* FIXME: We should not be casting between ints and
4288 pointers like this. */
4289 sym
= ((coff_symbol_type
*)
4290 ((symndx
+ obj_raw_syments (abfd
))
4291 ->u
.syment
._n
._n_n
._n_zeroes
));
4292 cache_ptr
->u
.sym
= (asymbol
*) sym
;
4293 if (sym
->lineno
!= NULL
&& ! warned
)
4295 (*_bfd_error_handler
)
4296 (_("%B: warning: duplicate line number information for `%s'"),
4297 abfd
, bfd_asymbol_name (&sym
->symbol
));
4299 sym
->lineno
= cache_ptr
;
4302 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
4303 - bfd_section_vma (abfd
, asect
);
4309 cache_ptr
->line_number
= 0;
4312 asect
->lineno
= lineno_cache
;
4313 /* FIXME, free native_lineno here, or use alloca or something. */
4317 /* Slurp in the symbol table, converting it to generic form. Note
4318 that if coff_relocate_section is defined, the linker will read
4319 symbols via coff_link_add_symbols, rather than via this routine. */
4322 coff_slurp_symbol_table (bfd
* abfd
)
4324 combined_entry_type
*native_symbols
;
4325 coff_symbol_type
*cached_area
;
4326 unsigned int *table_ptr
;
4328 unsigned int number_of_symbols
= 0;
4330 if (obj_symbols (abfd
))
4333 /* Read in the symbol table. */
4334 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4337 /* Allocate enough room for all the symbols in cached form. */
4338 amt
= obj_raw_syment_count (abfd
);
4339 amt
*= sizeof (coff_symbol_type
);
4340 cached_area
= bfd_alloc (abfd
, amt
);
4341 if (cached_area
== NULL
)
4344 amt
= obj_raw_syment_count (abfd
);
4345 amt
*= sizeof (unsigned int);
4346 table_ptr
= bfd_alloc (abfd
, amt
);
4348 if (table_ptr
== NULL
)
4352 coff_symbol_type
*dst
= cached_area
;
4353 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4354 unsigned int this_index
= 0;
4356 while (this_index
< last_native_index
)
4358 combined_entry_type
*src
= native_symbols
+ this_index
;
4359 table_ptr
[this_index
] = number_of_symbols
;
4360 dst
->symbol
.the_bfd
= abfd
;
4362 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4363 /* We use the native name field to point to the cached field. */
4364 src
->u
.syment
._n
._n_n
._n_zeroes
= (long) dst
;
4365 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4366 src
->u
.syment
.n_scnum
);
4367 dst
->symbol
.flags
= 0;
4368 dst
->done_lineno
= FALSE
;
4370 switch (src
->u
.syment
.n_sclass
)
4374 /* Fall through to next case. */
4381 case C_THUMBEXTFUNC
:
4387 case C_SYSTEM
: /* System Wide variable. */
4390 /* In PE, 0x68 (104) denotes a section symbol. */
4392 /* In PE, 0x69 (105) denotes a weak external symbol. */
4395 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4397 case COFF_SYMBOL_GLOBAL
:
4398 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4399 #if defined COFF_WITH_PE
4400 /* PE sets the symbol to a value relative to the
4401 start of the section. */
4402 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4404 dst
->symbol
.value
= (src
->u
.syment
.n_value
4405 - dst
->symbol
.section
->vma
);
4407 if (ISFCN ((src
->u
.syment
.n_type
)))
4408 /* A function ext does not go at the end of a
4410 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4413 case COFF_SYMBOL_COMMON
:
4414 dst
->symbol
.section
= bfd_com_section_ptr
;
4415 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4418 case COFF_SYMBOL_UNDEFINED
:
4419 dst
->symbol
.section
= bfd_und_section_ptr
;
4420 dst
->symbol
.value
= 0;
4423 case COFF_SYMBOL_PE_SECTION
:
4424 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4425 dst
->symbol
.value
= 0;
4428 case COFF_SYMBOL_LOCAL
:
4429 dst
->symbol
.flags
= BSF_LOCAL
;
4430 #if defined COFF_WITH_PE
4431 /* PE sets the symbol to a value relative to the
4432 start of the section. */
4433 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4435 dst
->symbol
.value
= (src
->u
.syment
.n_value
4436 - dst
->symbol
.section
->vma
);
4438 if (ISFCN ((src
->u
.syment
.n_type
)))
4439 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4444 /* A symbol with a csect entry should not go at the end. */
4445 if (src
->u
.syment
.n_numaux
> 0)
4446 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4450 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4451 dst
->symbol
.flags
|= BSF_WEAK
;
4453 if (src
->u
.syment
.n_sclass
== C_SECTION
4454 && src
->u
.syment
.n_scnum
> 0)
4455 dst
->symbol
.flags
= BSF_LOCAL
;
4457 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
)
4458 dst
->symbol
.flags
|= BSF_WEAK
;
4462 case C_STAT
: /* Static. */
4464 case C_LEAFSTAT
: /* Static leaf procedure. */
4467 case C_THUMBSTAT
: /* Thumb static. */
4468 case C_THUMBLABEL
: /* Thumb label. */
4469 case C_THUMBSTATFUNC
:/* Thumb static function. */
4471 case C_LABEL
: /* Label. */
4472 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4473 dst
->symbol
.flags
= BSF_DEBUGGING
;
4475 dst
->symbol
.flags
= BSF_LOCAL
;
4477 /* Base the value as an index from the base of the
4478 section, if there is one. */
4479 if (dst
->symbol
.section
)
4481 #if defined COFF_WITH_PE
4482 /* PE sets the symbol to a value relative to the
4483 start of the section. */
4484 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4486 dst
->symbol
.value
= (src
->u
.syment
.n_value
4487 - dst
->symbol
.section
->vma
);
4491 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4494 case C_MOS
: /* Member of structure. */
4495 case C_EOS
: /* End of structure. */
4496 case C_REGPARM
: /* Register parameter. */
4497 case C_REG
: /* register variable. */
4498 /* C_AUTOARG conflicts with TI COFF C_UEXT. */
4499 #if !defined (TIC80COFF) && !defined (TICOFF)
4501 case C_AUTOARG
: /* 960-specific storage class. */
4504 case C_TPDEF
: /* Type definition. */
4506 case C_AUTO
: /* Automatic variable. */
4507 case C_FIELD
: /* Bit field. */
4508 case C_ENTAG
: /* Enumeration tag. */
4509 case C_MOE
: /* Member of enumeration. */
4510 case C_MOU
: /* Member of union. */
4511 case C_UNTAG
: /* Union tag. */
4512 dst
->symbol
.flags
= BSF_DEBUGGING
;
4513 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4516 case C_FILE
: /* File name. */
4517 case C_STRTAG
: /* Structure tag. */
4534 dst
->symbol
.flags
= BSF_DEBUGGING
;
4535 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4539 case C_BINCL
: /* Beginning of include file. */
4540 case C_EINCL
: /* Ending of include file. */
4541 /* The value is actually a pointer into the line numbers
4542 of the file. We locate the line number entry, and
4543 set the section to the section which contains it, and
4544 the value to the index in that section. */
4548 dst
->symbol
.flags
= BSF_DEBUGGING
;
4549 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4550 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4551 && ((file_ptr
) (sec
->line_filepos
4552 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4553 > (file_ptr
) src
->u
.syment
.n_value
))
4556 dst
->symbol
.value
= 0;
4559 dst
->symbol
.section
= sec
;
4560 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4561 - sec
->line_filepos
)
4562 / bfd_coff_linesz (abfd
));
4569 dst
->symbol
.flags
= BSF_DEBUGGING
;
4571 /* The value is actually a symbol index. Save a pointer
4572 to the symbol instead of the index. FIXME: This
4573 should use a union. */
4574 src
->u
.syment
.n_value
=
4575 (long) (native_symbols
+ src
->u
.syment
.n_value
);
4576 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4581 case C_BLOCK
: /* ".bb" or ".eb". */
4582 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf"). */
4583 case C_EFCN
: /* Physical end of function. */
4584 #if defined COFF_WITH_PE
4585 /* PE sets the symbol to a value relative to the start
4587 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4588 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4590 /* PE uses funny values for .ef and .lf; don't
4592 dst
->symbol
.flags
= BSF_DEBUGGING
;
4595 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4597 /* Base the value as an index from the base of the
4599 dst
->symbol
.flags
= BSF_LOCAL
;
4600 dst
->symbol
.value
= (src
->u
.syment
.n_value
4601 - dst
->symbol
.section
->vma
);
4605 case C_STATLAB
: /* Static load time label. */
4606 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4607 dst
->symbol
.flags
= BSF_GLOBAL
;
4611 /* PE DLLs sometimes have zeroed out symbols for some
4612 reason. Just ignore them without a warning. */
4613 if (src
->u
.syment
.n_type
== 0
4614 && src
->u
.syment
.n_value
== 0
4615 && src
->u
.syment
.n_scnum
== 0)
4618 case C_EXTDEF
: /* External definition. */
4619 case C_ULABEL
: /* Undefined label. */
4620 case C_USTATIC
: /* Undefined static. */
4621 #ifndef COFF_WITH_PE
4622 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4623 class to represent a section symbol. */
4624 case C_LINE
: /* line # reformatted as symbol table entry. */
4625 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4626 case C_ALIAS
: /* Duplicate tag. */
4628 /* New storage classes for TI COFF. */
4629 #if defined(TIC80COFF) || defined(TICOFF)
4630 case C_UEXT
: /* Tentative external definition. */
4632 case C_EXTLAB
: /* External load time label. */
4633 case C_HIDDEN
: /* Ext symbol in dmert public lib. */
4635 (*_bfd_error_handler
)
4636 (_("%B: Unrecognized storage class %d for %s symbol `%s'"),
4637 abfd
, src
->u
.syment
.n_sclass
,
4638 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4639 dst
->symbol
.flags
= BSF_DEBUGGING
;
4640 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4646 dst
->symbol
.udata
.i
= 0;
4648 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
4650 number_of_symbols
++;
4654 obj_symbols (abfd
) = cached_area
;
4655 obj_raw_syments (abfd
) = native_symbols
;
4657 bfd_get_symcount (abfd
) = number_of_symbols
;
4658 obj_convert (abfd
) = table_ptr
;
4659 /* Slurp the line tables for each section too. */
4666 coff_slurp_line_table (abfd
, p
);
4674 /* Classify a COFF symbol. A couple of targets have globally visible
4675 symbols which are not class C_EXT, and this handles those. It also
4676 recognizes some special PE cases. */
4678 static enum coff_symbol_classification
4679 coff_classify_symbol (bfd
*abfd
,
4680 struct internal_syment
*syment
)
4682 /* FIXME: This partially duplicates the switch in
4683 coff_slurp_symbol_table. */
4684 switch (syment
->n_sclass
)
4693 case C_THUMBEXTFUNC
:
4701 if (syment
->n_scnum
== 0)
4703 if (syment
->n_value
== 0)
4704 return COFF_SYMBOL_UNDEFINED
;
4706 return COFF_SYMBOL_COMMON
;
4708 return COFF_SYMBOL_GLOBAL
;
4715 if (syment
->n_sclass
== C_STAT
)
4717 if (syment
->n_scnum
== 0)
4718 /* The Microsoft compiler sometimes generates these if a
4719 small static function is inlined every time it is used.
4720 The function is discarded, but the symbol table entry
4722 return COFF_SYMBOL_LOCAL
;
4724 #ifdef STRICT_PE_FORMAT
4725 /* This is correct for Microsoft generated objects, but it
4726 breaks gas generated objects. */
4727 if (syment
->n_value
== 0)
4730 char buf
[SYMNMLEN
+ 1];
4732 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
4734 && (strcmp (bfd_get_section_name (abfd
, sec
),
4735 _bfd_coff_internal_syment_name (abfd
, syment
, buf
))
4737 return COFF_SYMBOL_PE_SECTION
;
4741 return COFF_SYMBOL_LOCAL
;
4744 if (syment
->n_sclass
== C_SECTION
)
4746 /* In some cases in a DLL generated by the Microsoft linker, the
4747 n_value field will contain garbage. FIXME: This should
4748 probably be handled by the swapping function instead. */
4749 syment
->n_value
= 0;
4750 if (syment
->n_scnum
== 0)
4751 return COFF_SYMBOL_UNDEFINED
;
4752 return COFF_SYMBOL_PE_SECTION
;
4754 #endif /* COFF_WITH_PE */
4756 /* If it is not a global symbol, we presume it is a local symbol. */
4757 if (syment
->n_scnum
== 0)
4759 char buf
[SYMNMLEN
+ 1];
4761 (*_bfd_error_handler
)
4762 (_("warning: %B: local symbol `%s' has no section"),
4763 abfd
, _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
4766 return COFF_SYMBOL_LOCAL
;
4773 Coff relocations are easily transformed into the internal BFD form
4776 Reading a coff relocation table is done in the following stages:
4778 o Read the entire coff relocation table into memory.
4780 o Process each relocation in turn; first swap it from the
4781 external to the internal form.
4783 o Turn the symbol referenced in the relocation's symbol index
4784 into a pointer into the canonical symbol table.
4785 This table is the same as the one returned by a call to
4786 @code{bfd_canonicalize_symtab}. The back end will call that
4787 routine and save the result if a canonicalization hasn't been done.
4789 o The reloc index is turned into a pointer to a howto
4790 structure, in a back end specific way. For instance, the 386
4791 and 960 use the @code{r_type} to directly produce an index
4792 into a howto table vector; the 88k subtracts a number from the
4793 @code{r_type} field and creates an addend field.
4797 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
4799 coff_symbol_type *coffsym = NULL; \
4801 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
4802 coffsym = (obj_symbols (abfd) \
4803 + (cache_ptr->sym_ptr_ptr - symbols)); \
4805 coffsym = coff_symbol_from (abfd, ptr); \
4806 if (coffsym != NULL \
4807 && coffsym->native->u.syment.n_scnum == 0) \
4808 cache_ptr->addend = 0; \
4809 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
4810 && ptr->section != NULL) \
4811 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
4813 cache_ptr->addend = 0; \
4818 coff_slurp_reloc_table (bfd
* abfd
, sec_ptr asect
, asymbol
** symbols
)
4820 RELOC
*native_relocs
;
4821 arelent
*reloc_cache
;
4826 if (asect
->relocation
)
4828 if (asect
->reloc_count
== 0)
4830 if (asect
->flags
& SEC_CONSTRUCTOR
)
4832 if (!coff_slurp_symbol_table (abfd
))
4835 amt
= (bfd_size_type
) bfd_coff_relsz (abfd
) * asect
->reloc_count
;
4836 native_relocs
= (RELOC
*) buy_and_read (abfd
, asect
->rel_filepos
, amt
);
4837 amt
= (bfd_size_type
) asect
->reloc_count
* sizeof (arelent
);
4838 reloc_cache
= bfd_alloc (abfd
, amt
);
4840 if (reloc_cache
== NULL
|| native_relocs
== NULL
)
4843 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
4845 struct internal_reloc dst
;
4846 struct external_reloc
*src
;
4847 #ifndef RELOC_PROCESSING
4851 cache_ptr
= reloc_cache
+ idx
;
4852 src
= native_relocs
+ idx
;
4854 coff_swap_reloc_in (abfd
, src
, &dst
);
4856 #ifdef RELOC_PROCESSING
4857 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
4859 cache_ptr
->address
= dst
.r_vaddr
;
4861 if (dst
.r_symndx
!= -1)
4863 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
4865 (*_bfd_error_handler
)
4866 (_("%B: warning: illegal symbol index %ld in relocs"),
4867 abfd
, dst
.r_symndx
);
4868 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
4873 cache_ptr
->sym_ptr_ptr
= (symbols
4874 + obj_convert (abfd
)[dst
.r_symndx
]);
4875 ptr
= *(cache_ptr
->sym_ptr_ptr
);
4880 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
4884 /* The symbols definitions that we have read in have been
4885 relocated as if their sections started at 0. But the offsets
4886 refering to the symbols in the raw data have not been
4887 modified, so we have to have a negative addend to compensate.
4889 Note that symbols which used to be common must be left alone. */
4891 /* Calculate any reloc addend by looking at the symbol. */
4892 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
4894 cache_ptr
->address
-= asect
->vma
;
4895 /* !! cache_ptr->section = NULL;*/
4897 /* Fill in the cache_ptr->howto field from dst.r_type. */
4898 RTYPE2HOWTO (cache_ptr
, &dst
);
4899 #endif /* RELOC_PROCESSING */
4901 if (cache_ptr
->howto
== NULL
)
4903 (*_bfd_error_handler
)
4904 (_("%B: illegal relocation type %d at address 0x%lx"),
4905 abfd
, dst
.r_type
, (long) dst
.r_vaddr
);
4906 bfd_set_error (bfd_error_bad_value
);
4911 asect
->relocation
= reloc_cache
;
4915 #ifndef coff_rtype_to_howto
4918 /* Get the howto structure for a reloc. This is only used if the file
4919 including this one defines coff_relocate_section to be
4920 _bfd_coff_generic_relocate_section, so it is OK if it does not
4921 always work. It is the responsibility of the including file to
4922 make sure it is reasonable if it is needed. */
4924 static reloc_howto_type
*
4925 coff_rtype_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
4926 asection
*sec ATTRIBUTE_UNUSED
,
4927 struct internal_reloc
*rel
,
4928 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
,
4929 struct internal_syment
*sym ATTRIBUTE_UNUSED
,
4930 bfd_vma
*addendp ATTRIBUTE_UNUSED
)
4934 RTYPE2HOWTO (&genrel
, rel
);
4935 return genrel
.howto
;
4938 #else /* ! defined (RTYPE2HOWTO) */
4940 #define coff_rtype_to_howto NULL
4942 #endif /* ! defined (RTYPE2HOWTO) */
4943 #endif /* ! defined (coff_rtype_to_howto) */
4945 /* This is stupid. This function should be a boolean predicate. */
4948 coff_canonicalize_reloc (bfd
* abfd
,
4953 arelent
*tblptr
= section
->relocation
;
4954 unsigned int count
= 0;
4956 if (section
->flags
& SEC_CONSTRUCTOR
)
4958 /* This section has relocs made up by us, they are not in the
4959 file, so take them out of their chain and place them into
4960 the data area provided. */
4961 arelent_chain
*chain
= section
->constructor_chain
;
4963 for (count
= 0; count
< section
->reloc_count
; count
++)
4965 *relptr
++ = &chain
->relent
;
4966 chain
= chain
->next
;
4971 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
4974 tblptr
= section
->relocation
;
4976 for (; count
++ < section
->reloc_count
;)
4977 *relptr
++ = tblptr
++;
4980 return section
->reloc_count
;
4983 #ifndef coff_reloc16_estimate
4984 #define coff_reloc16_estimate dummy_reloc16_estimate
4987 dummy_reloc16_estimate (bfd
*abfd ATTRIBUTE_UNUSED
,
4988 asection
*input_section ATTRIBUTE_UNUSED
,
4989 arelent
*reloc ATTRIBUTE_UNUSED
,
4990 unsigned int shrink ATTRIBUTE_UNUSED
,
4991 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
)
4999 #ifndef coff_reloc16_extra_cases
5001 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5003 /* This works even if abort is not declared in any header file. */
5006 dummy_reloc16_extra_cases (bfd
*abfd ATTRIBUTE_UNUSED
,
5007 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
5008 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
,
5009 arelent
*reloc ATTRIBUTE_UNUSED
,
5010 bfd_byte
*data ATTRIBUTE_UNUSED
,
5011 unsigned int *src_ptr ATTRIBUTE_UNUSED
,
5012 unsigned int *dst_ptr ATTRIBUTE_UNUSED
)
5018 #ifndef coff_bfd_link_hash_table_free
5019 #define coff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
5022 /* If coff_relocate_section is defined, we can use the optimized COFF
5023 backend linker. Otherwise we must continue to use the old linker. */
5025 #ifdef coff_relocate_section
5027 #ifndef coff_bfd_link_hash_table_create
5028 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5030 #ifndef coff_bfd_link_add_symbols
5031 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5033 #ifndef coff_bfd_final_link
5034 #define coff_bfd_final_link _bfd_coff_final_link
5037 #else /* ! defined (coff_relocate_section) */
5039 #define coff_relocate_section NULL
5040 #ifndef coff_bfd_link_hash_table_create
5041 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5043 #ifndef coff_bfd_link_add_symbols
5044 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5046 #define coff_bfd_final_link _bfd_generic_final_link
5048 #endif /* ! defined (coff_relocate_section) */
5050 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5051 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5053 #ifndef coff_start_final_link
5054 #define coff_start_final_link NULL
5057 #ifndef coff_adjust_symndx
5058 #define coff_adjust_symndx NULL
5061 #ifndef coff_link_add_one_symbol
5062 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5065 #ifndef coff_link_output_has_begun
5068 coff_link_output_has_begun (bfd
* abfd
,
5069 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
)
5071 return abfd
->output_has_begun
;
5075 #ifndef coff_final_link_postscript
5078 coff_final_link_postscript (bfd
* abfd ATTRIBUTE_UNUSED
,
5079 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
)
5085 #ifndef coff_SWAP_aux_in
5086 #define coff_SWAP_aux_in coff_swap_aux_in
5088 #ifndef coff_SWAP_sym_in
5089 #define coff_SWAP_sym_in coff_swap_sym_in
5091 #ifndef coff_SWAP_lineno_in
5092 #define coff_SWAP_lineno_in coff_swap_lineno_in
5094 #ifndef coff_SWAP_aux_out
5095 #define coff_SWAP_aux_out coff_swap_aux_out
5097 #ifndef coff_SWAP_sym_out
5098 #define coff_SWAP_sym_out coff_swap_sym_out
5100 #ifndef coff_SWAP_lineno_out
5101 #define coff_SWAP_lineno_out coff_swap_lineno_out
5103 #ifndef coff_SWAP_reloc_out
5104 #define coff_SWAP_reloc_out coff_swap_reloc_out
5106 #ifndef coff_SWAP_filehdr_out
5107 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5109 #ifndef coff_SWAP_aouthdr_out
5110 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5112 #ifndef coff_SWAP_scnhdr_out
5113 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5115 #ifndef coff_SWAP_reloc_in
5116 #define coff_SWAP_reloc_in coff_swap_reloc_in
5118 #ifndef coff_SWAP_filehdr_in
5119 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5121 #ifndef coff_SWAP_aouthdr_in
5122 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5124 #ifndef coff_SWAP_scnhdr_in
5125 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5128 static const bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED
=
5130 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5131 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5132 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5133 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5134 coff_SWAP_scnhdr_out
,
5135 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5136 #ifdef COFF_LONG_FILENAMES
5141 #ifdef COFF_LONG_SECTION_NAMES
5146 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5147 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5152 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5157 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5158 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5159 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5160 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5161 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5162 coff_classify_symbol
, coff_compute_section_file_positions
,
5163 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5164 coff_adjust_symndx
, coff_link_add_one_symbol
,
5165 coff_link_output_has_begun
, coff_final_link_postscript
5169 /* COFF0 differs in file/section header size and relocation entry size. */
5171 static const bfd_coff_backend_data ticoff0_swap_table
=
5173 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5174 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5175 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5176 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5177 coff_SWAP_scnhdr_out
,
5178 FILHSZ_V0
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ_V0
, LINESZ
, FILNMLEN
,
5179 #ifdef COFF_LONG_FILENAMES
5184 #ifdef COFF_LONG_SECTION_NAMES
5189 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5190 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5195 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5200 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5201 coff_SWAP_reloc_in
, ticoff0_bad_format_hook
, coff_set_arch_mach_hook
,
5202 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5203 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5204 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5205 coff_classify_symbol
, coff_compute_section_file_positions
,
5206 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5207 coff_adjust_symndx
, coff_link_add_one_symbol
,
5208 coff_link_output_has_begun
, coff_final_link_postscript
5213 /* COFF1 differs in section header size. */
5215 static const bfd_coff_backend_data ticoff1_swap_table
=
5217 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5218 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5219 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5220 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5221 coff_SWAP_scnhdr_out
,
5222 FILHSZ
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5223 #ifdef COFF_LONG_FILENAMES
5228 #ifdef COFF_LONG_SECTION_NAMES
5233 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5234 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5239 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5244 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5245 coff_SWAP_reloc_in
, ticoff1_bad_format_hook
, coff_set_arch_mach_hook
,
5246 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5247 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5248 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5249 coff_classify_symbol
, coff_compute_section_file_positions
,
5250 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5251 coff_adjust_symndx
, coff_link_add_one_symbol
,
5252 coff_link_output_has_begun
, coff_final_link_postscript
5256 #ifndef coff_close_and_cleanup
5257 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5260 #ifndef coff_bfd_free_cached_info
5261 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5264 #ifndef coff_get_section_contents
5265 #define coff_get_section_contents _bfd_generic_get_section_contents
5268 #ifndef coff_bfd_copy_private_symbol_data
5269 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5272 #ifndef coff_bfd_copy_private_header_data
5273 #define coff_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
5276 #ifndef coff_bfd_copy_private_section_data
5277 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5280 #ifndef coff_bfd_copy_private_bfd_data
5281 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5284 #ifndef coff_bfd_merge_private_bfd_data
5285 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5288 #ifndef coff_bfd_set_private_flags
5289 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5292 #ifndef coff_bfd_print_private_bfd_data
5293 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5296 #ifndef coff_bfd_is_local_label_name
5297 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5300 #ifndef coff_bfd_is_target_special_symbol
5301 #define coff_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
5304 #ifndef coff_read_minisymbols
5305 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5308 #ifndef coff_minisymbol_to_symbol
5309 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5312 /* The reloc lookup routine must be supplied by each individual COFF
5314 #ifndef coff_bfd_reloc_type_lookup
5315 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5318 #ifndef coff_bfd_get_relocated_section_contents
5319 #define coff_bfd_get_relocated_section_contents \
5320 bfd_generic_get_relocated_section_contents
5323 #ifndef coff_bfd_relax_section
5324 #define coff_bfd_relax_section bfd_generic_relax_section
5327 #ifndef coff_bfd_gc_sections
5328 #define coff_bfd_gc_sections bfd_generic_gc_sections
5331 #ifndef coff_bfd_merge_sections
5332 #define coff_bfd_merge_sections bfd_generic_merge_sections
5335 #ifndef coff_bfd_is_group_section
5336 #define coff_bfd_is_group_section bfd_generic_is_group_section
5339 #ifndef coff_bfd_discard_group
5340 #define coff_bfd_discard_group bfd_generic_discard_group
5343 #ifndef coff_section_already_linked
5344 #define coff_section_already_linked \
5345 _bfd_generic_section_already_linked
5348 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5349 const bfd_target VAR = \
5352 bfd_target_coff_flavour, \
5353 BFD_ENDIAN_BIG, /* Data byte order is big. */ \
5354 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5355 /* object flags */ \
5356 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5357 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5358 /* section flags */ \
5359 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5360 UNDER, /* Leading symbol underscore. */ \
5361 '/', /* AR_pad_char. */ \
5362 15, /* AR_max_namelen. */ \
5364 /* Data conversion functions. */ \
5365 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5366 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5367 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5369 /* Header conversion functions. */ \
5370 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5371 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5372 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5374 /* bfd_check_format. */ \
5375 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5376 _bfd_dummy_target }, \
5377 /* bfd_set_format. */ \
5378 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5379 /* bfd_write_contents. */ \
5380 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5383 BFD_JUMP_TABLE_GENERIC (coff), \
5384 BFD_JUMP_TABLE_COPY (coff), \
5385 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5386 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5387 BFD_JUMP_TABLE_SYMBOLS (coff), \
5388 BFD_JUMP_TABLE_RELOCS (coff), \
5389 BFD_JUMP_TABLE_WRITE (coff), \
5390 BFD_JUMP_TABLE_LINK (coff), \
5391 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5398 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5399 const bfd_target VAR = \
5402 bfd_target_coff_flavour, \
5403 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5404 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5405 /* object flags */ \
5406 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5407 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5408 /* section flags */ \
5409 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5410 UNDER, /* Leading symbol underscore. */ \
5411 '/', /* AR_pad_char. */ \
5412 15, /* AR_max_namelen. */ \
5414 /* Data conversion functions. */ \
5415 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5416 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5417 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5419 /* Header conversion functions. */ \
5420 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5421 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5422 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5424 /* bfd_check_format. */ \
5425 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5426 _bfd_dummy_target }, \
5427 /* bfd_set_format. */ \
5428 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5429 /* bfd_write_contents. */ \
5430 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5433 BFD_JUMP_TABLE_GENERIC (coff), \
5434 BFD_JUMP_TABLE_COPY (coff), \
5435 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5436 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5437 BFD_JUMP_TABLE_SYMBOLS (coff), \
5438 BFD_JUMP_TABLE_RELOCS (coff), \
5439 BFD_JUMP_TABLE_WRITE (coff), \
5440 BFD_JUMP_TABLE_LINK (coff), \
5441 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5448 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5449 const bfd_target VAR = \
5452 bfd_target_coff_flavour, \
5453 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5454 BFD_ENDIAN_LITTLE, /* Header byte order is little. */ \
5455 /* object flags */ \
5456 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5457 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5458 /* section flags */ \
5459 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5460 UNDER, /* Leading symbol underscore. */ \
5461 '/', /* AR_pad_char. */ \
5462 15, /* AR_max_namelen. */ \
5464 /* Data conversion functions. */ \
5465 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5466 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5467 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5468 /* Header conversion functions. */ \
5469 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5470 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5471 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5472 /* bfd_check_format. */ \
5473 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5474 _bfd_dummy_target }, \
5475 /* bfd_set_format. */ \
5476 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5477 /* bfd_write_contents. */ \
5478 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5481 BFD_JUMP_TABLE_GENERIC (coff), \
5482 BFD_JUMP_TABLE_COPY (coff), \
5483 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5484 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5485 BFD_JUMP_TABLE_SYMBOLS (coff), \
5486 BFD_JUMP_TABLE_RELOCS (coff), \
5487 BFD_JUMP_TABLE_WRITE (coff), \
5488 BFD_JUMP_TABLE_LINK (coff), \
5489 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \