1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000
3 Free Software Foundation, Inc.
4 Written by Cygnus Support.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23 Most of this hacked by Steve Chamberlain,
31 BFD supports a number of different flavours of coff format.
32 The major differences between formats are the sizes and
33 alignments of fields in structures on disk, and the occasional
36 Coff in all its varieties is implemented with a few common
37 files and a number of implementation specific files. For
38 example, The 88k bcs coff format is implemented in the file
39 @file{coff-m88k.c}. This file @code{#include}s
40 @file{coff/m88k.h} which defines the external structure of the
41 coff format for the 88k, and @file{coff/internal.h} which
42 defines the internal structure. @file{coff-m88k.c} also
43 defines the relocations used by the 88k format
46 The Intel i960 processor version of coff is implemented in
47 @file{coff-i960.c}. This file has the same structure as
48 @file{coff-m88k.c}, except that it includes @file{coff/i960.h}
49 rather than @file{coff-m88k.h}.
52 Porting to a new version of coff
54 The recommended method is to select from the existing
55 implementations the version of coff which is most like the one
56 you want to use. For example, we'll say that i386 coff is
57 the one you select, and that your coff flavour is called foo.
58 Copy @file{i386coff.c} to @file{foocoff.c}, copy
59 @file{../include/coff/i386.h} to @file{../include/coff/foo.h},
60 and add the lines to @file{targets.c} and @file{Makefile.in}
61 so that your new back end is used. Alter the shapes of the
62 structures in @file{../include/coff/foo.h} so that they match
63 what you need. You will probably also have to add
64 @code{#ifdef}s to the code in @file{coff/internal.h} and
65 @file{coffcode.h} if your version of coff is too wild.
67 You can verify that your new BFD backend works quite simply by
68 building @file{objdump} from the @file{binutils} directory,
69 and making sure that its version of what's going on and your
70 host system's idea (assuming it has the pretty standard coff
71 dump utility, usually called @code{att-dump} or just
72 @code{dump}) are the same. Then clean up your code, and send
73 what you've done to Cygnus. Then your stuff will be in the
74 next release, and you won't have to keep integrating it.
77 How the coff backend works
82 The Coff backend is split into generic routines that are
83 applicable to any Coff target and routines that are specific
84 to a particular target. The target-specific routines are
85 further split into ones which are basically the same for all
86 Coff targets except that they use the external symbol format
87 or use different values for certain constants.
89 The generic routines are in @file{coffgen.c}. These routines
90 work for any Coff target. They use some hooks into the target
91 specific code; the hooks are in a @code{bfd_coff_backend_data}
92 structure, one of which exists for each target.
94 The essentially similar target-specific routines are in
95 @file{coffcode.h}. This header file includes executable C code.
96 The various Coff targets first include the appropriate Coff
97 header file, make any special defines that are needed, and
98 then include @file{coffcode.h}.
100 Some of the Coff targets then also have additional routines in
101 the target source file itself.
103 For example, @file{coff-i960.c} includes
104 @file{coff/internal.h} and @file{coff/i960.h}. It then
105 defines a few constants, such as @code{I960}, and includes
106 @file{coffcode.h}. Since the i960 has complex relocation
107 types, @file{coff-i960.c} also includes some code to
108 manipulate the i960 relocs. This code is not in
109 @file{coffcode.h} because it would not be used by any other
115 Each flavour of coff supported in BFD has its own header file
116 describing the external layout of the structures. There is also
117 an internal description of the coff layout, in
118 @file{coff/internal.h}. A major function of the
119 coff backend is swapping the bytes and twiddling the bits to
120 translate the external form of the structures into the normal
121 internal form. This is all performed in the
122 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
123 elements are different sizes between different versions of
124 coff; it is the duty of the coff version specific include file
125 to override the definitions of various packing routines in
126 @file{coffcode.h}. E.g., the size of line number entry in coff is
127 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
128 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
129 correct one. No doubt, some day someone will find a version of
130 coff which has a varying field size not catered to at the
131 moment. To port BFD, that person will have to add more @code{#defines}.
132 Three of the bit twiddling routines are exported to
133 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
134 and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol
135 table on its own, but uses BFD to fix things up. More of the
136 bit twiddlers are exported for @code{gas};
137 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
138 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
139 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
140 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
141 of all the symbol table and reloc drudgery itself, thereby
142 saving the internal BFD overhead, but uses BFD to swap things
143 on the way out, making cross ports much safer. Doing so also
144 allows BFD (and thus the linker) to use the same header files
145 as @code{gas}, which makes one avenue to disaster disappear.
150 The simple canonical form for symbols used by BFD is not rich
151 enough to keep all the information available in a coff symbol
152 table. The back end gets around this problem by keeping the original
153 symbol table around, "behind the scenes".
155 When a symbol table is requested (through a call to
156 @code{bfd_canonicalize_symtab}), a request gets through to
157 @code{coff_get_normalized_symtab}. This reads the symbol table from
158 the coff file and swaps all the structures inside into the
159 internal form. It also fixes up all the pointers in the table
160 (represented in the file by offsets from the first symbol in
161 the table) into physical pointers to elements in the new
162 internal table. This involves some work since the meanings of
163 fields change depending upon context: a field that is a
164 pointer to another structure in the symbol table at one moment
165 may be the size in bytes of a structure at the next. Another
166 pass is made over the table. All symbols which mark file names
167 (<<C_FILE>> symbols) are modified so that the internal
168 string points to the value in the auxent (the real filename)
169 rather than the normal text associated with the symbol
172 At this time the symbol names are moved around. Coff stores
173 all symbols less than nine characters long physically
174 within the symbol table; longer strings are kept at the end of
175 the file in the string table. This pass moves all strings
176 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 hierachy 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
252 . {* Remembers the offset from the first symbol in the file for
253 . this symbol. Generated by coff_renumber_symbols. *}
254 .unsigned int offset;
256 . {* Should the value of this symbol be renumbered. Used for
257 . XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
258 .unsigned int fix_value : 1;
260 . {* Should the tag field of this symbol be renumbered.
261 . Created by coff_pointerize_aux. *}
262 .unsigned int fix_tag : 1;
264 . {* Should the endidx field of this symbol be renumbered.
265 . Created by coff_pointerize_aux. *}
266 .unsigned int fix_end : 1;
268 . {* Should the x_csect.x_scnlen field be renumbered.
269 . Created by coff_pointerize_aux. *}
270 .unsigned int fix_scnlen : 1;
272 . {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
273 . index into the line number entries. Set by
274 . coff_slurp_symbol_table. *}
275 .unsigned int fix_line : 1;
277 . {* The container for the symbol structure as read and translated
281 . union internal_auxent auxent;
282 . struct internal_syment syment;
284 .} combined_entry_type;
287 .{* Each canonical asymbol really looks like this: *}
289 .typedef struct coff_symbol_struct
291 . {* The actual symbol which the rest of BFD works with *}
294 . {* A pointer to the hidden information for this symbol *}
295 .combined_entry_type *native;
297 . {* A pointer to the linenumber information for this symbol *}
298 .struct lineno_cache_entry *lineno;
300 . {* Have the line numbers been relocated yet ? *}
301 .boolean done_lineno;
310 #include "coffswap.h"
313 #define STRING_SIZE_SIZE (4)
315 static long sec_to_styp_flags
PARAMS ((const char *, flagword
));
316 static flagword styp_to_sec_flags
317 PARAMS ((bfd
*, PTR
, const char *, asection
*));
318 static boolean coff_bad_format_hook
PARAMS ((bfd
*, PTR
));
319 static void coff_set_custom_section_alignment
320 PARAMS ((bfd
*, asection
*, const struct coff_section_alignment_entry
*,
321 const unsigned int));
322 static boolean coff_new_section_hook
PARAMS ((bfd
*, asection
*));
323 static boolean coff_set_arch_mach_hook
PARAMS ((bfd
*, PTR
));
324 static boolean coff_write_relocs
PARAMS ((bfd
*, int));
325 static boolean coff_set_flags
326 PARAMS ((bfd
*, unsigned int *, unsigned short *));
327 static boolean coff_set_arch_mach
328 PARAMS ((bfd
*, enum bfd_architecture
, unsigned long));
329 static boolean coff_compute_section_file_positions
PARAMS ((bfd
*));
330 static boolean coff_write_object_contents
PARAMS ((bfd
*));
331 static boolean coff_set_section_contents
332 PARAMS ((bfd
*, asection
*, PTR
, file_ptr
, bfd_size_type
));
333 static PTR buy_and_read
PARAMS ((bfd
*, file_ptr
, int, size_t));
334 static boolean coff_slurp_line_table
PARAMS ((bfd
*, asection
*));
335 static boolean coff_slurp_symbol_table
PARAMS ((bfd
*));
336 static enum coff_symbol_classification coff_classify_symbol
337 PARAMS ((bfd
*, struct internal_syment
*));
338 static boolean coff_slurp_reloc_table
PARAMS ((bfd
*, asection
*, asymbol
**));
339 static long coff_canonicalize_reloc
340 PARAMS ((bfd
*, asection
*, arelent
**, asymbol
**));
341 #ifndef coff_mkobject_hook
342 static PTR coff_mkobject_hook
PARAMS ((bfd
*, PTR
, PTR
));
345 /* void warning(); */
347 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
348 the incoming SEC_* flags. The inverse of this function is
349 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
350 should probably mirror the changes in styp_to_sec_flags(). */
355 sec_to_styp_flags (sec_name
, sec_flags
)
356 CONST
char *sec_name
;
361 if (!strcmp (sec_name
, _TEXT
))
363 styp_flags
= STYP_TEXT
;
365 else if (!strcmp (sec_name
, _DATA
))
367 styp_flags
= STYP_DATA
;
369 else if (!strcmp (sec_name
, _BSS
))
371 styp_flags
= STYP_BSS
;
374 else if (!strcmp (sec_name
, _COMMENT
))
376 styp_flags
= STYP_INFO
;
377 #endif /* _COMMENT */
380 else if (!strcmp (sec_name
, _LIB
))
382 styp_flags
= STYP_LIB
;
386 else if (!strcmp (sec_name
, _LIT
))
388 styp_flags
= STYP_LIT
;
391 else if (!strcmp (sec_name
, ".debug"))
394 styp_flags
= STYP_DEBUG
;
396 styp_flags
= STYP_INFO
;
399 else if (!strncmp (sec_name
, ".stab", 5))
401 #ifdef COFF_ALIGN_IN_S_FLAGS
402 styp_flags
= STYP_DSECT
;
404 styp_flags
= STYP_INFO
;
408 else if (!strcmp (sec_name
, _PAD
))
410 styp_flags
= STYP_PAD
;
412 else if (!strcmp (sec_name
, _LOADER
))
414 styp_flags
= STYP_LOADER
;
417 /* Try and figure out what it should be */
418 else if (sec_flags
& SEC_CODE
)
420 styp_flags
= STYP_TEXT
;
422 else if (sec_flags
& SEC_DATA
)
424 styp_flags
= STYP_DATA
;
426 else if (sec_flags
& SEC_READONLY
)
428 #ifdef STYP_LIT /* 29k readonly text/data section */
429 styp_flags
= STYP_LIT
;
431 styp_flags
= STYP_TEXT
;
432 #endif /* STYP_LIT */
434 else if (sec_flags
& SEC_LOAD
)
436 styp_flags
= STYP_TEXT
;
438 else if (sec_flags
& SEC_ALLOC
)
440 styp_flags
= STYP_BSS
;
444 if (sec_flags
& SEC_CLINK
)
445 styp_flags
|= STYP_CLINK
;
449 if (sec_flags
& SEC_BLOCK
)
450 styp_flags
|= STYP_BLOCK
;
454 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
455 styp_flags
|= STYP_NOLOAD
;
461 #else /* COFF_WITH_PE */
463 /* The PE version; see above for the general comments. The non-PE
464 case seems to be more guessing, and breaks PE format; specifically,
465 .rdata is readonly, but it sure ain't text. Really, all this
466 should be set up properly in gas (or whatever assembler is in use),
467 and honor whatever objcopy/strip, etc. sent us as input. */
470 sec_to_styp_flags (sec_name
, sec_flags
)
471 const char *sec_name ATTRIBUTE_UNUSED
;
476 /* caution: there are at least three groups of symbols that have
477 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
478 SEC_* are the BFD internal flags, used for generic BFD
479 information. STYP_* are the COFF section flags which appear in
480 COFF files. IMAGE_SCN_* are the PE section flags which appear in
481 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
482 but there are more IMAGE_SCN_* flags. */
487 if ((sec_flags
& SEC_CODE
) != 0)
488 styp_flags
|= IMAGE_SCN_CNT_CODE
;
489 if ((sec_flags
& SEC_DATA
) != 0)
490 styp_flags
|= IMAGE_SCN_CNT_INITIALIZED_DATA
;
491 if ((sec_flags
& SEC_ALLOC
) != 0 && (sec_flags
& SEC_LOAD
) == 0)
492 styp_flags
|= IMAGE_SCN_CNT_UNINITIALIZED_DATA
; /* ==STYP_BSS */
494 /* skip CONSTRUCTOR */
497 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
498 styp_flags
|= STYP_NOLOAD
;
500 if ((sec_flags
& SEC_IS_COMMON
) != 0)
501 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
502 if ((sec_flags
& SEC_DEBUGGING
) != 0)
503 styp_flags
|= IMAGE_SCN_MEM_DISCARDABLE
;
504 if ((sec_flags
& SEC_EXCLUDE
) != 0)
505 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
506 if ((sec_flags
& SEC_NEVER_LOAD
) != 0)
507 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
510 if (sec_flags
& SEC_LINK_ONCE
)
511 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
512 /* skip LINK_DUPLICATES */
513 /* skip LINKER_CREATED */
515 /* For now, the read/write bits are mapped onto SEC_READONLY, even
516 though the semantics don't quite match. The bits from the input
517 are retained in pei_section_data(abfd, section)->pe_flags */
519 styp_flags
|= IMAGE_SCN_MEM_READ
; /* always readable. */
520 if ((sec_flags
& SEC_READONLY
) == 0)
521 styp_flags
|= IMAGE_SCN_MEM_WRITE
; /* Invert READONLY for write */
522 if (sec_flags
& SEC_CODE
)
523 styp_flags
|= IMAGE_SCN_MEM_EXECUTE
; /* CODE->EXECUTE */
524 if (sec_flags
& SEC_SHARED
)
525 styp_flags
|= IMAGE_SCN_MEM_SHARED
; /* Shared remains meaningful */
530 #endif /* COFF_WITH_PE */
532 /* Return a word with SEC_* flags set to represent the incoming STYP_*
533 flags (from scnhdr.s_flags). The inverse of this function is
534 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
535 should probably mirror the changes in sec_to_styp_flags(). */
540 styp_to_sec_flags (abfd
, hdr
, name
, section
)
541 bfd
*abfd ATTRIBUTE_UNUSED
;
544 asection
*section ATTRIBUTE_UNUSED
;
546 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
547 long styp_flags
= internal_s
->s_flags
;
548 flagword sec_flags
= 0;
551 if (styp_flags
& STYP_BLOCK
)
552 sec_flags
|= SEC_BLOCK
;
556 if (styp_flags
& STYP_CLINK
)
557 sec_flags
|= SEC_CLINK
;
561 if (styp_flags
& STYP_NOLOAD
)
563 sec_flags
|= SEC_NEVER_LOAD
;
565 #endif /* STYP_NOLOAD */
567 /* For 386 COFF, at least, an unloadable text or data section is
568 actually a shared library section. */
569 if (styp_flags
& STYP_TEXT
)
571 if (sec_flags
& SEC_NEVER_LOAD
)
572 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
574 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
576 else if (styp_flags
& STYP_DATA
)
578 if (sec_flags
& SEC_NEVER_LOAD
)
579 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
581 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
583 else if (styp_flags
& STYP_BSS
)
585 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
586 if (sec_flags
& SEC_NEVER_LOAD
)
587 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
590 sec_flags
|= SEC_ALLOC
;
592 else if (styp_flags
& STYP_INFO
)
594 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
595 defined. coff_compute_section_file_positions uses
596 COFF_PAGE_SIZE to ensure that the low order bits of the
597 section VMA and the file offset match. If we don't know
598 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
599 and demand page loading of the file will fail. */
600 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
601 sec_flags
|= SEC_DEBUGGING
;
604 else if (styp_flags
& STYP_PAD
)
608 else if (strcmp (name
, _TEXT
) == 0)
610 if (sec_flags
& SEC_NEVER_LOAD
)
611 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
613 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
615 else if (strcmp (name
, _DATA
) == 0)
617 if (sec_flags
& SEC_NEVER_LOAD
)
618 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
620 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
622 else if (strcmp (name
, _BSS
) == 0)
624 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
625 if (sec_flags
& SEC_NEVER_LOAD
)
626 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
629 sec_flags
|= SEC_ALLOC
;
631 else if (strcmp (name
, ".debug") == 0
633 || strcmp (name
, _COMMENT
) == 0
635 || strncmp (name
, ".stab", 5) == 0)
637 #ifdef COFF_PAGE_SIZE
638 sec_flags
|= SEC_DEBUGGING
;
642 else if (strcmp (name
, _LIB
) == 0)
646 else if (strcmp (name
, _LIT
) == 0)
648 sec_flags
= SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
653 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
656 #ifdef STYP_LIT /* A29k readonly text/data section type */
657 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
659 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
661 #endif /* STYP_LIT */
662 #ifdef STYP_OTHER_LOAD /* Other loaded sections */
663 if (styp_flags
& STYP_OTHER_LOAD
)
665 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
667 #endif /* STYP_SDATA */
669 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
670 /* As a GNU extension, if the name begins with .gnu.linkonce, we
671 only link a single copy of the section. This is used to support
672 g++. g++ will emit each template expansion in its own section.
673 The symbols will be defined as weak, so that multiple definitions
674 are permitted. The GNU linker extension is to actually discard
675 all but one of the sections. */
676 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
677 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
683 #else /* COFF_WITH_PE */
685 /* The PE version; see above for the general comments.
687 Since to set the SEC_LINK_ONCE and associated flags, we have to
688 look at the symbol table anyway, we return the symbol table index
689 of the symbol being used as the COMDAT symbol. This is admittedly
690 ugly, but there's really nowhere else that we have access to the
691 required information. FIXME: Is the COMDAT symbol index used for
692 any purpose other than objdump? */
695 styp_to_sec_flags (abfd
, hdr
, name
, section
)
696 bfd
*abfd ATTRIBUTE_UNUSED
;
701 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
702 long styp_flags
= internal_s
->s_flags
;
703 flagword sec_flags
= 0;
705 if (styp_flags
& STYP_DSECT
)
706 abort (); /* Don't know what to do */
707 #ifdef SEC_NEVER_LOAD
708 if (styp_flags
& STYP_NOLOAD
)
709 sec_flags
|= SEC_NEVER_LOAD
;
711 if (styp_flags
& STYP_GROUP
)
712 abort (); /* Don't know what to do */
713 /* skip IMAGE_SCN_TYPE_NO_PAD */
714 if (styp_flags
& STYP_COPY
)
715 abort (); /* Don't know what to do */
716 if (styp_flags
& IMAGE_SCN_CNT_CODE
)
717 sec_flags
|= SEC_CODE
| SEC_ALLOC
| SEC_LOAD
;
718 if (styp_flags
& IMAGE_SCN_CNT_INITIALIZED_DATA
)
719 sec_flags
|= SEC_DATA
| SEC_ALLOC
| SEC_LOAD
;
720 if (styp_flags
& IMAGE_SCN_CNT_UNINITIALIZED_DATA
)
721 sec_flags
|= SEC_ALLOC
;
722 if (styp_flags
& IMAGE_SCN_LNK_OTHER
)
723 abort (); /* Don't know what to do */
724 if (styp_flags
& IMAGE_SCN_LNK_INFO
)
726 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
727 defined. coff_compute_section_file_positions uses
728 COFF_PAGE_SIZE to ensure that the low order bits of the
729 section VMA and the file offset match. If we don't know
730 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
731 and demand page loading of the file will fail. */
732 #ifdef COFF_PAGE_SIZE
733 sec_flags
|= SEC_DEBUGGING
;
736 if (styp_flags
& STYP_OVER
)
737 abort (); /* Don't know what to do */
738 if (styp_flags
& IMAGE_SCN_LNK_REMOVE
)
739 sec_flags
|= SEC_EXCLUDE
;
741 if (styp_flags
& IMAGE_SCN_MEM_SHARED
)
742 sec_flags
|= SEC_SHARED
;
743 /* COMDAT: see below */
744 if (styp_flags
& IMAGE_SCN_MEM_DISCARDABLE
)
745 sec_flags
|= SEC_DEBUGGING
;
746 if (styp_flags
& IMAGE_SCN_MEM_NOT_CACHED
)
747 abort ();/* Don't know what to do */
748 if (styp_flags
& IMAGE_SCN_MEM_NOT_PAGED
)
749 abort (); /* Don't know what to do */
751 /* We infer from the distinct read/write/execute bits the settings
752 of some of the bfd flags; the actual values, should we need them,
753 are also in pei_section_data (abfd, section)->pe_flags. */
755 if (styp_flags
& IMAGE_SCN_MEM_EXECUTE
)
756 sec_flags
|= SEC_CODE
; /* Probably redundant */
757 /* IMAGE_SCN_MEM_READ is simply ignored, assuming it always to be true. */
758 if ((styp_flags
& IMAGE_SCN_MEM_WRITE
) == 0)
759 sec_flags
|= SEC_READONLY
;
761 /* COMDAT gets very special treatment. */
762 if (styp_flags
& IMAGE_SCN_LNK_COMDAT
)
764 sec_flags
|= SEC_LINK_ONCE
;
766 /* Unfortunately, the PE format stores essential information in
767 the symbol table, of all places. We need to extract that
768 information now, so that objdump and the linker will know how
769 to handle the section without worrying about the symbols. We
770 can't call slurp_symtab, because the linker doesn't want the
773 /* COMDAT sections are special. The first symbol is the section
774 symbol, which tells what kind of COMDAT section it is. The
775 second symbol is the "comdat symbol" - the one with the
776 unique name. GNU uses the section symbol for the unique
777 name; MS uses ".text" for every comdat section. Sigh. - DJ */
779 /* This is not mirrored in sec_to_styp_flags(), but there
780 doesn't seem to be a need to, either, and it would at best be
783 if (_bfd_coff_get_external_symbols (abfd
))
785 bfd_byte
*esymstart
, *esym
, *esymend
;
787 char *target_name
= NULL
;
789 esymstart
= esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
790 esymend
= esym
+ obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
792 while (esym
< esymend
)
794 struct internal_syment isym
;
795 char buf
[SYMNMLEN
+ 1];
798 bfd_coff_swap_sym_in (abfd
, (PTR
) esym
, (PTR
) &isym
);
800 if (sizeof (internal_s
->s_name
) > SYMNMLEN
)
802 /* This case implies that the matching symbol name
803 will be in the string table. */
807 if (isym
.n_scnum
== section
->target_index
)
809 /* According to the MSVC documentation, the first
810 TWO entries with the section # are both of
811 interest to us. The first one is the "section
812 symbol" (section name). The second is the comdat
813 symbol name. Here, we've found the first
814 qualifying entry; we distinguish it from the
815 second with a state flag.
817 In the case of gas-generated (at least until that
818 is fixed) .o files, it isn't necessarily the
819 second one. It may be some other later symbol.
821 Since gas also doesn't follow MS conventions and
822 emits the section similar to .text$<name>, where
823 <something> is the name we're looking for, we
824 distinguish the two as follows:
826 If the section name is simply a section name (no
827 $) we presume it's MS-generated, and look at
828 precisely the second symbol for the comdat name.
829 If the section name has a $, we assume it's
830 gas-generated, and look for <something> (whatever
831 follows the $) as the comdat symbol. */
833 /* All 3 branches use this */
834 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
, buf
);
843 /* The first time we've seen the symbol. */
844 union internal_auxent aux
;
848 /* If it isn't the stuff we're expecting, die;
849 The MS documentation is vague, but it
850 appears that the second entry serves BOTH
851 as the comdat symbol and the defining
852 symbol record (either C_STAT or C_EXT,
853 possibly with an aux entry with debug
854 information if it's a function.) It
855 appears the only way to find the second one
856 is to count. (On Intel, they appear to be
857 adjacent, but on Alpha, they have been
860 Here, we think we've found the first one,
861 but there's some checking we can do to be
864 if (! (isym
.n_sclass
== C_STAT
865 && isym
.n_type
== T_NULL
866 && isym
.n_value
== 0))
869 /* FIXME LATER: MSVC generates section names
870 like .text for comdats. Gas generates
871 names like .text$foo__Fv (in the case of a
872 function). See comment above for more. */
874 if (strcmp (name
, symname
) != 0)
877 /* This is the section symbol. */
879 bfd_coff_swap_aux_in (abfd
, (PTR
) (esym
+ bfd_coff_symesz (abfd
)),
880 isym
.n_type
, isym
.n_sclass
,
881 0, isym
.n_numaux
, (PTR
) &aux
);
883 target_name
= strchr (name
, '$');
884 if (target_name
!= NULL
)
892 /* FIXME: Microsoft uses NODUPLICATES and
893 ASSOCIATIVE, but gnu uses ANY and
894 SAME_SIZE. Unfortunately, gnu doesn't do
895 the comdat symbols right. So, until we can
896 fix it to do the right thing, we are
897 temporarily disabling comdats for the MS
898 types (they're used in DLLs and C++, but we
899 don't support *their* C++ libraries anyway
902 /* Cygwin does not follow the MS style, and
903 uses ANY and SAME_SIZE where NODUPLICATES
904 and ASSOCIATIVE should be used. For
905 Interix, we just do the right thing up
908 switch (aux
.x_scn
.x_comdat
)
910 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
911 #ifdef STRICT_PE_FORMAT
912 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
914 sec_flags
&= ~SEC_LINK_ONCE
;
918 case IMAGE_COMDAT_SELECT_ANY
:
919 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
922 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
923 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
926 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
927 /* Not yet fully implemented ??? */
928 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
931 /* debug$S gets this case; other
934 /* There may be no symbol... we'll search
935 the whole table... Is this the right
936 place to play this game? Or should we do
937 it when reading it in. */
938 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
939 #ifdef STRICT_PE_FORMAT
940 /* FIXME: This is not currently implemented. */
941 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
943 sec_flags
&= ~SEC_LINK_ONCE
;
947 default: /* 0 means "no symbol" */
948 /* debug$F gets this case; other
950 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
957 /* Gas mode: the first matching on partial name. */
959 #ifndef TARGET_UNDERSCORE
960 #define TARGET_UNDERSCORE 0
962 /* Is this the name we're looking for? */
963 if (strcmp (target_name
,
964 symname
+ (TARGET_UNDERSCORE
? 1 : 0)) != 0)
966 /* Not the name we're looking for */
967 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
972 /* MSVC mode: the lexically second symbol (or
973 drop through from the above). */
977 /* This must the the second symbol with the
978 section #. It is the actual symbol name.
979 Intel puts the two adjacent, but Alpha (at
980 least) spreads them out. */
983 bfd_alloc (abfd
, sizeof (struct bfd_comdat_info
));
984 if (section
->comdat
== NULL
)
986 section
->comdat
->symbol
=
987 (esym
- esymstart
) / bfd_coff_symesz (abfd
);
989 newname
= bfd_alloc (abfd
, strlen (symname
) + 1);
993 strcpy (newname
, symname
);
994 section
->comdat
->name
= newname
;
1002 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1008 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1009 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1010 only link a single copy of the section. This is used to support
1011 g++. g++ will emit each template expansion in its own section.
1012 The symbols will be defined as weak, so that multiple definitions
1013 are permitted. The GNU linker extension is to actually discard
1014 all but one of the sections. */
1015 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
1016 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1022 #endif /* COFF_WITH_PE */
1024 #define get_index(symbol) ((symbol)->udata.i)
1028 bfd_coff_backend_data
1032 .{* COFF symbol classifications. *}
1034 .enum coff_symbol_classification
1036 . {* Global symbol. *}
1037 . COFF_SYMBOL_GLOBAL,
1038 . {* Common symbol. *}
1039 . COFF_SYMBOL_COMMON,
1040 . {* Undefined symbol. *}
1041 . COFF_SYMBOL_UNDEFINED,
1042 . {* Local symbol. *}
1043 . COFF_SYMBOL_LOCAL,
1044 . {* PE section symbol. *}
1045 . COFF_SYMBOL_PE_SECTION
1048 Special entry points for gdb to swap in coff symbol table parts:
1051 . void (*_bfd_coff_swap_aux_in) PARAMS ((
1060 . void (*_bfd_coff_swap_sym_in) PARAMS ((
1065 . void (*_bfd_coff_swap_lineno_in) PARAMS ((
1071 Special entry points for gas to swap out coff parts:
1073 . unsigned int (*_bfd_coff_swap_aux_out) PARAMS ((
1082 . unsigned int (*_bfd_coff_swap_sym_out) PARAMS ((
1087 . unsigned int (*_bfd_coff_swap_lineno_out) PARAMS ((
1092 . unsigned int (*_bfd_coff_swap_reloc_out) PARAMS ((
1097 . unsigned int (*_bfd_coff_swap_filehdr_out) PARAMS ((
1102 . unsigned int (*_bfd_coff_swap_aouthdr_out) PARAMS ((
1107 . unsigned int (*_bfd_coff_swap_scnhdr_out) PARAMS ((
1113 Special entry points for generic COFF routines to call target
1114 dependent COFF routines:
1116 . unsigned int _bfd_filhsz;
1117 . unsigned int _bfd_aoutsz;
1118 . unsigned int _bfd_scnhsz;
1119 . unsigned int _bfd_symesz;
1120 . unsigned int _bfd_auxesz;
1121 . unsigned int _bfd_relsz;
1122 . unsigned int _bfd_linesz;
1123 . unsigned int _bfd_filnmlen;
1124 . boolean _bfd_coff_long_filenames;
1125 . boolean _bfd_coff_long_section_names;
1126 . unsigned int _bfd_coff_default_section_alignment_power;
1127 . boolean _bfd_coff_force_symnames_in_strings;
1128 . unsigned int _bfd_coff_debug_string_prefix_length;
1129 . void (*_bfd_coff_swap_filehdr_in) PARAMS ((
1133 . void (*_bfd_coff_swap_aouthdr_in) PARAMS ((
1137 . void (*_bfd_coff_swap_scnhdr_in) PARAMS ((
1141 . void (*_bfd_coff_swap_reloc_in) PARAMS ((
1145 . boolean (*_bfd_coff_bad_format_hook) PARAMS ((
1147 . PTR internal_filehdr));
1148 . boolean (*_bfd_coff_set_arch_mach_hook) PARAMS ((
1150 . PTR internal_filehdr));
1151 . PTR (*_bfd_coff_mkobject_hook) PARAMS ((
1153 . PTR internal_filehdr,
1154 . PTR internal_aouthdr));
1155 . flagword (*_bfd_styp_to_sec_flags_hook) PARAMS ((
1157 . PTR internal_scnhdr,
1159 . asection *section));
1160 . void (*_bfd_set_alignment_hook) PARAMS ((
1163 . PTR internal_scnhdr));
1164 . boolean (*_bfd_coff_slurp_symbol_table) PARAMS ((
1166 . boolean (*_bfd_coff_symname_in_debug) PARAMS ((
1168 . struct internal_syment *sym));
1169 . boolean (*_bfd_coff_pointerize_aux_hook) PARAMS ((
1171 . combined_entry_type *table_base,
1172 . combined_entry_type *symbol,
1173 . unsigned int indaux,
1174 . combined_entry_type *aux));
1175 . boolean (*_bfd_coff_print_aux) PARAMS ((
1178 . combined_entry_type *table_base,
1179 . combined_entry_type *symbol,
1180 . combined_entry_type *aux,
1181 . unsigned int indaux));
1182 . void (*_bfd_coff_reloc16_extra_cases) PARAMS ((
1184 . struct bfd_link_info *link_info,
1185 . struct bfd_link_order *link_order,
1188 . unsigned int *src_ptr,
1189 . unsigned int *dst_ptr));
1190 . int (*_bfd_coff_reloc16_estimate) PARAMS ((
1192 . asection *input_section,
1194 . unsigned int shrink,
1195 . struct bfd_link_info *link_info));
1196 . enum coff_symbol_classification (*_bfd_coff_classify_symbol) PARAMS ((
1198 . struct internal_syment *));
1199 . boolean (*_bfd_coff_compute_section_file_positions) PARAMS ((
1201 . boolean (*_bfd_coff_start_final_link) PARAMS ((
1203 . struct bfd_link_info *info));
1204 . boolean (*_bfd_coff_relocate_section) PARAMS ((
1206 . struct bfd_link_info *info,
1208 . asection *input_section,
1209 . bfd_byte *contents,
1210 . struct internal_reloc *relocs,
1211 . struct internal_syment *syms,
1212 . asection **sections));
1213 . reloc_howto_type *(*_bfd_coff_rtype_to_howto) PARAMS ((
1216 . struct internal_reloc *rel,
1217 . struct coff_link_hash_entry *h,
1218 . struct internal_syment *sym,
1219 . bfd_vma *addendp));
1220 . boolean (*_bfd_coff_adjust_symndx) PARAMS ((
1222 . struct bfd_link_info *info,
1225 . struct internal_reloc *reloc,
1226 . boolean *adjustedp));
1227 . boolean (*_bfd_coff_link_add_one_symbol) PARAMS ((
1228 . struct bfd_link_info *info,
1232 . asection *section,
1234 . const char *string,
1237 . struct bfd_link_hash_entry **hashp));
1239 . boolean (*_bfd_coff_link_output_has_begun) PARAMS ((
1241 . struct coff_final_link_info * pfinfo));
1242 . boolean (*_bfd_coff_final_link_postscript) PARAMS ((
1244 . struct coff_final_link_info * pfinfo));
1246 .} bfd_coff_backend_data;
1248 .#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1250 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1251 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1253 .#define bfd_coff_swap_sym_in(a,e,i) \
1254 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1256 .#define bfd_coff_swap_lineno_in(a,e,i) \
1257 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1259 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1260 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1262 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1263 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1265 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1266 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1268 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1269 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1271 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1272 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1274 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1275 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1277 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1278 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1280 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1281 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1282 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1283 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1284 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1285 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1286 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1287 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1288 .#define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1289 .#define bfd_coff_long_section_names(abfd) \
1290 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1291 .#define bfd_coff_default_section_alignment_power(abfd) \
1292 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1293 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1294 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1296 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1297 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1299 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1300 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1302 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1303 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1305 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1306 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1308 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1309 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1310 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1311 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
1313 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section)\
1314 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1315 . (abfd, scnhdr, name, section))
1317 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1318 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1320 .#define bfd_coff_slurp_symbol_table(abfd)\
1321 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1323 .#define bfd_coff_symname_in_debug(abfd, sym)\
1324 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1326 .#define bfd_coff_force_symnames_in_strings(abfd)\
1327 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1329 .#define bfd_coff_debug_string_prefix_length(abfd)\
1330 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1332 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1333 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1334 . (abfd, file, base, symbol, aux, indaux))
1336 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
1337 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1338 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1340 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1341 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1342 . (abfd, section, reloc, shrink, link_info))
1344 .#define bfd_coff_classify_symbol(abfd, sym)\
1345 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1348 .#define bfd_coff_compute_section_file_positions(abfd)\
1349 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1352 .#define bfd_coff_start_final_link(obfd, info)\
1353 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1355 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1356 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1357 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1358 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1359 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1360 . (abfd, sec, rel, h, sym, addendp))
1361 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1362 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1363 . (obfd, info, ibfd, sec, rel, adjustedp))
1364 .#define bfd_coff_link_add_one_symbol(info,abfd,name,flags,section,value,string,cp,coll,hashp)\
1365 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1366 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1368 .#define bfd_coff_link_output_has_begun(a,p) \
1369 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p))
1370 .#define bfd_coff_final_link_postscript(a,p) \
1371 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
1375 /* See whether the magic number matches. */
1378 coff_bad_format_hook (abfd
, filehdr
)
1379 bfd
* abfd ATTRIBUTE_UNUSED
;
1382 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1384 if (BADMAG (*internal_f
))
1387 /* if the optional header is NULL or not the correct size then
1388 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1389 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1390 optional header is of a different size.
1392 But the mips keeps extra stuff in it's opthdr, so dont check
1396 #if defined(M88) || defined(I960)
1397 if (internal_f
->f_opthdr
!= 0 && bfd_coff_aoutsz (abfd
) != internal_f
->f_opthdr
)
1404 /* Check whether this section uses an alignment other than the
1408 coff_set_custom_section_alignment (abfd
, section
, alignment_table
, table_size
)
1409 bfd
*abfd ATTRIBUTE_UNUSED
;
1411 const struct coff_section_alignment_entry
*alignment_table
;
1412 const unsigned int table_size
;
1414 const unsigned int default_alignment
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1417 for (i
= 0; i
< table_size
; ++i
)
1419 const char *secname
= bfd_get_section_name (abfd
, section
);
1420 if (alignment_table
[i
].comparison_length
== (unsigned int) -1
1421 ? strcmp (alignment_table
[i
].name
, secname
) == 0
1422 : strncmp (alignment_table
[i
].name
, secname
,
1423 alignment_table
[i
].comparison_length
) == 0)
1426 if (i
>= table_size
)
1429 if (alignment_table
[i
].default_alignment_min
!= COFF_ALIGNMENT_FIELD_EMPTY
1430 && default_alignment
< alignment_table
[i
].default_alignment_min
)
1433 if (alignment_table
[i
].default_alignment_max
!= COFF_ALIGNMENT_FIELD_EMPTY
1434 && default_alignment
> alignment_table
[i
].default_alignment_max
)
1437 section
->alignment_power
= alignment_table
[i
].alignment_power
;
1440 /* Custom section alignment records. */
1442 static const struct coff_section_alignment_entry
1443 coff_section_alignment_table
[] =
1445 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1446 COFF_SECTION_ALIGNMENT_ENTRIES
,
1448 /* There must not be any gaps between .stabstr sections. */
1449 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1450 1, COFF_ALIGNMENT_FIELD_EMPTY
, 0 },
1451 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1452 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1453 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1454 /* Similarly for the .ctors and .dtors sections. */
1455 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1456 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1457 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1458 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 }
1461 static const unsigned int coff_section_alignment_table_size
=
1462 sizeof coff_section_alignment_table
/ sizeof coff_section_alignment_table
[0];
1464 /* Initialize a section structure with information peculiar to this
1465 particular implementation of COFF. */
1468 coff_new_section_hook (abfd
, section
)
1472 combined_entry_type
*native
;
1474 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1477 if (xcoff_data (abfd
)->text_align_power
!= 0
1478 && strcmp (bfd_get_section_name (abfd
, section
), ".text") == 0)
1479 section
->alignment_power
= xcoff_data (abfd
)->text_align_power
;
1480 if (xcoff_data (abfd
)->data_align_power
!= 0
1481 && strcmp (bfd_get_section_name (abfd
, section
), ".data") == 0)
1482 section
->alignment_power
= xcoff_data (abfd
)->data_align_power
;
1485 /* Allocate aux records for section symbols, to store size and
1488 @@ The 10 is a guess at a plausible maximum number of aux entries
1489 (but shouldn't be a constant). */
1490 native
= ((combined_entry_type
*)
1491 bfd_zalloc (abfd
, sizeof (combined_entry_type
) * 10));
1495 /* We don't need to set up n_name, n_value, or n_scnum in the native
1496 symbol information, since they'll be overriden by the BFD symbol
1497 anyhow. However, we do need to set the type and storage class,
1498 in case this symbol winds up getting written out. The value 0
1499 for n_numaux is already correct. */
1501 native
->u
.syment
.n_type
= T_NULL
;
1502 native
->u
.syment
.n_sclass
= C_STAT
;
1504 coffsymbol (section
->symbol
)->native
= native
;
1506 coff_set_custom_section_alignment (abfd
, section
,
1507 coff_section_alignment_table
,
1508 coff_section_alignment_table_size
);
1513 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1515 /* Set the alignment of a BFD section. */
1517 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1520 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1521 bfd
* abfd ATTRIBUTE_UNUSED
;
1525 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1529 /* Extract ALIGN from 2**ALIGN stored in section header */
1530 for (i
= 0; i
< 32; i
++)
1531 if ((1 << i
) >= hdr
->s_align
)
1535 /* TI tools puts the alignment power in bits 8-11 */
1536 i
= (hdr
->s_flags
>> 8) & 0xF ;
1538 #ifdef COFF_DECODE_ALIGNMENT
1539 i
= COFF_DECODE_ALIGNMENT(hdr
->s_flags
);
1541 section
->alignment_power
= i
;
1543 #ifdef coff_set_section_load_page
1544 coff_set_section_load_page (section
, hdr
->s_page
);
1548 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1551 /* a couple of macros to help setting the alignment power field */
1552 #define ALIGN_SET(field,x,y) \
1553 if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1555 section->alignment_power = y;\
1558 #define ELIFALIGN_SET(field,x,y) \
1559 else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1561 section->alignment_power = y;\
1564 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1567 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1568 bfd
* abfd ATTRIBUTE_UNUSED
;
1572 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1574 ALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_64BYTES
, 6)
1575 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_32BYTES
, 5)
1576 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_16BYTES
, 4)
1577 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_8BYTES
, 3)
1578 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_4BYTES
, 2)
1579 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_2BYTES
, 1)
1580 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_1BYTES
, 0)
1582 /* In a PE image file, the s_paddr field holds the virtual size of a
1583 section, while the s_size field holds the raw size. We also keep
1584 the original section flag value, since not every bit can be
1585 mapped onto a generic BFD section bit. */
1586 if (coff_section_data (abfd
, section
) == NULL
)
1588 section
->used_by_bfd
=
1589 (PTR
) bfd_zalloc (abfd
, sizeof (struct coff_section_tdata
));
1590 if (section
->used_by_bfd
== NULL
)
1592 /* FIXME: Return error. */
1596 if (pei_section_data (abfd
, section
) == NULL
)
1598 coff_section_data (abfd
, section
)->tdata
=
1599 (PTR
) bfd_zalloc (abfd
, sizeof (struct pei_section_tdata
));
1600 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1602 /* FIXME: Return error. */
1606 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1607 pei_section_data (abfd
, section
)->pe_flags
= hdr
->s_flags
;
1609 section
->lma
= hdr
->s_vaddr
;
1612 #undef ELIFALIGN_SET
1614 #else /* ! COFF_WITH_PE */
1617 /* We grossly abuse this function to handle XCOFF overflow headers.
1618 When we see one, we correct the reloc and line number counts in the
1619 real header, and remove the section we just created. */
1621 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1624 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1629 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1633 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1636 real_sec
= coff_section_from_bfd_index (abfd
, hdr
->s_nreloc
);
1637 if (real_sec
== NULL
)
1640 real_sec
->reloc_count
= hdr
->s_paddr
;
1641 real_sec
->lineno_count
= hdr
->s_vaddr
;
1643 for (ps
= &abfd
->sections
; *ps
!= NULL
; ps
= &(*ps
)->next
)
1648 --abfd
->section_count
;
1654 #else /* ! RS6000COFF_C */
1656 #define coff_set_alignment_hook \
1657 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1659 #endif /* ! RS6000COFF_C */
1660 #endif /* ! COFF_WITH_PE */
1661 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1663 #ifndef coff_mkobject
1665 static boolean coff_mkobject
PARAMS ((bfd
*));
1668 coff_mkobject (abfd
)
1671 coff_data_type
*coff
;
1673 abfd
->tdata
.coff_obj_data
= (struct coff_tdata
*) bfd_zalloc (abfd
, sizeof (coff_data_type
));
1674 if (abfd
->tdata
.coff_obj_data
== 0)
1676 coff
= coff_data (abfd
);
1677 coff
->symbols
= (coff_symbol_type
*) NULL
;
1678 coff
->conversion_table
= (unsigned int *) NULL
;
1679 coff
->raw_syments
= (struct coff_ptr_struct
*) NULL
;
1680 coff
->relocbase
= 0;
1681 coff
->local_toc_sym_map
= 0;
1683 /* make_abs_section(abfd);*/
1689 /* Create the COFF backend specific information. */
1690 #ifndef coff_mkobject_hook
1692 coff_mkobject_hook (abfd
, filehdr
, aouthdr
)
1695 PTR aouthdr ATTRIBUTE_UNUSED
;
1697 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1698 coff_data_type
*coff
;
1700 if (coff_mkobject (abfd
) == false)
1703 coff
= coff_data (abfd
);
1705 coff
->sym_filepos
= internal_f
->f_symptr
;
1707 /* These members communicate important constants about the symbol
1708 table to GDB's symbol-reading code. These `constants'
1709 unfortunately vary among coff implementations... */
1710 coff
->local_n_btmask
= N_BTMASK
;
1711 coff
->local_n_btshft
= N_BTSHFT
;
1712 coff
->local_n_tmask
= N_TMASK
;
1713 coff
->local_n_tshift
= N_TSHIFT
;
1714 coff
->local_symesz
= bfd_coff_symesz (abfd
);
1715 coff
->local_auxesz
= bfd_coff_auxesz (abfd
);
1716 coff
->local_linesz
= bfd_coff_linesz (abfd
);
1718 coff
->timestamp
= internal_f
->f_timdat
;
1720 obj_raw_syment_count (abfd
) =
1721 obj_conv_table_size (abfd
) =
1722 internal_f
->f_nsyms
;
1725 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
1726 abfd
->flags
|= DYNAMIC
;
1727 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= bfd_coff_aoutsz (abfd
))
1729 struct internal_aouthdr
*internal_a
=
1730 (struct internal_aouthdr
*) aouthdr
;
1731 struct xcoff_tdata
*xcoff
;
1733 xcoff
= xcoff_data (abfd
);
1734 # ifdef U803XTOCMAGIC
1735 xcoff
->xcoff64
= internal_f
->f_magic
== U803XTOCMAGIC
;
1739 xcoff
->full_aouthdr
= true;
1740 xcoff
->toc
= internal_a
->o_toc
;
1741 xcoff
->sntoc
= internal_a
->o_sntoc
;
1742 xcoff
->snentry
= internal_a
->o_snentry
;
1743 xcoff
->text_align_power
= internal_a
->o_algntext
;
1744 xcoff
->data_align_power
= internal_a
->o_algndata
;
1745 xcoff
->modtype
= internal_a
->o_modtype
;
1746 xcoff
->cputype
= internal_a
->o_cputype
;
1747 xcoff
->maxdata
= internal_a
->o_maxdata
;
1748 xcoff
->maxstack
= internal_a
->o_maxstack
;
1753 /* Set the flags field from the COFF header read in */
1754 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
1759 /* FIXME: I'm not sure this is ever executed, since peicode.h
1760 defines coff_mkobject_hook. */
1761 if ((internal_f
->f_flags
& IMAGE_FILE_DEBUG_STRIPPED
) == 0)
1762 abfd
->flags
|= HAS_DEBUG
;
1769 /* Determine the machine architecture and type. FIXME: This is target
1770 dependent because the magic numbers are defined in the target
1771 dependent header files. But there is no particular need for this.
1772 If the magic numbers were moved to a separate file, this function
1773 would be target independent and would also be much more successful
1774 at linking together COFF files for different architectures. */
1777 coff_set_arch_mach_hook (abfd
, filehdr
)
1782 enum bfd_architecture arch
;
1783 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1786 switch (internal_f
->f_magic
)
1790 arch
= bfd_arch_powerpc
;
1791 machine
= 0; /* what does this mean? (krk) */
1797 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler */
1798 case LYNXCOFFMAGIC
: /* shadows the m68k Lynx number below, sigh */
1799 arch
= bfd_arch_i386
;
1805 arch
= bfd_arch_ia64
;
1809 #ifdef A29K_MAGIC_BIG
1810 case A29K_MAGIC_BIG
:
1811 case A29K_MAGIC_LITTLE
:
1812 arch
= bfd_arch_a29k
;
1820 arch
= bfd_arch_arm
;
1821 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
1823 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
1824 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
1825 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
1827 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
1828 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
1829 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
1830 case F_ARM_5
: machine
= bfd_mach_arm_5
; break;
1837 #ifdef MC68KBCSMAGIC
1840 #ifdef APOLLOM68KMAGIC
1841 case APOLLOM68KMAGIC
:
1843 #ifdef LYNXCOFFMAGIC
1846 arch
= bfd_arch_m68k
;
1847 machine
= bfd_mach_m68020
;
1854 arch
= bfd_arch_m88k
;
1860 arch
= bfd_arch_z8k
;
1861 switch (internal_f
->f_flags
& F_MACHMASK
)
1864 machine
= bfd_mach_z8001
;
1867 machine
= bfd_mach_z8002
;
1876 arch
= bfd_arch_i860
;
1883 arch
= bfd_arch_i960
;
1884 switch (F_I960TYPE
& internal_f
->f_flags
)
1888 machine
= bfd_mach_i960_core
;
1891 machine
= bfd_mach_i960_kb_sb
;
1894 machine
= bfd_mach_i960_mc
;
1897 machine
= bfd_mach_i960_xa
;
1900 machine
= bfd_mach_i960_ca
;
1903 machine
= bfd_mach_i960_ka_sa
;
1906 machine
= bfd_mach_i960_jx
;
1909 machine
= bfd_mach_i960_hx
;
1927 if (xcoff_data (abfd
)->cputype
!= -1)
1928 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
1931 /* We did not get a value from the a.out header. If the
1932 file has not been stripped, we may be able to get the
1933 architecture information from the first symbol, if it
1934 is a .file symbol. */
1935 if (obj_raw_syment_count (abfd
) == 0)
1940 struct internal_syment sym
;
1942 buf
= (bfd_byte
*) bfd_malloc (bfd_coff_symesz (abfd
));
1943 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1944 || (bfd_read (buf
, 1, bfd_coff_symesz (abfd
), abfd
)
1945 != bfd_coff_symesz (abfd
)))
1950 bfd_coff_swap_sym_in (abfd
, (PTR
) buf
, (PTR
) &sym
);
1951 if (sym
.n_sclass
== C_FILE
)
1952 cputype
= sym
.n_type
& 0xff;
1959 /* FIXME: We don't handle all cases here. */
1965 /* PowerPC Macs use the same magic numbers as RS/6000
1966 (because that's how they were bootstrapped originally),
1967 but they are always PowerPC architecture. */
1968 arch
= bfd_arch_powerpc
;
1969 machine
= bfd_mach_ppc
;
1972 arch
= bfd_arch_powerpc
;
1973 machine
= bfd_mach_ppc_620
;
1975 arch
= bfd_arch_rs6000
;
1976 machine
= bfd_mach_rs6k
;
1978 #endif /* POWERMAC */
1982 arch
= bfd_arch_powerpc
;
1983 machine
= bfd_mach_ppc_601
;
1985 case 2: /* 64 bit PowerPC */
1986 arch
= bfd_arch_powerpc
;
1987 machine
= bfd_mach_ppc_620
;
1990 arch
= bfd_arch_powerpc
;
1991 machine
= bfd_mach_ppc
;
1994 arch
= bfd_arch_rs6000
;
1995 machine
= bfd_mach_rs6k
;
2004 arch
= bfd_arch_we32k
;
2011 arch
= bfd_arch_h8300
;
2012 machine
= bfd_mach_h8300
;
2013 /* !! FIXME this probably isn't the right place for this */
2014 abfd
->flags
|= BFD_IS_RELAXABLE
;
2020 arch
= bfd_arch_h8300
;
2021 machine
= bfd_mach_h8300h
;
2022 /* !! FIXME this probably isn't the right place for this */
2023 abfd
->flags
|= BFD_IS_RELAXABLE
;
2029 arch
= bfd_arch_h8300
;
2030 machine
= bfd_mach_h8300s
;
2031 /* !! FIXME this probably isn't the right place for this */
2032 abfd
->flags
|= BFD_IS_RELAXABLE
;
2036 #ifdef SH_ARCH_MAGIC_BIG
2037 case SH_ARCH_MAGIC_BIG
:
2038 case SH_ARCH_MAGIC_LITTLE
:
2040 case SH_ARCH_MAGIC_WINCE
:
2047 #ifdef MIPS_ARCH_MAGIC_WINCE
2048 case MIPS_ARCH_MAGIC_WINCE
:
2049 arch
= bfd_arch_mips
;
2056 arch
= bfd_arch_h8500
;
2063 #ifdef LYNXCOFFMAGIC
2066 arch
= bfd_arch_sparc
;
2073 arch
= bfd_arch_tic30
;
2078 #ifdef TICOFF_TARGET_ARCH
2079 /* this TI COFF section should be used by all new TI COFF v0 targets */
2081 arch
= TICOFF_TARGET_ARCH
;
2087 /* this TI COFF section should be used by all new TI COFF v1/2 targets */
2088 /* TI COFF1 and COFF2 use the target_id field to specify which arch */
2091 switch (internal_f
->f_target_id
)
2095 arch
= TICOFF_TARGET_ARCH
;
2099 arch
= bfd_arch_obscure
;
2100 (*_bfd_error_handler
)
2101 (_("Unrecognized TI COFF target id '0x%x'"),
2102 internal_f
->f_target_id
);
2108 #ifdef TIC80_ARCH_MAGIC
2109 case TIC80_ARCH_MAGIC
:
2110 arch
= bfd_arch_tic80
;
2116 arch
= bfd_arch_mcore
;
2119 default: /* Unreadable input file type */
2120 arch
= bfd_arch_obscure
;
2124 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2128 #ifdef SYMNAME_IN_DEBUG
2130 static boolean symname_in_debug_hook
2131 PARAMS ((bfd
*, struct internal_syment
*));
2134 symname_in_debug_hook (abfd
, sym
)
2135 bfd
* abfd ATTRIBUTE_UNUSED
;
2136 struct internal_syment
*sym
;
2138 return SYMNAME_IN_DEBUG (sym
) ? true : false;
2143 #define symname_in_debug_hook \
2144 (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
2151 #define FORCE_SYMNAMES_IN_STRINGS
2154 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
2156 static boolean coff_pointerize_aux_hook
2157 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
2158 unsigned int, combined_entry_type
*));
2162 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
2163 bfd
*abfd ATTRIBUTE_UNUSED
;
2164 combined_entry_type
*table_base
;
2165 combined_entry_type
*symbol
;
2166 unsigned int indaux
;
2167 combined_entry_type
*aux
;
2169 int class = symbol
->u
.syment
.n_sclass
;
2171 if ((class == C_EXT
|| class == C_HIDEXT
)
2172 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2174 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2176 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2177 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2178 aux
->fix_scnlen
= 1;
2181 /* Return true to indicate that the caller should not do any
2182 further work on this auxent. */
2186 /* Return false to indicate that this auxent should be handled by
2194 /* We don't want to pointerize bal entries. */
2196 static boolean coff_pointerize_aux_hook
2197 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
2198 unsigned int, combined_entry_type
*));
2202 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
2203 bfd
*abfd ATTRIBUTE_UNUSED
;
2204 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
2205 combined_entry_type
*symbol
;
2206 unsigned int indaux
;
2207 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
2209 /* Return true if we don't want to pointerize this aux entry, which
2210 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2212 && (symbol
->u
.syment
.n_sclass
== C_LEAFPROC
2213 || symbol
->u
.syment
.n_sclass
== C_LEAFSTAT
2214 || symbol
->u
.syment
.n_sclass
== C_LEAFEXT
));
2219 #define coff_pointerize_aux_hook 0
2222 #endif /* ! RS6000COFF_C */
2224 /* Print an aux entry. This returns true if it has printed it. */
2226 static boolean coff_print_aux
2227 PARAMS ((bfd
*, FILE *, combined_entry_type
*, combined_entry_type
*,
2228 combined_entry_type
*, unsigned int));
2231 coff_print_aux (abfd
, file
, table_base
, symbol
, aux
, indaux
)
2232 bfd
*abfd ATTRIBUTE_UNUSED
;
2233 FILE *file ATTRIBUTE_UNUSED
;
2234 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
2235 combined_entry_type
*symbol ATTRIBUTE_UNUSED
;
2236 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
2237 unsigned int indaux ATTRIBUTE_UNUSED
;
2240 if ((symbol
->u
.syment
.n_sclass
== C_EXT
2241 || symbol
->u
.syment
.n_sclass
== C_HIDEXT
)
2242 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2244 /* This is a csect entry. */
2245 fprintf (file
, "AUX ");
2246 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2248 BFD_ASSERT (! aux
->fix_scnlen
);
2249 fprintf (file
, "val %5ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2253 fprintf (file
, "indx ");
2254 if (! aux
->fix_scnlen
)
2255 fprintf (file
, "%4ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2257 fprintf (file
, "%4ld",
2258 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2261 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2262 aux
->u
.auxent
.x_csect
.x_parmhash
,
2263 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2264 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2265 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2266 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2267 aux
->u
.auxent
.x_csect
.x_stab
,
2268 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2273 /* Return false to indicate that no special action was taken. */
2281 To write relocations, the back end steps though the
2282 canonical relocation table and create an
2283 @code{internal_reloc}. The symbol index to use is removed from
2284 the @code{offset} field in the symbol table supplied. The
2285 address comes directly from the sum of the section base
2286 address and the relocation offset; the type is dug directly
2287 from the howto field. Then the @code{internal_reloc} is
2288 swapped into the shape of an @code{external_reloc} and written
2295 static int compare_arelent_ptr
PARAMS ((const PTR
, const PTR
));
2297 /* AUX's ld wants relocations to be sorted */
2299 compare_arelent_ptr (x
, y
)
2303 const arelent
**a
= (const arelent
**) x
;
2304 const arelent
**b
= (const arelent
**) y
;
2305 bfd_size_type aadr
= (*a
)->address
;
2306 bfd_size_type badr
= (*b
)->address
;
2308 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2311 #endif /* TARG_AUX */
2314 coff_write_relocs (abfd
, first_undef
)
2320 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
2323 struct external_reloc dst
;
2329 /* sort relocations before we write them out */
2330 p
= (arelent
**) bfd_malloc (s
->reloc_count
* sizeof (arelent
*));
2331 if (p
== NULL
&& s
->reloc_count
> 0)
2333 memcpy (p
, s
->orelocation
, s
->reloc_count
* sizeof (arelent
*));
2334 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2337 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2339 for (i
= 0; i
< s
->reloc_count
; i
++)
2341 struct internal_reloc n
;
2343 memset ((PTR
) & n
, 0, sizeof (n
));
2345 /* Now we've renumbered the symbols we know where the
2346 undefined symbols live in the table. Check the reloc
2347 entries for symbols who's output bfd isn't the right one.
2348 This is because the symbol was undefined (which means
2349 that all the pointers are never made to point to the same
2350 place). This is a bad thing,'cause the symbols attached
2351 to the output bfd are indexed, so that the relocation
2352 entries know which symbol index they point to. So we
2353 have to look up the output symbol here. */
2355 if (q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2358 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2359 asymbol
**outsyms
= abfd
->outsymbols
;
2360 for (i
= first_undef
; outsyms
[i
]; i
++)
2362 const char *intable
= outsyms
[i
]->name
;
2363 if (strcmp (intable
, sname
) == 0) {
2364 /* got a hit, so repoint the reloc */
2365 q
->sym_ptr_ptr
= outsyms
+ i
;
2371 n
.r_vaddr
= q
->address
+ s
->vma
;
2374 /* The 29k const/consth reloc pair is a real kludge. The consth
2375 part doesn't have a symbol; it has an offset. So rebuilt
2377 if (q
->howto
->type
== R_IHCONST
)
2378 n
.r_symndx
= q
->addend
;
2383 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2384 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
,s
))
2386 if (q
->sym_ptr_ptr
== bfd_abs_section_ptr
->symbol_ptr_ptr
)
2388 /* This is a relocation relative to the absolute symbol. */
2392 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2393 /* Take notice if the symbol reloc points to a symbol
2394 we don't have in our symbol table. What should we
2396 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2401 #ifdef SWAP_OUT_RELOC_OFFSET
2402 n
.r_offset
= q
->addend
;
2406 /* Work out reloc type from what is required */
2407 SELECT_RELOC (n
, q
->howto
);
2409 n
.r_type
= q
->howto
->type
;
2411 coff_swap_reloc_out (abfd
, &n
, &dst
);
2412 if (bfd_write ((PTR
) & dst
, 1, bfd_coff_relsz (abfd
), abfd
)
2413 != bfd_coff_relsz (abfd
))
2426 /* Set flags and magic number of a coff file from architecture and machine
2427 type. Result is true if we can represent the arch&type, false if not. */
2430 coff_set_flags (abfd
, magicp
, flagsp
)
2432 unsigned int *magicp ATTRIBUTE_UNUSED
;
2433 unsigned short *flagsp ATTRIBUTE_UNUSED
;
2435 switch (bfd_get_arch (abfd
))
2440 switch (bfd_get_mach (abfd
))
2442 case bfd_mach_z8001
:
2445 case bfd_mach_z8002
:
2459 *magicp
= I960ROMAGIC
;
2461 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2462 I960RWMAGIC); FIXME???
2464 switch (bfd_get_mach (abfd
))
2466 case bfd_mach_i960_core
:
2469 case bfd_mach_i960_kb_sb
:
2472 case bfd_mach_i960_mc
:
2475 case bfd_mach_i960_xa
:
2478 case bfd_mach_i960_ca
:
2481 case bfd_mach_i960_ka_sa
:
2484 case bfd_mach_i960_jx
:
2487 case bfd_mach_i960_hx
:
2500 case bfd_arch_tic30
:
2501 *magicp
= TIC30MAGIC
;
2505 #ifdef TICOFF_DEFAULT_MAGIC
2506 case TICOFF_TARGET_ARCH
:
2507 /* if there's no indication of which version we want, use the default */
2509 *magicp
= TICOFF_DEFAULT_MAGIC
;
2512 /* we may want to output in a different COFF version */
2513 switch (abfd
->xvec
->name
[4])
2516 *magicp
= TICOFF0MAGIC
;
2519 *magicp
= TICOFF1MAGIC
;
2522 *magicp
= TICOFF2MAGIC
;
2531 #ifdef TIC80_ARCH_MAGIC
2532 case bfd_arch_tic80
:
2533 *magicp
= TIC80_ARCH_MAGIC
;
2539 * magicp
= ARMPEMAGIC
;
2541 * magicp
= ARMMAGIC
;
2544 if (APCS_SET (abfd
))
2546 if (APCS_26_FLAG (abfd
))
2547 * flagsp
|= F_APCS26
;
2549 if (APCS_FLOAT_FLAG (abfd
))
2550 * flagsp
|= F_APCS_FLOAT
;
2552 if (PIC_FLAG (abfd
))
2555 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2556 * flagsp
|= F_INTERWORK
;
2557 switch (bfd_get_mach (abfd
))
2559 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2560 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2561 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2562 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2563 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2564 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2565 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2566 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break; /* XXX - we do not have an F_ARM_5T */
2571 case bfd_arch_powerpc
:
2578 *magicp
= I386MAGIC
;
2580 /* Just overwrite the usual value if we're doing Lynx. */
2581 *magicp
= LYNXCOFFMAGIC
;
2588 *magicp
= I860MAGIC
;
2594 *magicp
= IA64MAGIC
;
2600 #ifdef APOLLOM68KMAGIC
2601 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
2603 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2604 #ifdef NAMES_HAVE_UNDERSCORE
2605 *magicp
= MC68KBCSMAGIC
;
2607 *magicp
= MC68MAGIC
;
2611 /* Just overwrite the usual value if we're doing Lynx. */
2612 *magicp
= LYNXCOFFMAGIC
;
2620 *magicp
= MC88OMAGIC
;
2625 case bfd_arch_h8300
:
2626 switch (bfd_get_mach (abfd
))
2628 case bfd_mach_h8300
:
2629 *magicp
= H8300MAGIC
;
2631 case bfd_mach_h8300h
:
2632 *magicp
= H8300HMAGIC
;
2634 case bfd_mach_h8300s
:
2635 *magicp
= H8300SMAGIC
;
2641 #ifdef SH_ARCH_MAGIC_BIG
2643 #ifdef COFF_IMAGE_WITH_PE
2644 *magicp
= SH_ARCH_MAGIC_WINCE
;
2646 if (bfd_big_endian (abfd
))
2647 *magicp
= SH_ARCH_MAGIC_BIG
;
2649 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2655 #ifdef MIPS_ARCH_MAGIC_WINCE
2657 *magicp
= MIPS_ARCH_MAGIC_WINCE
;
2663 case bfd_arch_sparc
:
2664 *magicp
= SPARCMAGIC
;
2666 /* Just overwrite the usual value if we're doing Lynx. */
2667 *magicp
= LYNXCOFFMAGIC
;
2674 case bfd_arch_h8500
:
2675 *magicp
= H8500MAGIC
;
2679 #ifdef A29K_MAGIC_BIG
2681 if (bfd_big_endian (abfd
))
2682 *magicp
= A29K_MAGIC_BIG
;
2684 *magicp
= A29K_MAGIC_LITTLE
;
2690 case bfd_arch_we32k
:
2691 *magicp
= WE32KMAGIC
;
2697 case bfd_arch_rs6000
:
2699 case bfd_arch_powerpc
:
2702 if (bfd_get_mach (abfd
) == bfd_mach_ppc_620
2703 && !strncmp (abfd
->xvec
->name
,"aix", 3))
2704 *magicp
= U803XTOCMAGIC
;
2707 *magicp
= U802TOCMAGIC
;
2714 case bfd_arch_mcore
:
2715 * magicp
= MCOREMAGIC
;
2719 default: /* Unknown architecture */
2720 /* return false; -- fall through to "return false" below, to avoid
2721 "statement never reached" errors on the one below. */
2730 coff_set_arch_mach (abfd
, arch
, machine
)
2732 enum bfd_architecture arch
;
2733 unsigned long machine
;
2736 unsigned short dummy2
;
2738 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
2741 if (arch
!= bfd_arch_unknown
&&
2742 coff_set_flags (abfd
, &dummy1
, &dummy2
) != true)
2743 return false; /* We can't represent this type */
2745 return true; /* We're easy ... */
2748 #ifdef COFF_IMAGE_WITH_PE
2750 /* This is used to sort sections by VMA, as required by PE image
2753 static int sort_by_secaddr
PARAMS ((const PTR
, const PTR
));
2756 sort_by_secaddr (arg1
, arg2
)
2760 const asection
*a
= *(const asection
**) arg1
;
2761 const asection
*b
= *(const asection
**) arg2
;
2763 if (a
->vma
< b
->vma
)
2765 else if (a
->vma
> b
->vma
)
2771 #endif /* COFF_IMAGE_WITH_PE */
2773 /* Calculate the file position for each section. */
2776 #define ALIGN_SECTIONS_IN_FILE
2778 #if defined(TIC80COFF) || defined(TICOFF)
2779 #undef ALIGN_SECTIONS_IN_FILE
2783 coff_compute_section_file_positions (abfd
)
2787 asection
*previous
= (asection
*) NULL
;
2788 file_ptr sofar
= bfd_coff_filhsz (abfd
);
2789 boolean align_adjust
;
2790 #ifdef ALIGN_SECTIONS_IN_FILE
2795 /* On XCOFF, if we have symbols, set up the .debug section. */
2796 if (bfd_get_symcount (abfd
) > 0)
2799 bfd_size_type i
, symcount
;
2803 symcount
= bfd_get_symcount (abfd
);
2804 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
2806 coff_symbol_type
*cf
;
2808 cf
= coff_symbol_from (abfd
, *symp
);
2810 && cf
->native
!= NULL
2811 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
2815 len
= strlen (bfd_asymbol_name (*symp
));
2816 if (len
> SYMNMLEN
|| bfd_coff_force_symnames_in_strings (abfd
))
2817 sz
+= len
+ 1 + bfd_coff_debug_string_prefix_length (abfd
);
2824 dsec
= bfd_make_section_old_way (abfd
, ".debug");
2827 dsec
->_raw_size
= sz
;
2828 dsec
->flags
|= SEC_HAS_CONTENTS
;
2833 #ifdef COFF_IMAGE_WITH_PE
2835 if (coff_data (abfd
)->link_info
)
2837 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
2840 page_size
= PE_DEF_FILE_ALIGNMENT
;
2842 #ifdef COFF_PAGE_SIZE
2843 int page_size
= COFF_PAGE_SIZE
;
2847 if (bfd_get_start_address (abfd
))
2849 /* A start address may have been added to the original file. In this
2850 case it will need an optional header to record it. */
2851 abfd
->flags
|= EXEC_P
;
2854 if (abfd
->flags
& EXEC_P
)
2855 sofar
+= bfd_coff_aoutsz (abfd
);
2857 else if (xcoff_data (abfd
)->full_aouthdr
)
2858 sofar
+= bfd_coff_aoutsz (abfd
);
2860 sofar
+= SMALL_AOUTSZ
;
2863 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2866 /* XCOFF handles overflows in the reloc and line number count fields
2867 by allocating a new section header to hold the correct counts. */
2868 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2869 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
2870 sofar
+= bfd_coff_scnhsz (abfd
);
2873 #ifdef COFF_IMAGE_WITH_PE
2875 /* PE requires the sections to be in memory order when listed in
2876 the section headers. It also does not like empty loadable
2877 sections. The sections apparently do not have to be in the
2878 right order in the image file itself, but we do need to get the
2879 target_index values right. */
2882 asection
**section_list
;
2887 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2890 /* We allocate an extra cell to simplify the final loop. */
2891 section_list
= bfd_malloc (sizeof (struct asection
*) * (count
+ 1));
2892 if (section_list
== NULL
)
2896 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2898 section_list
[i
] = current
;
2901 section_list
[i
] = NULL
;
2903 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
2905 /* Rethread the linked list into sorted order; at the same time,
2906 assign target_index values. */
2908 abfd
->sections
= section_list
[0];
2909 for (i
= 0; i
< count
; i
++)
2911 current
= section_list
[i
];
2912 current
->next
= section_list
[i
+ 1];
2914 /* Later, if the section has zero size, we'll be throwing it
2915 away, so we don't want to number it now. Note that having
2916 a zero size and having real contents are different
2917 concepts: .bss has no contents, but (usually) non-zero
2919 if (current
->_raw_size
== 0)
2921 /* Discard. However, it still might have (valid) symbols
2922 in it, so arbitrarily set it to section 1 (indexing is
2923 1-based here; usually .text). __end__ and other
2924 contents of .endsection really have this happen.
2925 FIXME: This seems somewhat dubious. */
2926 current
->target_index
= 1;
2929 current
->target_index
= target_index
++;
2932 free (section_list
);
2934 #else /* ! COFF_IMAGE_WITH_PE */
2936 /* Set the target_index field. */
2940 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2941 current
->target_index
= target_index
++;
2943 #endif /* ! COFF_IMAGE_WITH_PE */
2945 align_adjust
= false;
2946 for (current
= abfd
->sections
;
2947 current
!= (asection
*) NULL
;
2948 current
= current
->next
)
2950 #ifdef COFF_IMAGE_WITH_PE
2951 /* With PE we have to pad each section to be a multiple of its
2952 page size too, and remember both sizes. */
2953 if (coff_section_data (abfd
, current
) == NULL
)
2955 current
->used_by_bfd
=
2956 (PTR
) bfd_zalloc (abfd
, sizeof (struct coff_section_tdata
));
2957 if (current
->used_by_bfd
== NULL
)
2960 if (pei_section_data (abfd
, current
) == NULL
)
2962 coff_section_data (abfd
, current
)->tdata
=
2963 (PTR
) bfd_zalloc (abfd
, sizeof (struct pei_section_tdata
));
2964 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
2967 if (pei_section_data (abfd
, current
)->virt_size
== 0)
2968 pei_section_data (abfd
, current
)->virt_size
= current
->_raw_size
;
2971 /* Only deal with sections which have contents. */
2972 if (!(current
->flags
& SEC_HAS_CONTENTS
))
2975 #ifdef COFF_IMAGE_WITH_PE
2976 /* Make sure we skip empty sections in a PE image. */
2977 if (current
->_raw_size
== 0)
2981 /* Align the sections in the file to the same boundary on
2982 which they are aligned in virtual memory. I960 doesn't
2983 do this (FIXME) so we can stay in sync with Intel. 960
2984 doesn't yet page from files... */
2985 #ifdef ALIGN_SECTIONS_IN_FILE
2986 if ((abfd
->flags
& EXEC_P
) != 0)
2988 /* make sure this section is aligned on the right boundary - by
2989 padding the previous section up if necessary */
2992 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
2993 if (previous
!= (asection
*) NULL
)
2995 previous
->_raw_size
+= sofar
- old_sofar
;
3001 /* In demand paged files the low order bits of the file offset
3002 must match the low order bits of the virtual address. */
3003 #ifdef COFF_PAGE_SIZE
3004 if ((abfd
->flags
& D_PAGED
) != 0
3005 && (current
->flags
& SEC_ALLOC
) != 0)
3006 sofar
+= (current
->vma
- sofar
) % page_size
;
3008 current
->filepos
= sofar
;
3010 #ifdef COFF_IMAGE_WITH_PE
3011 /* Set the padded size. */
3012 current
->_raw_size
= (current
->_raw_size
+ page_size
-1) & -page_size
;
3015 sofar
+= current
->_raw_size
;
3017 #ifdef ALIGN_SECTIONS_IN_FILE
3018 /* make sure that this section is of the right size too */
3019 if ((abfd
->flags
& EXEC_P
) == 0)
3021 bfd_size_type old_size
;
3023 old_size
= current
->_raw_size
;
3024 current
->_raw_size
= BFD_ALIGN (current
->_raw_size
,
3025 1 << current
->alignment_power
);
3026 align_adjust
= current
->_raw_size
!= old_size
;
3027 sofar
+= current
->_raw_size
- old_size
;
3032 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3033 align_adjust
= sofar
!= old_sofar
;
3034 current
->_raw_size
+= sofar
- old_sofar
;
3038 #ifdef COFF_IMAGE_WITH_PE
3039 /* For PE we need to make sure we pad out to the aligned
3040 _raw_size, in case the caller only writes out data to the
3041 unaligned _raw_size. */
3042 if (pei_section_data (abfd
, current
)->virt_size
< current
->_raw_size
)
3043 align_adjust
= true;
3047 /* Force .lib sections to start at zero. The vma is then
3048 incremented in coff_set_section_contents. This is right for
3050 if (strcmp (current
->name
, _LIB
) == 0)
3051 bfd_set_section_vma (abfd
, current
, 0);
3057 /* It is now safe to write to the output file. If we needed an
3058 alignment adjustment for the last section, then make sure that
3059 there is a byte at offset sofar. If there are no symbols and no
3060 relocs, then nothing follows the last section. If we don't force
3061 the last byte out, then the file may appear to be truncated. */
3067 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
3068 || bfd_write (&b
, 1, 1, abfd
) != 1)
3072 /* Make sure the relocations are aligned. We don't need to make
3073 sure that this byte exists, because it will only matter if there
3074 really are relocs. */
3075 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
3077 obj_relocbase (abfd
) = sofar
;
3078 abfd
->output_has_begun
= true;
3085 /* This can never work, because it is called too late--after the
3086 section positions have been set. I can't figure out what it is
3087 for, so I am going to disable it--Ian Taylor 20 March 1996. */
3089 /* If .file, .text, .data, .bss symbols are missing, add them. */
3090 /* @@ Should we only be adding missing symbols, or overriding the aux
3091 values for existing section symbols? */
3093 coff_add_missing_symbols (abfd
)
3096 unsigned int nsyms
= bfd_get_symcount (abfd
);
3097 asymbol
**sympp
= abfd
->outsymbols
;
3100 int need_text
= 1, need_data
= 1, need_bss
= 1, need_file
= 1;
3102 for (i
= 0; i
< nsyms
; i
++)
3104 coff_symbol_type
*csym
= coff_symbol_from (abfd
, sympp
[i
]);
3108 /* only do this if there is a coff representation of the input
3110 if (csym
->native
&& csym
->native
->u
.syment
.n_sclass
== C_FILE
)
3115 name
= csym
->symbol
.name
;
3118 if (!strcmp (name
, _TEXT
))
3121 else if (!strcmp (name
, ".wtext"))
3124 else if (!strcmp (name
, _DATA
))
3126 else if (!strcmp (name
, _BSS
))
3130 /* Now i == bfd_get_symcount (abfd). */
3131 /* @@ For now, don't deal with .file symbol. */
3134 if (!need_text
&& !need_data
&& !need_bss
&& !need_file
)
3136 nsyms
+= need_text
+ need_data
+ need_bss
+ need_file
;
3137 sympp2
= (asymbol
**) bfd_alloc (abfd
, nsyms
* sizeof (asymbol
*));
3140 memcpy (sympp2
, sympp
, i
* sizeof (asymbol
*));
3143 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
3147 sympp2
[i
++] = coff_section_symbol (abfd
, _TEXT
);
3149 sympp2
[i
++] = coff_section_symbol (abfd
, _DATA
);
3151 sympp2
[i
++] = coff_section_symbol (abfd
, _BSS
);
3152 BFD_ASSERT (i
== nsyms
);
3153 bfd_set_symtab (abfd
, sympp2
, nsyms
);
3162 coff_write_object_contents (abfd
)
3166 boolean hasrelocs
= false;
3167 boolean haslinno
= false;
3168 boolean hasdebug
= false;
3170 file_ptr reloc_base
;
3171 file_ptr lineno_base
;
3173 unsigned long reloc_size
= 0;
3174 unsigned long lnno_size
= 0;
3175 boolean long_section_names
;
3176 asection
*text_sec
= NULL
;
3177 asection
*data_sec
= NULL
;
3178 asection
*bss_sec
= NULL
;
3179 struct internal_filehdr internal_f
;
3180 struct internal_aouthdr internal_a
;
3181 #ifdef COFF_LONG_SECTION_NAMES
3182 size_t string_size
= STRING_SIZE_SIZE
;
3185 bfd_set_error (bfd_error_system_call
);
3187 /* Make a pass through the symbol table to count line number entries and
3188 put them into the correct asections */
3190 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3192 if (abfd
->output_has_begun
== false)
3194 if (! coff_compute_section_file_positions (abfd
))
3198 reloc_base
= obj_relocbase (abfd
);
3200 /* Work out the size of the reloc and linno areas */
3202 for (current
= abfd
->sections
; current
!= NULL
; current
=
3204 reloc_size
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3206 lineno_base
= reloc_base
+ reloc_size
;
3207 sym_base
= lineno_base
+ lnno_size
;
3209 /* Indicate in each section->line_filepos its actual file address */
3210 for (current
= abfd
->sections
; current
!= NULL
; current
=
3213 if (current
->lineno_count
)
3215 current
->line_filepos
= lineno_base
;
3216 current
->moving_line_filepos
= lineno_base
;
3217 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3221 current
->line_filepos
= 0;
3223 if (current
->reloc_count
)
3225 current
->rel_filepos
= reloc_base
;
3226 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3230 current
->rel_filepos
= 0;
3234 /* Write section headers to the file. */
3235 internal_f
.f_nscns
= 0;
3237 if ((abfd
->flags
& EXEC_P
) != 0)
3238 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3241 scn_base
= bfd_coff_filhsz (abfd
);
3243 if (xcoff_data (abfd
)->full_aouthdr
)
3244 scn_base
+= bfd_coff_aoutsz (abfd
);
3246 scn_base
+= SMALL_AOUTSZ
;
3250 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3253 long_section_names
= false;
3254 for (current
= abfd
->sections
;
3256 current
= current
->next
)
3258 struct internal_scnhdr section
;
3259 boolean is_reloc_section
= false;
3261 #ifdef COFF_IMAGE_WITH_PE
3262 if (strcmp (current
->name
, ".reloc") == 0)
3264 is_reloc_section
= true;
3266 pe_data (abfd
)->has_reloc_section
= 1;
3270 internal_f
.f_nscns
++;
3272 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3274 #ifdef COFF_LONG_SECTION_NAMES
3275 /* Handle long section names as in PE. This must be compatible
3276 with the code in coff_write_symbols and _bfd_coff_final_link. */
3280 len
= strlen (current
->name
);
3283 memset (section
.s_name
, 0, SCNNMLEN
);
3284 sprintf (section
.s_name
, "/%lu", (unsigned long) string_size
);
3285 string_size
+= len
+ 1;
3286 long_section_names
= true;
3292 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3293 Ian Taylor <ian@cygnus.com>. */
3294 if (strcmp (current
->name
, _LIB
) == 0)
3295 section
.s_vaddr
= 0;
3298 section
.s_vaddr
= current
->vma
;
3299 section
.s_paddr
= current
->lma
;
3300 section
.s_size
= current
->_raw_size
;
3301 #ifdef coff_get_section_load_page
3302 section
.s_page
= coff_get_section_load_page (current
);
3306 section
.s_paddr
= 0;
3308 #ifdef COFF_IMAGE_WITH_PE
3309 /* Reminder: s_paddr holds the virtual size of the section. */
3310 if (coff_section_data (abfd
, current
) != NULL
3311 && pei_section_data (abfd
, current
) != NULL
)
3312 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3314 section
.s_paddr
= 0;
3318 If this section has no size or is unloadable then the scnptr
3321 if (current
->_raw_size
== 0 ||
3322 (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3324 section
.s_scnptr
= 0;
3328 section
.s_scnptr
= current
->filepos
;
3330 section
.s_relptr
= current
->rel_filepos
;
3331 section
.s_lnnoptr
= current
->line_filepos
;
3332 section
.s_nreloc
= current
->reloc_count
;
3333 section
.s_nlnno
= current
->lineno_count
;
3334 #ifndef COFF_IMAGE_WITH_PE
3335 /* In PEI, relocs come in the .reloc section. */
3336 if (current
->reloc_count
!= 0)
3339 if (current
->lineno_count
!= 0)
3341 if ((current
->flags
& SEC_DEBUGGING
) != 0
3342 && ! is_reloc_section
)
3347 /* Indicate the use of an XCOFF overflow section header. */
3348 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3350 section
.s_nreloc
= 0xffff;
3351 section
.s_nlnno
= 0xffff;
3356 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3358 if (!strcmp (current
->name
, _TEXT
))
3362 else if (!strcmp (current
->name
, _DATA
))
3366 else if (!strcmp (current
->name
, _BSS
))
3372 section
.s_align
= (current
->alignment_power
3373 ? 1 << current
->alignment_power
3377 /* TI COFF puts the alignment power in bits 8-11 of the flags */
3378 section
.s_flags
|= (current
->alignment_power
& 0xF) << 8;
3380 #ifdef COFF_ENCODE_ALIGNMENT
3381 COFF_ENCODE_ALIGNMENT(section
, current
->alignment_power
);
3384 #ifdef COFF_IMAGE_WITH_PE
3385 /* Suppress output of the sections if they are null. ld
3386 includes the bss and data sections even if there is no size
3387 assigned to them. NT loader doesn't like it if these section
3388 headers are included if the sections themselves are not
3389 needed. See also coff_compute_section_file_positions. */
3390 if (section
.s_size
== 0)
3391 internal_f
.f_nscns
--;
3396 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3397 || bfd_write ((PTR
) (&buff
), 1, bfd_coff_scnhsz (abfd
), abfd
)
3398 != bfd_coff_scnhsz (abfd
))
3403 /* PE stores COMDAT section information in the symbol table. If
3404 this section is supposed to have some COMDAT info, track down
3405 the symbol in the symbol table and modify it. */
3406 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3408 unsigned int i
, count
;
3410 coff_symbol_type
*csym
= NULL
;
3414 count
= bfd_get_symcount (abfd
);
3415 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3417 if ((*psym
)->section
!= current
)
3420 /* Remember the location of the first symbol in this
3422 if (psymsec
== NULL
)
3425 /* See if this is the section symbol. */
3426 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3428 csym
= coff_symbol_from (abfd
, *psym
);
3430 || csym
->native
== NULL
3431 || csym
->native
->u
.syment
.n_numaux
< 1
3432 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3433 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3436 /* Here *PSYM is the section symbol for CURRENT. */
3443 Note that we might not if we're converting the file from
3444 some other object file format. */
3447 combined_entry_type
*aux
;
3449 /* We don't touch the x_checksum field. The
3450 x_associated field is not currently supported. */
3452 aux
= csym
->native
+ 1;
3453 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3455 case SEC_LINK_DUPLICATES_DISCARD
:
3456 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3459 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3460 aux
->u
.auxent
.x_scn
.x_comdat
=
3461 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3464 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3465 aux
->u
.auxent
.x_scn
.x_comdat
=
3466 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3469 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3470 aux
->u
.auxent
.x_scn
.x_comdat
=
3471 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3475 /* The COMDAT symbol must be the first symbol from this
3476 section in the symbol table. In order to make this
3477 work, we move the COMDAT symbol before the first
3478 symbol we found in the search above. It's OK to
3479 rearrange the symbol table at this point, because
3480 coff_renumber_symbols is going to rearrange it
3481 further and fix up all the aux entries. */
3482 if (psym
!= psymsec
)
3488 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3489 pcopy
[0] = pcopy
[-1];
3494 #endif /* COFF_WITH_PE */
3498 /* XCOFF handles overflows in the reloc and line number count fields
3499 by creating a new section header to hold the correct values. */
3500 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3502 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3504 struct internal_scnhdr scnhdr
;
3507 internal_f
.f_nscns
++;
3508 strncpy (&(scnhdr
.s_name
[0]), current
->name
, 8);
3509 scnhdr
.s_paddr
= current
->reloc_count
;
3510 scnhdr
.s_vaddr
= current
->lineno_count
;
3512 scnhdr
.s_scnptr
= 0;
3513 scnhdr
.s_relptr
= current
->rel_filepos
;
3514 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3515 scnhdr
.s_nreloc
= current
->target_index
;
3516 scnhdr
.s_nlnno
= current
->target_index
;
3517 scnhdr
.s_flags
= STYP_OVRFLO
;
3518 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3519 || bfd_write ((PTR
) &buff
, 1, bfd_coff_scnhsz (abfd
), abfd
)
3520 != bfd_coff_scnhsz (abfd
))
3526 /* OK, now set up the filehdr... */
3528 /* Don't include the internal abs section in the section count */
3531 We will NOT put a fucking timestamp in the header here. Every time you
3532 put it back, I will come in and take it out again. I'm sorry. This
3533 field does not belong here. We fill it with a 0 so it compares the
3534 same but is not a reasonable time. -- gnu@cygnus.com
3536 internal_f
.f_timdat
= 0;
3538 internal_f
.f_flags
= 0;
3540 if (abfd
->flags
& EXEC_P
)
3541 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3544 internal_f
.f_opthdr
= 0;
3546 if (xcoff_data (abfd
)->full_aouthdr
)
3547 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3549 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
3554 internal_f
.f_flags
|= F_RELFLG
;
3556 internal_f
.f_flags
|= F_LNNO
;
3557 if (abfd
->flags
& EXEC_P
)
3558 internal_f
.f_flags
|= F_EXEC
;
3559 #ifdef COFF_IMAGE_WITH_PE
3561 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
3564 #ifndef COFF_WITH_PE
3565 if (bfd_little_endian (abfd
))
3566 internal_f
.f_flags
|= F_AR32WR
;
3568 internal_f
.f_flags
|= F_AR32W
;
3572 /* target id is used in TI COFF v1 and later; COFF0 won't use this field,
3573 but it doesn't hurt to set it internally */
3574 internal_f
.f_target_id
= TI_TARGET_ID
;
3576 #ifdef TIC80_TARGET_ID
3577 internal_f
.f_target_id
= TIC80_TARGET_ID
;
3581 FIXME, should do something about the other byte orders and
3586 if ((abfd
->flags
& DYNAMIC
) != 0)
3587 internal_f
.f_flags
|= F_SHROBJ
;
3588 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
3589 internal_f
.f_flags
|= F_DYNLOAD
;
3592 memset (&internal_a
, 0, sizeof internal_a
);
3594 /* Set up architecture-dependent stuff */
3597 unsigned int magic
= 0;
3598 unsigned short flags
= 0;
3599 coff_set_flags (abfd
, &magic
, &flags
);
3600 internal_f
.f_magic
= magic
;
3601 internal_f
.f_flags
|= flags
;
3602 /* ...and the "opt"hdr... */
3605 #ifdef ULTRA3 /* NYU's machine */
3606 /* FIXME: This is a bogus check. I really want to see if there
3607 * is a .shbss or a .shdata section, if so then set the magic
3608 * number to indicate a shared data executable.
3610 if (internal_f
.f_nscns
>= 7)
3611 internal_a
.magic
= SHMAGIC
; /* Shared magic */
3614 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
3615 #define __A_MAGIC_SET__
3617 #ifdef TICOFF_AOUT_MAGIC
3618 internal_a
.magic
= TICOFF_AOUT_MAGIC
;
3619 #define __A_MAGIC_SET__
3622 internal_a
.magic
= TIC80_ARCH_MAGIC
;
3623 #define __A_MAGIC_SET__
3626 /* FIXME: What are the a.out magic numbers for the i860? */
3627 internal_a
.magic
= 0;
3628 #define __A_MAGIC_SET__
3631 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
3632 #define __A_MAGIC_SET__
3635 #define __A_MAGIC_SET__
3636 internal_a
.magic
= PAGEMAGICBCS
;
3640 #define __A_MAGIC_SET__
3641 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
3644 #if defined(M68) || defined(WE32K) || defined(M68K)
3645 #define __A_MAGIC_SET__
3647 internal_a
.magic
= LYNXCOFFMAGIC
;
3649 #if defined(TARG_AUX)
3650 internal_a
.magic
= (abfd
->flags
& D_PAGED
? PAGEMAGICPEXECPAGED
:
3651 abfd
->flags
& WP_TEXT
? PAGEMAGICPEXECSWAPPED
:
3652 PAGEMAGICEXECSWAPPED
);
3654 #if defined (PAGEMAGICPEXECPAGED)
3655 internal_a
.magic
= PAGEMAGICPEXECPAGED
;
3657 #endif /* TARG_AUX */
3659 #endif /* M68 || WE32K || M68K */
3662 #define __A_MAGIC_SET__
3663 internal_a
.magic
= ZMAGIC
;
3667 #define __A_MAGIC_SET__
3668 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3671 #if defined MCORE_PE
3672 #define __A_MAGIC_SET__
3673 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3677 #define __A_MAGIC_SET__
3679 internal_a
.magic
= LYNXCOFFMAGIC
;
3681 internal_a
.magic
= ZMAGIC
;
3686 #define __A_MAGIC_SET__
3687 internal_a
.magic
= ZMAGIC
;
3691 #define __A_MAGIC_SET__
3693 internal_a
.magic
= LYNXCOFFMAGIC
;
3698 #define __A_MAGIC_SET__
3699 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
3700 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
3701 RS6K_AOUTHDR_OMAGIC
;
3704 #if defined(SH) && defined(COFF_WITH_PE)
3705 #define __A_MAGIC_SET__
3706 internal_a
.magic
= SH_PE_MAGIC
;
3709 #if defined(MIPS) && defined(COFF_WITH_PE)
3710 #define __A_MAGIC_SET__
3711 internal_a
.magic
= MIPS_PE_MAGIC
;
3714 #ifndef __A_MAGIC_SET__
3715 #include "Your aouthdr magic number is not being set!"
3717 #undef __A_MAGIC_SET__
3721 /* FIXME: Does anybody ever set this to another value? */
3722 internal_a
.vstamp
= 0;
3724 /* Now should write relocs, strings, syms */
3725 obj_sym_filepos (abfd
) = sym_base
;
3727 if (bfd_get_symcount (abfd
) != 0)
3731 if (!coff_add_missing_symbols (abfd
))
3734 if (!coff_renumber_symbols (abfd
, &firstundef
))
3736 coff_mangle_symbols (abfd
);
3737 if (! coff_write_symbols (abfd
))
3739 if (! coff_write_linenumbers (abfd
))
3741 if (! coff_write_relocs (abfd
, firstundef
))
3744 #ifdef COFF_LONG_SECTION_NAMES
3745 else if (long_section_names
)
3747 /* If we have long section names we have to write out the string
3748 table even if there are no symbols. */
3749 if (! coff_write_symbols (abfd
))
3753 #ifdef COFF_IMAGE_WITH_PE
3755 else if ((abfd
->flags
& EXEC_P
) != 0)
3759 /* PowerPC PE appears to require that all executable files be
3760 rounded up to the page size. */
3763 BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
3765 || bfd_write (&b
, 1, 1, abfd
) != 1)
3771 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3772 backend linker, and obj_raw_syment_count is not valid until after
3773 coff_write_symbols is called. */
3774 if (obj_raw_syment_count (abfd
) != 0)
3776 internal_f
.f_symptr
= sym_base
;
3778 /* AIX appears to require that F_RELFLG not be set if there are
3779 local symbols but no relocations. */
3780 internal_f
.f_flags
&=~ F_RELFLG
;
3785 if (long_section_names
)
3786 internal_f
.f_symptr
= sym_base
;
3788 internal_f
.f_symptr
= 0;
3789 internal_f
.f_flags
|= F_LSYMS
;
3794 internal_a
.tsize
= bfd_get_section_size_before_reloc (text_sec
);
3795 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
3799 internal_a
.dsize
= bfd_get_section_size_before_reloc (data_sec
);
3800 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
3804 internal_a
.bsize
= bfd_get_section_size_before_reloc (bss_sec
);
3805 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
3806 internal_a
.data_start
= bss_sec
->vma
;
3809 internal_a
.entry
= bfd_get_start_address (abfd
);
3810 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
3813 if (xcoff_data (abfd
)->full_aouthdr
)
3816 asection
*loader_sec
;
3818 internal_a
.vstamp
= 1;
3820 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
3821 if (internal_a
.o_snentry
== 0)
3822 internal_a
.entry
= (bfd_vma
) -1;
3824 if (text_sec
!= NULL
)
3826 internal_a
.o_sntext
= text_sec
->target_index
;
3827 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
3831 internal_a
.o_sntext
= 0;
3832 internal_a
.o_algntext
= 0;
3834 if (data_sec
!= NULL
)
3836 internal_a
.o_sndata
= data_sec
->target_index
;
3837 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
3841 internal_a
.o_sndata
= 0;
3842 internal_a
.o_algndata
= 0;
3844 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
3845 if (loader_sec
!= NULL
)
3846 internal_a
.o_snloader
= loader_sec
->target_index
;
3848 internal_a
.o_snloader
= 0;
3849 if (bss_sec
!= NULL
)
3850 internal_a
.o_snbss
= bss_sec
->target_index
;
3852 internal_a
.o_snbss
= 0;
3854 toc
= xcoff_data (abfd
)->toc
;
3855 internal_a
.o_toc
= toc
;
3856 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
3858 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
3859 if (xcoff_data (abfd
)->cputype
!= -1)
3860 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
3863 switch (bfd_get_arch (abfd
))
3865 case bfd_arch_rs6000
:
3866 internal_a
.o_cputype
= 4;
3868 case bfd_arch_powerpc
:
3869 if (bfd_get_mach (abfd
) == 0)
3870 internal_a
.o_cputype
= 3;
3872 internal_a
.o_cputype
= 1;
3878 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
3879 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
3883 /* now write them */
3884 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
3889 bfd_size_type amount
;
3891 buff
= bfd_malloc (bfd_coff_filhsz (abfd
));
3895 coff_swap_filehdr_out (abfd
, (PTR
) & internal_f
, (PTR
) buff
);
3896 amount
= bfd_write ((PTR
) buff
, 1, bfd_coff_filhsz (abfd
), abfd
);
3900 if (amount
!= bfd_coff_filhsz (abfd
))
3904 if (abfd
->flags
& EXEC_P
)
3906 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
3907 include/coff/pe.h sets AOUTSZ == sizeof(PEAOUTHDR)) */
3909 bfd_size_type amount
;
3911 buff
= bfd_malloc (bfd_coff_aoutsz (abfd
));
3915 coff_swap_aouthdr_out (abfd
, (PTR
) & internal_a
, (PTR
) buff
);
3916 amount
= bfd_write ((PTR
) buff
, 1, bfd_coff_aoutsz (abfd
), abfd
);
3920 if (amount
!= bfd_coff_aoutsz (abfd
))
3929 /* XCOFF seems to always write at least a small a.out header. */
3930 coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, (PTR
) &buff
);
3931 if (xcoff_data (abfd
)->full_aouthdr
)
3932 size
= bfd_coff_aoutsz (abfd
);
3934 size
= SMALL_AOUTSZ
;
3935 if (bfd_write ((PTR
) &buff
, 1, size
, abfd
) != size
)
3944 coff_set_section_contents (abfd
, section
, location
, offset
, count
)
3949 bfd_size_type count
;
3951 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
3953 if (! coff_compute_section_file_positions (abfd
))
3957 #if defined(_LIB) && !defined(TARG_AUX)
3959 /* The physical address field of a .lib section is used to hold the
3960 number of shared libraries in the section. This code counts the
3961 number of sections being written, and increments the lma field
3964 I have found no documentation on the contents of this section.
3965 Experimentation indicates that the section contains zero or more
3966 records, each of which has the following structure:
3968 - a (four byte) word holding the length of this record, in words,
3969 - a word that always seems to be set to "2",
3970 - the path to a shared library, null-terminated and then padded
3971 to a whole word boundary.
3973 bfd_assert calls have been added to alert if an attempt is made
3974 to write a section which doesn't follow these assumptions. The
3975 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
3976 <robertl@arnet.com> (Thanks!).
3978 Gvran Uddeborg <gvran@uddeborg.pp.se> */
3980 if (strcmp (section
->name
, _LIB
) == 0)
3982 bfd_byte
*rec
, *recend
;
3984 rec
= (bfd_byte
*) location
;
3985 recend
= rec
+ count
;
3986 while (rec
< recend
)
3989 rec
+= bfd_get_32 (abfd
, rec
) * 4;
3992 BFD_ASSERT (rec
== recend
);
3997 /* Don't write out bss sections - one way to do this is to
3998 see if the filepos has not been set. */
3999 if (section
->filepos
== 0)
4002 if (bfd_seek (abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
) != 0)
4007 return (bfd_write (location
, 1, count
, abfd
) == count
) ? true : false;
4013 coff_close_and_cleanup (abfd
)
4016 if (!bfd_read_p (abfd
))
4017 switch (abfd
->format
)
4020 if (!_bfd_write_archive_contents (abfd
))
4024 if (!coff_write_object_contents (abfd
))
4028 bfd_set_error (bfd_error_invalid_operation
);
4032 /* We depend on bfd_close to free all the memory on the objalloc. */
4039 buy_and_read (abfd
, where
, seek_direction
, size
)
4045 PTR area
= (PTR
) bfd_alloc (abfd
, size
);
4048 if (bfd_seek (abfd
, where
, seek_direction
) != 0
4049 || bfd_read (area
, 1, size
, abfd
) != size
)
4052 } /* buy_and_read() */
4058 Creating the linenumber table is done by reading in the entire
4059 coff linenumber table, and creating another table for internal use.
4061 A coff linenumber table is structured so that each function
4062 is marked as having a line number of 0. Each line within the
4063 function is an offset from the first line in the function. The
4064 base of the line number information for the table is stored in
4065 the symbol associated with the function.
4067 Note: The PE format uses line number 0 for a flag indicating a
4070 The information is copied from the external to the internal
4071 table, and each symbol which marks a function is marked by
4074 How does this work ?
4079 coff_slurp_line_table (abfd
, asect
)
4083 LINENO
*native_lineno
;
4084 alent
*lineno_cache
;
4086 BFD_ASSERT (asect
->lineno
== (alent
*) NULL
);
4088 native_lineno
= (LINENO
*) buy_and_read (abfd
,
4089 asect
->line_filepos
,
4091 (size_t) (bfd_coff_linesz (abfd
) *
4092 asect
->lineno_count
));
4094 (alent
*) bfd_alloc (abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof (alent
)));
4095 if (lineno_cache
== NULL
)
4099 unsigned int counter
= 0;
4100 alent
*cache_ptr
= lineno_cache
;
4101 LINENO
*src
= native_lineno
;
4103 while (counter
< asect
->lineno_count
)
4105 struct internal_lineno dst
;
4106 bfd_coff_swap_lineno_in (abfd
, src
, &dst
);
4107 cache_ptr
->line_number
= dst
.l_lnno
;
4109 if (cache_ptr
->line_number
== 0)
4113 coff_symbol_type
*sym
;
4116 symndx
= dst
.l_addr
.l_symndx
;
4118 || (unsigned long) symndx
>= obj_raw_syment_count (abfd
))
4120 (*_bfd_error_handler
)
4121 (_("%s: warning: illegal symbol index %ld in line numbers"),
4122 bfd_get_filename (abfd
), dst
.l_addr
.l_symndx
);
4126 /* FIXME: We should not be casting between ints and
4127 pointers like this. */
4128 sym
= ((coff_symbol_type
*)
4129 ((symndx
+ obj_raw_syments (abfd
))
4130 ->u
.syment
._n
._n_n
._n_zeroes
));
4131 cache_ptr
->u
.sym
= (asymbol
*) sym
;
4132 if (sym
->lineno
!= NULL
&& ! warned
)
4134 (*_bfd_error_handler
)
4135 (_("%s: warning: duplicate line number information for `%s'"),
4136 bfd_get_filename (abfd
),
4137 bfd_asymbol_name (&sym
->symbol
));
4139 sym
->lineno
= cache_ptr
;
4143 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
4144 - bfd_section_vma (abfd
, asect
);
4145 } /* If no linenumber expect a symbol index */
4151 cache_ptr
->line_number
= 0;
4154 asect
->lineno
= lineno_cache
;
4155 /* FIXME, free native_lineno here, or use alloca or something. */
4159 /* Slurp in the symbol table, converting it to generic form. Note
4160 that if coff_relocate_section is defined, the linker will read
4161 symbols via coff_link_add_symbols, rather than via this routine. */
4164 coff_slurp_symbol_table (abfd
)
4167 combined_entry_type
*native_symbols
;
4168 coff_symbol_type
*cached_area
;
4169 unsigned int *table_ptr
;
4171 unsigned int number_of_symbols
= 0;
4173 if (obj_symbols (abfd
))
4176 /* Read in the symbol table */
4177 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4182 /* Allocate enough room for all the symbols in cached form */
4183 cached_area
= ((coff_symbol_type
*)
4185 (obj_raw_syment_count (abfd
)
4186 * sizeof (coff_symbol_type
))));
4188 if (cached_area
== NULL
)
4190 table_ptr
= ((unsigned int *)
4192 (obj_raw_syment_count (abfd
)
4193 * sizeof (unsigned int))));
4195 if (table_ptr
== NULL
)
4199 coff_symbol_type
*dst
= cached_area
;
4200 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4201 unsigned int this_index
= 0;
4202 while (this_index
< last_native_index
)
4204 combined_entry_type
*src
= native_symbols
+ this_index
;
4205 table_ptr
[this_index
] = number_of_symbols
;
4206 dst
->symbol
.the_bfd
= abfd
;
4208 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4209 /* We use the native name field to point to the cached field. */
4210 src
->u
.syment
._n
._n_n
._n_zeroes
= (long) dst
;
4211 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4212 src
->u
.syment
.n_scnum
);
4213 dst
->symbol
.flags
= 0;
4214 dst
->done_lineno
= false;
4216 switch (src
->u
.syment
.n_sclass
)
4221 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
4222 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4223 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4225 /* Fall through to next case */
4233 case C_THUMBEXTFUNC
:
4239 case C_SYSTEM
: /* System Wide variable */
4242 /* In PE, 0x68 (104) denotes a section symbol */
4244 /* In PE, 0x69 (105) denotes a weak external symbol. */
4247 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4249 case COFF_SYMBOL_GLOBAL
:
4250 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4251 #if defined COFF_WITH_PE
4252 /* PE sets the symbol to a value relative to the
4253 start of the section. */
4254 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4256 dst
->symbol
.value
= (src
->u
.syment
.n_value
4257 - dst
->symbol
.section
->vma
);
4259 if (ISFCN ((src
->u
.syment
.n_type
)))
4261 /* A function ext does not go at the end of a
4263 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4267 case COFF_SYMBOL_COMMON
:
4268 dst
->symbol
.section
= bfd_com_section_ptr
;
4269 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4272 case COFF_SYMBOL_UNDEFINED
:
4273 dst
->symbol
.section
= bfd_und_section_ptr
;
4274 dst
->symbol
.value
= 0;
4277 case COFF_SYMBOL_PE_SECTION
:
4278 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4279 dst
->symbol
.value
= 0;
4282 case COFF_SYMBOL_LOCAL
:
4283 dst
->symbol
.flags
= BSF_LOCAL
;
4284 #if defined COFF_WITH_PE
4285 /* PE sets the symbol to a value relative to the
4286 start of the section. */
4287 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4289 dst
->symbol
.value
= (src
->u
.syment
.n_value
4290 - dst
->symbol
.section
->vma
);
4292 if (ISFCN ((src
->u
.syment
.n_type
)))
4293 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4298 /* A symbol with a csect entry should not go at the end. */
4299 if (src
->u
.syment
.n_numaux
> 0)
4300 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4304 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4305 dst
->symbol
.flags
= BSF_WEAK
;
4306 if (src
->u
.syment
.n_sclass
== C_SECTION
4307 && src
->u
.syment
.n_scnum
> 0)
4309 dst
->symbol
.flags
= BSF_LOCAL
;
4313 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
)
4314 dst
->symbol
.flags
= BSF_WEAK
;
4318 case C_STAT
: /* static */
4320 case C_LEAFSTAT
: /* static leaf procedure */
4323 case C_THUMBSTAT
: /* Thumb static */
4324 case C_THUMBLABEL
: /* Thumb label */
4325 case C_THUMBSTATFUNC
:/* Thumb static function */
4327 case C_LABEL
: /* label */
4328 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4329 dst
->symbol
.flags
= BSF_DEBUGGING
;
4331 dst
->symbol
.flags
= BSF_LOCAL
;
4333 /* Base the value as an index from the base of the
4334 section, if there is one. */
4335 if (dst
->symbol
.section
)
4337 #if defined COFF_WITH_PE
4338 /* PE sets the symbol to a value relative to the
4339 start of the section. */
4340 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4342 dst
->symbol
.value
= (src
->u
.syment
.n_value
4343 - dst
->symbol
.section
->vma
);
4347 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4350 case C_MOS
: /* member of structure */
4351 case C_EOS
: /* end of structure */
4352 #ifdef NOTDEF /* C_AUTOARG has the same value */
4354 case C_GLBLREG
: /* A29k-specific storage class */
4357 case C_REGPARM
: /* register parameter */
4358 case C_REG
: /* register variable */
4359 /* C_AUTOARG conflictes with TI COFF C_UEXT */
4360 #if !defined (TIC80COFF) && !defined (TICOFF)
4362 case C_AUTOARG
: /* 960-specific storage class */
4365 case C_TPDEF
: /* type definition */
4367 case C_AUTO
: /* automatic variable */
4368 case C_FIELD
: /* bit field */
4369 case C_ENTAG
: /* enumeration tag */
4370 case C_MOE
: /* member of enumeration */
4371 case C_MOU
: /* member of union */
4372 case C_UNTAG
: /* union tag */
4373 dst
->symbol
.flags
= BSF_DEBUGGING
;
4374 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4377 case C_FILE
: /* file name */
4378 case C_STRTAG
: /* structure tag */
4393 dst
->symbol
.flags
= BSF_DEBUGGING
;
4394 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4398 case C_BINCL
: /* beginning of include file */
4399 case C_EINCL
: /* ending of include file */
4400 /* The value is actually a pointer into the line numbers
4401 of the file. We locate the line number entry, and
4402 set the section to the section which contains it, and
4403 the value to the index in that section. */
4407 dst
->symbol
.flags
= BSF_DEBUGGING
;
4408 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4409 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4410 && ((file_ptr
) (sec
->line_filepos
4411 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4412 > (file_ptr
) src
->u
.syment
.n_value
))
4415 dst
->symbol
.value
= 0;
4418 dst
->symbol
.section
= sec
;
4419 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4420 - sec
->line_filepos
)
4421 / bfd_coff_linesz (abfd
));
4428 dst
->symbol
.flags
= BSF_DEBUGGING
;
4430 /* The value is actually a symbol index. Save a pointer
4431 to the symbol instead of the index. FIXME: This
4432 should use a union. */
4433 src
->u
.syment
.n_value
=
4434 (long) (native_symbols
+ src
->u
.syment
.n_value
);
4435 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4440 case C_BLOCK
: /* ".bb" or ".eb" */
4441 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf") */
4442 case C_EFCN
: /* physical end of function */
4443 #if defined COFF_WITH_PE
4444 /* PE sets the symbol to a value relative to the start
4446 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4447 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4449 /* PE uses funny values for .ef and .lf; don't
4451 dst
->symbol
.flags
= BSF_DEBUGGING
;
4454 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4456 /* Base the value as an index from the base of the
4458 dst
->symbol
.flags
= BSF_LOCAL
;
4459 dst
->symbol
.value
= (src
->u
.syment
.n_value
4460 - dst
->symbol
.section
->vma
);
4464 case C_STATLAB
: /* Static load time label */
4465 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4466 dst
->symbol
.flags
= BSF_GLOBAL
;
4470 /* PE DLLs sometimes have zeroed out symbols for some
4471 reason. Just ignore them without a warning. */
4472 if (src
->u
.syment
.n_type
== 0
4473 && src
->u
.syment
.n_value
== 0
4474 && src
->u
.syment
.n_scnum
== 0)
4477 case C_EXTDEF
: /* external definition */
4478 case C_ULABEL
: /* undefined label */
4479 case C_USTATIC
: /* undefined static */
4480 #ifndef COFF_WITH_PE
4481 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4482 class to represent a section symbol */
4483 case C_LINE
: /* line # reformatted as symbol table entry */
4484 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4485 case C_ALIAS
: /* duplicate tag */
4487 /* New storage classes for TI COFF */
4488 #if defined(TIC80COFF) || defined(TICOFF)
4489 case C_UEXT
: /* Tentative external definition */
4491 case C_EXTLAB
: /* External load time label */
4492 case C_HIDDEN
: /* ext symbol in dmert public lib */
4494 (*_bfd_error_handler
)
4495 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
4496 bfd_get_filename (abfd
), src
->u
.syment
.n_sclass
,
4497 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4498 dst
->symbol
.flags
= BSF_DEBUGGING
;
4499 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4503 /* BFD_ASSERT(dst->symbol.flags != 0);*/
4507 dst
->symbol
.udata
.i
= 0;
4508 dst
->lineno
= (alent
*) NULL
;
4509 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
4511 number_of_symbols
++;
4512 } /* walk the native symtab */
4513 } /* bfdize the native symtab */
4515 obj_symbols (abfd
) = cached_area
;
4516 obj_raw_syments (abfd
) = native_symbols
;
4518 bfd_get_symcount (abfd
) = number_of_symbols
;
4519 obj_convert (abfd
) = table_ptr
;
4520 /* Slurp the line tables for each section too */
4526 coff_slurp_line_table (abfd
, p
);
4531 } /* coff_slurp_symbol_table() */
4533 /* Classify a COFF symbol. A couple of targets have globally visible
4534 symbols which are not class C_EXT, and this handles those. It also
4535 recognizes some special PE cases. */
4537 static enum coff_symbol_classification
4538 coff_classify_symbol (abfd
, syment
)
4540 struct internal_syment
*syment
;
4542 /* FIXME: This partially duplicates the switch in
4543 coff_slurp_symbol_table. */
4544 switch (syment
->n_sclass
)
4553 case C_THUMBEXTFUNC
:
4561 if (syment
->n_scnum
== 0)
4563 if (syment
->n_value
== 0)
4564 return COFF_SYMBOL_UNDEFINED
;
4566 return COFF_SYMBOL_COMMON
;
4568 return COFF_SYMBOL_GLOBAL
;
4575 if (syment
->n_sclass
== C_STAT
)
4577 if (syment
->n_scnum
== 0)
4579 /* The Microsoft compiler sometimes generates these if a
4580 small static function is inlined every time it is used.
4581 The function is discarded, but the symbol table entry
4583 return COFF_SYMBOL_LOCAL
;
4586 #ifdef STRICT_PE_FORMAT
4587 /* This is correct for Microsoft generated objects, but it
4588 breaks gas generated objects. */
4590 if (syment
->n_value
== 0)
4593 char buf
[SYMNMLEN
+ 1];
4595 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
4597 && (strcmp (bfd_get_section_name (abfd
, sec
),
4598 _bfd_coff_internal_syment_name (abfd
, syment
, buf
))
4600 return COFF_SYMBOL_PE_SECTION
;
4604 return COFF_SYMBOL_LOCAL
;
4607 if (syment
->n_sclass
== C_SECTION
)
4609 /* In some cases in a DLL generated by the Microsoft linker, the
4610 n_value field will contain garbage. FIXME: This should
4611 probably be handled by the swapping function instead. */
4612 syment
->n_value
= 0;
4613 if (syment
->n_scnum
== 0)
4614 return COFF_SYMBOL_UNDEFINED
;
4615 return COFF_SYMBOL_PE_SECTION
;
4617 #endif /* COFF_WITH_PE */
4619 /* If it is not a global symbol, we presume it is a local symbol. */
4621 if (syment
->n_scnum
== 0)
4623 char buf
[SYMNMLEN
+ 1];
4625 (*_bfd_error_handler
)
4626 (_("warning: %s: local symbol `%s' has no section"),
4627 bfd_get_filename (abfd
),
4628 _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
4631 return COFF_SYMBOL_LOCAL
;
4638 Coff relocations are easily transformed into the internal BFD form
4641 Reading a coff relocation table is done in the following stages:
4643 o Read the entire coff relocation table into memory.
4645 o Process each relocation in turn; first swap it from the
4646 external to the internal form.
4648 o Turn the symbol referenced in the relocation's symbol index
4649 into a pointer into the canonical symbol table.
4650 This table is the same as the one returned by a call to
4651 @code{bfd_canonicalize_symtab}. The back end will call that
4652 routine and save the result if a canonicalization hasn't been done.
4654 o The reloc index is turned into a pointer to a howto
4655 structure, in a back end specific way. For instance, the 386
4656 and 960 use the @code{r_type} to directly produce an index
4657 into a howto table vector; the 88k subtracts a number from the
4658 @code{r_type} field and creates an addend field.
4664 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
4666 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
4667 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
4668 coffsym = (obj_symbols (abfd) \
4669 + (cache_ptr->sym_ptr_ptr - symbols)); \
4671 coffsym = coff_symbol_from (abfd, ptr); \
4672 if (coffsym != (coff_symbol_type *) NULL \
4673 && coffsym->native->u.syment.n_scnum == 0) \
4674 cache_ptr->addend = 0; \
4675 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
4676 && ptr->section != (asection *) NULL) \
4677 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
4679 cache_ptr->addend = 0; \
4684 coff_slurp_reloc_table (abfd
, asect
, symbols
)
4689 RELOC
*native_relocs
;
4690 arelent
*reloc_cache
;
4695 if (asect
->relocation
)
4697 if (asect
->reloc_count
== 0)
4699 if (asect
->flags
& SEC_CONSTRUCTOR
)
4701 if (!coff_slurp_symbol_table (abfd
))
4704 (RELOC
*) buy_and_read (abfd
,
4707 (size_t) (bfd_coff_relsz (abfd
) *
4708 asect
->reloc_count
));
4709 reloc_cache
= (arelent
*)
4710 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
4712 if (reloc_cache
== NULL
)
4716 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
4718 struct internal_reloc dst
;
4719 struct external_reloc
*src
;
4720 #ifndef RELOC_PROCESSING
4724 cache_ptr
= reloc_cache
+ idx
;
4725 src
= native_relocs
+ idx
;
4727 coff_swap_reloc_in (abfd
, src
, &dst
);
4729 #ifdef RELOC_PROCESSING
4730 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
4732 cache_ptr
->address
= dst
.r_vaddr
;
4734 if (dst
.r_symndx
!= -1)
4736 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
4738 (*_bfd_error_handler
)
4739 (_("%s: warning: illegal symbol index %ld in relocs"),
4740 bfd_get_filename (abfd
), dst
.r_symndx
);
4741 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
4746 cache_ptr
->sym_ptr_ptr
= (symbols
4747 + obj_convert (abfd
)[dst
.r_symndx
]);
4748 ptr
= *(cache_ptr
->sym_ptr_ptr
);
4753 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
4757 /* The symbols definitions that we have read in have been
4758 relocated as if their sections started at 0. But the offsets
4759 refering to the symbols in the raw data have not been
4760 modified, so we have to have a negative addend to compensate.
4762 Note that symbols which used to be common must be left alone */
4764 /* Calculate any reloc addend by looking at the symbol */
4765 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
4767 cache_ptr
->address
-= asect
->vma
;
4768 /* !! cache_ptr->section = (asection *) NULL;*/
4770 /* Fill in the cache_ptr->howto field from dst.r_type */
4771 RTYPE2HOWTO (cache_ptr
, &dst
);
4772 #endif /* RELOC_PROCESSING */
4774 if (cache_ptr
->howto
== NULL
)
4776 (*_bfd_error_handler
)
4777 (_("%s: illegal relocation type %d at address 0x%lx"),
4778 bfd_get_filename (abfd
), dst
.r_type
, (long) dst
.r_vaddr
);
4779 bfd_set_error (bfd_error_bad_value
);
4784 asect
->relocation
= reloc_cache
;
4788 #ifndef coff_rtype_to_howto
4791 /* Get the howto structure for a reloc. This is only used if the file
4792 including this one defines coff_relocate_section to be
4793 _bfd_coff_generic_relocate_section, so it is OK if it does not
4794 always work. It is the responsibility of the including file to
4795 make sure it is reasonable if it is needed. */
4797 static reloc_howto_type
*coff_rtype_to_howto
4798 PARAMS ((bfd
*, asection
*, struct internal_reloc
*,
4799 struct coff_link_hash_entry
*, struct internal_syment
*,
4803 static reloc_howto_type
*
4804 coff_rtype_to_howto (abfd
, sec
, rel
, h
, sym
, addendp
)
4805 bfd
*abfd ATTRIBUTE_UNUSED
;
4806 asection
*sec ATTRIBUTE_UNUSED
;
4807 struct internal_reloc
*rel
;
4808 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
;
4809 struct internal_syment
*sym ATTRIBUTE_UNUSED
;
4810 bfd_vma
*addendp ATTRIBUTE_UNUSED
;
4814 RTYPE2HOWTO (&genrel
, rel
);
4815 return genrel
.howto
;
4818 #else /* ! defined (RTYPE2HOWTO) */
4820 #define coff_rtype_to_howto NULL
4822 #endif /* ! defined (RTYPE2HOWTO) */
4823 #endif /* ! defined (coff_rtype_to_howto) */
4825 /* This is stupid. This function should be a boolean predicate. */
4827 coff_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
4833 arelent
*tblptr
= section
->relocation
;
4834 unsigned int count
= 0;
4837 if (section
->flags
& SEC_CONSTRUCTOR
)
4839 /* this section has relocs made up by us, they are not in the
4840 file, so take them out of their chain and place them into
4841 the data area provided */
4842 arelent_chain
*chain
= section
->constructor_chain
;
4843 for (count
= 0; count
< section
->reloc_count
; count
++)
4845 *relptr
++ = &chain
->relent
;
4846 chain
= chain
->next
;
4852 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
4855 tblptr
= section
->relocation
;
4857 for (; count
++ < section
->reloc_count
;)
4858 *relptr
++ = tblptr
++;
4863 return section
->reloc_count
;
4868 coff_sym_filepos (abfd
)
4871 return obj_sym_filepos (abfd
);
4875 #ifndef coff_reloc16_estimate
4876 #define coff_reloc16_estimate dummy_reloc16_estimate
4878 static int dummy_reloc16_estimate
4879 PARAMS ((bfd
*, asection
*, arelent
*, unsigned int,
4880 struct bfd_link_info
*));
4883 dummy_reloc16_estimate (abfd
, input_section
, reloc
, shrink
, link_info
)
4884 bfd
*abfd ATTRIBUTE_UNUSED
;
4885 asection
*input_section ATTRIBUTE_UNUSED
;
4886 arelent
*reloc ATTRIBUTE_UNUSED
;
4887 unsigned int shrink ATTRIBUTE_UNUSED
;
4888 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
4896 #ifndef coff_reloc16_extra_cases
4898 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
4900 /* This works even if abort is not declared in any header file. */
4902 static void dummy_reloc16_extra_cases
4903 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*, arelent
*,
4904 bfd_byte
*, unsigned int *, unsigned int *));
4907 dummy_reloc16_extra_cases (abfd
, link_info
, link_order
, reloc
, data
, src_ptr
,
4909 bfd
*abfd ATTRIBUTE_UNUSED
;
4910 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
4911 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
;
4912 arelent
*reloc ATTRIBUTE_UNUSED
;
4913 bfd_byte
*data ATTRIBUTE_UNUSED
;
4914 unsigned int *src_ptr ATTRIBUTE_UNUSED
;
4915 unsigned int *dst_ptr ATTRIBUTE_UNUSED
;
4921 /* If coff_relocate_section is defined, we can use the optimized COFF
4922 backend linker. Otherwise we must continue to use the old linker. */
4923 #ifdef coff_relocate_section
4924 #ifndef coff_bfd_link_hash_table_create
4925 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
4927 #ifndef coff_bfd_link_add_symbols
4928 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
4930 #ifndef coff_bfd_final_link
4931 #define coff_bfd_final_link _bfd_coff_final_link
4933 #else /* ! defined (coff_relocate_section) */
4934 #define coff_relocate_section NULL
4935 #ifndef coff_bfd_link_hash_table_create
4936 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
4938 #ifndef coff_bfd_link_add_symbols
4939 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
4941 #define coff_bfd_final_link _bfd_generic_final_link
4942 #endif /* ! defined (coff_relocate_section) */
4944 #define coff_bfd_link_split_section _bfd_generic_link_split_section
4946 #ifndef coff_start_final_link
4947 #define coff_start_final_link NULL
4950 #ifndef coff_adjust_symndx
4951 #define coff_adjust_symndx NULL
4954 #ifndef coff_link_add_one_symbol
4955 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
4958 #ifndef coff_link_output_has_begun
4960 static boolean coff_link_output_has_begun
4961 PARAMS ((bfd
*, struct coff_final_link_info
*));
4964 coff_link_output_has_begun (abfd
, info
)
4966 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
;
4968 return abfd
->output_has_begun
;
4972 #ifndef coff_final_link_postscript
4974 static boolean coff_final_link_postscript
4975 PARAMS ((bfd
*, struct coff_final_link_info
*));
4978 coff_final_link_postscript (abfd
, pfinfo
)
4979 bfd
* abfd ATTRIBUTE_UNUSED
;
4980 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
;
4986 #ifndef coff_SWAP_aux_in
4987 #define coff_SWAP_aux_in coff_swap_aux_in
4989 #ifndef coff_SWAP_sym_in
4990 #define coff_SWAP_sym_in coff_swap_sym_in
4992 #ifndef coff_SWAP_lineno_in
4993 #define coff_SWAP_lineno_in coff_swap_lineno_in
4995 #ifndef coff_SWAP_aux_out
4996 #define coff_SWAP_aux_out coff_swap_aux_out
4998 #ifndef coff_SWAP_sym_out
4999 #define coff_SWAP_sym_out coff_swap_sym_out
5001 #ifndef coff_SWAP_lineno_out
5002 #define coff_SWAP_lineno_out coff_swap_lineno_out
5004 #ifndef coff_SWAP_reloc_out
5005 #define coff_SWAP_reloc_out coff_swap_reloc_out
5007 #ifndef coff_SWAP_filehdr_out
5008 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5010 #ifndef coff_SWAP_aouthdr_out
5011 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5013 #ifndef coff_SWAP_scnhdr_out
5014 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5016 #ifndef coff_SWAP_reloc_in
5017 #define coff_SWAP_reloc_in coff_swap_reloc_in
5019 #ifndef coff_SWAP_filehdr_in
5020 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5022 #ifndef coff_SWAP_aouthdr_in
5023 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5025 #ifndef coff_SWAP_scnhdr_in
5026 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5029 static const bfd_coff_backend_data bfd_coff_std_swap_table
=
5031 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5032 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5033 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5034 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5035 coff_SWAP_scnhdr_out
,
5036 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5037 #ifdef COFF_LONG_FILENAMES
5042 #ifdef COFF_LONG_SECTION_NAMES
5047 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5048 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5053 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5058 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5059 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5060 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5061 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5062 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5063 coff_classify_symbol
, coff_compute_section_file_positions
,
5064 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5065 coff_adjust_symndx
, coff_link_add_one_symbol
,
5066 coff_link_output_has_begun
, coff_final_link_postscript
5069 #ifndef coff_close_and_cleanup
5070 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5073 #ifndef coff_bfd_free_cached_info
5074 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5077 #ifndef coff_get_section_contents
5078 #define coff_get_section_contents _bfd_generic_get_section_contents
5081 #ifndef coff_bfd_copy_private_symbol_data
5082 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5085 #ifndef coff_bfd_copy_private_section_data
5086 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5089 #ifndef coff_bfd_copy_private_bfd_data
5090 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5093 #ifndef coff_bfd_merge_private_bfd_data
5094 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5097 #ifndef coff_bfd_set_private_flags
5098 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5101 #ifndef coff_bfd_print_private_bfd_data
5102 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5105 #ifndef coff_bfd_is_local_label_name
5106 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5109 #ifndef coff_read_minisymbols
5110 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5113 #ifndef coff_minisymbol_to_symbol
5114 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5117 /* The reloc lookup routine must be supplied by each individual COFF
5119 #ifndef coff_bfd_reloc_type_lookup
5120 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5123 #ifndef coff_bfd_get_relocated_section_contents
5124 #define coff_bfd_get_relocated_section_contents \
5125 bfd_generic_get_relocated_section_contents
5128 #ifndef coff_bfd_relax_section
5129 #define coff_bfd_relax_section bfd_generic_relax_section
5132 #ifndef coff_bfd_gc_sections
5133 #define coff_bfd_gc_sections bfd_generic_gc_sections
5136 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
5137 const bfd_target VAR = \
5140 bfd_target_coff_flavour, \
5141 BFD_ENDIAN_BIG, /* data byte order is big */ \
5142 BFD_ENDIAN_BIG, /* header byte order is big */ \
5143 /* object flags */ \
5144 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5145 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5146 /* section flags */ \
5147 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5148 UNDER, /* leading symbol underscore */ \
5149 '/', /* ar_pad_char */ \
5150 15, /* ar_max_namelen */ \
5152 /* Data conversion functions. */ \
5153 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5154 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5155 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5157 /* Header conversion functions. */ \
5158 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5159 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5160 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5162 /* bfd_check_format */ \
5163 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5164 _bfd_dummy_target }, \
5165 /* bfd_set_format */ \
5166 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5167 /* bfd_write_contents */ \
5168 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5171 BFD_JUMP_TABLE_GENERIC (coff), \
5172 BFD_JUMP_TABLE_COPY (coff), \
5173 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5174 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5175 BFD_JUMP_TABLE_SYMBOLS (coff), \
5176 BFD_JUMP_TABLE_RELOCS (coff), \
5177 BFD_JUMP_TABLE_WRITE (coff), \
5178 BFD_JUMP_TABLE_LINK (coff), \
5179 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5186 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
5187 const bfd_target VAR = \
5190 bfd_target_coff_flavour, \
5191 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
5192 BFD_ENDIAN_LITTLE, /* header byte order is little */ \
5193 /* object flags */ \
5194 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5195 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5196 /* section flags */ \
5197 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5198 UNDER, /* leading symbol underscore */ \
5199 '/', /* ar_pad_char */ \
5200 15, /* ar_max_namelen */ \
5202 /* Data conversion functions. */ \
5203 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5204 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5205 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5206 /* Header conversion functions. */ \
5207 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5208 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5209 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5210 /* bfd_check_format */ \
5211 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5212 _bfd_dummy_target }, \
5213 /* bfd_set_format */ \
5214 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5215 /* bfd_write_contents */ \
5216 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5219 BFD_JUMP_TABLE_GENERIC (coff), \
5220 BFD_JUMP_TABLE_COPY (coff), \
5221 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5222 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5223 BFD_JUMP_TABLE_SYMBOLS (coff), \
5224 BFD_JUMP_TABLE_RELOCS (coff), \
5225 BFD_JUMP_TABLE_WRITE (coff), \
5226 BFD_JUMP_TABLE_LINK (coff), \
5227 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \