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
4 Free Software Foundation, Inc.
5 Written by Cygnus Support.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
24 Most of this hacked by Steve Chamberlain,
32 BFD supports a number of different flavours of coff format.
33 The major differences between formats are the sizes and
34 alignments of fields in structures on disk, and the occasional
37 Coff in all its varieties is implemented with a few common
38 files and a number of implementation specific files. For
39 example, The 88k bcs coff format is implemented in the file
40 @file{coff-m88k.c}. This file @code{#include}s
41 @file{coff/m88k.h} which defines the external structure of the
42 coff format for the 88k, and @file{coff/internal.h} which
43 defines the internal structure. @file{coff-m88k.c} also
44 defines the relocations used by the 88k format
47 The Intel i960 processor version of coff is implemented in
48 @file{coff-i960.c}. This file has the same structure as
49 @file{coff-m88k.c}, except that it includes @file{coff/i960.h}
50 rather than @file{coff-m88k.h}.
53 Porting to a new version of coff
55 The recommended method is to select from the existing
56 implementations the version of coff which is most like the one
57 you want to use. For example, we'll say that i386 coff is
58 the one you select, and that your coff flavour is called foo.
59 Copy @file{i386coff.c} to @file{foocoff.c}, copy
60 @file{../include/coff/i386.h} to @file{../include/coff/foo.h},
61 and add the lines to @file{targets.c} and @file{Makefile.in}
62 so that your new back end is used. Alter the shapes of the
63 structures in @file{../include/coff/foo.h} so that they match
64 what you need. You will probably also have to add
65 @code{#ifdef}s to the code in @file{coff/internal.h} and
66 @file{coffcode.h} if your version of coff is too wild.
68 You can verify that your new BFD backend works quite simply by
69 building @file{objdump} from the @file{binutils} directory,
70 and making sure that its version of what's going on and your
71 host system's idea (assuming it has the pretty standard coff
72 dump utility, usually called @code{att-dump} or just
73 @code{dump}) are the same. Then clean up your code, and send
74 what you've done to Cygnus. Then your stuff will be in the
75 next release, and you won't have to keep integrating it.
78 How the coff backend works
83 The Coff backend is split into generic routines that are
84 applicable to any Coff target and routines that are specific
85 to a particular target. The target-specific routines are
86 further split into ones which are basically the same for all
87 Coff targets except that they use the external symbol format
88 or use different values for certain constants.
90 The generic routines are in @file{coffgen.c}. These routines
91 work for any Coff target. They use some hooks into the target
92 specific code; the hooks are in a @code{bfd_coff_backend_data}
93 structure, one of which exists for each target.
95 The essentially similar target-specific routines are in
96 @file{coffcode.h}. This header file includes executable C code.
97 The various Coff targets first include the appropriate Coff
98 header file, make any special defines that are needed, and
99 then include @file{coffcode.h}.
101 Some of the Coff targets then also have additional routines in
102 the target source file itself.
104 For example, @file{coff-i960.c} includes
105 @file{coff/internal.h} and @file{coff/i960.h}. It then
106 defines a few constants, such as @code{I960}, and includes
107 @file{coffcode.h}. Since the i960 has complex relocation
108 types, @file{coff-i960.c} also includes some code to
109 manipulate the i960 relocs. This code is not in
110 @file{coffcode.h} because it would not be used by any other
116 Each flavour of coff supported in BFD has its own header file
117 describing the external layout of the structures. There is also
118 an internal description of the coff layout, in
119 @file{coff/internal.h}. A major function of the
120 coff backend is swapping the bytes and twiddling the bits to
121 translate the external form of the structures into the normal
122 internal form. This is all performed in the
123 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
124 elements are different sizes between different versions of
125 coff; it is the duty of the coff version specific include file
126 to override the definitions of various packing routines in
127 @file{coffcode.h}. E.g., the size of line number entry in coff is
128 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
129 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
130 correct one. No doubt, some day someone will find a version of
131 coff which has a varying field size not catered to at the
132 moment. To port BFD, that person will have to add more @code{#defines}.
133 Three of the bit twiddling routines are exported to
134 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
135 and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol
136 table on its own, but uses BFD to fix things up. More of the
137 bit twiddlers are exported for @code{gas};
138 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
139 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
140 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
141 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
142 of all the symbol table and reloc drudgery itself, thereby
143 saving the internal BFD overhead, but uses BFD to swap things
144 on the way out, making cross ports much safer. Doing so also
145 allows BFD (and thus the linker) to use the same header files
146 as @code{gas}, which makes one avenue to disaster disappear.
151 The simple canonical form for symbols used by BFD is not rich
152 enough to keep all the information available in a coff symbol
153 table. The back end gets around this problem by keeping the original
154 symbol table around, "behind the scenes".
156 When a symbol table is requested (through a call to
157 @code{bfd_canonicalize_symtab}), a request gets through to
158 @code{coff_get_normalized_symtab}. This reads the symbol table from
159 the coff file and swaps all the structures inside into the
160 internal form. It also fixes up all the pointers in the table
161 (represented in the file by offsets from the first symbol in
162 the table) into physical pointers to elements in the new
163 internal table. This involves some work since the meanings of
164 fields change depending upon context: a field that is a
165 pointer to another structure in the symbol table at one moment
166 may be the size in bytes of a structure at the next. Another
167 pass is made over the table. All symbols which mark file names
168 (<<C_FILE>> symbols) are modified so that the internal
169 string points to the value in the auxent (the real filename)
170 rather than the normal text associated with the symbol
173 At this time the symbol names are moved around. Coff stores
174 all symbols less than nine characters long physically
175 within the symbol table; longer strings are kept at the end of
176 the file in the string table. This pass moves all strings
177 into memory and replaces them with pointers to the strings.
179 The symbol table is massaged once again, this time to create
180 the canonical table used by the BFD application. Each symbol
181 is inspected in turn, and a decision made (using the
182 @code{sclass} field) about the various flags to set in the
183 @code{asymbol}. @xref{Symbols}. The generated canonical table
184 shares strings with the hidden internal symbol table.
186 Any linenumbers are read from the coff file too, and attached
187 to the symbols which own the functions the linenumbers belong to.
192 Writing a symbol to a coff file which didn't come from a coff
193 file will lose any debugging information. The @code{asymbol}
194 structure remembers the BFD from which the symbol was taken, and on
195 output the back end makes sure that the same destination target as
196 source target is present.
198 When the symbols have come from a coff file then all the
199 debugging information is preserved.
201 Symbol tables are provided for writing to the back end in a
202 vector of pointers to pointers. This allows applications like
203 the linker to accumulate and output large symbol tables
204 without having to do too much byte copying.
206 This function runs through the provided symbol table and
207 patches each symbol marked as a file place holder
208 (@code{C_FILE}) to point to the next file place holder in the
209 list. It also marks each @code{offset} field in the list with
210 the offset from the first symbol of the current symbol.
212 Another function of this procedure is to turn the canonical
213 value form of BFD into the form used by coff. Internally, BFD
214 expects symbol values to be offsets from a section base; so a
215 symbol physically at 0x120, but in a section starting at
216 0x100, would have the value 0x20. Coff expects symbols to
217 contain their final value, so symbols have their values
218 changed at this point to reflect their sum with their owning
219 section. This transformation uses the
220 <<output_section>> field of the @code{asymbol}'s
221 @code{asection} @xref{Sections}.
223 o <<coff_mangle_symbols>>
225 This routine runs though the provided symbol table and uses
226 the offsets generated by the previous pass and the pointers
227 generated when the symbol table was read in to create the
228 structured hierarchy required by coff. It changes each pointer
229 to a symbol into the index into the symbol table of the asymbol.
231 o <<coff_write_symbols>>
233 This routine runs through the symbol table and patches up the
234 symbols from their internal form into the coff way, calls the
235 bit twiddlers, and writes out the table to the file.
244 The hidden information for an <<asymbol>> is described in a
245 <<combined_entry_type>>:
249 .typedef struct coff_ptr_struct
251 . {* Remembers the offset from the first symbol in the file for
252 . this symbol. Generated by coff_renumber_symbols. *}
253 . unsigned int offset;
255 . {* Should the value of this symbol be renumbered. Used for
256 . XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
257 . unsigned int fix_value : 1;
259 . {* Should the tag field of this symbol be renumbered.
260 . Created by coff_pointerize_aux. *}
261 . unsigned int fix_tag : 1;
263 . {* Should the endidx field of this symbol be renumbered.
264 . Created by coff_pointerize_aux. *}
265 . unsigned int fix_end : 1;
267 . {* Should the x_csect.x_scnlen field be renumbered.
268 . Created by coff_pointerize_aux. *}
269 . unsigned int fix_scnlen : 1;
271 . {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
272 . index into the line number entries. Set by coff_slurp_symbol_table. *}
273 . unsigned int fix_line : 1;
275 . {* The container for the symbol structure as read and translated
279 . union internal_auxent auxent;
280 . struct internal_syment syment;
282 .} combined_entry_type;
285 .{* Each canonical asymbol really looks like this: *}
287 .typedef struct coff_symbol_struct
289 . {* The actual symbol which the rest of BFD works with *}
292 . {* A pointer to the hidden information for this symbol *}
293 . combined_entry_type *native;
295 . {* A pointer to the linenumber information for this symbol *}
296 . struct lineno_cache_entry *lineno;
298 . {* Have the line numbers been relocated yet ? *}
299 . bfd_boolean done_lineno;
307 #include "coffswap.h"
310 #define STRING_SIZE_SIZE (4)
312 #define DOT_DEBUG ".debug"
313 #define GNU_LINKONCE_WI ".gnu.linkonce.wi."
315 static long sec_to_styp_flags
316 PARAMS ((const char *, flagword
));
317 static bfd_boolean styp_to_sec_flags
318 PARAMS ((bfd
*, PTR
, const char *, asection
*, flagword
*));
319 static bfd_boolean coff_bad_format_hook
320 PARAMS ((bfd
*, PTR
));
321 static void coff_set_custom_section_alignment
322 PARAMS ((bfd
*, asection
*, const struct coff_section_alignment_entry
*,
323 const unsigned int));
324 static bfd_boolean coff_new_section_hook
325 PARAMS ((bfd
*, asection
*));
326 static bfd_boolean coff_set_arch_mach_hook
327 PARAMS ((bfd
*, PTR
));
328 static bfd_boolean coff_write_relocs
329 PARAMS ((bfd
*, int));
330 static bfd_boolean coff_set_flags
331 PARAMS ((bfd
*, unsigned int *, unsigned short *));
332 static bfd_boolean coff_set_arch_mach
333 PARAMS ((bfd
*, enum bfd_architecture
, unsigned long)) ATTRIBUTE_UNUSED
;
334 static bfd_boolean coff_compute_section_file_positions
336 static bfd_boolean coff_write_object_contents
337 PARAMS ((bfd
*)) ATTRIBUTE_UNUSED
;
338 static bfd_boolean coff_set_section_contents
339 PARAMS ((bfd
*, asection
*, const PTR
, file_ptr
, bfd_size_type
));
340 static PTR buy_and_read
341 PARAMS ((bfd
*, file_ptr
, bfd_size_type
));
342 static bfd_boolean coff_slurp_line_table
343 PARAMS ((bfd
*, asection
*));
344 static bfd_boolean coff_slurp_symbol_table
346 static enum coff_symbol_classification coff_classify_symbol
347 PARAMS ((bfd
*, struct internal_syment
*));
348 static bfd_boolean coff_slurp_reloc_table
349 PARAMS ((bfd
*, asection
*, asymbol
**));
350 static long coff_canonicalize_reloc
351 PARAMS ((bfd
*, asection
*, arelent
**, asymbol
**));
352 #ifndef coff_mkobject_hook
353 static PTR coff_mkobject_hook
354 PARAMS ((bfd
*, PTR
, PTR
));
357 static flagword handle_COMDAT
358 PARAMS ((bfd
*, flagword
, PTR
, const char *, asection
*));
360 #ifdef COFF_IMAGE_WITH_PE
361 static bfd_boolean coff_read_word
362 PARAMS ((bfd
*, unsigned int *));
363 static unsigned int coff_compute_checksum
365 static bfd_boolean coff_apply_checksum
369 static bfd_boolean ticoff0_bad_format_hook
370 PARAMS ((bfd
*, PTR
));
371 static bfd_boolean ticoff1_bad_format_hook
372 PARAMS ((bfd
*, PTR
));
375 /* void warning(); */
377 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
378 the incoming SEC_* flags. The inverse of this function is
379 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
380 should probably mirror the changes in styp_to_sec_flags(). */
384 /* Macros for setting debugging flags. */
386 #define STYP_XCOFF_DEBUG STYP_DEBUG
388 #define STYP_XCOFF_DEBUG STYP_INFO
391 #ifdef COFF_ALIGN_IN_S_FLAGS
392 #define STYP_DEBUG_INFO STYP_DSECT
394 #define STYP_DEBUG_INFO STYP_INFO
398 sec_to_styp_flags (sec_name
, sec_flags
)
399 const char *sec_name
;
404 if (!strcmp (sec_name
, _TEXT
))
406 styp_flags
= STYP_TEXT
;
408 else if (!strcmp (sec_name
, _DATA
))
410 styp_flags
= STYP_DATA
;
412 else if (!strcmp (sec_name
, _BSS
))
414 styp_flags
= STYP_BSS
;
417 else if (!strcmp (sec_name
, _COMMENT
))
419 styp_flags
= STYP_INFO
;
420 #endif /* _COMMENT */
423 else if (!strcmp (sec_name
, _LIB
))
425 styp_flags
= STYP_LIB
;
429 else if (!strcmp (sec_name
, _LIT
))
431 styp_flags
= STYP_LIT
;
434 else if (!strncmp (sec_name
, DOT_DEBUG
, sizeof (DOT_DEBUG
) - 1))
436 /* Handle the XCOFF debug section and DWARF2 debug sections. */
438 styp_flags
= STYP_XCOFF_DEBUG
;
440 styp_flags
= STYP_DEBUG_INFO
;
442 else if (!strncmp (sec_name
, ".stab", 5))
444 styp_flags
= STYP_DEBUG_INFO
;
446 #ifdef COFF_LONG_SECTION_NAMES
447 else if (!strncmp (sec_name
, GNU_LINKONCE_WI
, sizeof (GNU_LINKONCE_WI
) - 1))
449 styp_flags
= STYP_DEBUG_INFO
;
453 else if (!strcmp (sec_name
, _PAD
))
455 styp_flags
= STYP_PAD
;
457 else if (!strcmp (sec_name
, _LOADER
))
459 styp_flags
= STYP_LOADER
;
461 else if (!strcmp (sec_name
, _EXCEPT
))
463 styp_flags
= STYP_EXCEPT
;
465 else if (!strcmp (sec_name
, _TYPCHK
))
467 styp_flags
= STYP_TYPCHK
;
470 /* Try and figure out what it should be */
471 else if (sec_flags
& SEC_CODE
)
473 styp_flags
= STYP_TEXT
;
475 else if (sec_flags
& SEC_DATA
)
477 styp_flags
= STYP_DATA
;
479 else if (sec_flags
& SEC_READONLY
)
481 #ifdef STYP_LIT /* 29k readonly text/data section */
482 styp_flags
= STYP_LIT
;
484 styp_flags
= STYP_TEXT
;
485 #endif /* STYP_LIT */
487 else if (sec_flags
& SEC_LOAD
)
489 styp_flags
= STYP_TEXT
;
491 else if (sec_flags
& SEC_ALLOC
)
493 styp_flags
= STYP_BSS
;
497 if (sec_flags
& SEC_TIC54X_CLINK
)
498 styp_flags
|= STYP_CLINK
;
502 if (sec_flags
& SEC_TIC54X_BLOCK
)
503 styp_flags
|= STYP_BLOCK
;
507 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
508 styp_flags
|= STYP_NOLOAD
;
514 #else /* COFF_WITH_PE */
516 /* The PE version; see above for the general comments. The non-PE
517 case seems to be more guessing, and breaks PE format; specifically,
518 .rdata is readonly, but it sure ain't text. Really, all this
519 should be set up properly in gas (or whatever assembler is in use),
520 and honor whatever objcopy/strip, etc. sent us as input. */
523 sec_to_styp_flags (sec_name
, sec_flags
)
524 const char *sec_name
;
529 /* caution: there are at least three groups of symbols that have
530 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
531 SEC_* are the BFD internal flags, used for generic BFD
532 information. STYP_* are the COFF section flags which appear in
533 COFF files. IMAGE_SCN_* are the PE section flags which appear in
534 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
535 but there are more IMAGE_SCN_* flags. */
537 /* FIXME: There is no gas syntax to specify the debug section flag. */
538 if (strncmp (sec_name
, DOT_DEBUG
, sizeof (DOT_DEBUG
) - 1) == 0
539 || strncmp (sec_name
, GNU_LINKONCE_WI
, sizeof (GNU_LINKONCE_WI
) - 1) == 0)
540 sec_flags
= SEC_READONLY
| SEC_DEBUGGING
;
545 if ((sec_flags
& SEC_CODE
) != 0)
546 styp_flags
|= IMAGE_SCN_CNT_CODE
;
547 if ((sec_flags
& SEC_DATA
) != 0)
548 styp_flags
|= IMAGE_SCN_CNT_INITIALIZED_DATA
;
549 if ((sec_flags
& SEC_ALLOC
) != 0 && (sec_flags
& SEC_LOAD
) == 0)
550 styp_flags
|= IMAGE_SCN_CNT_UNINITIALIZED_DATA
; /* ==STYP_BSS */
552 /* skip constRUCTOR */
555 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
556 styp_flags
|= STYP_NOLOAD
;
558 if ((sec_flags
& SEC_IS_COMMON
) != 0)
559 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
560 if ((sec_flags
& SEC_DEBUGGING
) != 0)
561 styp_flags
|= IMAGE_SCN_MEM_DISCARDABLE
;
562 if ((sec_flags
& SEC_EXCLUDE
) != 0)
563 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
564 if ((sec_flags
& SEC_NEVER_LOAD
) != 0)
565 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
568 if (sec_flags
& SEC_LINK_ONCE
)
569 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
570 /* skip LINK_DUPLICATES */
571 /* skip LINKER_CREATED */
573 /* For now, the read/write bits are mapped onto SEC_READONLY, even
574 though the semantics don't quite match. The bits from the input
575 are retained in pei_section_data(abfd, section)->pe_flags. */
577 styp_flags
|= IMAGE_SCN_MEM_READ
; /* Always readable. */
578 if ((sec_flags
& SEC_READONLY
) == 0)
579 styp_flags
|= IMAGE_SCN_MEM_WRITE
; /* Invert READONLY for write. */
580 if (sec_flags
& SEC_CODE
)
581 styp_flags
|= IMAGE_SCN_MEM_EXECUTE
; /* CODE->EXECUTE. */
582 if (sec_flags
& SEC_COFF_SHARED
)
583 styp_flags
|= IMAGE_SCN_MEM_SHARED
; /* Shared remains meaningful. */
588 #endif /* COFF_WITH_PE */
590 /* Return a word with SEC_* flags set to represent the incoming STYP_*
591 flags (from scnhdr.s_flags). The inverse of this function is
592 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
593 should probably mirror the changes in sec_to_styp_flags(). */
598 styp_to_sec_flags (abfd
, hdr
, name
, section
, flags_ptr
)
599 bfd
*abfd ATTRIBUTE_UNUSED
;
602 asection
*section ATTRIBUTE_UNUSED
;
605 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
606 long styp_flags
= internal_s
->s_flags
;
607 flagword sec_flags
= 0;
610 if (styp_flags
& STYP_BLOCK
)
611 sec_flags
|= SEC_TIC54X_BLOCK
;
615 if (styp_flags
& STYP_CLINK
)
616 sec_flags
|= SEC_TIC54X_CLINK
;
620 if (styp_flags
& STYP_NOLOAD
)
621 sec_flags
|= SEC_NEVER_LOAD
;
622 #endif /* STYP_NOLOAD */
624 /* For 386 COFF, at least, an unloadable text or data section is
625 actually a shared library section. */
626 if (styp_flags
& STYP_TEXT
)
628 if (sec_flags
& SEC_NEVER_LOAD
)
629 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
631 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
633 else if (styp_flags
& STYP_DATA
)
635 if (sec_flags
& SEC_NEVER_LOAD
)
636 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
638 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
640 else if (styp_flags
& STYP_BSS
)
642 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
643 if (sec_flags
& SEC_NEVER_LOAD
)
644 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
647 sec_flags
|= SEC_ALLOC
;
649 else if (styp_flags
& STYP_INFO
)
651 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
652 defined. coff_compute_section_file_positions uses
653 COFF_PAGE_SIZE to ensure that the low order bits of the
654 section VMA and the file offset match. If we don't know
655 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
656 and demand page loading of the file will fail. */
657 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
658 sec_flags
|= SEC_DEBUGGING
;
661 else if (styp_flags
& STYP_PAD
)
663 else if (strcmp (name
, _TEXT
) == 0)
665 if (sec_flags
& SEC_NEVER_LOAD
)
666 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
668 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
670 else if (strcmp (name
, _DATA
) == 0)
672 if (sec_flags
& SEC_NEVER_LOAD
)
673 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
675 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
677 else if (strcmp (name
, _BSS
) == 0)
679 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
680 if (sec_flags
& SEC_NEVER_LOAD
)
681 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
684 sec_flags
|= SEC_ALLOC
;
686 else if (strncmp (name
, DOT_DEBUG
, sizeof (DOT_DEBUG
) - 1) == 0
688 || strcmp (name
, _COMMENT
) == 0
690 #ifdef COFF_LONG_SECTION_NAMES
691 || strncmp (name
, GNU_LINKONCE_WI
, sizeof (GNU_LINKONCE_WI
) - 1) == 0
693 || strncmp (name
, ".stab", 5) == 0)
695 #ifdef COFF_PAGE_SIZE
696 sec_flags
|= SEC_DEBUGGING
;
700 else if (strcmp (name
, _LIB
) == 0)
704 else if (strcmp (name
, _LIT
) == 0)
705 sec_flags
= SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
708 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
710 #ifdef STYP_LIT /* A29k readonly text/data section type. */
711 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
712 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
713 #endif /* STYP_LIT */
715 #ifdef STYP_OTHER_LOAD /* Other loaded sections. */
716 if (styp_flags
& STYP_OTHER_LOAD
)
717 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
718 #endif /* STYP_SDATA */
720 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
721 /* As a GNU extension, if the name begins with .gnu.linkonce, we
722 only link a single copy of the section. This is used to support
723 g++. g++ will emit each template expansion in its own section.
724 The symbols will be defined as weak, so that multiple definitions
725 are permitted. The GNU linker extension is to actually discard
726 all but one of the sections. */
727 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
728 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
731 if (flags_ptr
== NULL
)
734 * flags_ptr
= sec_flags
;
738 #else /* COFF_WITH_PE */
741 handle_COMDAT (abfd
, sec_flags
, hdr
, name
, section
)
748 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
749 bfd_byte
*esymstart
, *esym
, *esymend
;
751 char *target_name
= NULL
;
753 sec_flags
|= SEC_LINK_ONCE
;
755 /* Unfortunately, the PE format stores essential information in
756 the symbol table, of all places. We need to extract that
757 information now, so that objdump and the linker will know how
758 to handle the section without worrying about the symbols. We
759 can't call slurp_symtab, because the linker doesn't want the
762 /* COMDAT sections are special. The first symbol is the section
763 symbol, which tells what kind of COMDAT section it is. The
764 second symbol is the "comdat symbol" - the one with the
765 unique name. GNU uses the section symbol for the unique
766 name; MS uses ".text" for every comdat section. Sigh. - DJ */
768 /* This is not mirrored in sec_to_styp_flags(), but there
769 doesn't seem to be a need to, either, and it would at best be
772 if (! _bfd_coff_get_external_symbols (abfd
))
775 esymstart
= esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
776 esymend
= esym
+ obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
778 while (esym
< esymend
)
780 struct internal_syment isym
;
781 char buf
[SYMNMLEN
+ 1];
784 bfd_coff_swap_sym_in (abfd
, (PTR
) esym
, (PTR
) &isym
);
786 if (sizeof (internal_s
->s_name
) > SYMNMLEN
)
788 /* This case implies that the matching
789 symbol name will be in the string table. */
793 if (isym
.n_scnum
== section
->target_index
)
795 /* According to the MSVC documentation, the first
796 TWO entries with the section # are both of
797 interest to us. The first one is the "section
798 symbol" (section name). The second is the comdat
799 symbol name. Here, we've found the first
800 qualifying entry; we distinguish it from the
801 second with a state flag.
803 In the case of gas-generated (at least until that
804 is fixed) .o files, it isn't necessarily the
805 second one. It may be some other later symbol.
807 Since gas also doesn't follow MS conventions and
808 emits the section similar to .text$<name>, where
809 <something> is the name we're looking for, we
810 distinguish the two as follows:
812 If the section name is simply a section name (no
813 $) we presume it's MS-generated, and look at
814 precisely the second symbol for the comdat name.
815 If the section name has a $, we assume it's
816 gas-generated, and look for <something> (whatever
817 follows the $) as the comdat symbol. */
819 /* All 3 branches use this. */
820 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
, buf
);
829 /* The first time we've seen the symbol. */
830 union internal_auxent aux
;
832 /* If it isn't the stuff we're expecting, die;
833 The MS documentation is vague, but it
834 appears that the second entry serves BOTH
835 as the comdat symbol and the defining
836 symbol record (either C_STAT or C_EXT,
837 possibly with an aux entry with debug
838 information if it's a function.) It
839 appears the only way to find the second one
840 is to count. (On Intel, they appear to be
841 adjacent, but on Alpha, they have been
844 Here, we think we've found the first one,
845 but there's some checking we can do to be
848 if (! (isym
.n_sclass
== C_STAT
849 && isym
.n_type
== T_NULL
850 && isym
.n_value
== 0))
853 /* FIXME LATER: MSVC generates section names
854 like .text for comdats. Gas generates
855 names like .text$foo__Fv (in the case of a
856 function). See comment above for more. */
858 if (strcmp (name
, symname
) != 0)
859 _bfd_error_handler (_("%B: warning: COMDAT symbol '%s' does not match section name '%s'"),
860 abfd
, symname
, name
);
864 /* This is the section symbol. */
865 bfd_coff_swap_aux_in (abfd
, (PTR
) (esym
+ bfd_coff_symesz (abfd
)),
866 isym
.n_type
, isym
.n_sclass
,
867 0, isym
.n_numaux
, (PTR
) &aux
);
869 target_name
= strchr (name
, '$');
870 if (target_name
!= NULL
)
878 /* FIXME: Microsoft uses NODUPLICATES and
879 ASSOCIATIVE, but gnu uses ANY and
880 SAME_SIZE. Unfortunately, gnu doesn't do
881 the comdat symbols right. So, until we can
882 fix it to do the right thing, we are
883 temporarily disabling comdats for the MS
884 types (they're used in DLLs and C++, but we
885 don't support *their* C++ libraries anyway
888 /* Cygwin does not follow the MS style, and
889 uses ANY and SAME_SIZE where NODUPLICATES
890 and ASSOCIATIVE should be used. For
891 Interix, we just do the right thing up
894 switch (aux
.x_scn
.x_comdat
)
896 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
897 #ifdef STRICT_PE_FORMAT
898 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
900 sec_flags
&= ~SEC_LINK_ONCE
;
904 case IMAGE_COMDAT_SELECT_ANY
:
905 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
908 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
909 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
912 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
913 /* Not yet fully implemented ??? */
914 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
917 /* debug$S gets this case; other
920 /* There may be no symbol... we'll search
921 the whole table... Is this the right
922 place to play this game? Or should we do
923 it when reading it in. */
924 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
925 #ifdef STRICT_PE_FORMAT
926 /* FIXME: This is not currently implemented. */
927 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
929 sec_flags
&= ~SEC_LINK_ONCE
;
933 default: /* 0 means "no symbol" */
934 /* debug$F gets this case; other
936 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
943 /* Gas mode: the first matching on partial name. */
945 #ifndef TARGET_UNDERSCORE
946 #define TARGET_UNDERSCORE 0
948 /* Is this the name we're looking for ? */
949 if (strcmp (target_name
,
950 symname
+ (TARGET_UNDERSCORE
? 1 : 0)) != 0)
952 /* Not the name we're looking for */
953 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
958 /* MSVC mode: the lexically second symbol (or
959 drop through from the above). */
964 /* This must the second symbol with the
965 section #. It is the actual symbol name.
966 Intel puts the two adjacent, but Alpha (at
967 least) spreads them out. */
969 amt
= sizeof (struct coff_comdat_info
);
970 coff_section_data (abfd
, section
)->comdat
971 = bfd_alloc (abfd
, amt
);
972 if (coff_section_data (abfd
, section
)->comdat
== NULL
)
975 coff_section_data (abfd
, section
)->comdat
->symbol
=
976 (esym
- esymstart
) / bfd_coff_symesz (abfd
);
978 amt
= strlen (symname
) + 1;
979 newname
= bfd_alloc (abfd
, amt
);
983 strcpy (newname
, symname
);
984 coff_section_data (abfd
, section
)->comdat
->name
992 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1000 /* The PE version; see above for the general comments.
1002 Since to set the SEC_LINK_ONCE and associated flags, we have to
1003 look at the symbol table anyway, we return the symbol table index
1004 of the symbol being used as the COMDAT symbol. This is admittedly
1005 ugly, but there's really nowhere else that we have access to the
1006 required information. FIXME: Is the COMDAT symbol index used for
1007 any purpose other than objdump? */
1010 styp_to_sec_flags (abfd
, hdr
, name
, section
, flags_ptr
)
1015 flagword
*flags_ptr
;
1017 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
1018 long styp_flags
= internal_s
->s_flags
;
1020 bfd_boolean result
= TRUE
;
1022 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
1023 sec_flags
= SEC_READONLY
;
1025 /* Process each flag bit in styp_flags in turn. */
1028 long flag
= styp_flags
& - styp_flags
;
1029 char * unhandled
= NULL
;
1031 styp_flags
&= ~ flag
;
1033 /* We infer from the distinct read/write/execute bits the settings
1034 of some of the bfd flags; the actual values, should we need them,
1035 are also in pei_section_data (abfd, section)->pe_flags. */
1040 unhandled
= "STYP_DSECT";
1043 unhandled
= "STYP_GROUP";
1046 unhandled
= "STYP_COPY";
1049 unhandled
= "STYP_OVER";
1051 #ifdef SEC_NEVER_LOAD
1053 sec_flags
|= SEC_NEVER_LOAD
;
1056 case IMAGE_SCN_MEM_READ
:
1057 /* Ignored, assume it always to be true. */
1059 case IMAGE_SCN_TYPE_NO_PAD
:
1062 case IMAGE_SCN_LNK_OTHER
:
1063 unhandled
= "IMAGE_SCN_LNK_OTHER";
1065 case IMAGE_SCN_MEM_NOT_CACHED
:
1066 unhandled
= "IMAGE_SCN_MEM_NOT_CACHED";
1068 case IMAGE_SCN_MEM_NOT_PAGED
:
1069 /* Generate a warning message rather using the 'unhandled'
1070 variable as this will allow some .sys files generate by
1071 other toolchains to be processed. See bugzilla issue 196. */
1072 _bfd_error_handler (_("%B: Warning: Ignoring section flag IMAGE_SCN_MEM_NOT_PAGED in section %s"),
1075 case IMAGE_SCN_MEM_EXECUTE
:
1076 sec_flags
|= SEC_CODE
;
1078 case IMAGE_SCN_MEM_WRITE
:
1079 sec_flags
&= ~ SEC_READONLY
;
1081 case IMAGE_SCN_MEM_DISCARDABLE
:
1082 /* The MS PE spec sets the DISCARDABLE flag on .reloc sections
1083 but we do not want them to be labelled as debug section, since
1084 then strip would remove them. */
1085 if (strncmp (name
, ".reloc", sizeof ".reloc" - 1) != 0)
1086 sec_flags
|= SEC_DEBUGGING
;
1088 case IMAGE_SCN_MEM_SHARED
:
1089 sec_flags
|= SEC_COFF_SHARED
;
1091 case IMAGE_SCN_LNK_REMOVE
:
1092 sec_flags
|= SEC_EXCLUDE
;
1094 case IMAGE_SCN_CNT_CODE
:
1095 sec_flags
|= SEC_CODE
| SEC_ALLOC
| SEC_LOAD
;
1097 case IMAGE_SCN_CNT_INITIALIZED_DATA
:
1098 sec_flags
|= SEC_DATA
| SEC_ALLOC
| SEC_LOAD
;
1100 case IMAGE_SCN_CNT_UNINITIALIZED_DATA
:
1101 sec_flags
|= SEC_ALLOC
;
1103 case IMAGE_SCN_LNK_INFO
:
1104 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1105 defined. coff_compute_section_file_positions uses
1106 COFF_PAGE_SIZE to ensure that the low order bits of the
1107 section VMA and the file offset match. If we don't know
1108 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1109 and demand page loading of the file will fail. */
1110 #ifdef COFF_PAGE_SIZE
1111 sec_flags
|= SEC_DEBUGGING
;
1114 case IMAGE_SCN_LNK_COMDAT
:
1115 /* COMDAT gets very special treatment. */
1116 sec_flags
= handle_COMDAT (abfd
, sec_flags
, hdr
, name
, section
);
1119 /* Silently ignore for now. */
1123 /* If the section flag was not handled, report it here. */
1124 if (unhandled
!= NULL
)
1126 (*_bfd_error_handler
)
1127 (_("%B (%s): Section flag %s (0x%x) ignored"),
1128 abfd
, name
, unhandled
, flag
);
1133 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1134 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1135 only link a single copy of the section. This is used to support
1136 g++. g++ will emit each template expansion in its own section.
1137 The symbols will be defined as weak, so that multiple definitions
1138 are permitted. The GNU linker extension is to actually discard
1139 all but one of the sections. */
1140 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
1141 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1145 * flags_ptr
= sec_flags
;
1150 #endif /* COFF_WITH_PE */
1152 #define get_index(symbol) ((symbol)->udata.i)
1156 bfd_coff_backend_data
1160 .{* COFF symbol classifications. *}
1162 .enum coff_symbol_classification
1164 . {* Global symbol. *}
1165 . COFF_SYMBOL_GLOBAL,
1166 . {* Common symbol. *}
1167 . COFF_SYMBOL_COMMON,
1168 . {* Undefined symbol. *}
1169 . COFF_SYMBOL_UNDEFINED,
1170 . {* Local symbol. *}
1171 . COFF_SYMBOL_LOCAL,
1172 . {* PE section symbol. *}
1173 . COFF_SYMBOL_PE_SECTION
1176 Special entry points for gdb to swap in coff symbol table parts:
1179 . void (*_bfd_coff_swap_aux_in)
1180 . PARAMS ((bfd *, PTR, int, int, int, int, PTR));
1182 . void (*_bfd_coff_swap_sym_in)
1183 . PARAMS ((bfd *, PTR, PTR));
1185 . void (*_bfd_coff_swap_lineno_in)
1186 . PARAMS ((bfd *, PTR, PTR));
1188 . unsigned int (*_bfd_coff_swap_aux_out)
1189 . PARAMS ((bfd *, PTR, int, int, int, int, PTR));
1191 . unsigned int (*_bfd_coff_swap_sym_out)
1192 . PARAMS ((bfd *, PTR, PTR));
1194 . unsigned int (*_bfd_coff_swap_lineno_out)
1195 . PARAMS ((bfd *, PTR, PTR));
1197 . unsigned int (*_bfd_coff_swap_reloc_out)
1198 . PARAMS ((bfd *, PTR, PTR));
1200 . unsigned int (*_bfd_coff_swap_filehdr_out)
1201 . PARAMS ((bfd *, PTR, PTR));
1203 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1204 . PARAMS ((bfd *, PTR, PTR));
1206 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1207 . PARAMS ((bfd *, PTR, PTR));
1209 . unsigned int _bfd_filhsz;
1210 . unsigned int _bfd_aoutsz;
1211 . unsigned int _bfd_scnhsz;
1212 . unsigned int _bfd_symesz;
1213 . unsigned int _bfd_auxesz;
1214 . unsigned int _bfd_relsz;
1215 . unsigned int _bfd_linesz;
1216 . unsigned int _bfd_filnmlen;
1217 . bfd_boolean _bfd_coff_long_filenames;
1218 . bfd_boolean _bfd_coff_long_section_names;
1219 . unsigned int _bfd_coff_default_section_alignment_power;
1220 . bfd_boolean _bfd_coff_force_symnames_in_strings;
1221 . unsigned int _bfd_coff_debug_string_prefix_length;
1223 . void (*_bfd_coff_swap_filehdr_in)
1224 . PARAMS ((bfd *, PTR, PTR));
1226 . void (*_bfd_coff_swap_aouthdr_in)
1227 . PARAMS ((bfd *, PTR, PTR));
1229 . void (*_bfd_coff_swap_scnhdr_in)
1230 . PARAMS ((bfd *, PTR, PTR));
1232 . void (*_bfd_coff_swap_reloc_in)
1233 . PARAMS ((bfd *abfd, PTR, PTR));
1235 . bfd_boolean (*_bfd_coff_bad_format_hook)
1236 . PARAMS ((bfd *, PTR));
1238 . bfd_boolean (*_bfd_coff_set_arch_mach_hook)
1239 . PARAMS ((bfd *, PTR));
1241 . PTR (*_bfd_coff_mkobject_hook)
1242 . PARAMS ((bfd *, PTR, PTR));
1244 . bfd_boolean (*_bfd_styp_to_sec_flags_hook)
1245 . PARAMS ((bfd *, PTR, const char *, asection *, flagword *));
1247 . void (*_bfd_set_alignment_hook)
1248 . PARAMS ((bfd *, asection *, PTR));
1250 . bfd_boolean (*_bfd_coff_slurp_symbol_table)
1253 . bfd_boolean (*_bfd_coff_symname_in_debug)
1254 . PARAMS ((bfd *, struct internal_syment *));
1256 . bfd_boolean (*_bfd_coff_pointerize_aux_hook)
1257 . PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
1258 . unsigned int, combined_entry_type *));
1260 . bfd_boolean (*_bfd_coff_print_aux)
1261 . PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1262 . combined_entry_type *, unsigned int));
1264 . void (*_bfd_coff_reloc16_extra_cases)
1265 . PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1266 . bfd_byte *, unsigned int *, unsigned int *));
1268 . int (*_bfd_coff_reloc16_estimate)
1269 . PARAMS ((bfd *, asection *, arelent *, unsigned int,
1270 . struct bfd_link_info *));
1272 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1273 . PARAMS ((bfd *, struct internal_syment *));
1275 . bfd_boolean (*_bfd_coff_compute_section_file_positions)
1278 . bfd_boolean (*_bfd_coff_start_final_link)
1279 . PARAMS ((bfd *, struct bfd_link_info *));
1281 . bfd_boolean (*_bfd_coff_relocate_section)
1282 . PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1283 . struct internal_reloc *, struct internal_syment *, asection **));
1285 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1286 . PARAMS ((bfd *, asection *, struct internal_reloc *,
1287 . struct coff_link_hash_entry *, struct internal_syment *,
1290 . bfd_boolean (*_bfd_coff_adjust_symndx)
1291 . PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
1292 . struct internal_reloc *, bfd_boolean *));
1294 . bfd_boolean (*_bfd_coff_link_add_one_symbol)
1295 . PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword,
1296 . asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
1297 . struct bfd_link_hash_entry **));
1299 . bfd_boolean (*_bfd_coff_link_output_has_begun)
1300 . PARAMS ((bfd *, struct coff_final_link_info *));
1302 . bfd_boolean (*_bfd_coff_final_link_postscript)
1303 . PARAMS ((bfd *, struct coff_final_link_info *));
1305 .} bfd_coff_backend_data;
1307 .#define coff_backend_info(abfd) \
1308 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1310 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1311 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1313 .#define bfd_coff_swap_sym_in(a,e,i) \
1314 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1316 .#define bfd_coff_swap_lineno_in(a,e,i) \
1317 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1319 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1320 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1322 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1323 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1325 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1326 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1328 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1329 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1331 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1332 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1334 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1335 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1337 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1338 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1340 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1341 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1342 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1343 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1344 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1345 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1346 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1347 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1348 .#define bfd_coff_long_filenames(abfd) \
1349 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1350 .#define bfd_coff_long_section_names(abfd) \
1351 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1352 .#define bfd_coff_default_section_alignment_power(abfd) \
1353 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1354 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1355 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1357 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1358 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1360 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1361 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1363 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1364 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1366 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1367 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1369 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1370 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1371 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1372 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1373 . (abfd, filehdr, aouthdr))
1375 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1376 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1377 . (abfd, scnhdr, name, section, flags_ptr))
1379 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1380 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1382 .#define bfd_coff_slurp_symbol_table(abfd)\
1383 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1385 .#define bfd_coff_symname_in_debug(abfd, sym)\
1386 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1388 .#define bfd_coff_force_symnames_in_strings(abfd)\
1389 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1391 .#define bfd_coff_debug_string_prefix_length(abfd)\
1392 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1394 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1395 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1396 . (abfd, file, base, symbol, aux, indaux))
1398 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1399 . reloc, data, src_ptr, dst_ptr)\
1400 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1401 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1403 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1404 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1405 . (abfd, section, reloc, shrink, link_info))
1407 .#define bfd_coff_classify_symbol(abfd, sym)\
1408 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1411 .#define bfd_coff_compute_section_file_positions(abfd)\
1412 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1415 .#define bfd_coff_start_final_link(obfd, info)\
1416 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1418 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1419 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1420 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1421 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1422 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1423 . (abfd, sec, rel, h, sym, addendp))
1424 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1425 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1426 . (obfd, info, ibfd, sec, rel, adjustedp))
1427 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1428 . value, string, cp, coll, hashp)\
1429 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1430 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1432 .#define bfd_coff_link_output_has_begun(a,p) \
1433 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p))
1434 .#define bfd_coff_final_link_postscript(a,p) \
1435 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
1439 /* See whether the magic number matches. */
1442 coff_bad_format_hook (abfd
, filehdr
)
1443 bfd
* abfd ATTRIBUTE_UNUSED
;
1446 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1448 if (BADMAG (*internal_f
))
1451 /* If the optional header is NULL or not the correct size then
1452 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1453 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1454 optional header is of a different size.
1456 But the mips keeps extra stuff in it's opthdr, so dont check
1459 #if defined(M88) || defined(I960)
1460 if (internal_f
->f_opthdr
!= 0 && bfd_coff_aoutsz (abfd
) != internal_f
->f_opthdr
)
1469 ticoff0_bad_format_hook (abfd
, filehdr
)
1470 bfd
*abfd ATTRIBUTE_UNUSED
;
1473 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1475 if (COFF0_BADMAG (*internal_f
))
1484 ticoff1_bad_format_hook (abfd
, filehdr
)
1485 bfd
*abfd ATTRIBUTE_UNUSED
;
1488 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1490 if (COFF1_BADMAG (*internal_f
))
1497 /* Check whether this section uses an alignment other than the
1501 coff_set_custom_section_alignment (abfd
, section
, alignment_table
, table_size
)
1502 bfd
*abfd ATTRIBUTE_UNUSED
;
1504 const struct coff_section_alignment_entry
*alignment_table
;
1505 const unsigned int table_size
;
1507 const unsigned int default_alignment
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1510 for (i
= 0; i
< table_size
; ++i
)
1512 const char *secname
= bfd_get_section_name (abfd
, section
);
1514 if (alignment_table
[i
].comparison_length
== (unsigned int) -1
1515 ? strcmp (alignment_table
[i
].name
, secname
) == 0
1516 : strncmp (alignment_table
[i
].name
, secname
,
1517 alignment_table
[i
].comparison_length
) == 0)
1520 if (i
>= table_size
)
1523 if (alignment_table
[i
].default_alignment_min
!= COFF_ALIGNMENT_FIELD_EMPTY
1524 && default_alignment
< alignment_table
[i
].default_alignment_min
)
1527 if (alignment_table
[i
].default_alignment_max
!= COFF_ALIGNMENT_FIELD_EMPTY
1528 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1529 && default_alignment
> alignment_table
[i
].default_alignment_max
1534 section
->alignment_power
= alignment_table
[i
].alignment_power
;
1537 /* Custom section alignment records. */
1539 static const struct coff_section_alignment_entry
1540 coff_section_alignment_table
[] =
1542 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1543 COFF_SECTION_ALIGNMENT_ENTRIES
,
1545 /* There must not be any gaps between .stabstr sections. */
1546 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1547 1, COFF_ALIGNMENT_FIELD_EMPTY
, 0 },
1548 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1549 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1550 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1551 /* Similarly for the .ctors and .dtors sections. */
1552 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1553 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1554 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1555 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 }
1558 static const unsigned int coff_section_alignment_table_size
=
1559 sizeof coff_section_alignment_table
/ sizeof coff_section_alignment_table
[0];
1561 /* Initialize a section structure with information peculiar to this
1562 particular implementation of COFF. */
1565 coff_new_section_hook (abfd
, section
)
1569 combined_entry_type
*native
;
1572 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1575 if (bfd_xcoff_text_align_power (abfd
) != 0
1576 && strcmp (bfd_get_section_name (abfd
, section
), ".text") == 0)
1577 section
->alignment_power
= bfd_xcoff_text_align_power (abfd
);
1578 if (bfd_xcoff_data_align_power (abfd
) != 0
1579 && strcmp (bfd_get_section_name (abfd
, section
), ".data") == 0)
1580 section
->alignment_power
= bfd_xcoff_data_align_power (abfd
);
1583 /* Allocate aux records for section symbols, to store size and
1586 @@ The 10 is a guess at a plausible maximum number of aux entries
1587 (but shouldn't be a constant). */
1588 amt
= sizeof (combined_entry_type
) * 10;
1589 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
1593 /* We don't need to set up n_name, n_value, or n_scnum in the native
1594 symbol information, since they'll be overridden by the BFD symbol
1595 anyhow. However, we do need to set the type and storage class,
1596 in case this symbol winds up getting written out. The value 0
1597 for n_numaux is already correct. */
1599 native
->u
.syment
.n_type
= T_NULL
;
1600 native
->u
.syment
.n_sclass
= C_STAT
;
1602 coffsymbol (section
->symbol
)->native
= native
;
1604 coff_set_custom_section_alignment (abfd
, section
,
1605 coff_section_alignment_table
,
1606 coff_section_alignment_table_size
);
1611 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1613 /* Set the alignment of a BFD section. */
1615 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1618 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1619 bfd
* abfd ATTRIBUTE_UNUSED
;
1623 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1627 /* Extract ALIGN from 2**ALIGN stored in section header. */
1628 for (i
= 0; i
< 32; i
++)
1629 if ((1 << i
) >= hdr
->s_align
)
1633 /* TI tools puts the alignment power in bits 8-11. */
1634 i
= (hdr
->s_flags
>> 8) & 0xF ;
1636 #ifdef COFF_DECODE_ALIGNMENT
1637 i
= COFF_DECODE_ALIGNMENT(hdr
->s_flags
);
1639 section
->alignment_power
= i
;
1641 #ifdef coff_set_section_load_page
1642 coff_set_section_load_page (section
, hdr
->s_page
);
1646 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1649 /* A couple of macros to help setting the alignment power field. */
1650 #define ALIGN_SET(field,x,y) \
1651 if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1653 section->alignment_power = y;\
1656 #define ELIFALIGN_SET(field,x,y) \
1657 else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1659 section->alignment_power = y;\
1662 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1665 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1666 bfd
* abfd ATTRIBUTE_UNUSED
;
1670 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1673 ALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_64BYTES
, 6)
1674 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_32BYTES
, 5)
1675 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_16BYTES
, 4)
1676 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_8BYTES
, 3)
1677 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_4BYTES
, 2)
1678 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_2BYTES
, 1)
1679 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_1BYTES
, 0)
1681 /* In a PE image file, the s_paddr field holds the virtual size of a
1682 section, while the s_size field holds the raw size. We also keep
1683 the original section flag value, since not every bit can be
1684 mapped onto a generic BFD section bit. */
1685 if (coff_section_data (abfd
, section
) == NULL
)
1687 amt
= sizeof (struct coff_section_tdata
);
1688 section
->used_by_bfd
= (PTR
) bfd_zalloc (abfd
, amt
);
1689 if (section
->used_by_bfd
== NULL
)
1691 /* FIXME: Return error. */
1695 if (pei_section_data (abfd
, section
) == NULL
)
1697 amt
= sizeof (struct pei_section_tdata
);
1698 coff_section_data (abfd
, section
)->tdata
= (PTR
) bfd_zalloc (abfd
, amt
);
1699 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1701 /* FIXME: Return error. */
1705 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1706 pei_section_data (abfd
, section
)->pe_flags
= hdr
->s_flags
;
1708 section
->lma
= hdr
->s_vaddr
;
1710 /* Check for extended relocs. */
1711 if (hdr
->s_flags
& IMAGE_SCN_LNK_NRELOC_OVFL
)
1713 struct external_reloc dst
;
1714 struct internal_reloc n
;
1715 file_ptr oldpos
= bfd_tell (abfd
);
1716 bfd_size_type relsz
= bfd_coff_relsz (abfd
);
1718 bfd_seek (abfd
, (file_ptr
) hdr
->s_relptr
, 0);
1719 if (bfd_bread ((PTR
) &dst
, relsz
, abfd
) != relsz
)
1722 coff_swap_reloc_in (abfd
, &dst
, &n
);
1723 bfd_seek (abfd
, oldpos
, 0);
1724 section
->reloc_count
= hdr
->s_nreloc
= n
.r_vaddr
- 1;
1725 section
->rel_filepos
+= relsz
;
1727 else if (hdr
->s_nreloc
== 0xffff)
1728 (*_bfd_error_handler
)
1729 ("%s: warning: claims to have 0xffff relocs, without overflow",
1730 bfd_get_filename (abfd
));
1733 #undef ELIFALIGN_SET
1735 #else /* ! COFF_WITH_PE */
1738 /* We grossly abuse this function to handle XCOFF overflow headers.
1739 When we see one, we correct the reloc and line number counts in the
1740 real header, and remove the section we just created. */
1742 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1745 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1750 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1754 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1757 real_sec
= coff_section_from_bfd_index (abfd
, (int) hdr
->s_nreloc
);
1758 if (real_sec
== NULL
)
1761 real_sec
->reloc_count
= hdr
->s_paddr
;
1762 real_sec
->lineno_count
= hdr
->s_vaddr
;
1764 for (ps
= &abfd
->sections
; *ps
!= NULL
; ps
= &(*ps
)->next
)
1768 bfd_section_list_remove (abfd
, ps
);
1769 --abfd
->section_count
;
1775 #else /* ! RS6000COFF_C */
1777 #define coff_set_alignment_hook \
1778 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1780 #endif /* ! RS6000COFF_C */
1781 #endif /* ! COFF_WITH_PE */
1782 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1784 #ifndef coff_mkobject
1786 static bfd_boolean coff_mkobject
PARAMS ((bfd
*));
1789 coff_mkobject (abfd
)
1792 coff_data_type
*coff
;
1793 bfd_size_type amt
= sizeof (coff_data_type
);
1795 abfd
->tdata
.coff_obj_data
= (struct coff_tdata
*) bfd_zalloc (abfd
, amt
);
1796 if (abfd
->tdata
.coff_obj_data
== 0)
1798 coff
= coff_data (abfd
);
1799 coff
->symbols
= (coff_symbol_type
*) NULL
;
1800 coff
->conversion_table
= (unsigned int *) NULL
;
1801 coff
->raw_syments
= (struct coff_ptr_struct
*) NULL
;
1802 coff
->relocbase
= 0;
1803 coff
->local_toc_sym_map
= 0;
1805 /* make_abs_section(abfd);*/
1811 /* Create the COFF backend specific information. */
1813 #ifndef coff_mkobject_hook
1815 coff_mkobject_hook (abfd
, filehdr
, aouthdr
)
1818 PTR aouthdr ATTRIBUTE_UNUSED
;
1820 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1821 coff_data_type
*coff
;
1823 if (! coff_mkobject (abfd
))
1826 coff
= coff_data (abfd
);
1828 coff
->sym_filepos
= internal_f
->f_symptr
;
1830 /* These members communicate important constants about the symbol
1831 table to GDB's symbol-reading code. These `constants'
1832 unfortunately vary among coff implementations... */
1833 coff
->local_n_btmask
= N_BTMASK
;
1834 coff
->local_n_btshft
= N_BTSHFT
;
1835 coff
->local_n_tmask
= N_TMASK
;
1836 coff
->local_n_tshift
= N_TSHIFT
;
1837 coff
->local_symesz
= bfd_coff_symesz (abfd
);
1838 coff
->local_auxesz
= bfd_coff_auxesz (abfd
);
1839 coff
->local_linesz
= bfd_coff_linesz (abfd
);
1841 coff
->timestamp
= internal_f
->f_timdat
;
1843 obj_raw_syment_count (abfd
) =
1844 obj_conv_table_size (abfd
) =
1845 internal_f
->f_nsyms
;
1848 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
1849 abfd
->flags
|= DYNAMIC
;
1850 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= bfd_coff_aoutsz (abfd
))
1852 struct internal_aouthdr
*internal_a
=
1853 (struct internal_aouthdr
*) aouthdr
;
1854 struct xcoff_tdata
*xcoff
;
1856 xcoff
= xcoff_data (abfd
);
1857 # ifdef U803XTOCMAGIC
1858 xcoff
->xcoff64
= internal_f
->f_magic
== U803XTOCMAGIC
;
1862 xcoff
->full_aouthdr
= TRUE
;
1863 xcoff
->toc
= internal_a
->o_toc
;
1864 xcoff
->sntoc
= internal_a
->o_sntoc
;
1865 xcoff
->snentry
= internal_a
->o_snentry
;
1866 bfd_xcoff_text_align_power (abfd
) = internal_a
->o_algntext
;
1867 bfd_xcoff_data_align_power (abfd
) = internal_a
->o_algndata
;
1868 xcoff
->modtype
= internal_a
->o_modtype
;
1869 xcoff
->cputype
= internal_a
->o_cputype
;
1870 xcoff
->maxdata
= internal_a
->o_maxdata
;
1871 xcoff
->maxstack
= internal_a
->o_maxstack
;
1876 /* Set the flags field from the COFF header read in. */
1877 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
1882 /* FIXME: I'm not sure this is ever executed, since peicode.h
1883 defines coff_mkobject_hook. */
1884 if ((internal_f
->f_flags
& IMAGE_FILE_DEBUG_STRIPPED
) == 0)
1885 abfd
->flags
|= HAS_DEBUG
;
1892 /* Determine the machine architecture and type. FIXME: This is target
1893 dependent because the magic numbers are defined in the target
1894 dependent header files. But there is no particular need for this.
1895 If the magic numbers were moved to a separate file, this function
1896 would be target independent and would also be much more successful
1897 at linking together COFF files for different architectures. */
1900 coff_set_arch_mach_hook (abfd
, filehdr
)
1904 unsigned long machine
;
1905 enum bfd_architecture arch
;
1906 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1908 /* Zero selects the default machine for an arch. */
1910 switch (internal_f
->f_magic
)
1912 #ifdef OR32_MAGIC_BIG
1913 case OR32_MAGIC_BIG
:
1914 case OR32_MAGIC_LITTLE
:
1915 arch
= bfd_arch_or32
;
1920 arch
= bfd_arch_powerpc
;
1926 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler */
1927 case LYNXCOFFMAGIC
: /* shadows the m68k Lynx number below, sigh */
1928 arch
= bfd_arch_i386
;
1933 arch
= bfd_arch_ia64
;
1936 #ifdef A29K_MAGIC_BIG
1937 case A29K_MAGIC_BIG
:
1938 case A29K_MAGIC_LITTLE
:
1939 arch
= bfd_arch_a29k
;
1946 arch
= bfd_arch_arm
;
1947 machine
= bfd_arm_get_mach_from_notes (abfd
, ARM_NOTE_SECTION
);
1948 if (machine
== bfd_mach_arm_unknown
)
1950 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
1952 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
1953 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
1954 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
1956 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
1957 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
1958 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
1959 /* The COFF header does not have enough bits available
1960 to cover all the different ARM architectures. So
1961 we interpret F_ARM_5, the highest flag value to mean
1962 "the highest ARM architecture known to BFD" which is
1963 currently the XScale. */
1964 case F_ARM_5
: machine
= bfd_mach_arm_XScale
; break;
1972 #ifdef MC68KBCSMAGIC
1975 #ifdef APOLLOM68KMAGIC
1976 case APOLLOM68KMAGIC
:
1978 #ifdef LYNXCOFFMAGIC
1981 arch
= bfd_arch_m68k
;
1982 machine
= bfd_mach_m68020
;
1987 arch
= bfd_arch_maxq
;
1988 switch (internal_f
->f_flags
& F_MACHMASK
)
1991 machine
= bfd_mach_maxq10
;
1994 machine
= bfd_mach_maxq20
;
2005 arch
= bfd_arch_m88k
;
2011 arch
= bfd_arch_z8k
;
2012 switch (internal_f
->f_flags
& F_MACHMASK
)
2015 machine
= bfd_mach_z8001
;
2018 machine
= bfd_mach_z8002
;
2027 arch
= bfd_arch_i860
;
2034 arch
= bfd_arch_i960
;
2035 switch (F_I960TYPE
& internal_f
->f_flags
)
2039 machine
= bfd_mach_i960_core
;
2042 machine
= bfd_mach_i960_kb_sb
;
2045 machine
= bfd_mach_i960_mc
;
2048 machine
= bfd_mach_i960_xa
;
2051 machine
= bfd_mach_i960_ca
;
2054 machine
= bfd_mach_i960_ka_sa
;
2057 machine
= bfd_mach_i960_jx
;
2060 machine
= bfd_mach_i960_hx
;
2079 if (xcoff_data (abfd
)->cputype
!= -1)
2080 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
2083 /* We did not get a value from the a.out header. If the
2084 file has not been stripped, we may be able to get the
2085 architecture information from the first symbol, if it
2086 is a .file symbol. */
2087 if (obj_raw_syment_count (abfd
) == 0)
2092 struct internal_syment sym
;
2093 bfd_size_type amt
= bfd_coff_symesz (abfd
);
2095 buf
= (bfd_byte
*) bfd_malloc (amt
);
2096 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
2097 || bfd_bread (buf
, amt
, abfd
) != amt
)
2102 bfd_coff_swap_sym_in (abfd
, (PTR
) buf
, (PTR
) &sym
);
2103 if (sym
.n_sclass
== C_FILE
)
2104 cputype
= sym
.n_type
& 0xff;
2111 /* FIXME: We don't handle all cases here. */
2116 arch
= bfd_xcoff_architecture (abfd
);
2117 machine
= bfd_xcoff_machine (abfd
);
2121 arch
= bfd_arch_powerpc
;
2122 machine
= bfd_mach_ppc_601
;
2124 case 2: /* 64 bit PowerPC */
2125 arch
= bfd_arch_powerpc
;
2126 machine
= bfd_mach_ppc_620
;
2129 arch
= bfd_arch_powerpc
;
2130 machine
= bfd_mach_ppc
;
2133 arch
= bfd_arch_rs6000
;
2134 machine
= bfd_mach_rs6k
;
2143 arch
= bfd_arch_we32k
;
2149 arch
= bfd_arch_h8300
;
2150 machine
= bfd_mach_h8300
;
2151 /* !! FIXME this probably isn't the right place for this. */
2152 abfd
->flags
|= BFD_IS_RELAXABLE
;
2158 arch
= bfd_arch_h8300
;
2159 machine
= bfd_mach_h8300h
;
2160 /* !! FIXME this probably isn't the right place for this. */
2161 abfd
->flags
|= BFD_IS_RELAXABLE
;
2167 arch
= bfd_arch_h8300
;
2168 machine
= bfd_mach_h8300s
;
2169 /* !! FIXME this probably isn't the right place for this. */
2170 abfd
->flags
|= BFD_IS_RELAXABLE
;
2176 arch
= bfd_arch_h8300
;
2177 machine
= bfd_mach_h8300hn
;
2178 /* !! FIXME this probably isn't the right place for this. */
2179 abfd
->flags
|= BFD_IS_RELAXABLE
;
2185 arch
= bfd_arch_h8300
;
2186 machine
= bfd_mach_h8300sn
;
2187 /* !! FIXME this probably isn't the right place for this. */
2188 abfd
->flags
|= BFD_IS_RELAXABLE
;
2192 #ifdef SH_ARCH_MAGIC_BIG
2193 case SH_ARCH_MAGIC_BIG
:
2194 case SH_ARCH_MAGIC_LITTLE
:
2196 case SH_ARCH_MAGIC_WINCE
:
2202 #ifdef MIPS_ARCH_MAGIC_WINCE
2203 case MIPS_ARCH_MAGIC_WINCE
:
2204 arch
= bfd_arch_mips
;
2210 arch
= bfd_arch_h8500
;
2216 #ifdef LYNXCOFFMAGIC
2219 arch
= bfd_arch_sparc
;
2225 arch
= bfd_arch_tic30
;
2230 #ifdef TICOFF_TARGET_ARCH
2231 /* This TI COFF section should be used by all new TI COFF v0 targets. */
2233 arch
= TICOFF_TARGET_ARCH
;
2234 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2240 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */
2241 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */
2244 switch (internal_f
->f_target_id
)
2248 arch
= TICOFF_TARGET_ARCH
;
2249 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2253 arch
= bfd_arch_obscure
;
2254 (*_bfd_error_handler
)
2255 (_("Unrecognized TI COFF target id '0x%x'"),
2256 internal_f
->f_target_id
);
2262 #ifdef TIC80_ARCH_MAGIC
2263 case TIC80_ARCH_MAGIC
:
2264 arch
= bfd_arch_tic80
;
2270 arch
= bfd_arch_mcore
;
2276 arch
= bfd_arch_w65
;
2280 default: /* Unreadable input file type. */
2281 arch
= bfd_arch_obscure
;
2285 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2289 #ifdef SYMNAME_IN_DEBUG
2291 static bfd_boolean symname_in_debug_hook
2292 PARAMS ((bfd
*, struct internal_syment
*));
2295 symname_in_debug_hook (abfd
, sym
)
2296 bfd
* abfd ATTRIBUTE_UNUSED
;
2297 struct internal_syment
*sym
;
2299 return SYMNAME_IN_DEBUG (sym
) != 0;
2304 #define symname_in_debug_hook \
2305 (bfd_boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
2312 #define FORCE_SYMNAMES_IN_STRINGS
2315 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
2317 static bfd_boolean coff_pointerize_aux_hook
2318 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
2319 unsigned int, combined_entry_type
*));
2322 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
2323 bfd
*abfd ATTRIBUTE_UNUSED
;
2324 combined_entry_type
*table_base
;
2325 combined_entry_type
*symbol
;
2326 unsigned int indaux
;
2327 combined_entry_type
*aux
;
2329 int class = symbol
->u
.syment
.n_sclass
;
2331 if ((class == C_EXT
|| class == C_HIDEXT
)
2332 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2334 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2336 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2337 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2338 aux
->fix_scnlen
= 1;
2341 /* Return TRUE to indicate that the caller should not do any
2342 further work on this auxent. */
2346 /* Return FALSE to indicate that this auxent should be handled by
2354 /* We don't want to pointerize bal entries. */
2356 static bfd_boolean coff_pointerize_aux_hook
2357 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
2358 unsigned int, combined_entry_type
*));
2361 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
2362 bfd
*abfd ATTRIBUTE_UNUSED
;
2363 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
2364 combined_entry_type
*symbol
;
2365 unsigned int indaux
;
2366 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
2368 /* Return TRUE if we don't want to pointerize this aux entry, which
2369 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2371 && (symbol
->u
.syment
.n_sclass
== C_LEAFPROC
2372 || symbol
->u
.syment
.n_sclass
== C_LEAFSTAT
2373 || symbol
->u
.syment
.n_sclass
== C_LEAFEXT
));
2378 #define coff_pointerize_aux_hook 0
2381 #endif /* ! RS6000COFF_C */
2383 /* Print an aux entry. This returns TRUE if it has printed it. */
2385 static bfd_boolean coff_print_aux
2386 PARAMS ((bfd
*, FILE *, combined_entry_type
*, combined_entry_type
*,
2387 combined_entry_type
*, unsigned int));
2390 coff_print_aux (abfd
, file
, table_base
, symbol
, aux
, indaux
)
2391 bfd
*abfd ATTRIBUTE_UNUSED
;
2392 FILE *file ATTRIBUTE_UNUSED
;
2393 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
2394 combined_entry_type
*symbol ATTRIBUTE_UNUSED
;
2395 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
2396 unsigned int indaux ATTRIBUTE_UNUSED
;
2399 if ((symbol
->u
.syment
.n_sclass
== C_EXT
2400 || symbol
->u
.syment
.n_sclass
== C_HIDEXT
)
2401 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2403 /* This is a csect entry. */
2404 fprintf (file
, "AUX ");
2405 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2407 BFD_ASSERT (! aux
->fix_scnlen
);
2409 fprintf (file
, "val %5lld",
2410 (long long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2412 fprintf (file
, "val %5ld", (long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2417 fprintf (file
, "indx ");
2418 if (! aux
->fix_scnlen
)
2420 fprintf (file
, "%4lld",
2421 (long long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2423 fprintf (file
, "%4ld", (long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2426 fprintf (file
, "%4ld",
2427 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2430 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2431 aux
->u
.auxent
.x_csect
.x_parmhash
,
2432 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2433 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2434 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2435 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2436 aux
->u
.auxent
.x_csect
.x_stab
,
2437 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2442 /* Return FALSE to indicate that no special action was taken. */
2450 To write relocations, the back end steps though the
2451 canonical relocation table and create an
2452 @code{internal_reloc}. The symbol index to use is removed from
2453 the @code{offset} field in the symbol table supplied. The
2454 address comes directly from the sum of the section base
2455 address and the relocation offset; the type is dug directly
2456 from the howto field. Then the @code{internal_reloc} is
2457 swapped into the shape of an @code{external_reloc} and written
2464 static int compare_arelent_ptr
PARAMS ((const PTR
, const PTR
));
2466 /* AUX's ld wants relocations to be sorted. */
2468 compare_arelent_ptr (x
, y
)
2472 const arelent
**a
= (const arelent
**) x
;
2473 const arelent
**b
= (const arelent
**) y
;
2474 bfd_size_type aadr
= (*a
)->address
;
2475 bfd_size_type badr
= (*b
)->address
;
2477 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2480 #endif /* TARG_AUX */
2483 coff_write_relocs (abfd
, first_undef
)
2489 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
2492 struct external_reloc dst
;
2499 /* Sort relocations before we write them out. */
2502 amt
= s
->reloc_count
;
2503 amt
*= sizeof (arelent
*);
2504 p
= (arelent
**) bfd_malloc (amt
);
2505 if (p
== NULL
&& s
->reloc_count
> 0)
2507 memcpy (p
, s
->orelocation
, (size_t) amt
);
2508 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2512 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2516 if (obj_pe (abfd
) && s
->reloc_count
>= 0xffff)
2518 /* Encode real count here as first reloc. */
2519 struct internal_reloc n
;
2521 memset ((PTR
) & n
, 0, sizeof (n
));
2522 /* Add one to count *this* reloc (grr). */
2523 n
.r_vaddr
= s
->reloc_count
+ 1;
2524 coff_swap_reloc_out (abfd
, &n
, &dst
);
2525 if (bfd_bwrite ((PTR
) & dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2526 abfd
) != bfd_coff_relsz (abfd
))
2531 for (i
= 0; i
< s
->reloc_count
; i
++)
2533 struct internal_reloc n
;
2536 memset ((PTR
) & n
, 0, sizeof (n
));
2538 /* Now we've renumbered the symbols we know where the
2539 undefined symbols live in the table. Check the reloc
2540 entries for symbols who's output bfd isn't the right one.
2541 This is because the symbol was undefined (which means
2542 that all the pointers are never made to point to the same
2543 place). This is a bad thing,'cause the symbols attached
2544 to the output bfd are indexed, so that the relocation
2545 entries know which symbol index they point to. So we
2546 have to look up the output symbol here. */
2548 if (q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2551 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2552 asymbol
**outsyms
= abfd
->outsymbols
;
2554 for (j
= first_undef
; outsyms
[j
]; j
++)
2556 const char *intable
= outsyms
[j
]->name
;
2558 if (strcmp (intable
, sname
) == 0) {
2559 /* Got a hit, so repoint the reloc. */
2560 q
->sym_ptr_ptr
= outsyms
+ j
;
2566 n
.r_vaddr
= q
->address
+ s
->vma
;
2569 /* The 29k const/consth reloc pair is a real kludge. The consth
2570 part doesn't have a symbol; it has an offset. So rebuilt
2572 if (q
->howto
->type
== R_IHCONST
)
2573 n
.r_symndx
= q
->addend
;
2578 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2579 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
,s
))
2581 if ((*q
->sym_ptr_ptr
)->section
== bfd_abs_section_ptr
2582 && ((*q
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) != 0)
2584 /* This is a relocation relative to the absolute symbol. */
2588 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2589 /* Take notice if the symbol reloc points to a symbol
2590 we don't have in our symbol table. What should we
2592 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2597 #ifdef SWAP_OUT_RELOC_OFFSET
2598 n
.r_offset
= q
->addend
;
2602 /* Work out reloc type from what is required. */
2603 SELECT_RELOC (n
, q
->howto
);
2605 n
.r_type
= q
->howto
->type
;
2607 coff_swap_reloc_out (abfd
, &n
, &dst
);
2609 if (bfd_bwrite ((PTR
) & dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2610 abfd
) != bfd_coff_relsz (abfd
))
2623 /* Set flags and magic number of a coff file from architecture and machine
2624 type. Result is TRUE if we can represent the arch&type, FALSE if not. */
2627 coff_set_flags (abfd
, magicp
, flagsp
)
2629 unsigned int *magicp ATTRIBUTE_UNUSED
;
2630 unsigned short *flagsp ATTRIBUTE_UNUSED
;
2632 switch (bfd_get_arch (abfd
))
2637 switch (bfd_get_mach (abfd
))
2639 case bfd_mach_z8001
:
2642 case bfd_mach_z8002
:
2656 *magicp
= I960ROMAGIC
;
2658 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2659 I960RWMAGIC); FIXME???
2661 switch (bfd_get_mach (abfd
))
2663 case bfd_mach_i960_core
:
2666 case bfd_mach_i960_kb_sb
:
2669 case bfd_mach_i960_mc
:
2672 case bfd_mach_i960_xa
:
2675 case bfd_mach_i960_ca
:
2678 case bfd_mach_i960_ka_sa
:
2681 case bfd_mach_i960_jx
:
2684 case bfd_mach_i960_hx
:
2697 case bfd_arch_tic30
:
2698 *magicp
= TIC30MAGIC
;
2702 #ifdef TICOFF_DEFAULT_MAGIC
2703 case TICOFF_TARGET_ARCH
:
2704 /* If there's no indication of which version we want, use the default. */
2706 *magicp
= TICOFF_DEFAULT_MAGIC
;
2709 /* We may want to output in a different COFF version. */
2710 switch (abfd
->xvec
->name
[4])
2713 *magicp
= TICOFF0MAGIC
;
2716 *magicp
= TICOFF1MAGIC
;
2719 *magicp
= TICOFF2MAGIC
;
2725 TICOFF_TARGET_MACHINE_SET (flagsp
, bfd_get_mach (abfd
));
2729 #ifdef TIC80_ARCH_MAGIC
2730 case bfd_arch_tic80
:
2731 *magicp
= TIC80_ARCH_MAGIC
;
2737 * magicp
= ARMPEMAGIC
;
2739 * magicp
= ARMMAGIC
;
2742 if (APCS_SET (abfd
))
2744 if (APCS_26_FLAG (abfd
))
2745 * flagsp
|= F_APCS26
;
2747 if (APCS_FLOAT_FLAG (abfd
))
2748 * flagsp
|= F_APCS_FLOAT
;
2750 if (PIC_FLAG (abfd
))
2753 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2754 * flagsp
|= F_INTERWORK
;
2755 switch (bfd_get_mach (abfd
))
2757 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2758 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2759 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2760 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2761 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2762 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2763 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2764 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2765 See also the comment in coff_set_arch_mach_hook(). */
2766 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break;
2767 case bfd_mach_arm_5TE
: * flagsp
|= F_ARM_5
; break;
2768 case bfd_mach_arm_XScale
: * flagsp
|= F_ARM_5
; break;
2773 case bfd_arch_powerpc
:
2780 *magicp
= I386MAGIC
;
2782 /* Just overwrite the usual value if we're doing Lynx. */
2783 *magicp
= LYNXCOFFMAGIC
;
2790 *magicp
= I860MAGIC
;
2796 *magicp
= IA64MAGIC
;
2802 #ifdef APOLLOM68KMAGIC
2803 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
2805 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2806 #ifdef NAMES_HAVE_UNDERSCORE
2807 *magicp
= MC68KBCSMAGIC
;
2809 *magicp
= MC68MAGIC
;
2813 /* Just overwrite the usual value if we're doing Lynx. */
2814 *magicp
= LYNXCOFFMAGIC
;
2822 *magicp
= MC88OMAGIC
;
2827 case bfd_arch_h8300
:
2828 switch (bfd_get_mach (abfd
))
2830 case bfd_mach_h8300
:
2831 *magicp
= H8300MAGIC
;
2833 case bfd_mach_h8300h
:
2834 *magicp
= H8300HMAGIC
;
2836 case bfd_mach_h8300s
:
2837 *magicp
= H8300SMAGIC
;
2839 case bfd_mach_h8300hn
:
2840 *magicp
= H8300HNMAGIC
;
2842 case bfd_mach_h8300sn
:
2843 *magicp
= H8300SNMAGIC
;
2849 #ifdef SH_ARCH_MAGIC_BIG
2851 #ifdef COFF_IMAGE_WITH_PE
2852 *magicp
= SH_ARCH_MAGIC_WINCE
;
2854 if (bfd_big_endian (abfd
))
2855 *magicp
= SH_ARCH_MAGIC_BIG
;
2857 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2863 #ifdef MIPS_ARCH_MAGIC_WINCE
2865 *magicp
= MIPS_ARCH_MAGIC_WINCE
;
2871 case bfd_arch_sparc
:
2872 *magicp
= SPARCMAGIC
;
2874 /* Just overwrite the usual value if we're doing Lynx. */
2875 *magicp
= LYNXCOFFMAGIC
;
2882 case bfd_arch_h8500
:
2883 *magicp
= H8500MAGIC
;
2887 #ifdef A29K_MAGIC_BIG
2889 if (bfd_big_endian (abfd
))
2890 *magicp
= A29K_MAGIC_BIG
;
2892 *magicp
= A29K_MAGIC_LITTLE
;
2898 case bfd_arch_we32k
:
2899 *magicp
= WE32KMAGIC
;
2905 case bfd_arch_rs6000
:
2907 case bfd_arch_powerpc
:
2909 BFD_ASSERT (bfd_get_flavour (abfd
) == bfd_target_xcoff_flavour
);
2910 *magicp
= bfd_xcoff_magic_number (abfd
);
2916 case bfd_arch_mcore
:
2917 * magicp
= MCOREMAGIC
;
2927 #ifdef OR32_MAGIC_BIG
2929 if (bfd_big_endian (abfd
))
2930 * magicp
= OR32_MAGIC_BIG
;
2932 * magicp
= OR32_MAGIC_LITTLE
;
2938 * magicp
= MAXQ20MAGIC
;
2939 switch (bfd_get_mach (abfd
))
2941 case bfd_mach_maxq10
:
2942 * flagsp
= F_MAXQ10
;
2944 case bfd_mach_maxq20
:
2945 * flagsp
= F_MAXQ20
;
2952 default: /* Unknown architecture. */
2953 /* Fall through to "return FALSE" below, to avoid
2954 "statement never reached" errors on the one below. */
2962 coff_set_arch_mach (abfd
, arch
, machine
)
2964 enum bfd_architecture arch
;
2965 unsigned long machine
;
2968 unsigned short dummy2
;
2970 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
2973 if (arch
!= bfd_arch_unknown
2974 && ! coff_set_flags (abfd
, &dummy1
, &dummy2
))
2975 return FALSE
; /* We can't represent this type */
2977 return TRUE
; /* We're easy ... */
2980 #ifdef COFF_IMAGE_WITH_PE
2982 /* This is used to sort sections by VMA, as required by PE image
2985 static int sort_by_secaddr
PARAMS ((const PTR
, const PTR
));
2988 sort_by_secaddr (arg1
, arg2
)
2992 const asection
*a
= *(const asection
**) arg1
;
2993 const asection
*b
= *(const asection
**) arg2
;
2995 if (a
->vma
< b
->vma
)
2997 else if (a
->vma
> b
->vma
)
3003 #endif /* COFF_IMAGE_WITH_PE */
3005 /* Calculate the file position for each section. */
3008 #define ALIGN_SECTIONS_IN_FILE
3010 #if defined(TIC80COFF) || defined(TICOFF)
3011 #undef ALIGN_SECTIONS_IN_FILE
3015 coff_compute_section_file_positions (abfd
)
3019 asection
*previous
= (asection
*) NULL
;
3020 file_ptr sofar
= bfd_coff_filhsz (abfd
);
3021 bfd_boolean align_adjust
;
3022 #ifdef ALIGN_SECTIONS_IN_FILE
3027 /* On XCOFF, if we have symbols, set up the .debug section. */
3028 if (bfd_get_symcount (abfd
) > 0)
3031 bfd_size_type i
, symcount
;
3035 symcount
= bfd_get_symcount (abfd
);
3036 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
3038 coff_symbol_type
*cf
;
3040 cf
= coff_symbol_from (abfd
, *symp
);
3042 && cf
->native
!= NULL
3043 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
3047 len
= strlen (bfd_asymbol_name (*symp
));
3048 if (len
> SYMNMLEN
|| bfd_coff_force_symnames_in_strings (abfd
))
3049 sz
+= len
+ 1 + bfd_coff_debug_string_prefix_length (abfd
);
3056 dsec
= bfd_make_section_old_way (abfd
, DOT_DEBUG
);
3060 dsec
->flags
|= SEC_HAS_CONTENTS
;
3065 #ifdef COFF_IMAGE_WITH_PE
3067 if (coff_data (abfd
)->link_info
)
3069 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
3071 /* If no file alignment has been set, default to one.
3072 This repairs 'ld -r' for arm-wince-pe target. */
3077 page_size
= PE_DEF_FILE_ALIGNMENT
;
3079 #ifdef COFF_PAGE_SIZE
3080 int page_size
= COFF_PAGE_SIZE
;
3084 if (bfd_get_start_address (abfd
))
3086 /* A start address may have been added to the original file. In this
3087 case it will need an optional header to record it. */
3088 abfd
->flags
|= EXEC_P
;
3091 if (abfd
->flags
& EXEC_P
)
3092 sofar
+= bfd_coff_aoutsz (abfd
);
3094 else if (xcoff_data (abfd
)->full_aouthdr
)
3095 sofar
+= bfd_coff_aoutsz (abfd
);
3097 sofar
+= SMALL_AOUTSZ
;
3100 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
3103 /* XCOFF handles overflows in the reloc and line number count fields
3104 by allocating a new section header to hold the correct counts. */
3105 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3106 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3107 sofar
+= bfd_coff_scnhsz (abfd
);
3110 #ifdef COFF_IMAGE_WITH_PE
3112 /* PE requires the sections to be in memory order when listed in
3113 the section headers. It also does not like empty loadable
3114 sections. The sections apparently do not have to be in the
3115 right order in the image file itself, but we do need to get the
3116 target_index values right. */
3119 asection
**section_list
;
3125 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3128 /* We allocate an extra cell to simplify the final loop. */
3129 amt
= sizeof (struct asection
*) * (count
+ 1);
3130 section_list
= bfd_malloc (amt
);
3131 if (section_list
== NULL
)
3135 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3137 section_list
[i
] = current
;
3140 section_list
[i
] = NULL
;
3142 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
3144 /* Rethread the linked list into sorted order; at the same time,
3145 assign target_index values. */
3147 abfd
->sections
= section_list
[0];
3148 for (i
= 0; i
< count
; i
++)
3150 current
= section_list
[i
];
3151 current
->next
= section_list
[i
+ 1];
3153 /* Later, if the section has zero size, we'll be throwing it
3154 away, so we don't want to number it now. Note that having
3155 a zero size and having real contents are different
3156 concepts: .bss has no contents, but (usually) non-zero
3158 if (current
->size
== 0)
3160 /* Discard. However, it still might have (valid) symbols
3161 in it, so arbitrarily set it to section 1 (indexing is
3162 1-based here; usually .text). __end__ and other
3163 contents of .endsection really have this happen.
3164 FIXME: This seems somewhat dubious. */
3165 current
->target_index
= 1;
3168 current
->target_index
= target_index
++;
3170 abfd
->section_tail
= ¤t
->next
;
3172 free (section_list
);
3174 #else /* ! COFF_IMAGE_WITH_PE */
3176 /* Set the target_index field. */
3180 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3181 current
->target_index
= target_index
++;
3183 #endif /* ! COFF_IMAGE_WITH_PE */
3185 align_adjust
= FALSE
;
3186 for (current
= abfd
->sections
;
3187 current
!= (asection
*) NULL
;
3188 current
= current
->next
)
3190 #ifdef COFF_IMAGE_WITH_PE
3191 /* With PE we have to pad each section to be a multiple of its
3192 page size too, and remember both sizes. */
3193 if (coff_section_data (abfd
, current
) == NULL
)
3195 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
3196 current
->used_by_bfd
= (PTR
) bfd_zalloc (abfd
, amt
);
3197 if (current
->used_by_bfd
== NULL
)
3200 if (pei_section_data (abfd
, current
) == NULL
)
3202 bfd_size_type amt
= sizeof (struct pei_section_tdata
);
3203 coff_section_data (abfd
, current
)->tdata
3204 = (PTR
) bfd_zalloc (abfd
, amt
);
3205 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
3208 if (pei_section_data (abfd
, current
)->virt_size
== 0)
3209 pei_section_data (abfd
, current
)->virt_size
= current
->size
;
3212 /* Only deal with sections which have contents. */
3213 if (!(current
->flags
& SEC_HAS_CONTENTS
))
3216 #ifdef COFF_IMAGE_WITH_PE
3217 /* Make sure we skip empty sections in a PE image. */
3218 if (current
->size
== 0)
3222 /* Align the sections in the file to the same boundary on
3223 which they are aligned in virtual memory. I960 doesn't
3224 do this (FIXME) so we can stay in sync with Intel. 960
3225 doesn't yet page from files... */
3226 #ifdef ALIGN_SECTIONS_IN_FILE
3227 if ((abfd
->flags
& EXEC_P
) != 0)
3229 /* Make sure this section is aligned on the right boundary - by
3230 padding the previous section up if necessary. */
3234 /* AIX loader checks the text section alignment of (vma - filepos)
3235 So even though the filepos may be aligned wrt the o_algntext, for
3236 AIX executables, this check fails. This shows up when a native
3237 AIX executable is stripped with gnu strip because the default vma
3238 of native is 0x10000150 but default for gnu is 0x10000140. Gnu
3239 stripped gnu excutable passes this check because the filepos is
3240 0x0140. This problem also show up with 64 bit shared objects. The
3241 data section must also be aligned. */
3242 if (!strcmp (current
->name
, _TEXT
)
3243 || !strcmp (current
->name
, _DATA
))
3248 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3250 align
= 1 << current
->alignment_power
;
3251 pad
= abs (current
->vma
- sofar
) % align
;
3262 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3265 if (previous
!= (asection
*) NULL
)
3266 previous
->size
+= sofar
- old_sofar
;
3271 /* In demand paged files the low order bits of the file offset
3272 must match the low order bits of the virtual address. */
3273 #ifdef COFF_PAGE_SIZE
3274 if ((abfd
->flags
& D_PAGED
) != 0
3275 && (current
->flags
& SEC_ALLOC
) != 0)
3276 sofar
+= (current
->vma
- (bfd_vma
) sofar
) % page_size
;
3278 current
->filepos
= sofar
;
3280 #ifdef COFF_IMAGE_WITH_PE
3281 /* Set the padded size. */
3282 current
->size
= (current
->size
+ page_size
-1) & -page_size
;
3285 sofar
+= current
->size
;
3287 #ifdef ALIGN_SECTIONS_IN_FILE
3288 /* Make sure that this section is of the right size too. */
3289 if ((abfd
->flags
& EXEC_P
) == 0)
3291 bfd_size_type old_size
;
3293 old_size
= current
->size
;
3294 current
->size
= BFD_ALIGN (current
->size
,
3295 1 << current
->alignment_power
);
3296 align_adjust
= current
->size
!= old_size
;
3297 sofar
+= current
->size
- old_size
;
3302 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3303 align_adjust
= sofar
!= old_sofar
;
3304 current
->size
+= sofar
- old_sofar
;
3308 #ifdef COFF_IMAGE_WITH_PE
3309 /* For PE we need to make sure we pad out to the aligned
3310 size, in case the caller only writes out data to the
3312 if (pei_section_data (abfd
, current
)->virt_size
< current
->size
)
3313 align_adjust
= TRUE
;
3317 /* Force .lib sections to start at zero. The vma is then
3318 incremented in coff_set_section_contents. This is right for
3320 if (strcmp (current
->name
, _LIB
) == 0)
3321 bfd_set_section_vma (abfd
, current
, 0);
3327 /* It is now safe to write to the output file. If we needed an
3328 alignment adjustment for the last section, then make sure that
3329 there is a byte at offset sofar. If there are no symbols and no
3330 relocs, then nothing follows the last section. If we don't force
3331 the last byte out, then the file may appear to be truncated. */
3337 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
3338 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3342 /* Make sure the relocations are aligned. We don't need to make
3343 sure that this byte exists, because it will only matter if there
3344 really are relocs. */
3345 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
3347 obj_relocbase (abfd
) = sofar
;
3348 abfd
->output_has_begun
= TRUE
;
3353 #ifdef COFF_IMAGE_WITH_PE
3355 static unsigned int pelength
;
3356 static unsigned int peheader
;
3359 coff_read_word (abfd
, value
)
3361 unsigned int *value
;
3366 status
= bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3374 *value
= (unsigned int) b
[0];
3376 *value
= (unsigned int) (b
[0] + (b
[1] << 8));
3378 pelength
+= (unsigned int) status
;
3384 coff_compute_checksum (abfd
)
3387 bfd_boolean more_data
;
3394 filepos
= (file_ptr
) 0;
3398 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
3401 more_data
= coff_read_word (abfd
, &value
);
3403 total
= 0xffff & (total
+ (total
>> 0x10));
3408 return (0xffff & (total
+ (total
>> 0x10)));
3412 coff_apply_checksum (abfd
)
3415 unsigned int computed
;
3416 unsigned int checksum
= 0;
3418 if (bfd_seek (abfd
, 0x3c, SEEK_SET
) != 0)
3421 if (!coff_read_word (abfd
, &peheader
))
3424 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3428 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3430 if (bfd_seek (abfd
, peheader
, SEEK_SET
) != 0)
3433 computed
= coff_compute_checksum (abfd
);
3435 checksum
= computed
+ pelength
;
3437 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3440 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3445 #endif /* COFF_IMAGE_WITH_PE */
3450 coff_write_object_contents (abfd
)
3454 bfd_boolean hasrelocs
= FALSE
;
3455 bfd_boolean haslinno
= FALSE
;
3456 bfd_boolean hasdebug
= FALSE
;
3458 file_ptr reloc_base
;
3459 file_ptr lineno_base
;
3461 unsigned long reloc_size
= 0, reloc_count
= 0;
3462 unsigned long lnno_size
= 0;
3463 bfd_boolean long_section_names
;
3464 asection
*text_sec
= NULL
;
3465 asection
*data_sec
= NULL
;
3466 asection
*bss_sec
= NULL
;
3467 struct internal_filehdr internal_f
;
3468 struct internal_aouthdr internal_a
;
3469 #ifdef COFF_LONG_SECTION_NAMES
3470 size_t string_size
= STRING_SIZE_SIZE
;
3473 bfd_set_error (bfd_error_system_call
);
3475 /* Make a pass through the symbol table to count line number entries and
3476 put them into the correct asections. */
3478 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3480 if (! abfd
->output_has_begun
)
3482 if (! coff_compute_section_file_positions (abfd
))
3486 reloc_base
= obj_relocbase (abfd
);
3488 /* Work out the size of the reloc and linno areas. */
3490 for (current
= abfd
->sections
; current
!= NULL
; current
=
3494 /* We store the actual reloc count in the first reloc's addr. */
3495 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3498 reloc_count
+= current
->reloc_count
;
3501 reloc_size
= reloc_count
* bfd_coff_relsz (abfd
);
3503 lineno_base
= reloc_base
+ reloc_size
;
3504 sym_base
= lineno_base
+ lnno_size
;
3506 /* Indicate in each section->line_filepos its actual file address. */
3507 for (current
= abfd
->sections
; current
!= NULL
; current
=
3510 if (current
->lineno_count
)
3512 current
->line_filepos
= lineno_base
;
3513 current
->moving_line_filepos
= lineno_base
;
3514 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3518 current
->line_filepos
= 0;
3520 if (current
->reloc_count
)
3522 current
->rel_filepos
= reloc_base
;
3523 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3525 /* Extra reloc to hold real count. */
3526 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3527 reloc_base
+= bfd_coff_relsz (abfd
);
3532 current
->rel_filepos
= 0;
3536 /* Write section headers to the file. */
3537 internal_f
.f_nscns
= 0;
3539 if ((abfd
->flags
& EXEC_P
) != 0)
3540 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3543 scn_base
= bfd_coff_filhsz (abfd
);
3546 if (xcoff_data (abfd
)->full_aouthdr
)
3547 scn_base
+= bfd_coff_aoutsz (abfd
);
3549 scn_base
+= SMALL_AOUTSZ
;
3554 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3557 long_section_names
= FALSE
;
3558 for (current
= abfd
->sections
;
3560 current
= current
->next
)
3562 struct internal_scnhdr section
;
3563 bfd_boolean is_reloc_section
= FALSE
;
3565 #ifdef COFF_IMAGE_WITH_PE
3566 if (strcmp (current
->name
, ".reloc") == 0)
3568 is_reloc_section
= TRUE
;
3570 pe_data (abfd
)->has_reloc_section
= 1;
3574 internal_f
.f_nscns
++;
3576 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3578 #ifdef COFF_LONG_SECTION_NAMES
3579 /* Handle long section names as in PE. This must be compatible
3580 with the code in coff_write_symbols and _bfd_coff_final_link. */
3584 len
= strlen (current
->name
);
3587 memset (section
.s_name
, 0, SCNNMLEN
);
3588 sprintf (section
.s_name
, "/%lu", (unsigned long) string_size
);
3589 string_size
+= len
+ 1;
3590 long_section_names
= TRUE
;
3596 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3597 Ian Taylor <ian@cygnus.com>. */
3598 if (strcmp (current
->name
, _LIB
) == 0)
3599 section
.s_vaddr
= 0;
3602 section
.s_vaddr
= current
->vma
;
3603 section
.s_paddr
= current
->lma
;
3604 section
.s_size
= current
->size
;
3605 #ifdef coff_get_section_load_page
3606 section
.s_page
= coff_get_section_load_page (current
);
3610 section
.s_paddr
= 0;
3612 #ifdef COFF_IMAGE_WITH_PE
3613 /* Reminder: s_paddr holds the virtual size of the section. */
3614 if (coff_section_data (abfd
, current
) != NULL
3615 && pei_section_data (abfd
, current
) != NULL
)
3616 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3618 section
.s_paddr
= 0;
3621 /* If this section has no size or is unloadable then the scnptr
3623 if (current
->size
== 0
3624 || (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3625 section
.s_scnptr
= 0;
3627 section
.s_scnptr
= current
->filepos
;
3629 section
.s_relptr
= current
->rel_filepos
;
3630 section
.s_lnnoptr
= current
->line_filepos
;
3631 section
.s_nreloc
= current
->reloc_count
;
3632 section
.s_nlnno
= current
->lineno_count
;
3633 #ifndef COFF_IMAGE_WITH_PE
3634 /* In PEI, relocs come in the .reloc section. */
3635 if (current
->reloc_count
!= 0)
3638 if (current
->lineno_count
!= 0)
3640 if ((current
->flags
& SEC_DEBUGGING
) != 0
3641 && ! is_reloc_section
)
3646 /* Indicate the use of an XCOFF overflow section header. */
3647 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3649 section
.s_nreloc
= 0xffff;
3650 section
.s_nlnno
= 0xffff;
3655 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3657 if (!strcmp (current
->name
, _TEXT
))
3659 else if (!strcmp (current
->name
, _DATA
))
3661 else if (!strcmp (current
->name
, _BSS
))
3665 section
.s_align
= (current
->alignment_power
3666 ? 1 << current
->alignment_power
3670 /* TI COFF puts the alignment power in bits 8-11 of the flags. */
3671 section
.s_flags
|= (current
->alignment_power
& 0xF) << 8;
3673 #ifdef COFF_ENCODE_ALIGNMENT
3674 COFF_ENCODE_ALIGNMENT(section
, current
->alignment_power
);
3677 #ifdef COFF_IMAGE_WITH_PE
3678 /* Suppress output of the sections if they are null. ld
3679 includes the bss and data sections even if there is no size
3680 assigned to them. NT loader doesn't like it if these section
3681 headers are included if the sections themselves are not
3682 needed. See also coff_compute_section_file_positions. */
3683 if (section
.s_size
== 0)
3684 internal_f
.f_nscns
--;
3689 bfd_size_type amt
= bfd_coff_scnhsz (abfd
);
3691 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3692 || bfd_bwrite ((PTR
) &buff
, amt
, abfd
) != amt
)
3697 /* PE stores COMDAT section information in the symbol table. If
3698 this section is supposed to have some COMDAT info, track down
3699 the symbol in the symbol table and modify it. */
3700 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3702 unsigned int i
, count
;
3704 coff_symbol_type
*csym
= NULL
;
3708 count
= bfd_get_symcount (abfd
);
3709 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3711 if ((*psym
)->section
!= current
)
3714 /* Remember the location of the first symbol in this
3716 if (psymsec
== NULL
)
3719 /* See if this is the section symbol. */
3720 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3722 csym
= coff_symbol_from (abfd
, *psym
);
3724 || csym
->native
== NULL
3725 || csym
->native
->u
.syment
.n_numaux
< 1
3726 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3727 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3730 /* Here *PSYM is the section symbol for CURRENT. */
3737 Note that we might not if we're converting the file from
3738 some other object file format. */
3741 combined_entry_type
*aux
;
3743 /* We don't touch the x_checksum field. The
3744 x_associated field is not currently supported. */
3746 aux
= csym
->native
+ 1;
3747 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3749 case SEC_LINK_DUPLICATES_DISCARD
:
3750 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3753 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3754 aux
->u
.auxent
.x_scn
.x_comdat
=
3755 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3758 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3759 aux
->u
.auxent
.x_scn
.x_comdat
=
3760 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3763 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3764 aux
->u
.auxent
.x_scn
.x_comdat
=
3765 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3769 /* The COMDAT symbol must be the first symbol from this
3770 section in the symbol table. In order to make this
3771 work, we move the COMDAT symbol before the first
3772 symbol we found in the search above. It's OK to
3773 rearrange the symbol table at this point, because
3774 coff_renumber_symbols is going to rearrange it
3775 further and fix up all the aux entries. */
3776 if (psym
!= psymsec
)
3782 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3783 pcopy
[0] = pcopy
[-1];
3788 #endif /* COFF_WITH_PE */
3793 /* XCOFF handles overflows in the reloc and line number count fields
3794 by creating a new section header to hold the correct values. */
3795 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3797 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3799 struct internal_scnhdr scnhdr
;
3803 internal_f
.f_nscns
++;
3804 strncpy (&(scnhdr
.s_name
[0]), current
->name
, 8);
3805 scnhdr
.s_paddr
= current
->reloc_count
;
3806 scnhdr
.s_vaddr
= current
->lineno_count
;
3808 scnhdr
.s_scnptr
= 0;
3809 scnhdr
.s_relptr
= current
->rel_filepos
;
3810 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3811 scnhdr
.s_nreloc
= current
->target_index
;
3812 scnhdr
.s_nlnno
= current
->target_index
;
3813 scnhdr
.s_flags
= STYP_OVRFLO
;
3814 amt
= bfd_coff_scnhsz (abfd
);
3815 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3816 || bfd_bwrite ((PTR
) &buff
, amt
, abfd
) != amt
)
3823 /* OK, now set up the filehdr... */
3825 /* Don't include the internal abs section in the section count */
3827 /* We will NOT put a fucking timestamp in the header here. Every time you
3828 put it back, I will come in and take it out again. I'm sorry. This
3829 field does not belong here. We fill it with a 0 so it compares the
3830 same but is not a reasonable time. -- gnu@cygnus.com */
3831 internal_f
.f_timdat
= 0;
3832 internal_f
.f_flags
= 0;
3834 if (abfd
->flags
& EXEC_P
)
3835 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3838 internal_f
.f_opthdr
= 0;
3841 if (xcoff_data (abfd
)->full_aouthdr
)
3842 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3844 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
3850 internal_f
.f_flags
|= F_RELFLG
;
3852 internal_f
.f_flags
|= F_LNNO
;
3853 if (abfd
->flags
& EXEC_P
)
3854 internal_f
.f_flags
|= F_EXEC
;
3855 #ifdef COFF_IMAGE_WITH_PE
3857 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
3858 if (pe_data (abfd
)->real_flags
& IMAGE_FILE_LARGE_ADDRESS_AWARE
)
3859 internal_f
.f_flags
|= IMAGE_FILE_LARGE_ADDRESS_AWARE
;
3863 internal_f
.f_flags
|= IMAGE_FILE_32BIT_MACHINE
;
3865 if (bfd_little_endian (abfd
))
3866 internal_f
.f_flags
|= F_AR32WR
;
3868 internal_f
.f_flags
|= F_AR32W
;
3872 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
3873 but it doesn't hurt to set it internally. */
3874 internal_f
.f_target_id
= TI_TARGET_ID
;
3876 #ifdef TIC80_TARGET_ID
3877 internal_f
.f_target_id
= TIC80_TARGET_ID
;
3880 /* FIXME, should do something about the other byte orders and
3884 if ((abfd
->flags
& DYNAMIC
) != 0)
3885 internal_f
.f_flags
|= F_SHROBJ
;
3886 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
3887 internal_f
.f_flags
|= F_DYNLOAD
;
3890 memset (&internal_a
, 0, sizeof internal_a
);
3892 /* Set up architecture-dependent stuff. */
3894 unsigned int magic
= 0;
3895 unsigned short flags
= 0;
3897 coff_set_flags (abfd
, &magic
, &flags
);
3898 internal_f
.f_magic
= magic
;
3899 internal_f
.f_flags
|= flags
;
3900 /* ...and the "opt"hdr... */
3903 #ifdef ULTRA3 /* NYU's machine */
3904 /* FIXME: This is a bogus check. I really want to see if there
3905 is a .shbss or a .shdata section, if so then set the magic
3906 number to indicate a shared data executable. */
3907 if (internal_f
.f_nscns
>= 7)
3908 internal_a
.magic
= SHMAGIC
; /* Shared magic. */
3911 internal_a
.magic
= NMAGIC
; /* Assume separate i/d. */
3912 #define __A_MAGIC_SET__
3914 #ifdef TICOFF_AOUT_MAGIC
3915 internal_a
.magic
= TICOFF_AOUT_MAGIC
;
3916 #define __A_MAGIC_SET__
3919 internal_a
.magic
= TIC80_ARCH_MAGIC
;
3920 #define __A_MAGIC_SET__
3923 /* FIXME: What are the a.out magic numbers for the i860? */
3924 internal_a
.magic
= 0;
3925 #define __A_MAGIC_SET__
3928 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
3929 #define __A_MAGIC_SET__
3932 #define __A_MAGIC_SET__
3933 internal_a
.magic
= PAGEMAGICBCS
;
3937 #define __A_MAGIC_SET__
3938 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
3941 #if defined(M68) || defined(WE32K) || defined(M68K)
3942 #define __A_MAGIC_SET__
3944 internal_a
.magic
= LYNXCOFFMAGIC
;
3946 #if defined(TARG_AUX)
3947 internal_a
.magic
= (abfd
->flags
& D_PAGED
? PAGEMAGICPEXECPAGED
:
3948 abfd
->flags
& WP_TEXT
? PAGEMAGICPEXECSWAPPED
:
3949 PAGEMAGICEXECSWAPPED
);
3951 #if defined (PAGEMAGICPEXECPAGED)
3952 internal_a
.magic
= PAGEMAGICPEXECPAGED
;
3954 #endif /* TARG_AUX */
3956 #endif /* M68 || WE32K || M68K */
3959 #define __A_MAGIC_SET__
3960 internal_a
.magic
= ZMAGIC
;
3964 #define __A_MAGIC_SET__
3965 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3968 #if defined MCORE_PE
3969 #define __A_MAGIC_SET__
3970 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3974 #define __A_MAGIC_SET__
3976 internal_a
.magic
= LYNXCOFFMAGIC
;
3978 internal_a
.magic
= ZMAGIC
;
3983 #define __A_MAGIC_SET__
3984 internal_a
.magic
= ZMAGIC
;
3988 #define __A_MAGIC_SET__
3990 internal_a
.magic
= LYNXCOFFMAGIC
;
3995 #define __A_MAGIC_SET__
3996 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
3997 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
3998 RS6K_AOUTHDR_OMAGIC
;
4001 #if defined(SH) && defined(COFF_WITH_PE)
4002 #define __A_MAGIC_SET__
4003 internal_a
.magic
= SH_PE_MAGIC
;
4006 #if defined(MIPS) && defined(COFF_WITH_PE)
4007 #define __A_MAGIC_SET__
4008 internal_a
.magic
= MIPS_PE_MAGIC
;
4012 #define __A_MAGIC_SET__
4013 internal_a
.magic
= NMAGIC
; /* Assume separate i/d. */
4017 #define __A_MAGIC_SET__
4018 internal_a
.magic
= MAXQ20MAGIC
;
4021 #ifndef __A_MAGIC_SET__
4022 #include "Your aouthdr magic number is not being set!"
4024 #undef __A_MAGIC_SET__
4028 /* FIXME: Does anybody ever set this to another value? */
4029 internal_a
.vstamp
= 0;
4031 /* Now should write relocs, strings, syms. */
4032 obj_sym_filepos (abfd
) = sym_base
;
4034 if (bfd_get_symcount (abfd
) != 0)
4038 if (!coff_renumber_symbols (abfd
, &firstundef
))
4040 coff_mangle_symbols (abfd
);
4041 if (! coff_write_symbols (abfd
))
4043 if (! coff_write_linenumbers (abfd
))
4045 if (! coff_write_relocs (abfd
, firstundef
))
4048 #ifdef COFF_LONG_SECTION_NAMES
4049 else if (long_section_names
&& ! obj_coff_strings_written (abfd
))
4051 /* If we have long section names we have to write out the string
4052 table even if there are no symbols. */
4053 if (! coff_write_symbols (abfd
))
4057 #ifdef COFF_IMAGE_WITH_PE
4059 else if ((abfd
->flags
& EXEC_P
) != 0)
4063 /* PowerPC PE appears to require that all executable files be
4064 rounded up to the page size. */
4067 (file_ptr
) BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
4069 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
4075 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
4076 backend linker, and obj_raw_syment_count is not valid until after
4077 coff_write_symbols is called. */
4078 if (obj_raw_syment_count (abfd
) != 0)
4080 internal_f
.f_symptr
= sym_base
;
4082 /* AIX appears to require that F_RELFLG not be set if there are
4083 local symbols but no relocations. */
4084 internal_f
.f_flags
&=~ F_RELFLG
;
4089 if (long_section_names
)
4090 internal_f
.f_symptr
= sym_base
;
4092 internal_f
.f_symptr
= 0;
4093 internal_f
.f_flags
|= F_LSYMS
;
4098 internal_a
.tsize
= text_sec
->size
;
4099 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
4103 internal_a
.dsize
= data_sec
->size
;
4104 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
4108 internal_a
.bsize
= bss_sec
->size
;
4109 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
4110 internal_a
.data_start
= bss_sec
->vma
;
4113 internal_a
.entry
= bfd_get_start_address (abfd
);
4114 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
4117 if (xcoff_data (abfd
)->full_aouthdr
)
4120 asection
*loader_sec
;
4122 internal_a
.vstamp
= 1;
4124 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
4125 if (internal_a
.o_snentry
== 0)
4126 internal_a
.entry
= (bfd_vma
) -1;
4128 if (text_sec
!= NULL
)
4130 internal_a
.o_sntext
= text_sec
->target_index
;
4131 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
4135 internal_a
.o_sntext
= 0;
4136 internal_a
.o_algntext
= 0;
4138 if (data_sec
!= NULL
)
4140 internal_a
.o_sndata
= data_sec
->target_index
;
4141 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
4145 internal_a
.o_sndata
= 0;
4146 internal_a
.o_algndata
= 0;
4148 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
4149 if (loader_sec
!= NULL
)
4150 internal_a
.o_snloader
= loader_sec
->target_index
;
4152 internal_a
.o_snloader
= 0;
4153 if (bss_sec
!= NULL
)
4154 internal_a
.o_snbss
= bss_sec
->target_index
;
4156 internal_a
.o_snbss
= 0;
4158 toc
= xcoff_data (abfd
)->toc
;
4159 internal_a
.o_toc
= toc
;
4160 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
4162 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
4163 if (xcoff_data (abfd
)->cputype
!= -1)
4164 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
4167 switch (bfd_get_arch (abfd
))
4169 case bfd_arch_rs6000
:
4170 internal_a
.o_cputype
= 4;
4172 case bfd_arch_powerpc
:
4173 if (bfd_get_mach (abfd
) == bfd_mach_ppc
)
4174 internal_a
.o_cputype
= 3;
4176 internal_a
.o_cputype
= 1;
4182 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
4183 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
4187 /* now write them */
4188 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
4193 bfd_size_type amount
= bfd_coff_filhsz (abfd
);
4195 buff
= bfd_malloc (amount
);
4199 bfd_coff_swap_filehdr_out (abfd
, (PTR
) &internal_f
, (PTR
) buff
);
4200 amount
= bfd_bwrite ((PTR
) buff
, amount
, abfd
);
4204 if (amount
!= bfd_coff_filhsz (abfd
))
4208 if (abfd
->flags
& EXEC_P
)
4210 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4211 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4213 bfd_size_type amount
= bfd_coff_aoutsz (abfd
);
4215 buff
= bfd_malloc (amount
);
4219 coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, (PTR
) buff
);
4220 amount
= bfd_bwrite ((PTR
) buff
, amount
, abfd
);
4224 if (amount
!= bfd_coff_aoutsz (abfd
))
4227 #ifdef COFF_IMAGE_WITH_PE
4228 if (! coff_apply_checksum (abfd
))
4238 /* XCOFF seems to always write at least a small a.out header. */
4239 coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, (PTR
) &buff
);
4240 if (xcoff_data (abfd
)->full_aouthdr
)
4241 size
= bfd_coff_aoutsz (abfd
);
4243 size
= SMALL_AOUTSZ
;
4244 if (bfd_bwrite ((PTR
) &buff
, (bfd_size_type
) size
, abfd
) != size
)
4253 coff_set_section_contents (abfd
, section
, location
, offset
, count
)
4258 bfd_size_type count
;
4260 if (! abfd
->output_has_begun
) /* Set by bfd.c handler. */
4262 if (! coff_compute_section_file_positions (abfd
))
4266 #if defined(_LIB) && !defined(TARG_AUX)
4268 /* The physical address field of a .lib section is used to hold the
4269 number of shared libraries in the section. This code counts the
4270 number of sections being written, and increments the lma field
4273 I have found no documentation on the contents of this section.
4274 Experimentation indicates that the section contains zero or more
4275 records, each of which has the following structure:
4277 - a (four byte) word holding the length of this record, in words,
4278 - a word that always seems to be set to "2",
4279 - the path to a shared library, null-terminated and then padded
4280 to a whole word boundary.
4282 bfd_assert calls have been added to alert if an attempt is made
4283 to write a section which doesn't follow these assumptions. The
4284 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4285 <robertl@arnet.com> (Thanks!).
4287 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4289 if (strcmp (section
->name
, _LIB
) == 0)
4291 bfd_byte
*rec
, *recend
;
4293 rec
= (bfd_byte
*) location
;
4294 recend
= rec
+ count
;
4295 while (rec
< recend
)
4298 rec
+= bfd_get_32 (abfd
, rec
) * 4;
4301 BFD_ASSERT (rec
== recend
);
4306 /* Don't write out bss sections - one way to do this is to
4307 see if the filepos has not been set. */
4308 if (section
->filepos
== 0)
4311 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0)
4317 return bfd_bwrite (location
, count
, abfd
) == count
;
4321 buy_and_read (abfd
, where
, size
)
4326 PTR area
= (PTR
) bfd_alloc (abfd
, size
);
4329 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0
4330 || bfd_bread (area
, size
, abfd
) != size
)
4333 } /* buy_and_read() */
4339 Creating the linenumber table is done by reading in the entire
4340 coff linenumber table, and creating another table for internal use.
4342 A coff linenumber table is structured so that each function
4343 is marked as having a line number of 0. Each line within the
4344 function is an offset from the first line in the function. The
4345 base of the line number information for the table is stored in
4346 the symbol associated with the function.
4348 Note: The PE format uses line number 0 for a flag indicating a
4351 The information is copied from the external to the internal
4352 table, and each symbol which marks a function is marked by
4355 How does this work ?
4360 coff_slurp_line_table (abfd
, asect
)
4364 LINENO
*native_lineno
;
4365 alent
*lineno_cache
;
4368 BFD_ASSERT (asect
->lineno
== (alent
*) NULL
);
4370 amt
= (bfd_size_type
) bfd_coff_linesz (abfd
) * asect
->lineno_count
;
4371 native_lineno
= (LINENO
*) buy_and_read (abfd
, asect
->line_filepos
, amt
);
4372 if (native_lineno
== NULL
)
4374 (*_bfd_error_handler
)
4375 (_("%B: warning: line number table read failed"), abfd
);
4378 amt
= ((bfd_size_type
) asect
->lineno_count
+ 1) * sizeof (alent
);
4379 lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
);
4380 if (lineno_cache
== NULL
)
4384 unsigned int counter
= 0;
4385 alent
*cache_ptr
= lineno_cache
;
4386 LINENO
*src
= native_lineno
;
4388 while (counter
< asect
->lineno_count
)
4390 struct internal_lineno dst
;
4392 bfd_coff_swap_lineno_in (abfd
, src
, &dst
);
4393 cache_ptr
->line_number
= dst
.l_lnno
;
4395 if (cache_ptr
->line_number
== 0)
4398 bfd_signed_vma symndx
;
4399 coff_symbol_type
*sym
;
4402 symndx
= dst
.l_addr
.l_symndx
;
4404 || (bfd_vma
) symndx
>= obj_raw_syment_count (abfd
))
4406 (*_bfd_error_handler
)
4407 (_("%B: warning: illegal symbol index %ld in line numbers"),
4408 abfd
, dst
.l_addr
.l_symndx
);
4412 /* FIXME: We should not be casting between ints and
4413 pointers like this. */
4414 sym
= ((coff_symbol_type
*)
4415 ((symndx
+ obj_raw_syments (abfd
))
4416 ->u
.syment
._n
._n_n
._n_zeroes
));
4417 cache_ptr
->u
.sym
= (asymbol
*) sym
;
4418 if (sym
->lineno
!= NULL
&& ! warned
)
4420 (*_bfd_error_handler
)
4421 (_("%B: warning: duplicate line number information for `%s'"),
4422 abfd
, bfd_asymbol_name (&sym
->symbol
));
4424 sym
->lineno
= cache_ptr
;
4428 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
4429 - bfd_section_vma (abfd
, asect
);
4430 } /* If no linenumber expect a symbol index */
4436 cache_ptr
->line_number
= 0;
4439 asect
->lineno
= lineno_cache
;
4440 /* FIXME, free native_lineno here, or use alloca or something. */
4444 /* Slurp in the symbol table, converting it to generic form. Note
4445 that if coff_relocate_section is defined, the linker will read
4446 symbols via coff_link_add_symbols, rather than via this routine. */
4449 coff_slurp_symbol_table (abfd
)
4452 combined_entry_type
*native_symbols
;
4453 coff_symbol_type
*cached_area
;
4454 unsigned int *table_ptr
;
4456 unsigned int number_of_symbols
= 0;
4458 if (obj_symbols (abfd
))
4461 /* Read in the symbol table. */
4462 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4465 /* Allocate enough room for all the symbols in cached form. */
4466 amt
= obj_raw_syment_count (abfd
);
4467 amt
*= sizeof (coff_symbol_type
);
4468 cached_area
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
4469 if (cached_area
== NULL
)
4472 amt
= obj_raw_syment_count (abfd
);
4473 amt
*= sizeof (unsigned int);
4474 table_ptr
= (unsigned int *) bfd_alloc (abfd
, amt
);
4476 if (table_ptr
== NULL
)
4480 coff_symbol_type
*dst
= cached_area
;
4481 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4482 unsigned int this_index
= 0;
4484 while (this_index
< last_native_index
)
4486 combined_entry_type
*src
= native_symbols
+ this_index
;
4487 table_ptr
[this_index
] = number_of_symbols
;
4488 dst
->symbol
.the_bfd
= abfd
;
4490 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4491 /* We use the native name field to point to the cached field. */
4492 src
->u
.syment
._n
._n_n
._n_zeroes
= (long) dst
;
4493 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4494 src
->u
.syment
.n_scnum
);
4495 dst
->symbol
.flags
= 0;
4496 dst
->done_lineno
= FALSE
;
4498 switch (src
->u
.syment
.n_sclass
)
4502 /* Fall through to next case. */
4509 case C_THUMBEXTFUNC
:
4515 case C_SYSTEM
: /* System Wide variable. */
4518 /* In PE, 0x68 (104) denotes a section symbol. */
4520 /* In PE, 0x69 (105) denotes a weak external symbol. */
4523 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4525 case COFF_SYMBOL_GLOBAL
:
4526 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4527 #if defined COFF_WITH_PE
4528 /* PE sets the symbol to a value relative to the
4529 start of the section. */
4530 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4532 dst
->symbol
.value
= (src
->u
.syment
.n_value
4533 - dst
->symbol
.section
->vma
);
4535 if (ISFCN ((src
->u
.syment
.n_type
)))
4537 /* A function ext does not go at the end of a
4539 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4543 case COFF_SYMBOL_COMMON
:
4544 dst
->symbol
.section
= bfd_com_section_ptr
;
4545 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4548 case COFF_SYMBOL_UNDEFINED
:
4549 dst
->symbol
.section
= bfd_und_section_ptr
;
4550 dst
->symbol
.value
= 0;
4553 case COFF_SYMBOL_PE_SECTION
:
4554 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4555 dst
->symbol
.value
= 0;
4558 case COFF_SYMBOL_LOCAL
:
4559 dst
->symbol
.flags
= BSF_LOCAL
;
4560 #if defined COFF_WITH_PE
4561 /* PE sets the symbol to a value relative to the
4562 start of the section. */
4563 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4565 dst
->symbol
.value
= (src
->u
.syment
.n_value
4566 - dst
->symbol
.section
->vma
);
4568 if (ISFCN ((src
->u
.syment
.n_type
)))
4569 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4574 /* A symbol with a csect entry should not go at the end. */
4575 if (src
->u
.syment
.n_numaux
> 0)
4576 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4580 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4581 dst
->symbol
.flags
|= BSF_WEAK
;
4583 if (src
->u
.syment
.n_sclass
== C_SECTION
4584 && src
->u
.syment
.n_scnum
> 0)
4585 dst
->symbol
.flags
= BSF_LOCAL
;
4587 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
)
4588 dst
->symbol
.flags
|= BSF_WEAK
;
4592 case C_STAT
: /* Static. */
4594 case C_LEAFSTAT
: /* Static leaf procedure. */
4597 case C_THUMBSTAT
: /* Thumb static. */
4598 case C_THUMBLABEL
: /* Thumb label. */
4599 case C_THUMBSTATFUNC
:/* Thumb static function. */
4601 case C_LABEL
: /* Label. */
4602 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4603 dst
->symbol
.flags
= BSF_DEBUGGING
;
4605 dst
->symbol
.flags
= BSF_LOCAL
;
4607 /* Base the value as an index from the base of the
4608 section, if there is one. */
4609 if (dst
->symbol
.section
)
4611 #if defined COFF_WITH_PE
4612 /* PE sets the symbol to a value relative to the
4613 start of the section. */
4614 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4616 dst
->symbol
.value
= (src
->u
.syment
.n_value
4617 - dst
->symbol
.section
->vma
);
4621 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4624 case C_MOS
: /* Member of structure. */
4625 case C_EOS
: /* End of structure. */
4626 #ifdef NOTDEF /* C_AUTOARG has the same value. */
4628 case C_GLBLREG
: /* A29k-specific storage class. */
4631 case C_REGPARM
: /* Register parameter. */
4632 case C_REG
: /* register variable. */
4633 /* C_AUTOARG conflicts with TI COFF C_UEXT. */
4634 #if !defined (TIC80COFF) && !defined (TICOFF)
4636 case C_AUTOARG
: /* 960-specific storage class. */
4639 case C_TPDEF
: /* Type definition. */
4641 case C_AUTO
: /* Automatic variable. */
4642 case C_FIELD
: /* Bit field. */
4643 case C_ENTAG
: /* Enumeration tag. */
4644 case C_MOE
: /* Member of enumeration. */
4645 case C_MOU
: /* Member of union. */
4646 case C_UNTAG
: /* Union tag. */
4647 dst
->symbol
.flags
= BSF_DEBUGGING
;
4648 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4651 case C_FILE
: /* File name. */
4652 case C_STRTAG
: /* Structure tag. */
4669 dst
->symbol
.flags
= BSF_DEBUGGING
;
4670 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4674 case C_BINCL
: /* Beginning of include file. */
4675 case C_EINCL
: /* Ending of include file. */
4676 /* The value is actually a pointer into the line numbers
4677 of the file. We locate the line number entry, and
4678 set the section to the section which contains it, and
4679 the value to the index in that section. */
4683 dst
->symbol
.flags
= BSF_DEBUGGING
;
4684 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4685 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4686 && ((file_ptr
) (sec
->line_filepos
4687 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4688 > (file_ptr
) src
->u
.syment
.n_value
))
4691 dst
->symbol
.value
= 0;
4694 dst
->symbol
.section
= sec
;
4695 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4696 - sec
->line_filepos
)
4697 / bfd_coff_linesz (abfd
));
4704 dst
->symbol
.flags
= BSF_DEBUGGING
;
4706 /* The value is actually a symbol index. Save a pointer
4707 to the symbol instead of the index. FIXME: This
4708 should use a union. */
4709 src
->u
.syment
.n_value
=
4710 (long) (native_symbols
+ src
->u
.syment
.n_value
);
4711 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4716 case C_BLOCK
: /* ".bb" or ".eb". */
4717 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf"). */
4718 case C_EFCN
: /* Physical end of function. */
4719 #if defined COFF_WITH_PE
4720 /* PE sets the symbol to a value relative to the start
4722 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4723 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4725 /* PE uses funny values for .ef and .lf; don't
4727 dst
->symbol
.flags
= BSF_DEBUGGING
;
4730 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4732 /* Base the value as an index from the base of the
4734 dst
->symbol
.flags
= BSF_LOCAL
;
4735 dst
->symbol
.value
= (src
->u
.syment
.n_value
4736 - dst
->symbol
.section
->vma
);
4740 case C_STATLAB
: /* Static load time label. */
4741 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4742 dst
->symbol
.flags
= BSF_GLOBAL
;
4746 /* PE DLLs sometimes have zeroed out symbols for some
4747 reason. Just ignore them without a warning. */
4748 if (src
->u
.syment
.n_type
== 0
4749 && src
->u
.syment
.n_value
== 0
4750 && src
->u
.syment
.n_scnum
== 0)
4753 case C_EXTDEF
: /* External definition. */
4754 case C_ULABEL
: /* Undefined label. */
4755 case C_USTATIC
: /* Undefined static. */
4756 #ifndef COFF_WITH_PE
4757 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4758 class to represent a section symbol. */
4759 case C_LINE
: /* line # reformatted as symbol table entry. */
4760 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4761 case C_ALIAS
: /* Duplicate tag. */
4763 /* New storage classes for TI COFF. */
4764 #if defined(TIC80COFF) || defined(TICOFF)
4765 case C_UEXT
: /* Tentative external definition. */
4767 case C_EXTLAB
: /* External load time label. */
4768 case C_HIDDEN
: /* Ext symbol in dmert public lib. */
4770 (*_bfd_error_handler
)
4771 (_("%B: Unrecognized storage class %d for %s symbol `%s'"),
4772 abfd
, src
->u
.syment
.n_sclass
,
4773 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4774 dst
->symbol
.flags
= BSF_DEBUGGING
;
4775 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4779 /* BFD_ASSERT(dst->symbol.flags != 0);*/
4783 dst
->symbol
.udata
.i
= 0;
4784 dst
->lineno
= (alent
*) NULL
;
4785 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
4787 number_of_symbols
++;
4791 obj_symbols (abfd
) = cached_area
;
4792 obj_raw_syments (abfd
) = native_symbols
;
4794 bfd_get_symcount (abfd
) = number_of_symbols
;
4795 obj_convert (abfd
) = table_ptr
;
4796 /* Slurp the line tables for each section too. */
4803 coff_slurp_line_table (abfd
, p
);
4809 } /* coff_slurp_symbol_table() */
4811 /* Classify a COFF symbol. A couple of targets have globally visible
4812 symbols which are not class C_EXT, and this handles those. It also
4813 recognizes some special PE cases. */
4815 static enum coff_symbol_classification
4816 coff_classify_symbol (abfd
, syment
)
4818 struct internal_syment
*syment
;
4820 /* FIXME: This partially duplicates the switch in
4821 coff_slurp_symbol_table. */
4822 switch (syment
->n_sclass
)
4831 case C_THUMBEXTFUNC
:
4839 if (syment
->n_scnum
== 0)
4841 if (syment
->n_value
== 0)
4842 return COFF_SYMBOL_UNDEFINED
;
4844 return COFF_SYMBOL_COMMON
;
4846 return COFF_SYMBOL_GLOBAL
;
4853 if (syment
->n_sclass
== C_STAT
)
4855 if (syment
->n_scnum
== 0)
4857 /* The Microsoft compiler sometimes generates these if a
4858 small static function is inlined every time it is used.
4859 The function is discarded, but the symbol table entry
4861 return COFF_SYMBOL_LOCAL
;
4864 #ifdef STRICT_PE_FORMAT
4865 /* This is correct for Microsoft generated objects, but it
4866 breaks gas generated objects. */
4868 if (syment
->n_value
== 0)
4871 char buf
[SYMNMLEN
+ 1];
4873 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
4875 && (strcmp (bfd_get_section_name (abfd
, sec
),
4876 _bfd_coff_internal_syment_name (abfd
, syment
, buf
))
4878 return COFF_SYMBOL_PE_SECTION
;
4882 return COFF_SYMBOL_LOCAL
;
4885 if (syment
->n_sclass
== C_SECTION
)
4887 /* In some cases in a DLL generated by the Microsoft linker, the
4888 n_value field will contain garbage. FIXME: This should
4889 probably be handled by the swapping function instead. */
4890 syment
->n_value
= 0;
4891 if (syment
->n_scnum
== 0)
4892 return COFF_SYMBOL_UNDEFINED
;
4893 return COFF_SYMBOL_PE_SECTION
;
4895 #endif /* COFF_WITH_PE */
4897 /* If it is not a global symbol, we presume it is a local symbol. */
4899 if (syment
->n_scnum
== 0)
4901 char buf
[SYMNMLEN
+ 1];
4903 (*_bfd_error_handler
)
4904 (_("warning: %B: local symbol `%s' has no section"),
4905 abfd
, _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
4908 return COFF_SYMBOL_LOCAL
;
4915 Coff relocations are easily transformed into the internal BFD form
4918 Reading a coff relocation table is done in the following stages:
4920 o Read the entire coff relocation table into memory.
4922 o Process each relocation in turn; first swap it from the
4923 external to the internal form.
4925 o Turn the symbol referenced in the relocation's symbol index
4926 into a pointer into the canonical symbol table.
4927 This table is the same as the one returned by a call to
4928 @code{bfd_canonicalize_symtab}. The back end will call that
4929 routine and save the result if a canonicalization hasn't been done.
4931 o The reloc index is turned into a pointer to a howto
4932 structure, in a back end specific way. For instance, the 386
4933 and 960 use the @code{r_type} to directly produce an index
4934 into a howto table vector; the 88k subtracts a number from the
4935 @code{r_type} field and creates an addend field.
4940 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
4942 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
4943 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
4944 coffsym = (obj_symbols (abfd) \
4945 + (cache_ptr->sym_ptr_ptr - symbols)); \
4947 coffsym = coff_symbol_from (abfd, ptr); \
4948 if (coffsym != (coff_symbol_type *) NULL \
4949 && coffsym->native->u.syment.n_scnum == 0) \
4950 cache_ptr->addend = 0; \
4951 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
4952 && ptr->section != (asection *) NULL) \
4953 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
4955 cache_ptr->addend = 0; \
4960 coff_slurp_reloc_table (abfd
, asect
, symbols
)
4965 RELOC
*native_relocs
;
4966 arelent
*reloc_cache
;
4971 if (asect
->relocation
)
4973 if (asect
->reloc_count
== 0)
4975 if (asect
->flags
& SEC_CONSTRUCTOR
)
4977 if (!coff_slurp_symbol_table (abfd
))
4979 amt
= (bfd_size_type
) bfd_coff_relsz (abfd
) * asect
->reloc_count
;
4980 native_relocs
= (RELOC
*) buy_and_read (abfd
, asect
->rel_filepos
, amt
);
4981 amt
= (bfd_size_type
) asect
->reloc_count
* sizeof (arelent
);
4982 reloc_cache
= (arelent
*) bfd_alloc (abfd
, amt
);
4984 if (reloc_cache
== NULL
)
4987 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
4989 struct internal_reloc dst
;
4990 struct external_reloc
*src
;
4991 #ifndef RELOC_PROCESSING
4995 cache_ptr
= reloc_cache
+ idx
;
4996 src
= native_relocs
+ idx
;
4998 coff_swap_reloc_in (abfd
, src
, &dst
);
5000 #ifdef RELOC_PROCESSING
5001 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
5003 cache_ptr
->address
= dst
.r_vaddr
;
5005 if (dst
.r_symndx
!= -1)
5007 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
5009 (*_bfd_error_handler
)
5010 (_("%B: warning: illegal symbol index %ld in relocs"),
5011 abfd
, dst
.r_symndx
);
5012 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5017 cache_ptr
->sym_ptr_ptr
= (symbols
5018 + obj_convert (abfd
)[dst
.r_symndx
]);
5019 ptr
= *(cache_ptr
->sym_ptr_ptr
);
5024 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5028 /* The symbols definitions that we have read in have been
5029 relocated as if their sections started at 0. But the offsets
5030 refering to the symbols in the raw data have not been
5031 modified, so we have to have a negative addend to compensate.
5033 Note that symbols which used to be common must be left alone. */
5035 /* Calculate any reloc addend by looking at the symbol. */
5036 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
5038 cache_ptr
->address
-= asect
->vma
;
5039 /* !! cache_ptr->section = (asection *) NULL;*/
5041 /* Fill in the cache_ptr->howto field from dst.r_type. */
5042 RTYPE2HOWTO (cache_ptr
, &dst
);
5043 #endif /* RELOC_PROCESSING */
5045 if (cache_ptr
->howto
== NULL
)
5047 (*_bfd_error_handler
)
5048 (_("%B: illegal relocation type %d at address 0x%lx"),
5049 abfd
, dst
.r_type
, (long) dst
.r_vaddr
);
5050 bfd_set_error (bfd_error_bad_value
);
5055 asect
->relocation
= reloc_cache
;
5059 #ifndef coff_rtype_to_howto
5062 /* Get the howto structure for a reloc. This is only used if the file
5063 including this one defines coff_relocate_section to be
5064 _bfd_coff_generic_relocate_section, so it is OK if it does not
5065 always work. It is the responsibility of the including file to
5066 make sure it is reasonable if it is needed. */
5068 static reloc_howto_type
*coff_rtype_to_howto
5069 PARAMS ((bfd
*, asection
*, struct internal_reloc
*,
5070 struct coff_link_hash_entry
*, struct internal_syment
*,
5073 static reloc_howto_type
*
5074 coff_rtype_to_howto (abfd
, sec
, rel
, h
, sym
, addendp
)
5075 bfd
*abfd ATTRIBUTE_UNUSED
;
5076 asection
*sec ATTRIBUTE_UNUSED
;
5077 struct internal_reloc
*rel
;
5078 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
;
5079 struct internal_syment
*sym ATTRIBUTE_UNUSED
;
5080 bfd_vma
*addendp ATTRIBUTE_UNUSED
;
5084 RTYPE2HOWTO (&genrel
, rel
);
5085 return genrel
.howto
;
5088 #else /* ! defined (RTYPE2HOWTO) */
5090 #define coff_rtype_to_howto NULL
5092 #endif /* ! defined (RTYPE2HOWTO) */
5093 #endif /* ! defined (coff_rtype_to_howto) */
5095 /* This is stupid. This function should be a boolean predicate. */
5097 coff_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
5103 arelent
*tblptr
= section
->relocation
;
5104 unsigned int count
= 0;
5106 if (section
->flags
& SEC_CONSTRUCTOR
)
5108 /* This section has relocs made up by us, they are not in the
5109 file, so take them out of their chain and place them into
5110 the data area provided. */
5111 arelent_chain
*chain
= section
->constructor_chain
;
5113 for (count
= 0; count
< section
->reloc_count
; count
++)
5115 *relptr
++ = &chain
->relent
;
5116 chain
= chain
->next
;
5121 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
5124 tblptr
= section
->relocation
;
5126 for (; count
++ < section
->reloc_count
;)
5127 *relptr
++ = tblptr
++;
5130 return section
->reloc_count
;
5133 #ifndef coff_reloc16_estimate
5134 #define coff_reloc16_estimate dummy_reloc16_estimate
5136 static int dummy_reloc16_estimate
5137 PARAMS ((bfd
*, asection
*, arelent
*, unsigned int,
5138 struct bfd_link_info
*));
5141 dummy_reloc16_estimate (abfd
, input_section
, reloc
, shrink
, link_info
)
5142 bfd
*abfd ATTRIBUTE_UNUSED
;
5143 asection
*input_section ATTRIBUTE_UNUSED
;
5144 arelent
*reloc ATTRIBUTE_UNUSED
;
5145 unsigned int shrink ATTRIBUTE_UNUSED
;
5146 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
5154 #ifndef coff_reloc16_extra_cases
5156 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5158 /* This works even if abort is not declared in any header file. */
5160 static void dummy_reloc16_extra_cases
5161 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*, arelent
*,
5162 bfd_byte
*, unsigned int *, unsigned int *));
5165 dummy_reloc16_extra_cases (abfd
, link_info
, link_order
, reloc
, data
, src_ptr
,
5167 bfd
*abfd ATTRIBUTE_UNUSED
;
5168 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
5169 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
;
5170 arelent
*reloc ATTRIBUTE_UNUSED
;
5171 bfd_byte
*data ATTRIBUTE_UNUSED
;
5172 unsigned int *src_ptr ATTRIBUTE_UNUSED
;
5173 unsigned int *dst_ptr ATTRIBUTE_UNUSED
;
5179 #ifndef coff_bfd_link_hash_table_free
5180 #define coff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
5183 /* If coff_relocate_section is defined, we can use the optimized COFF
5184 backend linker. Otherwise we must continue to use the old linker. */
5185 #ifdef coff_relocate_section
5186 #ifndef coff_bfd_link_hash_table_create
5187 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5189 #ifndef coff_bfd_link_add_symbols
5190 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5192 #ifndef coff_bfd_final_link
5193 #define coff_bfd_final_link _bfd_coff_final_link
5195 #else /* ! defined (coff_relocate_section) */
5196 #define coff_relocate_section NULL
5197 #ifndef coff_bfd_link_hash_table_create
5198 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5200 #ifndef coff_bfd_link_add_symbols
5201 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5203 #define coff_bfd_final_link _bfd_generic_final_link
5204 #endif /* ! defined (coff_relocate_section) */
5206 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5207 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5209 #ifndef coff_start_final_link
5210 #define coff_start_final_link NULL
5213 #ifndef coff_adjust_symndx
5214 #define coff_adjust_symndx NULL
5217 #ifndef coff_link_add_one_symbol
5218 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5221 #ifndef coff_link_output_has_begun
5223 static bfd_boolean coff_link_output_has_begun
5224 PARAMS ((bfd
*, struct coff_final_link_info
*));
5227 coff_link_output_has_begun (abfd
, info
)
5229 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
;
5231 return abfd
->output_has_begun
;
5235 #ifndef coff_final_link_postscript
5237 static bfd_boolean coff_final_link_postscript
5238 PARAMS ((bfd
*, struct coff_final_link_info
*));
5241 coff_final_link_postscript (abfd
, pfinfo
)
5242 bfd
* abfd ATTRIBUTE_UNUSED
;
5243 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
;
5249 #ifndef coff_SWAP_aux_in
5250 #define coff_SWAP_aux_in coff_swap_aux_in
5252 #ifndef coff_SWAP_sym_in
5253 #define coff_SWAP_sym_in coff_swap_sym_in
5255 #ifndef coff_SWAP_lineno_in
5256 #define coff_SWAP_lineno_in coff_swap_lineno_in
5258 #ifndef coff_SWAP_aux_out
5259 #define coff_SWAP_aux_out coff_swap_aux_out
5261 #ifndef coff_SWAP_sym_out
5262 #define coff_SWAP_sym_out coff_swap_sym_out
5264 #ifndef coff_SWAP_lineno_out
5265 #define coff_SWAP_lineno_out coff_swap_lineno_out
5267 #ifndef coff_SWAP_reloc_out
5268 #define coff_SWAP_reloc_out coff_swap_reloc_out
5270 #ifndef coff_SWAP_filehdr_out
5271 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5273 #ifndef coff_SWAP_aouthdr_out
5274 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5276 #ifndef coff_SWAP_scnhdr_out
5277 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5279 #ifndef coff_SWAP_reloc_in
5280 #define coff_SWAP_reloc_in coff_swap_reloc_in
5282 #ifndef coff_SWAP_filehdr_in
5283 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5285 #ifndef coff_SWAP_aouthdr_in
5286 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5288 #ifndef coff_SWAP_scnhdr_in
5289 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5292 static const bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED
=
5294 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5295 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5296 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5297 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5298 coff_SWAP_scnhdr_out
,
5299 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5300 #ifdef COFF_LONG_FILENAMES
5305 #ifdef COFF_LONG_SECTION_NAMES
5310 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5311 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5316 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5321 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5322 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5323 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5324 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5325 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5326 coff_classify_symbol
, coff_compute_section_file_positions
,
5327 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5328 coff_adjust_symndx
, coff_link_add_one_symbol
,
5329 coff_link_output_has_begun
, coff_final_link_postscript
5333 /* COFF0 differs in file/section header size and relocation entry size. */
5334 static const bfd_coff_backend_data ticoff0_swap_table
=
5336 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5337 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5338 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5339 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5340 coff_SWAP_scnhdr_out
,
5341 FILHSZ_V0
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ_V0
, LINESZ
, FILNMLEN
,
5342 #ifdef COFF_LONG_FILENAMES
5347 #ifdef COFF_LONG_SECTION_NAMES
5352 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5353 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5358 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5363 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5364 coff_SWAP_reloc_in
, ticoff0_bad_format_hook
, coff_set_arch_mach_hook
,
5365 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5366 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5367 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5368 coff_classify_symbol
, coff_compute_section_file_positions
,
5369 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5370 coff_adjust_symndx
, coff_link_add_one_symbol
,
5371 coff_link_output_has_begun
, coff_final_link_postscript
5376 /* COFF1 differs in section header size. */
5377 static const bfd_coff_backend_data ticoff1_swap_table
=
5379 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5380 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5381 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5382 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5383 coff_SWAP_scnhdr_out
,
5384 FILHSZ
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5385 #ifdef COFF_LONG_FILENAMES
5390 #ifdef COFF_LONG_SECTION_NAMES
5395 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5396 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5401 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5406 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5407 coff_SWAP_reloc_in
, ticoff1_bad_format_hook
, coff_set_arch_mach_hook
,
5408 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5409 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5410 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5411 coff_classify_symbol
, coff_compute_section_file_positions
,
5412 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5413 coff_adjust_symndx
, coff_link_add_one_symbol
,
5414 coff_link_output_has_begun
, coff_final_link_postscript
5418 #ifndef coff_close_and_cleanup
5419 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5422 #ifndef coff_bfd_free_cached_info
5423 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5426 #ifndef coff_get_section_contents
5427 #define coff_get_section_contents _bfd_generic_get_section_contents
5430 #ifndef coff_bfd_copy_private_symbol_data
5431 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5434 #ifndef coff_bfd_copy_private_header_data
5435 #define coff_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
5438 #ifndef coff_bfd_copy_private_section_data
5439 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5442 #ifndef coff_bfd_copy_private_bfd_data
5443 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5446 #ifndef coff_bfd_merge_private_bfd_data
5447 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5450 #ifndef coff_bfd_set_private_flags
5451 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5454 #ifndef coff_bfd_print_private_bfd_data
5455 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5458 #ifndef coff_bfd_is_local_label_name
5459 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5462 #ifndef coff_bfd_is_target_special_symbol
5463 #define coff_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
5466 #ifndef coff_read_minisymbols
5467 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5470 #ifndef coff_minisymbol_to_symbol
5471 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5474 /* The reloc lookup routine must be supplied by each individual COFF
5476 #ifndef coff_bfd_reloc_type_lookup
5477 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5480 #ifndef coff_bfd_get_relocated_section_contents
5481 #define coff_bfd_get_relocated_section_contents \
5482 bfd_generic_get_relocated_section_contents
5485 #ifndef coff_bfd_relax_section
5486 #define coff_bfd_relax_section bfd_generic_relax_section
5489 #ifndef coff_bfd_gc_sections
5490 #define coff_bfd_gc_sections bfd_generic_gc_sections
5493 #ifndef coff_bfd_merge_sections
5494 #define coff_bfd_merge_sections bfd_generic_merge_sections
5497 #ifndef coff_bfd_is_group_section
5498 #define coff_bfd_is_group_section bfd_generic_is_group_section
5501 #ifndef coff_bfd_discard_group
5502 #define coff_bfd_discard_group bfd_generic_discard_group
5505 #ifndef coff_section_already_linked
5506 #define coff_section_already_linked \
5507 _bfd_generic_section_already_linked
5510 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5511 const bfd_target VAR = \
5514 bfd_target_coff_flavour, \
5515 BFD_ENDIAN_BIG, /* data byte order is big */ \
5516 BFD_ENDIAN_BIG, /* header byte order is big */ \
5517 /* object flags */ \
5518 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5519 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5520 /* section flags */ \
5521 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5522 UNDER, /* leading symbol underscore */ \
5523 '/', /* ar_pad_char */ \
5524 15, /* ar_max_namelen */ \
5526 /* Data conversion functions. */ \
5527 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5528 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5529 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5531 /* Header conversion functions. */ \
5532 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5533 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5534 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5536 /* bfd_check_format */ \
5537 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5538 _bfd_dummy_target }, \
5539 /* bfd_set_format */ \
5540 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5541 /* bfd_write_contents */ \
5542 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5545 BFD_JUMP_TABLE_GENERIC (coff), \
5546 BFD_JUMP_TABLE_COPY (coff), \
5547 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5548 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5549 BFD_JUMP_TABLE_SYMBOLS (coff), \
5550 BFD_JUMP_TABLE_RELOCS (coff), \
5551 BFD_JUMP_TABLE_WRITE (coff), \
5552 BFD_JUMP_TABLE_LINK (coff), \
5553 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5560 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5561 const bfd_target VAR = \
5564 bfd_target_coff_flavour, \
5565 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
5566 BFD_ENDIAN_BIG, /* header byte order is big */ \
5567 /* object flags */ \
5568 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5569 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5570 /* section flags */ \
5571 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5572 UNDER, /* leading symbol underscore */ \
5573 '/', /* ar_pad_char */ \
5574 15, /* ar_max_namelen */ \
5576 /* Data conversion functions. */ \
5577 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5578 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5579 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5581 /* Header conversion functions. */ \
5582 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5583 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5584 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5586 /* bfd_check_format */ \
5587 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5588 _bfd_dummy_target }, \
5589 /* bfd_set_format */ \
5590 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5591 /* bfd_write_contents */ \
5592 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5595 BFD_JUMP_TABLE_GENERIC (coff), \
5596 BFD_JUMP_TABLE_COPY (coff), \
5597 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5598 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5599 BFD_JUMP_TABLE_SYMBOLS (coff), \
5600 BFD_JUMP_TABLE_RELOCS (coff), \
5601 BFD_JUMP_TABLE_WRITE (coff), \
5602 BFD_JUMP_TABLE_LINK (coff), \
5603 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5610 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5611 const bfd_target VAR = \
5614 bfd_target_coff_flavour, \
5615 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
5616 BFD_ENDIAN_LITTLE, /* header byte order is little */ \
5617 /* object flags */ \
5618 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5619 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5620 /* section flags */ \
5621 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5622 UNDER, /* leading symbol underscore */ \
5623 '/', /* ar_pad_char */ \
5624 15, /* ar_max_namelen */ \
5626 /* Data conversion functions. */ \
5627 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5628 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5629 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5630 /* Header conversion functions. */ \
5631 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5632 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5633 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5634 /* bfd_check_format */ \
5635 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5636 _bfd_dummy_target }, \
5637 /* bfd_set_format */ \
5638 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5639 /* bfd_write_contents */ \
5640 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5643 BFD_JUMP_TABLE_GENERIC (coff), \
5644 BFD_JUMP_TABLE_COPY (coff), \
5645 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5646 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5647 BFD_JUMP_TABLE_SYMBOLS (coff), \
5648 BFD_JUMP_TABLE_RELOCS (coff), \
5649 BFD_JUMP_TABLE_WRITE (coff), \
5650 BFD_JUMP_TABLE_LINK (coff), \
5651 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \