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 . void (*_bfd_coff_swap_filehdr_in) PARAMS ((
1131 . void (*_bfd_coff_swap_aouthdr_in) PARAMS ((
1135 . void (*_bfd_coff_swap_scnhdr_in) PARAMS ((
1139 . void (*_bfd_coff_swap_reloc_in) PARAMS ((
1143 . boolean (*_bfd_coff_bad_format_hook) PARAMS ((
1145 . PTR internal_filehdr));
1146 . boolean (*_bfd_coff_set_arch_mach_hook) PARAMS ((
1148 . PTR internal_filehdr));
1149 . PTR (*_bfd_coff_mkobject_hook) PARAMS ((
1151 . PTR internal_filehdr,
1152 . PTR internal_aouthdr));
1153 . flagword (*_bfd_styp_to_sec_flags_hook) PARAMS ((
1155 . PTR internal_scnhdr,
1157 . asection *section));
1158 . void (*_bfd_set_alignment_hook) PARAMS ((
1161 . PTR internal_scnhdr));
1162 . boolean (*_bfd_coff_slurp_symbol_table) PARAMS ((
1164 . boolean (*_bfd_coff_symname_in_debug) PARAMS ((
1166 . struct internal_syment *sym));
1167 . boolean (*_bfd_coff_pointerize_aux_hook) PARAMS ((
1169 . combined_entry_type *table_base,
1170 . combined_entry_type *symbol,
1171 . unsigned int indaux,
1172 . combined_entry_type *aux));
1173 . boolean (*_bfd_coff_print_aux) PARAMS ((
1176 . combined_entry_type *table_base,
1177 . combined_entry_type *symbol,
1178 . combined_entry_type *aux,
1179 . unsigned int indaux));
1180 . void (*_bfd_coff_reloc16_extra_cases) PARAMS ((
1182 . struct bfd_link_info *link_info,
1183 . struct bfd_link_order *link_order,
1186 . unsigned int *src_ptr,
1187 . unsigned int *dst_ptr));
1188 . int (*_bfd_coff_reloc16_estimate) PARAMS ((
1190 . asection *input_section,
1192 . unsigned int shrink,
1193 . struct bfd_link_info *link_info));
1194 . enum coff_symbol_classification (*_bfd_coff_classify_symbol) PARAMS ((
1196 . struct internal_syment *));
1197 . boolean (*_bfd_coff_compute_section_file_positions) PARAMS ((
1199 . boolean (*_bfd_coff_start_final_link) PARAMS ((
1201 . struct bfd_link_info *info));
1202 . boolean (*_bfd_coff_relocate_section) PARAMS ((
1204 . struct bfd_link_info *info,
1206 . asection *input_section,
1207 . bfd_byte *contents,
1208 . struct internal_reloc *relocs,
1209 . struct internal_syment *syms,
1210 . asection **sections));
1211 . reloc_howto_type *(*_bfd_coff_rtype_to_howto) PARAMS ((
1214 . struct internal_reloc *rel,
1215 . struct coff_link_hash_entry *h,
1216 . struct internal_syment *sym,
1217 . bfd_vma *addendp));
1218 . boolean (*_bfd_coff_adjust_symndx) PARAMS ((
1220 . struct bfd_link_info *info,
1223 . struct internal_reloc *reloc,
1224 . boolean *adjustedp));
1225 . boolean (*_bfd_coff_link_add_one_symbol) PARAMS ((
1226 . struct bfd_link_info *info,
1230 . asection *section,
1232 . const char *string,
1235 . struct bfd_link_hash_entry **hashp));
1237 . boolean (*_bfd_coff_link_output_has_begun) PARAMS ((
1239 . struct coff_final_link_info * pfinfo));
1240 . boolean (*_bfd_coff_final_link_postscript) PARAMS ((
1242 . struct coff_final_link_info * pfinfo));
1244 .} bfd_coff_backend_data;
1246 .#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1248 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1249 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1251 .#define bfd_coff_swap_sym_in(a,e,i) \
1252 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1254 .#define bfd_coff_swap_lineno_in(a,e,i) \
1255 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1257 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1258 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1260 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1261 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1263 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1264 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1266 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1267 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1269 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1270 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1272 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1273 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1275 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1276 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1278 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1279 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1280 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1281 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1282 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1283 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1284 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1285 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1286 .#define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1287 .#define bfd_coff_long_section_names(abfd) \
1288 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1289 .#define bfd_coff_default_section_alignment_power(abfd) \
1290 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1291 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1292 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1294 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1295 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1297 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1298 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1300 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1301 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1303 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1304 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1306 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1307 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1308 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1309 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
1311 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section)\
1312 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1313 . (abfd, scnhdr, name, section))
1315 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1316 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1318 .#define bfd_coff_slurp_symbol_table(abfd)\
1319 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1321 .#define bfd_coff_symname_in_debug(abfd, sym)\
1322 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1324 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1325 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1326 . (abfd, file, base, symbol, aux, indaux))
1328 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
1329 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1330 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1332 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1333 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1334 . (abfd, section, reloc, shrink, link_info))
1336 .#define bfd_coff_classify_symbol(abfd, sym)\
1337 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1340 .#define bfd_coff_compute_section_file_positions(abfd)\
1341 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1344 .#define bfd_coff_start_final_link(obfd, info)\
1345 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1347 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1348 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1349 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1350 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1351 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1352 . (abfd, sec, rel, h, sym, addendp))
1353 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1354 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1355 . (obfd, info, ibfd, sec, rel, adjustedp))
1356 .#define bfd_coff_link_add_one_symbol(info,abfd,name,flags,section,value,string,cp,coll,hashp)\
1357 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1358 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1360 .#define bfd_coff_link_output_has_begun(a,p) \
1361 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p))
1362 .#define bfd_coff_final_link_postscript(a,p) \
1363 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
1367 /* See whether the magic number matches. */
1370 coff_bad_format_hook (abfd
, filehdr
)
1371 bfd
* abfd ATTRIBUTE_UNUSED
;
1374 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1376 if (BADMAG (*internal_f
))
1379 /* if the optional header is NULL or not the correct size then
1380 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1381 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1382 optional header is of a different size.
1384 But the mips keeps extra stuff in it's opthdr, so dont check
1388 #if defined(M88) || defined(I960)
1389 if (internal_f
->f_opthdr
!= 0 && bfd_coff_aoutsz (abfd
) != internal_f
->f_opthdr
)
1396 /* Check whether this section uses an alignment other than the
1400 coff_set_custom_section_alignment (abfd
, section
, alignment_table
, table_size
)
1401 bfd
*abfd ATTRIBUTE_UNUSED
;
1403 const struct coff_section_alignment_entry
*alignment_table
;
1404 const unsigned int table_size
;
1406 const unsigned int default_alignment
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1409 for (i
= 0; i
< table_size
; ++i
)
1411 const char *secname
= bfd_get_section_name (abfd
, section
);
1412 if (alignment_table
[i
].comparison_length
== (unsigned int) -1
1413 ? strcmp (alignment_table
[i
].name
, secname
) == 0
1414 : strncmp (alignment_table
[i
].name
, secname
,
1415 alignment_table
[i
].comparison_length
) == 0)
1418 if (i
>= table_size
)
1421 if (alignment_table
[i
].default_alignment_min
!= COFF_ALIGNMENT_FIELD_EMPTY
1422 && default_alignment
< alignment_table
[i
].default_alignment_min
)
1425 if (alignment_table
[i
].default_alignment_max
!= COFF_ALIGNMENT_FIELD_EMPTY
1426 && default_alignment
> alignment_table
[i
].default_alignment_max
)
1429 section
->alignment_power
= alignment_table
[i
].alignment_power
;
1432 /* Custom section alignment records. */
1434 static const struct coff_section_alignment_entry
1435 coff_section_alignment_table
[] =
1437 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1438 COFF_SECTION_ALIGNMENT_ENTRIES
,
1440 /* There must not be any gaps between .stabstr sections. */
1441 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1442 1, COFF_ALIGNMENT_FIELD_EMPTY
, 0 },
1443 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1444 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1445 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1446 /* Similarly for the .ctors and .dtors sections. */
1447 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1448 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1449 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1450 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 }
1453 static const unsigned int coff_section_alignment_table_size
=
1454 sizeof coff_section_alignment_table
/ sizeof coff_section_alignment_table
[0];
1456 /* Initialize a section structure with information peculiar to this
1457 particular implementation of COFF. */
1460 coff_new_section_hook (abfd
, section
)
1464 combined_entry_type
*native
;
1466 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1469 if (xcoff_data (abfd
)->text_align_power
!= 0
1470 && strcmp (bfd_get_section_name (abfd
, section
), ".text") == 0)
1471 section
->alignment_power
= xcoff_data (abfd
)->text_align_power
;
1472 if (xcoff_data (abfd
)->data_align_power
!= 0
1473 && strcmp (bfd_get_section_name (abfd
, section
), ".data") == 0)
1474 section
->alignment_power
= xcoff_data (abfd
)->data_align_power
;
1477 /* Allocate aux records for section symbols, to store size and
1480 @@ The 10 is a guess at a plausible maximum number of aux entries
1481 (but shouldn't be a constant). */
1482 native
= ((combined_entry_type
*)
1483 bfd_zalloc (abfd
, sizeof (combined_entry_type
) * 10));
1487 /* We don't need to set up n_name, n_value, or n_scnum in the native
1488 symbol information, since they'll be overriden by the BFD symbol
1489 anyhow. However, we do need to set the type and storage class,
1490 in case this symbol winds up getting written out. The value 0
1491 for n_numaux is already correct. */
1493 native
->u
.syment
.n_type
= T_NULL
;
1494 native
->u
.syment
.n_sclass
= C_STAT
;
1496 coffsymbol (section
->symbol
)->native
= native
;
1498 coff_set_custom_section_alignment (abfd
, section
,
1499 coff_section_alignment_table
,
1500 coff_section_alignment_table_size
);
1505 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1507 /* Set the alignment of a BFD section. */
1509 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1512 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1513 bfd
* abfd ATTRIBUTE_UNUSED
;
1517 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1521 /* Extract ALIGN from 2**ALIGN stored in section header */
1522 for (i
= 0; i
< 32; i
++)
1523 if ((1 << i
) >= hdr
->s_align
)
1527 /* TI tools puts the alignment power in bits 8-11 */
1528 i
= (hdr
->s_flags
>> 8) & 0xF ;
1530 #ifdef COFF_DECODE_ALIGNMENT
1531 i
= COFF_DECODE_ALIGNMENT(hdr
->s_flags
);
1533 section
->alignment_power
= i
;
1536 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1539 /* a couple of macros to help setting the alignment power field */
1540 #define ALIGN_SET(field,x,y) \
1541 if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1543 section->alignment_power = y;\
1546 #define ELIFALIGN_SET(field,x,y) \
1547 else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1549 section->alignment_power = y;\
1552 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1555 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1556 bfd
* abfd ATTRIBUTE_UNUSED
;
1560 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1562 ALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_64BYTES
, 6)
1563 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_32BYTES
, 5)
1564 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_16BYTES
, 4)
1565 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_8BYTES
, 3)
1566 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_4BYTES
, 2)
1567 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_2BYTES
, 1)
1568 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_1BYTES
, 0)
1570 /* In a PE image file, the s_paddr field holds the virtual size of a
1571 section, while the s_size field holds the raw size. We also keep
1572 the original section flag value, since not every bit can be
1573 mapped onto a generic BFD section bit. */
1574 if (coff_section_data (abfd
, section
) == NULL
)
1576 section
->used_by_bfd
=
1577 (PTR
) bfd_zalloc (abfd
, sizeof (struct coff_section_tdata
));
1578 if (section
->used_by_bfd
== NULL
)
1580 /* FIXME: Return error. */
1584 if (pei_section_data (abfd
, section
) == NULL
)
1586 coff_section_data (abfd
, section
)->tdata
=
1587 (PTR
) bfd_zalloc (abfd
, sizeof (struct pei_section_tdata
));
1588 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1590 /* FIXME: Return error. */
1594 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1595 pei_section_data (abfd
, section
)->pe_flags
= hdr
->s_flags
;
1597 section
->lma
= hdr
->s_vaddr
;
1600 #undef ELIFALIGN_SET
1602 #else /* ! COFF_WITH_PE */
1605 /* We grossly abuse this function to handle XCOFF overflow headers.
1606 When we see one, we correct the reloc and line number counts in the
1607 real header, and remove the section we just created. */
1609 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1612 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1617 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1621 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1624 real_sec
= coff_section_from_bfd_index (abfd
, hdr
->s_nreloc
);
1625 if (real_sec
== NULL
)
1628 real_sec
->reloc_count
= hdr
->s_paddr
;
1629 real_sec
->lineno_count
= hdr
->s_vaddr
;
1631 for (ps
= &abfd
->sections
; *ps
!= NULL
; ps
= &(*ps
)->next
)
1636 --abfd
->section_count
;
1642 #else /* ! RS6000COFF_C */
1644 #define coff_set_alignment_hook \
1645 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1647 #endif /* ! RS6000COFF_C */
1648 #endif /* ! COFF_WITH_PE */
1649 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1651 #ifndef coff_mkobject
1653 static boolean coff_mkobject
PARAMS ((bfd
*));
1656 coff_mkobject (abfd
)
1659 coff_data_type
*coff
;
1661 abfd
->tdata
.coff_obj_data
= (struct coff_tdata
*) bfd_zalloc (abfd
, sizeof (coff_data_type
));
1662 if (abfd
->tdata
.coff_obj_data
== 0)
1664 coff
= coff_data (abfd
);
1665 coff
->symbols
= (coff_symbol_type
*) NULL
;
1666 coff
->conversion_table
= (unsigned int *) NULL
;
1667 coff
->raw_syments
= (struct coff_ptr_struct
*) NULL
;
1668 coff
->relocbase
= 0;
1669 coff
->local_toc_sym_map
= 0;
1671 /* make_abs_section(abfd);*/
1677 /* Create the COFF backend specific information. */
1678 #ifndef coff_mkobject_hook
1680 coff_mkobject_hook (abfd
, filehdr
, aouthdr
)
1683 PTR aouthdr ATTRIBUTE_UNUSED
;
1685 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1686 coff_data_type
*coff
;
1688 if (coff_mkobject (abfd
) == false)
1691 coff
= coff_data (abfd
);
1693 coff
->sym_filepos
= internal_f
->f_symptr
;
1695 /* These members communicate important constants about the symbol
1696 table to GDB's symbol-reading code. These `constants'
1697 unfortunately vary among coff implementations... */
1698 coff
->local_n_btmask
= N_BTMASK
;
1699 coff
->local_n_btshft
= N_BTSHFT
;
1700 coff
->local_n_tmask
= N_TMASK
;
1701 coff
->local_n_tshift
= N_TSHIFT
;
1702 coff
->local_symesz
= bfd_coff_symesz (abfd
);
1703 coff
->local_auxesz
= bfd_coff_auxesz (abfd
);
1704 coff
->local_linesz
= bfd_coff_linesz (abfd
);
1706 coff
->timestamp
= internal_f
->f_timdat
;
1708 obj_raw_syment_count (abfd
) =
1709 obj_conv_table_size (abfd
) =
1710 internal_f
->f_nsyms
;
1713 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
1714 abfd
->flags
|= DYNAMIC
;
1715 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= bfd_coff_aoutsz (abfd
))
1717 struct internal_aouthdr
*internal_a
=
1718 (struct internal_aouthdr
*) aouthdr
;
1719 struct xcoff_tdata
*xcoff
;
1721 xcoff
= xcoff_data (abfd
);
1722 xcoff
->full_aouthdr
= true;
1723 xcoff
->toc
= internal_a
->o_toc
;
1724 xcoff
->sntoc
= internal_a
->o_sntoc
;
1725 xcoff
->snentry
= internal_a
->o_snentry
;
1726 xcoff
->text_align_power
= internal_a
->o_algntext
;
1727 xcoff
->data_align_power
= internal_a
->o_algndata
;
1728 xcoff
->modtype
= internal_a
->o_modtype
;
1729 xcoff
->cputype
= internal_a
->o_cputype
;
1730 xcoff
->maxdata
= internal_a
->o_maxdata
;
1731 xcoff
->maxstack
= internal_a
->o_maxstack
;
1736 /* Set the flags field from the COFF header read in */
1737 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
1742 /* FIXME: I'm not sure this is ever executed, since peicode.h
1743 defines coff_mkobject_hook. */
1744 if ((internal_f
->f_flags
& IMAGE_FILE_DEBUG_STRIPPED
) == 0)
1745 abfd
->flags
|= HAS_DEBUG
;
1752 /* Determine the machine architecture and type. FIXME: This is target
1753 dependent because the magic numbers are defined in the target
1754 dependent header files. But there is no particular need for this.
1755 If the magic numbers were moved to a separate file, this function
1756 would be target independent and would also be much more successful
1757 at linking together COFF files for different architectures. */
1760 coff_set_arch_mach_hook (abfd
, filehdr
)
1765 enum bfd_architecture arch
;
1766 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1769 switch (internal_f
->f_magic
)
1773 arch
= bfd_arch_powerpc
;
1774 machine
= 0; /* what does this mean? (krk) */
1780 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler */
1781 case LYNXCOFFMAGIC
: /* shadows the m68k Lynx number below, sigh */
1782 arch
= bfd_arch_i386
;
1786 #ifdef A29K_MAGIC_BIG
1787 case A29K_MAGIC_BIG
:
1788 case A29K_MAGIC_LITTLE
:
1789 arch
= bfd_arch_a29k
;
1797 arch
= bfd_arch_arm
;
1798 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
1800 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
1801 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
1802 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
1804 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
1805 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
1806 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
1807 case F_ARM_5
: machine
= bfd_mach_arm_5
; break;
1814 #ifdef MC68KBCSMAGIC
1817 #ifdef APOLLOM68KMAGIC
1818 case APOLLOM68KMAGIC
:
1820 #ifdef LYNXCOFFMAGIC
1823 arch
= bfd_arch_m68k
;
1824 machine
= bfd_mach_m68020
;
1831 arch
= bfd_arch_m88k
;
1837 arch
= bfd_arch_z8k
;
1838 switch (internal_f
->f_flags
& F_MACHMASK
)
1841 machine
= bfd_mach_z8001
;
1844 machine
= bfd_mach_z8002
;
1853 arch
= bfd_arch_i860
;
1860 arch
= bfd_arch_i960
;
1861 switch (F_I960TYPE
& internal_f
->f_flags
)
1865 machine
= bfd_mach_i960_core
;
1868 machine
= bfd_mach_i960_kb_sb
;
1871 machine
= bfd_mach_i960_mc
;
1874 machine
= bfd_mach_i960_xa
;
1877 machine
= bfd_mach_i960_ca
;
1880 machine
= bfd_mach_i960_ka_sa
;
1883 machine
= bfd_mach_i960_jx
;
1886 machine
= bfd_mach_i960_hx
;
1900 if (xcoff_data (abfd
)->cputype
!= -1)
1901 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
1904 /* We did not get a value from the a.out header. If the
1905 file has not been stripped, we may be able to get the
1906 architecture information from the first symbol, if it
1907 is a .file symbol. */
1908 if (obj_raw_syment_count (abfd
) == 0)
1913 struct internal_syment sym
;
1915 buf
= (bfd_byte
*) bfd_malloc (bfd_coff_symesz (abfd
));
1916 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1917 || (bfd_read (buf
, 1, bfd_coff_symesz (abfd
), abfd
)
1918 != bfd_coff_symesz (abfd
)))
1923 coff_swap_sym_in (abfd
, (PTR
) buf
, (PTR
) &sym
);
1924 if (sym
.n_sclass
== C_FILE
)
1925 cputype
= sym
.n_type
& 0xff;
1932 /* FIXME: We don't handle all cases here. */
1938 /* PowerPC Macs use the same magic numbers as RS/6000
1939 (because that's how they were bootstrapped originally),
1940 but they are always PowerPC architecture. */
1941 arch
= bfd_arch_powerpc
;
1944 arch
= bfd_arch_rs6000
;
1946 #endif /* POWERMAC */
1950 arch
= bfd_arch_powerpc
;
1953 case 2: /* 64 bit PowerPC */
1954 arch
= bfd_arch_powerpc
;
1958 arch
= bfd_arch_powerpc
;
1962 arch
= bfd_arch_rs6000
;
1972 arch
= bfd_arch_we32k
;
1979 arch
= bfd_arch_h8300
;
1980 machine
= bfd_mach_h8300
;
1981 /* !! FIXME this probably isn't the right place for this */
1982 abfd
->flags
|= BFD_IS_RELAXABLE
;
1988 arch
= bfd_arch_h8300
;
1989 machine
= bfd_mach_h8300h
;
1990 /* !! FIXME this probably isn't the right place for this */
1991 abfd
->flags
|= BFD_IS_RELAXABLE
;
1997 arch
= bfd_arch_h8300
;
1998 machine
= bfd_mach_h8300s
;
1999 /* !! FIXME this probably isn't the right place for this */
2000 abfd
->flags
|= BFD_IS_RELAXABLE
;
2004 #ifdef SH_ARCH_MAGIC_BIG
2005 case SH_ARCH_MAGIC_BIG
:
2006 case SH_ARCH_MAGIC_LITTLE
:
2008 case SH_ARCH_MAGIC_WINCE
:
2015 #ifdef MIPS_ARCH_MAGIC_WINCE
2016 case MIPS_ARCH_MAGIC_WINCE
:
2017 arch
= bfd_arch_mips
;
2024 arch
= bfd_arch_h8500
;
2031 #ifdef LYNXCOFFMAGIC
2034 arch
= bfd_arch_sparc
;
2041 arch
= bfd_arch_tic30
;
2046 #ifdef TICOFF_TARGET_ARCH
2047 /* this TI COFF section should be used by all new TI COFF v0 targets */
2049 arch
= TICOFF_TARGET_ARCH
;
2055 /* this TI COFF section should be used by all new TI COFF v1/2 targets */
2056 /* TI COFF1 and COFF2 use the target_id field to specify which arch */
2059 switch (internal_f
->f_target_id
)
2063 arch
= TICOFF_TARGET_ARCH
;
2067 (*_bfd_error_handler
)
2068 (_("Unrecognized TI COFF target id '0x%x'"),
2069 internal_f
->f_target_id
);
2075 #ifdef TIC80_ARCH_MAGIC
2076 case TIC80_ARCH_MAGIC
:
2077 arch
= bfd_arch_tic80
;
2083 arch
= bfd_arch_mcore
;
2086 default: /* Unreadable input file type */
2087 arch
= bfd_arch_obscure
;
2091 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2095 #ifdef SYMNAME_IN_DEBUG
2097 static boolean symname_in_debug_hook
2098 PARAMS ((bfd
*, struct internal_syment
*));
2101 symname_in_debug_hook (abfd
, sym
)
2102 bfd
* abfd ATTRIBUTE_UNUSED
;
2103 struct internal_syment
*sym
;
2105 return SYMNAME_IN_DEBUG (sym
) ? true : false;
2110 #define symname_in_debug_hook \
2111 (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
2117 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
2119 static boolean coff_pointerize_aux_hook
2120 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
2121 unsigned int, combined_entry_type
*));
2125 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
2126 bfd
*abfd ATTRIBUTE_UNUSED
;
2127 combined_entry_type
*table_base
;
2128 combined_entry_type
*symbol
;
2129 unsigned int indaux
;
2130 combined_entry_type
*aux
;
2132 int class = symbol
->u
.syment
.n_sclass
;
2134 if ((class == C_EXT
|| class == C_HIDEXT
)
2135 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2137 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2139 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2140 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2141 aux
->fix_scnlen
= 1;
2144 /* Return true to indicate that the caller should not do any
2145 further work on this auxent. */
2149 /* Return false to indicate that this auxent should be handled by
2157 /* We don't want to pointerize bal entries. */
2159 static boolean coff_pointerize_aux_hook
2160 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
2161 unsigned int, combined_entry_type
*));
2165 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
2166 bfd
*abfd ATTRIBUTE_UNUSED
;
2167 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
2168 combined_entry_type
*symbol
;
2169 unsigned int indaux
;
2170 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
2172 /* Return true if we don't want to pointerize this aux entry, which
2173 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2175 && (symbol
->u
.syment
.n_sclass
== C_LEAFPROC
2176 || symbol
->u
.syment
.n_sclass
== C_LEAFSTAT
2177 || symbol
->u
.syment
.n_sclass
== C_LEAFEXT
));
2182 #define coff_pointerize_aux_hook 0
2185 #endif /* ! RS6000COFF_C */
2187 /* Print an aux entry. This returns true if it has printed it. */
2189 static boolean coff_print_aux
2190 PARAMS ((bfd
*, FILE *, combined_entry_type
*, combined_entry_type
*,
2191 combined_entry_type
*, unsigned int));
2194 coff_print_aux (abfd
, file
, table_base
, symbol
, aux
, indaux
)
2195 bfd
*abfd ATTRIBUTE_UNUSED
;
2196 FILE *file ATTRIBUTE_UNUSED
;
2197 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
2198 combined_entry_type
*symbol ATTRIBUTE_UNUSED
;
2199 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
2200 unsigned int indaux ATTRIBUTE_UNUSED
;
2203 if ((symbol
->u
.syment
.n_sclass
== C_EXT
2204 || symbol
->u
.syment
.n_sclass
== C_HIDEXT
)
2205 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2207 /* This is a csect entry. */
2208 fprintf (file
, "AUX ");
2209 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2211 BFD_ASSERT (! aux
->fix_scnlen
);
2212 fprintf (file
, "val %5ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2216 fprintf (file
, "indx ");
2217 if (! aux
->fix_scnlen
)
2218 fprintf (file
, "%4ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2220 fprintf (file
, "%4ld",
2221 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2224 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2225 aux
->u
.auxent
.x_csect
.x_parmhash
,
2226 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2227 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2228 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2229 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2230 aux
->u
.auxent
.x_csect
.x_stab
,
2231 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2236 /* Return false to indicate that no special action was taken. */
2244 To write relocations, the back end steps though the
2245 canonical relocation table and create an
2246 @code{internal_reloc}. The symbol index to use is removed from
2247 the @code{offset} field in the symbol table supplied. The
2248 address comes directly from the sum of the section base
2249 address and the relocation offset; the type is dug directly
2250 from the howto field. Then the @code{internal_reloc} is
2251 swapped into the shape of an @code{external_reloc} and written
2258 static int compare_arelent_ptr
PARAMS ((const PTR
, const PTR
));
2260 /* AUX's ld wants relocations to be sorted */
2262 compare_arelent_ptr (x
, y
)
2266 const arelent
**a
= (const arelent
**) x
;
2267 const arelent
**b
= (const arelent
**) y
;
2268 bfd_size_type aadr
= (*a
)->address
;
2269 bfd_size_type badr
= (*b
)->address
;
2271 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2274 #endif /* TARG_AUX */
2277 coff_write_relocs (abfd
, first_undef
)
2283 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
2286 struct external_reloc dst
;
2292 /* sort relocations before we write them out */
2293 p
= (arelent
**) bfd_malloc (s
->reloc_count
* sizeof (arelent
*));
2294 if (p
== NULL
&& s
->reloc_count
> 0)
2296 memcpy (p
, s
->orelocation
, s
->reloc_count
* sizeof (arelent
*));
2297 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2300 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2302 for (i
= 0; i
< s
->reloc_count
; i
++)
2304 struct internal_reloc n
;
2306 memset ((PTR
) & n
, 0, sizeof (n
));
2308 /* Now we've renumbered the symbols we know where the
2309 undefined symbols live in the table. Check the reloc
2310 entries for symbols who's output bfd isn't the right one.
2311 This is because the symbol was undefined (which means
2312 that all the pointers are never made to point to the same
2313 place). This is a bad thing,'cause the symbols attached
2314 to the output bfd are indexed, so that the relocation
2315 entries know which symbol index they point to. So we
2316 have to look up the output symbol here. */
2318 if (q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2321 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2322 asymbol
**outsyms
= abfd
->outsymbols
;
2323 for (i
= first_undef
; outsyms
[i
]; i
++)
2325 const char *intable
= outsyms
[i
]->name
;
2326 if (strcmp (intable
, sname
) == 0) {
2327 /* got a hit, so repoint the reloc */
2328 q
->sym_ptr_ptr
= outsyms
+ i
;
2334 n
.r_vaddr
= q
->address
+ s
->vma
;
2337 /* The 29k const/consth reloc pair is a real kludge. The consth
2338 part doesn't have a symbol; it has an offset. So rebuilt
2340 if (q
->howto
->type
== R_IHCONST
)
2341 n
.r_symndx
= q
->addend
;
2346 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2347 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
,s
))
2349 if (q
->sym_ptr_ptr
== bfd_abs_section_ptr
->symbol_ptr_ptr
)
2351 /* This is a relocation relative to the absolute symbol. */
2355 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2356 /* Take notice if the symbol reloc points to a symbol
2357 we don't have in our symbol table. What should we
2359 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2364 #ifdef SWAP_OUT_RELOC_OFFSET
2365 n
.r_offset
= q
->addend
;
2369 /* Work out reloc type from what is required */
2370 SELECT_RELOC (n
, q
->howto
);
2372 n
.r_type
= q
->howto
->type
;
2374 coff_swap_reloc_out (abfd
, &n
, &dst
);
2375 if (bfd_write ((PTR
) & dst
, 1, bfd_coff_relsz (abfd
), abfd
)
2376 != bfd_coff_relsz (abfd
))
2389 /* Set flags and magic number of a coff file from architecture and machine
2390 type. Result is true if we can represent the arch&type, false if not. */
2393 coff_set_flags (abfd
, magicp
, flagsp
)
2395 unsigned int *magicp ATTRIBUTE_UNUSED
;
2396 unsigned short *flagsp ATTRIBUTE_UNUSED
;
2398 switch (bfd_get_arch (abfd
))
2403 switch (bfd_get_mach (abfd
))
2405 case bfd_mach_z8001
:
2408 case bfd_mach_z8002
:
2422 *magicp
= I960ROMAGIC
;
2424 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2425 I960RWMAGIC); FIXME???
2427 switch (bfd_get_mach (abfd
))
2429 case bfd_mach_i960_core
:
2432 case bfd_mach_i960_kb_sb
:
2435 case bfd_mach_i960_mc
:
2438 case bfd_mach_i960_xa
:
2441 case bfd_mach_i960_ca
:
2444 case bfd_mach_i960_ka_sa
:
2447 case bfd_mach_i960_jx
:
2450 case bfd_mach_i960_hx
:
2463 case bfd_arch_tic30
:
2464 *magicp
= TIC30MAGIC
;
2468 #ifdef TICOFF_DEFAULT_MAGIC
2469 case TICOFF_TARGET_ARCH
:
2470 /* if there's no indication of which version we want, use the default */
2472 *magicp
= TICOFF_DEFAULT_MAGIC
;
2475 /* we may want to output in a different COFF version */
2476 switch (abfd
->xvec
->name
[4])
2479 *magicp
= TICOFF0MAGIC
;
2482 *magicp
= TICOFF1MAGIC
;
2485 *magicp
= TICOFF2MAGIC
;
2494 #ifdef TIC80_ARCH_MAGIC
2495 case bfd_arch_tic80
:
2496 *magicp
= TIC80_ARCH_MAGIC
;
2502 * magicp
= ARMPEMAGIC
;
2504 * magicp
= ARMMAGIC
;
2507 if (APCS_SET (abfd
))
2509 if (APCS_26_FLAG (abfd
))
2510 * flagsp
|= F_APCS26
;
2512 if (APCS_FLOAT_FLAG (abfd
))
2513 * flagsp
|= F_APCS_FLOAT
;
2515 if (PIC_FLAG (abfd
))
2518 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2519 * flagsp
|= F_INTERWORK
;
2520 switch (bfd_get_mach (abfd
))
2522 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2523 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2524 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2525 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2526 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2527 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2528 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2529 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break; /* XXX - we do not have an F_ARM_5T */
2534 case bfd_arch_powerpc
:
2541 *magicp
= I386MAGIC
;
2543 /* Just overwrite the usual value if we're doing Lynx. */
2544 *magicp
= LYNXCOFFMAGIC
;
2551 *magicp
= I860MAGIC
;
2557 #ifdef APOLLOM68KMAGIC
2558 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
2560 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2561 #ifdef NAMES_HAVE_UNDERSCORE
2562 *magicp
= MC68KBCSMAGIC
;
2564 *magicp
= MC68MAGIC
;
2568 /* Just overwrite the usual value if we're doing Lynx. */
2569 *magicp
= LYNXCOFFMAGIC
;
2577 *magicp
= MC88OMAGIC
;
2582 case bfd_arch_h8300
:
2583 switch (bfd_get_mach (abfd
))
2585 case bfd_mach_h8300
:
2586 *magicp
= H8300MAGIC
;
2588 case bfd_mach_h8300h
:
2589 *magicp
= H8300HMAGIC
;
2591 case bfd_mach_h8300s
:
2592 *magicp
= H8300SMAGIC
;
2598 #ifdef SH_ARCH_MAGIC_BIG
2600 #ifdef COFF_IMAGE_WITH_PE
2601 *magicp
= SH_ARCH_MAGIC_WINCE
;
2603 if (bfd_big_endian (abfd
))
2604 *magicp
= SH_ARCH_MAGIC_BIG
;
2606 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2612 #ifdef MIPS_ARCH_MAGIC_WINCE
2614 *magicp
= MIPS_ARCH_MAGIC_WINCE
;
2620 case bfd_arch_sparc
:
2621 *magicp
= SPARCMAGIC
;
2623 /* Just overwrite the usual value if we're doing Lynx. */
2624 *magicp
= LYNXCOFFMAGIC
;
2631 case bfd_arch_h8500
:
2632 *magicp
= H8500MAGIC
;
2636 #ifdef A29K_MAGIC_BIG
2638 if (bfd_big_endian (abfd
))
2639 *magicp
= A29K_MAGIC_BIG
;
2641 *magicp
= A29K_MAGIC_LITTLE
;
2647 case bfd_arch_we32k
:
2648 *magicp
= WE32KMAGIC
;
2654 case bfd_arch_rs6000
:
2656 case bfd_arch_powerpc
:
2658 *magicp
= U802TOCMAGIC
;
2664 case bfd_arch_mcore
:
2665 * magicp
= MCOREMAGIC
;
2669 default: /* Unknown architecture */
2670 /* return false; -- fall through to "return false" below, to avoid
2671 "statement never reached" errors on the one below. */
2680 coff_set_arch_mach (abfd
, arch
, machine
)
2682 enum bfd_architecture arch
;
2683 unsigned long machine
;
2686 unsigned short dummy2
;
2688 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
2691 if (arch
!= bfd_arch_unknown
&&
2692 coff_set_flags (abfd
, &dummy1
, &dummy2
) != true)
2693 return false; /* We can't represent this type */
2695 return true; /* We're easy ... */
2698 #ifdef COFF_IMAGE_WITH_PE
2700 /* This is used to sort sections by VMA, as required by PE image
2703 static int sort_by_secaddr
PARAMS ((const PTR
, const PTR
));
2706 sort_by_secaddr (arg1
, arg2
)
2710 const asection
*a
= *(const asection
**) arg1
;
2711 const asection
*b
= *(const asection
**) arg2
;
2713 if (a
->vma
< b
->vma
)
2715 else if (a
->vma
> b
->vma
)
2721 #endif /* COFF_IMAGE_WITH_PE */
2723 /* Calculate the file position for each section. */
2726 #define ALIGN_SECTIONS_IN_FILE
2728 #if defined(TIC80COFF) || defined(TICOFF)
2729 #undef ALIGN_SECTIONS_IN_FILE
2733 coff_compute_section_file_positions (abfd
)
2737 asection
*previous
= (asection
*) NULL
;
2738 file_ptr sofar
= bfd_coff_filhsz (abfd
);
2739 boolean align_adjust
;
2740 #ifdef ALIGN_SECTIONS_IN_FILE
2745 /* On XCOFF, if we have symbols, set up the .debug section. */
2746 if (bfd_get_symcount (abfd
) > 0)
2749 bfd_size_type i
, symcount
;
2753 symcount
= bfd_get_symcount (abfd
);
2754 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
2756 coff_symbol_type
*cf
;
2758 cf
= coff_symbol_from (abfd
, *symp
);
2760 && cf
->native
!= NULL
2761 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
2765 len
= strlen (bfd_asymbol_name (*symp
));
2774 dsec
= bfd_make_section_old_way (abfd
, ".debug");
2777 dsec
->_raw_size
= sz
;
2778 dsec
->flags
|= SEC_HAS_CONTENTS
;
2783 #ifdef COFF_IMAGE_WITH_PE
2785 if (coff_data (abfd
)->link_info
)
2787 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
2790 page_size
= PE_DEF_FILE_ALIGNMENT
;
2792 #ifdef COFF_PAGE_SIZE
2793 int page_size
= COFF_PAGE_SIZE
;
2797 if (bfd_get_start_address (abfd
))
2799 /* A start address may have been added to the original file. In this
2800 case it will need an optional header to record it. */
2801 abfd
->flags
|= EXEC_P
;
2804 if (abfd
->flags
& EXEC_P
)
2805 sofar
+= bfd_coff_aoutsz (abfd
);
2807 else if (xcoff_data (abfd
)->full_aouthdr
)
2808 sofar
+= bfd_coff_aoutsz (abfd
);
2810 sofar
+= SMALL_AOUTSZ
;
2813 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2816 /* XCOFF handles overflows in the reloc and line number count fields
2817 by allocating a new section header to hold the correct counts. */
2818 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2819 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
2820 sofar
+= bfd_coff_scnhsz (abfd
);
2823 #ifdef COFF_IMAGE_WITH_PE
2825 /* PE requires the sections to be in memory order when listed in
2826 the section headers. It also does not like empty loadable
2827 sections. The sections apparently do not have to be in the
2828 right order in the image file itself, but we do need to get the
2829 target_index values right. */
2832 asection
**section_list
;
2837 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2840 /* We allocate an extra cell to simplify the final loop. */
2841 section_list
= bfd_malloc (sizeof (struct asection
*) * (count
+ 1));
2842 if (section_list
== NULL
)
2846 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2848 section_list
[i
] = current
;
2851 section_list
[i
] = NULL
;
2853 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
2855 /* Rethread the linked list into sorted order; at the same time,
2856 assign target_index values. */
2858 abfd
->sections
= section_list
[0];
2859 for (i
= 0; i
< count
; i
++)
2861 current
= section_list
[i
];
2862 current
->next
= section_list
[i
+ 1];
2864 /* Later, if the section has zero size, we'll be throwing it
2865 away, so we don't want to number it now. Note that having
2866 a zero size and having real contents are different
2867 concepts: .bss has no contents, but (usually) non-zero
2869 if (current
->_raw_size
== 0)
2871 /* Discard. However, it still might have (valid) symbols
2872 in it, so arbitrarily set it to section 1 (indexing is
2873 1-based here; usually .text). __end__ and other
2874 contents of .endsection really have this happen.
2875 FIXME: This seems somewhat dubious. */
2876 current
->target_index
= 1;
2879 current
->target_index
= target_index
++;
2882 free (section_list
);
2884 #else /* ! COFF_IMAGE_WITH_PE */
2886 /* Set the target_index field. */
2890 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2891 current
->target_index
= target_index
++;
2893 #endif /* ! COFF_IMAGE_WITH_PE */
2895 align_adjust
= false;
2896 for (current
= abfd
->sections
;
2897 current
!= (asection
*) NULL
;
2898 current
= current
->next
)
2900 #ifdef COFF_IMAGE_WITH_PE
2901 /* With PE we have to pad each section to be a multiple of its
2902 page size too, and remember both sizes. */
2903 if (coff_section_data (abfd
, current
) == NULL
)
2905 current
->used_by_bfd
=
2906 (PTR
) bfd_zalloc (abfd
, sizeof (struct coff_section_tdata
));
2907 if (current
->used_by_bfd
== NULL
)
2910 if (pei_section_data (abfd
, current
) == NULL
)
2912 coff_section_data (abfd
, current
)->tdata
=
2913 (PTR
) bfd_zalloc (abfd
, sizeof (struct pei_section_tdata
));
2914 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
2917 if (pei_section_data (abfd
, current
)->virt_size
== 0)
2918 pei_section_data (abfd
, current
)->virt_size
= current
->_raw_size
;
2921 /* Only deal with sections which have contents. */
2922 if (!(current
->flags
& SEC_HAS_CONTENTS
))
2925 #ifdef COFF_IMAGE_WITH_PE
2926 /* Make sure we skip empty sections in a PE image. */
2927 if (current
->_raw_size
== 0)
2931 /* Align the sections in the file to the same boundary on
2932 which they are aligned in virtual memory. I960 doesn't
2933 do this (FIXME) so we can stay in sync with Intel. 960
2934 doesn't yet page from files... */
2935 #ifdef ALIGN_SECTIONS_IN_FILE
2936 if ((abfd
->flags
& EXEC_P
) != 0)
2938 /* make sure this section is aligned on the right boundary - by
2939 padding the previous section up if necessary */
2942 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
2943 if (previous
!= (asection
*) NULL
)
2945 previous
->_raw_size
+= sofar
- old_sofar
;
2951 /* In demand paged files the low order bits of the file offset
2952 must match the low order bits of the virtual address. */
2953 #ifdef COFF_PAGE_SIZE
2954 if ((abfd
->flags
& D_PAGED
) != 0
2955 && (current
->flags
& SEC_ALLOC
) != 0)
2956 sofar
+= (current
->vma
- sofar
) % page_size
;
2958 current
->filepos
= sofar
;
2960 #ifdef COFF_IMAGE_WITH_PE
2961 /* Set the padded size. */
2962 current
->_raw_size
= (current
->_raw_size
+ page_size
-1) & -page_size
;
2965 sofar
+= current
->_raw_size
;
2967 #ifdef ALIGN_SECTIONS_IN_FILE
2968 /* make sure that this section is of the right size too */
2969 if ((abfd
->flags
& EXEC_P
) == 0)
2971 bfd_size_type old_size
;
2973 old_size
= current
->_raw_size
;
2974 current
->_raw_size
= BFD_ALIGN (current
->_raw_size
,
2975 1 << current
->alignment_power
);
2976 align_adjust
= current
->_raw_size
!= old_size
;
2977 sofar
+= current
->_raw_size
- old_size
;
2982 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
2983 align_adjust
= sofar
!= old_sofar
;
2984 current
->_raw_size
+= sofar
- old_sofar
;
2988 #ifdef COFF_IMAGE_WITH_PE
2989 /* For PE we need to make sure we pad out to the aligned
2990 _raw_size, in case the caller only writes out data to the
2991 unaligned _raw_size. */
2992 if (pei_section_data (abfd
, current
)->virt_size
< current
->_raw_size
)
2993 align_adjust
= true;
2997 /* Force .lib sections to start at zero. The vma is then
2998 incremented in coff_set_section_contents. This is right for
3000 if (strcmp (current
->name
, _LIB
) == 0)
3001 bfd_set_section_vma (abfd
, current
, 0);
3007 /* It is now safe to write to the output file. If we needed an
3008 alignment adjustment for the last section, then make sure that
3009 there is a byte at offset sofar. If there are no symbols and no
3010 relocs, then nothing follows the last section. If we don't force
3011 the last byte out, then the file may appear to be truncated. */
3017 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
3018 || bfd_write (&b
, 1, 1, abfd
) != 1)
3022 /* Make sure the relocations are aligned. We don't need to make
3023 sure that this byte exists, because it will only matter if there
3024 really are relocs. */
3025 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
3027 obj_relocbase (abfd
) = sofar
;
3028 abfd
->output_has_begun
= true;
3035 /* This can never work, because it is called too late--after the
3036 section positions have been set. I can't figure out what it is
3037 for, so I am going to disable it--Ian Taylor 20 March 1996. */
3039 /* If .file, .text, .data, .bss symbols are missing, add them. */
3040 /* @@ Should we only be adding missing symbols, or overriding the aux
3041 values for existing section symbols? */
3043 coff_add_missing_symbols (abfd
)
3046 unsigned int nsyms
= bfd_get_symcount (abfd
);
3047 asymbol
**sympp
= abfd
->outsymbols
;
3050 int need_text
= 1, need_data
= 1, need_bss
= 1, need_file
= 1;
3052 for (i
= 0; i
< nsyms
; i
++)
3054 coff_symbol_type
*csym
= coff_symbol_from (abfd
, sympp
[i
]);
3058 /* only do this if there is a coff representation of the input
3060 if (csym
->native
&& csym
->native
->u
.syment
.n_sclass
== C_FILE
)
3065 name
= csym
->symbol
.name
;
3068 if (!strcmp (name
, _TEXT
))
3071 else if (!strcmp (name
, ".wtext"))
3074 else if (!strcmp (name
, _DATA
))
3076 else if (!strcmp (name
, _BSS
))
3080 /* Now i == bfd_get_symcount (abfd). */
3081 /* @@ For now, don't deal with .file symbol. */
3084 if (!need_text
&& !need_data
&& !need_bss
&& !need_file
)
3086 nsyms
+= need_text
+ need_data
+ need_bss
+ need_file
;
3087 sympp2
= (asymbol
**) bfd_alloc (abfd
, nsyms
* sizeof (asymbol
*));
3090 memcpy (sympp2
, sympp
, i
* sizeof (asymbol
*));
3093 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
3097 sympp2
[i
++] = coff_section_symbol (abfd
, _TEXT
);
3099 sympp2
[i
++] = coff_section_symbol (abfd
, _DATA
);
3101 sympp2
[i
++] = coff_section_symbol (abfd
, _BSS
);
3102 BFD_ASSERT (i
== nsyms
);
3103 bfd_set_symtab (abfd
, sympp2
, nsyms
);
3112 coff_write_object_contents (abfd
)
3116 boolean hasrelocs
= false;
3117 boolean haslinno
= false;
3118 boolean hasdebug
= false;
3120 file_ptr reloc_base
;
3121 file_ptr lineno_base
;
3123 unsigned long reloc_size
= 0;
3124 unsigned long lnno_size
= 0;
3125 boolean long_section_names
;
3126 asection
*text_sec
= NULL
;
3127 asection
*data_sec
= NULL
;
3128 asection
*bss_sec
= NULL
;
3129 struct internal_filehdr internal_f
;
3130 struct internal_aouthdr internal_a
;
3131 #ifdef COFF_LONG_SECTION_NAMES
3132 size_t string_size
= STRING_SIZE_SIZE
;
3135 bfd_set_error (bfd_error_system_call
);
3137 /* Make a pass through the symbol table to count line number entries and
3138 put them into the correct asections */
3140 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3142 if (abfd
->output_has_begun
== false)
3144 if (! coff_compute_section_file_positions (abfd
))
3148 reloc_base
= obj_relocbase (abfd
);
3150 /* Work out the size of the reloc and linno areas */
3152 for (current
= abfd
->sections
; current
!= NULL
; current
=
3154 reloc_size
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3156 lineno_base
= reloc_base
+ reloc_size
;
3157 sym_base
= lineno_base
+ lnno_size
;
3159 /* Indicate in each section->line_filepos its actual file address */
3160 for (current
= abfd
->sections
; current
!= NULL
; current
=
3163 if (current
->lineno_count
)
3165 current
->line_filepos
= lineno_base
;
3166 current
->moving_line_filepos
= lineno_base
;
3167 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3171 current
->line_filepos
= 0;
3173 if (current
->reloc_count
)
3175 current
->rel_filepos
= reloc_base
;
3176 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3180 current
->rel_filepos
= 0;
3184 /* Write section headers to the file. */
3185 internal_f
.f_nscns
= 0;
3187 if ((abfd
->flags
& EXEC_P
) != 0)
3188 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3191 scn_base
= bfd_coff_filhsz (abfd
);
3193 if (xcoff_data (abfd
)->full_aouthdr
)
3194 scn_base
+= bfd_coff_aoutsz (abfd
);
3196 scn_base
+= SMALL_AOUTSZ
;
3200 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3203 long_section_names
= false;
3204 for (current
= abfd
->sections
;
3206 current
= current
->next
)
3208 struct internal_scnhdr section
;
3209 boolean is_reloc_section
= false;
3211 #ifdef COFF_IMAGE_WITH_PE
3212 if (strcmp (current
->name
, ".reloc") == 0)
3214 is_reloc_section
= true;
3216 pe_data (abfd
)->has_reloc_section
= 1;
3220 internal_f
.f_nscns
++;
3222 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3224 #ifdef COFF_LONG_SECTION_NAMES
3225 /* Handle long section names as in PE. This must be compatible
3226 with the code in coff_write_symbols and _bfd_coff_final_link. */
3230 len
= strlen (current
->name
);
3233 memset (section
.s_name
, 0, SCNNMLEN
);
3234 sprintf (section
.s_name
, "/%lu", (unsigned long) string_size
);
3235 string_size
+= len
+ 1;
3236 long_section_names
= true;
3242 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3243 Ian Taylor <ian@cygnus.com>. */
3244 if (strcmp (current
->name
, _LIB
) == 0)
3245 section
.s_vaddr
= 0;
3248 section
.s_vaddr
= current
->vma
;
3249 section
.s_paddr
= current
->lma
;
3250 section
.s_size
= current
->_raw_size
;
3253 section
.s_paddr
= 0;
3255 #ifdef COFF_IMAGE_WITH_PE
3256 /* Reminder: s_paddr holds the virtual size of the section. */
3257 if (coff_section_data (abfd
, current
) != NULL
3258 && pei_section_data (abfd
, current
) != NULL
)
3259 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3261 section
.s_paddr
= 0;
3265 If this section has no size or is unloadable then the scnptr
3268 if (current
->_raw_size
== 0 ||
3269 (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3271 section
.s_scnptr
= 0;
3275 section
.s_scnptr
= current
->filepos
;
3277 section
.s_relptr
= current
->rel_filepos
;
3278 section
.s_lnnoptr
= current
->line_filepos
;
3279 section
.s_nreloc
= current
->reloc_count
;
3280 section
.s_nlnno
= current
->lineno_count
;
3281 #ifndef COFF_IMAGE_WITH_PE
3282 /* In PEI, relocs come in the .reloc section. */
3283 if (current
->reloc_count
!= 0)
3286 if (current
->lineno_count
!= 0)
3288 if ((current
->flags
& SEC_DEBUGGING
) != 0
3289 && ! is_reloc_section
)
3293 /* Indicate the use of an XCOFF overflow section header. */
3294 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3296 section
.s_nreloc
= 0xffff;
3297 section
.s_nlnno
= 0xffff;
3301 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3303 if (!strcmp (current
->name
, _TEXT
))
3307 else if (!strcmp (current
->name
, _DATA
))
3311 else if (!strcmp (current
->name
, _BSS
))
3317 section
.s_align
= (current
->alignment_power
3318 ? 1 << current
->alignment_power
3322 /* TI COFF puts the alignment power in bits 8-11 of the flags */
3323 section
.s_flags
|= (current
->alignment_power
& 0xF) << 8;
3325 #ifdef COFF_ENCODE_ALIGNMENT
3326 COFF_ENCODE_ALIGNMENT(section
, current
->alignment_power
);
3329 #ifdef COFF_IMAGE_WITH_PE
3330 /* Suppress output of the sections if they are null. ld
3331 includes the bss and data sections even if there is no size
3332 assigned to them. NT loader doesn't like it if these section
3333 headers are included if the sections themselves are not
3334 needed. See also coff_compute_section_file_positions. */
3335 if (section
.s_size
== 0)
3336 internal_f
.f_nscns
--;
3341 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3342 || bfd_write ((PTR
) (&buff
), 1, bfd_coff_scnhsz (abfd
), abfd
)
3343 != bfd_coff_scnhsz (abfd
))
3348 /* PE stores COMDAT section information in the symbol table. If
3349 this section is supposed to have some COMDAT info, track down
3350 the symbol in the symbol table and modify it. */
3351 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3353 unsigned int i
, count
;
3355 coff_symbol_type
*csym
= NULL
;
3359 count
= bfd_get_symcount (abfd
);
3360 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3362 if ((*psym
)->section
!= current
)
3365 /* Remember the location of the first symbol in this
3367 if (psymsec
== NULL
)
3370 /* See if this is the section symbol. */
3371 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3373 csym
= coff_symbol_from (abfd
, *psym
);
3375 || csym
->native
== NULL
3376 || csym
->native
->u
.syment
.n_numaux
< 1
3377 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3378 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3381 /* Here *PSYM is the section symbol for CURRENT. */
3388 Note that we might not if we're converting the file from
3389 some other object file format. */
3392 combined_entry_type
*aux
;
3394 /* We don't touch the x_checksum field. The
3395 x_associated field is not currently supported. */
3397 aux
= csym
->native
+ 1;
3398 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3400 case SEC_LINK_DUPLICATES_DISCARD
:
3401 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3404 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3405 aux
->u
.auxent
.x_scn
.x_comdat
=
3406 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3409 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3410 aux
->u
.auxent
.x_scn
.x_comdat
=
3411 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3414 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3415 aux
->u
.auxent
.x_scn
.x_comdat
=
3416 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3420 /* The COMDAT symbol must be the first symbol from this
3421 section in the symbol table. In order to make this
3422 work, we move the COMDAT symbol before the first
3423 symbol we found in the search above. It's OK to
3424 rearrange the symbol table at this point, because
3425 coff_renumber_symbols is going to rearrange it
3426 further and fix up all the aux entries. */
3427 if (psym
!= psymsec
)
3433 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3434 pcopy
[0] = pcopy
[-1];
3439 #endif /* COFF_WITH_PE */
3443 /* XCOFF handles overflows in the reloc and line number count fields
3444 by creating a new section header to hold the correct values. */
3445 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3447 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3449 struct internal_scnhdr scnhdr
;
3452 internal_f
.f_nscns
++;
3453 strncpy (&(scnhdr
.s_name
[0]), current
->name
, 8);
3454 scnhdr
.s_paddr
= current
->reloc_count
;
3455 scnhdr
.s_vaddr
= current
->lineno_count
;
3457 scnhdr
.s_scnptr
= 0;
3458 scnhdr
.s_relptr
= current
->rel_filepos
;
3459 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3460 scnhdr
.s_nreloc
= current
->target_index
;
3461 scnhdr
.s_nlnno
= current
->target_index
;
3462 scnhdr
.s_flags
= STYP_OVRFLO
;
3463 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3464 || bfd_write ((PTR
) &buff
, 1, bfd_coff_scnhsz (abfd
), abfd
)
3465 != bfd_coff_scnhsz (abfd
))
3471 /* OK, now set up the filehdr... */
3473 /* Don't include the internal abs section in the section count */
3476 We will NOT put a fucking timestamp in the header here. Every time you
3477 put it back, I will come in and take it out again. I'm sorry. This
3478 field does not belong here. We fill it with a 0 so it compares the
3479 same but is not a reasonable time. -- gnu@cygnus.com
3481 internal_f
.f_timdat
= 0;
3483 internal_f
.f_flags
= 0;
3485 if (abfd
->flags
& EXEC_P
)
3486 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3489 internal_f
.f_opthdr
= 0;
3491 if (xcoff_data (abfd
)->full_aouthdr
)
3492 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3494 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
3499 internal_f
.f_flags
|= F_RELFLG
;
3501 internal_f
.f_flags
|= F_LNNO
;
3502 if (abfd
->flags
& EXEC_P
)
3503 internal_f
.f_flags
|= F_EXEC
;
3504 #ifdef COFF_IMAGE_WITH_PE
3506 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
3509 #ifndef COFF_WITH_PE
3510 if (bfd_little_endian (abfd
))
3511 internal_f
.f_flags
|= F_AR32WR
;
3513 internal_f
.f_flags
|= F_AR32W
;
3517 /* target id is used in TI COFF v1 and later; COFF0 won't use this field,
3518 but it doesn't hurt to set it internally */
3519 internal_f
.f_target_id
= TI_TARGET_ID
;
3521 #ifdef TIC80_TARGET_ID
3522 internal_f
.f_target_id
= TIC80_TARGET_ID
;
3526 FIXME, should do something about the other byte orders and
3531 if ((abfd
->flags
& DYNAMIC
) != 0)
3532 internal_f
.f_flags
|= F_SHROBJ
;
3533 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
3534 internal_f
.f_flags
|= F_DYNLOAD
;
3537 memset (&internal_a
, 0, sizeof internal_a
);
3539 /* Set up architecture-dependent stuff */
3542 unsigned int magic
= 0;
3543 unsigned short flags
= 0;
3544 coff_set_flags (abfd
, &magic
, &flags
);
3545 internal_f
.f_magic
= magic
;
3546 internal_f
.f_flags
|= flags
;
3547 /* ...and the "opt"hdr... */
3550 #ifdef ULTRA3 /* NYU's machine */
3551 /* FIXME: This is a bogus check. I really want to see if there
3552 * is a .shbss or a .shdata section, if so then set the magic
3553 * number to indicate a shared data executable.
3555 if (internal_f
.f_nscns
>= 7)
3556 internal_a
.magic
= SHMAGIC
; /* Shared magic */
3559 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
3560 #define __A_MAGIC_SET__
3562 #ifdef TICOFF_AOUT_MAGIC
3563 internal_a
.magic
= TICOFF_AOUT_MAGIC
;
3564 #define __A_MAGIC_SET__
3567 internal_a
.magic
= TIC80_ARCH_MAGIC
;
3568 #define __A_MAGIC_SET__
3571 /* FIXME: What are the a.out magic numbers for the i860? */
3572 internal_a
.magic
= 0;
3573 #define __A_MAGIC_SET__
3576 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
3577 #define __A_MAGIC_SET__
3580 #define __A_MAGIC_SET__
3581 internal_a
.magic
= PAGEMAGICBCS
;
3585 #define __A_MAGIC_SET__
3586 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
3589 #if defined(M68) || defined(WE32K) || defined(M68K)
3590 #define __A_MAGIC_SET__
3592 internal_a
.magic
= LYNXCOFFMAGIC
;
3594 #if defined(TARG_AUX)
3595 internal_a
.magic
= (abfd
->flags
& D_PAGED
? PAGEMAGICPEXECPAGED
:
3596 abfd
->flags
& WP_TEXT
? PAGEMAGICPEXECSWAPPED
:
3597 PAGEMAGICEXECSWAPPED
);
3599 #if defined (PAGEMAGICPEXECPAGED)
3600 internal_a
.magic
= PAGEMAGICPEXECPAGED
;
3602 #endif /* TARG_AUX */
3604 #endif /* M68 || WE32K || M68K */
3607 #define __A_MAGIC_SET__
3608 internal_a
.magic
= ZMAGIC
;
3612 #define __A_MAGIC_SET__
3613 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3616 #if defined MCORE_PE
3617 #define __A_MAGIC_SET__
3618 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3622 #define __A_MAGIC_SET__
3624 internal_a
.magic
= LYNXCOFFMAGIC
;
3626 internal_a
.magic
= ZMAGIC
;
3631 #define __A_MAGIC_SET__
3633 internal_a
.magic
= LYNXCOFFMAGIC
;
3638 #define __A_MAGIC_SET__
3639 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
3640 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
3641 RS6K_AOUTHDR_OMAGIC
;
3644 #if defined(SH) && defined(COFF_WITH_PE)
3645 #define __A_MAGIC_SET__
3646 internal_a
.magic
= SH_PE_MAGIC
;
3649 #if defined(MIPS) && defined(COFF_WITH_PE)
3650 #define __A_MAGIC_SET__
3651 internal_a
.magic
= MIPS_PE_MAGIC
;
3654 #ifndef __A_MAGIC_SET__
3655 #include "Your aouthdr magic number is not being set!"
3657 #undef __A_MAGIC_SET__
3661 /* FIXME: Does anybody ever set this to another value? */
3662 internal_a
.vstamp
= 0;
3664 /* Now should write relocs, strings, syms */
3665 obj_sym_filepos (abfd
) = sym_base
;
3667 if (bfd_get_symcount (abfd
) != 0)
3671 if (!coff_add_missing_symbols (abfd
))
3674 if (!coff_renumber_symbols (abfd
, &firstundef
))
3676 coff_mangle_symbols (abfd
);
3677 if (! coff_write_symbols (abfd
))
3679 if (! coff_write_linenumbers (abfd
))
3681 if (! coff_write_relocs (abfd
, firstundef
))
3684 #ifdef COFF_LONG_SECTION_NAMES
3685 else if (long_section_names
)
3687 /* If we have long section names we have to write out the string
3688 table even if there are no symbols. */
3689 if (! coff_write_symbols (abfd
))
3693 #ifdef COFF_IMAGE_WITH_PE
3695 else if ((abfd
->flags
& EXEC_P
) != 0)
3699 /* PowerPC PE appears to require that all executable files be
3700 rounded up to the page size. */
3703 BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
3705 || bfd_write (&b
, 1, 1, abfd
) != 1)
3711 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3712 backend linker, and obj_raw_syment_count is not valid until after
3713 coff_write_symbols is called. */
3714 if (obj_raw_syment_count (abfd
) != 0)
3716 internal_f
.f_symptr
= sym_base
;
3718 /* AIX appears to require that F_RELFLG not be set if there are
3719 local symbols but no relocations. */
3720 internal_f
.f_flags
&=~ F_RELFLG
;
3725 if (long_section_names
)
3726 internal_f
.f_symptr
= sym_base
;
3728 internal_f
.f_symptr
= 0;
3729 internal_f
.f_flags
|= F_LSYMS
;
3734 internal_a
.tsize
= bfd_get_section_size_before_reloc (text_sec
);
3735 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
3739 internal_a
.dsize
= bfd_get_section_size_before_reloc (data_sec
);
3740 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
3744 internal_a
.bsize
= bfd_get_section_size_before_reloc (bss_sec
);
3745 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
3746 internal_a
.data_start
= bss_sec
->vma
;
3749 internal_a
.entry
= bfd_get_start_address (abfd
);
3750 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
3753 if (xcoff_data (abfd
)->full_aouthdr
)
3756 asection
*loader_sec
;
3758 internal_a
.vstamp
= 1;
3760 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
3761 if (internal_a
.o_snentry
== 0)
3762 internal_a
.entry
= (bfd_vma
) -1;
3764 if (text_sec
!= NULL
)
3766 internal_a
.o_sntext
= text_sec
->target_index
;
3767 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
3771 internal_a
.o_sntext
= 0;
3772 internal_a
.o_algntext
= 0;
3774 if (data_sec
!= NULL
)
3776 internal_a
.o_sndata
= data_sec
->target_index
;
3777 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
3781 internal_a
.o_sndata
= 0;
3782 internal_a
.o_algndata
= 0;
3784 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
3785 if (loader_sec
!= NULL
)
3786 internal_a
.o_snloader
= loader_sec
->target_index
;
3788 internal_a
.o_snloader
= 0;
3789 if (bss_sec
!= NULL
)
3790 internal_a
.o_snbss
= bss_sec
->target_index
;
3792 internal_a
.o_snbss
= 0;
3794 toc
= xcoff_data (abfd
)->toc
;
3795 internal_a
.o_toc
= toc
;
3796 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
3798 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
3799 if (xcoff_data (abfd
)->cputype
!= -1)
3800 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
3803 switch (bfd_get_arch (abfd
))
3805 case bfd_arch_rs6000
:
3806 internal_a
.o_cputype
= 4;
3808 case bfd_arch_powerpc
:
3809 if (bfd_get_mach (abfd
) == 0)
3810 internal_a
.o_cputype
= 3;
3812 internal_a
.o_cputype
= 1;
3818 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
3819 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
3823 /* now write them */
3824 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
3829 bfd_size_type amount
;
3831 buff
= bfd_malloc (bfd_coff_filhsz (abfd
));
3835 coff_swap_filehdr_out (abfd
, (PTR
) & internal_f
, (PTR
) buff
);
3836 amount
= bfd_write ((PTR
) buff
, 1, bfd_coff_filhsz (abfd
), abfd
);
3840 if (amount
!= bfd_coff_filhsz (abfd
))
3844 if (abfd
->flags
& EXEC_P
)
3846 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
3847 include/coff/pe.h sets AOUTSZ == sizeof(PEAOUTHDR)) */
3849 bfd_size_type amount
;
3851 buff
= bfd_malloc (bfd_coff_aoutsz (abfd
));
3855 coff_swap_aouthdr_out (abfd
, (PTR
) & internal_a
, (PTR
) buff
);
3856 amount
= bfd_write ((PTR
) buff
, 1, bfd_coff_aoutsz (abfd
), abfd
);
3860 if (amount
!= bfd_coff_aoutsz (abfd
))
3869 /* XCOFF seems to always write at least a small a.out header. */
3870 coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, (PTR
) &buff
);
3871 if (xcoff_data (abfd
)->full_aouthdr
)
3872 size
= bfd_coff_aoutsz (abfd
);
3874 size
= SMALL_AOUTSZ
;
3875 if (bfd_write ((PTR
) &buff
, 1, size
, abfd
) != size
)
3884 coff_set_section_contents (abfd
, section
, location
, offset
, count
)
3889 bfd_size_type count
;
3891 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
3893 if (! coff_compute_section_file_positions (abfd
))
3897 #if defined(_LIB) && !defined(TARG_AUX)
3899 /* The physical address field of a .lib section is used to hold the
3900 number of shared libraries in the section. This code counts the
3901 number of sections being written, and increments the lma field
3904 I have found no documentation on the contents of this section.
3905 Experimentation indicates that the section contains zero or more
3906 records, each of which has the following structure:
3908 - a (four byte) word holding the length of this record, in words,
3909 - a word that always seems to be set to "2",
3910 - the path to a shared library, null-terminated and then padded
3911 to a whole word boundary.
3913 bfd_assert calls have been added to alert if an attempt is made
3914 to write a section which doesn't follow these assumptions. The
3915 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
3916 <robertl@arnet.com> (Thanks!).
3918 Gvran Uddeborg <gvran@uddeborg.pp.se> */
3920 if (strcmp (section
->name
, _LIB
) == 0)
3922 bfd_byte
*rec
, *recend
;
3924 rec
= (bfd_byte
*) location
;
3925 recend
= rec
+ count
;
3926 while (rec
< recend
)
3929 rec
+= bfd_get_32 (abfd
, rec
) * 4;
3932 BFD_ASSERT (rec
== recend
);
3937 /* Don't write out bss sections - one way to do this is to
3938 see if the filepos has not been set. */
3939 if (section
->filepos
== 0)
3942 if (bfd_seek (abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
) != 0)
3947 return (bfd_write (location
, 1, count
, abfd
) == count
) ? true : false;
3953 coff_close_and_cleanup (abfd
)
3956 if (!bfd_read_p (abfd
))
3957 switch (abfd
->format
)
3960 if (!_bfd_write_archive_contents (abfd
))
3964 if (!coff_write_object_contents (abfd
))
3968 bfd_set_error (bfd_error_invalid_operation
);
3972 /* We depend on bfd_close to free all the memory on the objalloc. */
3979 buy_and_read (abfd
, where
, seek_direction
, size
)
3985 PTR area
= (PTR
) bfd_alloc (abfd
, size
);
3988 if (bfd_seek (abfd
, where
, seek_direction
) != 0
3989 || bfd_read (area
, 1, size
, abfd
) != size
)
3992 } /* buy_and_read() */
3998 Creating the linenumber table is done by reading in the entire
3999 coff linenumber table, and creating another table for internal use.
4001 A coff linenumber table is structured so that each function
4002 is marked as having a line number of 0. Each line within the
4003 function is an offset from the first line in the function. The
4004 base of the line number information for the table is stored in
4005 the symbol associated with the function.
4007 Note: The PE format uses line number 0 for a flag indicating a
4010 The information is copied from the external to the internal
4011 table, and each symbol which marks a function is marked by
4014 How does this work ?
4019 coff_slurp_line_table (abfd
, asect
)
4023 LINENO
*native_lineno
;
4024 alent
*lineno_cache
;
4026 BFD_ASSERT (asect
->lineno
== (alent
*) NULL
);
4028 native_lineno
= (LINENO
*) buy_and_read (abfd
,
4029 asect
->line_filepos
,
4031 (size_t) (bfd_coff_linesz (abfd
) *
4032 asect
->lineno_count
));
4034 (alent
*) bfd_alloc (abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof (alent
)));
4035 if (lineno_cache
== NULL
)
4039 unsigned int counter
= 0;
4040 alent
*cache_ptr
= lineno_cache
;
4041 LINENO
*src
= native_lineno
;
4043 while (counter
< asect
->lineno_count
)
4045 struct internal_lineno dst
;
4046 coff_swap_lineno_in (abfd
, src
, &dst
);
4047 cache_ptr
->line_number
= dst
.l_lnno
;
4049 if (cache_ptr
->line_number
== 0)
4053 coff_symbol_type
*sym
;
4056 symndx
= dst
.l_addr
.l_symndx
;
4058 || (unsigned long) symndx
>= obj_raw_syment_count (abfd
))
4060 (*_bfd_error_handler
)
4061 (_("%s: warning: illegal symbol index %ld in line numbers"),
4062 bfd_get_filename (abfd
), dst
.l_addr
.l_symndx
);
4066 /* FIXME: We should not be casting between ints and
4067 pointers like this. */
4068 sym
= ((coff_symbol_type
*)
4069 ((symndx
+ obj_raw_syments (abfd
))
4070 ->u
.syment
._n
._n_n
._n_zeroes
));
4071 cache_ptr
->u
.sym
= (asymbol
*) sym
;
4072 if (sym
->lineno
!= NULL
&& ! warned
)
4074 (*_bfd_error_handler
)
4075 (_("%s: warning: duplicate line number information for `%s'"),
4076 bfd_get_filename (abfd
),
4077 bfd_asymbol_name (&sym
->symbol
));
4079 sym
->lineno
= cache_ptr
;
4083 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
4084 - bfd_section_vma (abfd
, asect
);
4085 } /* If no linenumber expect a symbol index */
4091 cache_ptr
->line_number
= 0;
4094 asect
->lineno
= lineno_cache
;
4095 /* FIXME, free native_lineno here, or use alloca or something. */
4099 /* Slurp in the symbol table, converting it to generic form. Note
4100 that if coff_relocate_section is defined, the linker will read
4101 symbols via coff_link_add_symbols, rather than via this routine. */
4104 coff_slurp_symbol_table (abfd
)
4107 combined_entry_type
*native_symbols
;
4108 coff_symbol_type
*cached_area
;
4109 unsigned int *table_ptr
;
4111 unsigned int number_of_symbols
= 0;
4113 if (obj_symbols (abfd
))
4116 /* Read in the symbol table */
4117 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4122 /* Allocate enough room for all the symbols in cached form */
4123 cached_area
= ((coff_symbol_type
*)
4125 (obj_raw_syment_count (abfd
)
4126 * sizeof (coff_symbol_type
))));
4128 if (cached_area
== NULL
)
4130 table_ptr
= ((unsigned int *)
4132 (obj_raw_syment_count (abfd
)
4133 * sizeof (unsigned int))));
4135 if (table_ptr
== NULL
)
4139 coff_symbol_type
*dst
= cached_area
;
4140 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4141 unsigned int this_index
= 0;
4142 while (this_index
< last_native_index
)
4144 combined_entry_type
*src
= native_symbols
+ this_index
;
4145 table_ptr
[this_index
] = number_of_symbols
;
4146 dst
->symbol
.the_bfd
= abfd
;
4148 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4149 /* We use the native name field to point to the cached field. */
4150 src
->u
.syment
._n
._n_n
._n_zeroes
= (long) dst
;
4151 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4152 src
->u
.syment
.n_scnum
);
4153 dst
->symbol
.flags
= 0;
4154 dst
->done_lineno
= false;
4156 switch (src
->u
.syment
.n_sclass
)
4161 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
4162 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4163 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4165 /* Fall through to next case */
4173 case C_THUMBEXTFUNC
:
4179 case C_SYSTEM
: /* System Wide variable */
4182 /* In PE, 0x68 (104) denotes a section symbol */
4184 /* In PE, 0x69 (105) denotes a weak external symbol. */
4187 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4189 case COFF_SYMBOL_GLOBAL
:
4190 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4191 #if defined COFF_WITH_PE
4192 /* PE sets the symbol to a value relative to the
4193 start of the section. */
4194 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4196 dst
->symbol
.value
= (src
->u
.syment
.n_value
4197 - dst
->symbol
.section
->vma
);
4199 if (ISFCN ((src
->u
.syment
.n_type
)))
4201 /* A function ext does not go at the end of a
4203 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4207 case COFF_SYMBOL_COMMON
:
4208 dst
->symbol
.section
= bfd_com_section_ptr
;
4209 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4212 case COFF_SYMBOL_UNDEFINED
:
4213 dst
->symbol
.section
= bfd_und_section_ptr
;
4214 dst
->symbol
.value
= 0;
4217 case COFF_SYMBOL_PE_SECTION
:
4218 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4219 dst
->symbol
.value
= 0;
4222 case COFF_SYMBOL_LOCAL
:
4223 dst
->symbol
.flags
= BSF_LOCAL
;
4224 #if defined COFF_WITH_PE
4225 /* PE sets the symbol to a value relative to the
4226 start of the section. */
4227 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4229 dst
->symbol
.value
= (src
->u
.syment
.n_value
4230 - dst
->symbol
.section
->vma
);
4232 if (ISFCN ((src
->u
.syment
.n_type
)))
4233 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4238 /* A symbol with a csect entry should not go at the end. */
4239 if (src
->u
.syment
.n_numaux
> 0)
4240 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4244 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4245 dst
->symbol
.flags
= BSF_WEAK
;
4246 if (src
->u
.syment
.n_sclass
== C_SECTION
4247 && src
->u
.syment
.n_scnum
> 0)
4249 dst
->symbol
.flags
= BSF_LOCAL
;
4253 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
)
4254 dst
->symbol
.flags
= BSF_WEAK
;
4258 case C_STAT
: /* static */
4260 case C_LEAFSTAT
: /* static leaf procedure */
4263 case C_THUMBSTAT
: /* Thumb static */
4264 case C_THUMBLABEL
: /* Thumb label */
4265 case C_THUMBSTATFUNC
:/* Thumb static function */
4267 case C_LABEL
: /* label */
4268 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4269 dst
->symbol
.flags
= BSF_DEBUGGING
;
4271 dst
->symbol
.flags
= BSF_LOCAL
;
4273 /* Base the value as an index from the base of the
4274 section, if there is one. */
4275 if (dst
->symbol
.section
)
4277 #if defined COFF_WITH_PE
4278 /* PE sets the symbol to a value relative to the
4279 start of the section. */
4280 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4282 dst
->symbol
.value
= (src
->u
.syment
.n_value
4283 - dst
->symbol
.section
->vma
);
4287 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4290 case C_MOS
: /* member of structure */
4291 case C_EOS
: /* end of structure */
4292 #ifdef NOTDEF /* C_AUTOARG has the same value */
4294 case C_GLBLREG
: /* A29k-specific storage class */
4297 case C_REGPARM
: /* register parameter */
4298 case C_REG
: /* register variable */
4299 /* C_AUTOARG conflictes with TI COFF C_UEXT */
4300 #if !defined (TIC80COFF) && !defined (TICOFF)
4302 case C_AUTOARG
: /* 960-specific storage class */
4305 case C_TPDEF
: /* type definition */
4307 case C_AUTO
: /* automatic variable */
4308 case C_FIELD
: /* bit field */
4309 case C_ENTAG
: /* enumeration tag */
4310 case C_MOE
: /* member of enumeration */
4311 case C_MOU
: /* member of union */
4312 case C_UNTAG
: /* union tag */
4313 dst
->symbol
.flags
= BSF_DEBUGGING
;
4314 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4317 case C_FILE
: /* file name */
4318 case C_STRTAG
: /* structure tag */
4333 dst
->symbol
.flags
= BSF_DEBUGGING
;
4334 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4338 case C_BINCL
: /* beginning of include file */
4339 case C_EINCL
: /* ending of include file */
4340 /* The value is actually a pointer into the line numbers
4341 of the file. We locate the line number entry, and
4342 set the section to the section which contains it, and
4343 the value to the index in that section. */
4347 dst
->symbol
.flags
= BSF_DEBUGGING
;
4348 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4349 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4350 && ((file_ptr
) (sec
->line_filepos
4351 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4352 > (file_ptr
) src
->u
.syment
.n_value
))
4355 dst
->symbol
.value
= 0;
4358 dst
->symbol
.section
= sec
;
4359 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4360 - sec
->line_filepos
)
4361 / bfd_coff_linesz (abfd
));
4368 dst
->symbol
.flags
= BSF_DEBUGGING
;
4370 /* The value is actually a symbol index. Save a pointer
4371 to the symbol instead of the index. FIXME: This
4372 should use a union. */
4373 src
->u
.syment
.n_value
=
4374 (long) (native_symbols
+ src
->u
.syment
.n_value
);
4375 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4380 case C_BLOCK
: /* ".bb" or ".eb" */
4381 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf") */
4382 case C_EFCN
: /* physical end of function */
4383 #if defined COFF_WITH_PE
4384 /* PE sets the symbol to a value relative to the start
4386 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4387 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4389 /* PE uses funny values for .ef and .lf; don't
4391 dst
->symbol
.flags
= BSF_DEBUGGING
;
4394 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4396 /* Base the value as an index from the base of the
4398 dst
->symbol
.flags
= BSF_LOCAL
;
4399 dst
->symbol
.value
= (src
->u
.syment
.n_value
4400 - dst
->symbol
.section
->vma
);
4404 case C_STATLAB
: /* Static load time label */
4405 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4406 dst
->symbol
.flags
= BSF_GLOBAL
;
4410 /* PE DLLs sometimes have zeroed out symbols for some
4411 reason. Just ignore them without a warning. */
4412 if (src
->u
.syment
.n_type
== 0
4413 && src
->u
.syment
.n_value
== 0
4414 && src
->u
.syment
.n_scnum
== 0)
4417 case C_EXTDEF
: /* external definition */
4418 case C_ULABEL
: /* undefined label */
4419 case C_USTATIC
: /* undefined static */
4420 #ifndef COFF_WITH_PE
4421 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4422 class to represent a section symbol */
4423 case C_LINE
: /* line # reformatted as symbol table entry */
4424 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4425 case C_ALIAS
: /* duplicate tag */
4427 /* New storage classes for TI COFF */
4428 #if defined(TIC80COFF) || defined(TICOFF)
4429 case C_UEXT
: /* Tentative external definition */
4431 case C_EXTLAB
: /* External load time label */
4432 case C_HIDDEN
: /* ext symbol in dmert public lib */
4434 (*_bfd_error_handler
)
4435 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
4436 bfd_get_filename (abfd
), src
->u
.syment
.n_sclass
,
4437 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4438 dst
->symbol
.flags
= BSF_DEBUGGING
;
4439 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4443 /* BFD_ASSERT(dst->symbol.flags != 0);*/
4447 dst
->symbol
.udata
.i
= 0;
4448 dst
->lineno
= (alent
*) NULL
;
4449 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
4451 number_of_symbols
++;
4452 } /* walk the native symtab */
4453 } /* bfdize the native symtab */
4455 obj_symbols (abfd
) = cached_area
;
4456 obj_raw_syments (abfd
) = native_symbols
;
4458 bfd_get_symcount (abfd
) = number_of_symbols
;
4459 obj_convert (abfd
) = table_ptr
;
4460 /* Slurp the line tables for each section too */
4466 coff_slurp_line_table (abfd
, p
);
4471 } /* coff_slurp_symbol_table() */
4473 /* Classify a COFF symbol. A couple of targets have globally visible
4474 symbols which are not class C_EXT, and this handles those. It also
4475 recognizes some special PE cases. */
4477 static enum coff_symbol_classification
4478 coff_classify_symbol (abfd
, syment
)
4480 struct internal_syment
*syment
;
4482 /* FIXME: This partially duplicates the switch in
4483 coff_slurp_symbol_table. */
4484 switch (syment
->n_sclass
)
4493 case C_THUMBEXTFUNC
:
4501 if (syment
->n_scnum
== 0)
4503 if (syment
->n_value
== 0)
4504 return COFF_SYMBOL_UNDEFINED
;
4506 return COFF_SYMBOL_COMMON
;
4508 return COFF_SYMBOL_GLOBAL
;
4515 if (syment
->n_sclass
== C_STAT
)
4517 if (syment
->n_scnum
== 0)
4519 /* The Microsoft compiler sometimes generates these if a
4520 small static function is inlined every time it is used.
4521 The function is discarded, but the symbol table entry
4523 return COFF_SYMBOL_LOCAL
;
4526 #ifdef STRICT_PE_FORMAT
4527 /* This is correct for Microsoft generated objects, but it
4528 breaks gas generated objects. */
4530 if (syment
->n_value
== 0)
4533 char buf
[SYMNMLEN
+ 1];
4535 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
4537 && (strcmp (bfd_get_section_name (abfd
, sec
),
4538 _bfd_coff_internal_syment_name (abfd
, syment
, buf
))
4540 return COFF_SYMBOL_PE_SECTION
;
4544 return COFF_SYMBOL_LOCAL
;
4547 if (syment
->n_sclass
== C_SECTION
)
4549 /* In some cases in a DLL generated by the Microsoft linker, the
4550 n_value field will contain garbage. FIXME: This should
4551 probably be handled by the swapping function instead. */
4552 syment
->n_value
= 0;
4553 if (syment
->n_scnum
== 0)
4554 return COFF_SYMBOL_UNDEFINED
;
4555 return COFF_SYMBOL_PE_SECTION
;
4557 #endif /* COFF_WITH_PE */
4559 /* If it is not a global symbol, we presume it is a local symbol. */
4561 if (syment
->n_scnum
== 0)
4563 char buf
[SYMNMLEN
+ 1];
4565 (*_bfd_error_handler
)
4566 (_("warning: %s: local symbol `%s' has no section"),
4567 bfd_get_filename (abfd
),
4568 _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
4571 return COFF_SYMBOL_LOCAL
;
4578 Coff relocations are easily transformed into the internal BFD form
4581 Reading a coff relocation table is done in the following stages:
4583 o Read the entire coff relocation table into memory.
4585 o Process each relocation in turn; first swap it from the
4586 external to the internal form.
4588 o Turn the symbol referenced in the relocation's symbol index
4589 into a pointer into the canonical symbol table.
4590 This table is the same as the one returned by a call to
4591 @code{bfd_canonicalize_symtab}. The back end will call that
4592 routine and save the result if a canonicalization hasn't been done.
4594 o The reloc index is turned into a pointer to a howto
4595 structure, in a back end specific way. For instance, the 386
4596 and 960 use the @code{r_type} to directly produce an index
4597 into a howto table vector; the 88k subtracts a number from the
4598 @code{r_type} field and creates an addend field.
4604 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
4606 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
4607 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
4608 coffsym = (obj_symbols (abfd) \
4609 + (cache_ptr->sym_ptr_ptr - symbols)); \
4611 coffsym = coff_symbol_from (abfd, ptr); \
4612 if (coffsym != (coff_symbol_type *) NULL \
4613 && coffsym->native->u.syment.n_scnum == 0) \
4614 cache_ptr->addend = 0; \
4615 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
4616 && ptr->section != (asection *) NULL) \
4617 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
4619 cache_ptr->addend = 0; \
4624 coff_slurp_reloc_table (abfd
, asect
, symbols
)
4629 RELOC
*native_relocs
;
4630 arelent
*reloc_cache
;
4635 if (asect
->relocation
)
4637 if (asect
->reloc_count
== 0)
4639 if (asect
->flags
& SEC_CONSTRUCTOR
)
4641 if (!coff_slurp_symbol_table (abfd
))
4644 (RELOC
*) buy_and_read (abfd
,
4647 (size_t) (bfd_coff_relsz (abfd
) *
4648 asect
->reloc_count
));
4649 reloc_cache
= (arelent
*)
4650 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
4652 if (reloc_cache
== NULL
)
4656 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
4658 struct internal_reloc dst
;
4659 struct external_reloc
*src
;
4660 #ifndef RELOC_PROCESSING
4664 cache_ptr
= reloc_cache
+ idx
;
4665 src
= native_relocs
+ idx
;
4667 coff_swap_reloc_in (abfd
, src
, &dst
);
4669 #ifdef RELOC_PROCESSING
4670 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
4672 cache_ptr
->address
= dst
.r_vaddr
;
4674 if (dst
.r_symndx
!= -1)
4676 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
4678 (*_bfd_error_handler
)
4679 (_("%s: warning: illegal symbol index %ld in relocs"),
4680 bfd_get_filename (abfd
), dst
.r_symndx
);
4681 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
4686 cache_ptr
->sym_ptr_ptr
= (symbols
4687 + obj_convert (abfd
)[dst
.r_symndx
]);
4688 ptr
= *(cache_ptr
->sym_ptr_ptr
);
4693 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
4697 /* The symbols definitions that we have read in have been
4698 relocated as if their sections started at 0. But the offsets
4699 refering to the symbols in the raw data have not been
4700 modified, so we have to have a negative addend to compensate.
4702 Note that symbols which used to be common must be left alone */
4704 /* Calculate any reloc addend by looking at the symbol */
4705 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
4707 cache_ptr
->address
-= asect
->vma
;
4708 /* !! cache_ptr->section = (asection *) NULL;*/
4710 /* Fill in the cache_ptr->howto field from dst.r_type */
4711 RTYPE2HOWTO (cache_ptr
, &dst
);
4712 #endif /* RELOC_PROCESSING */
4714 if (cache_ptr
->howto
== NULL
)
4716 (*_bfd_error_handler
)
4717 (_("%s: illegal relocation type %d at address 0x%lx"),
4718 bfd_get_filename (abfd
), dst
.r_type
, (long) dst
.r_vaddr
);
4719 bfd_set_error (bfd_error_bad_value
);
4724 asect
->relocation
= reloc_cache
;
4728 #ifndef coff_rtype_to_howto
4731 /* Get the howto structure for a reloc. This is only used if the file
4732 including this one defines coff_relocate_section to be
4733 _bfd_coff_generic_relocate_section, so it is OK if it does not
4734 always work. It is the responsibility of the including file to
4735 make sure it is reasonable if it is needed. */
4737 static reloc_howto_type
*coff_rtype_to_howto
4738 PARAMS ((bfd
*, asection
*, struct internal_reloc
*,
4739 struct coff_link_hash_entry
*, struct internal_syment
*,
4743 static reloc_howto_type
*
4744 coff_rtype_to_howto (abfd
, sec
, rel
, h
, sym
, addendp
)
4745 bfd
*abfd ATTRIBUTE_UNUSED
;
4746 asection
*sec ATTRIBUTE_UNUSED
;
4747 struct internal_reloc
*rel
;
4748 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
;
4749 struct internal_syment
*sym ATTRIBUTE_UNUSED
;
4750 bfd_vma
*addendp ATTRIBUTE_UNUSED
;
4754 RTYPE2HOWTO (&genrel
, rel
);
4755 return genrel
.howto
;
4758 #else /* ! defined (RTYPE2HOWTO) */
4760 #define coff_rtype_to_howto NULL
4762 #endif /* ! defined (RTYPE2HOWTO) */
4763 #endif /* ! defined (coff_rtype_to_howto) */
4765 /* This is stupid. This function should be a boolean predicate. */
4767 coff_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
4773 arelent
*tblptr
= section
->relocation
;
4774 unsigned int count
= 0;
4777 if (section
->flags
& SEC_CONSTRUCTOR
)
4779 /* this section has relocs made up by us, they are not in the
4780 file, so take them out of their chain and place them into
4781 the data area provided */
4782 arelent_chain
*chain
= section
->constructor_chain
;
4783 for (count
= 0; count
< section
->reloc_count
; count
++)
4785 *relptr
++ = &chain
->relent
;
4786 chain
= chain
->next
;
4792 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
4795 tblptr
= section
->relocation
;
4797 for (; count
++ < section
->reloc_count
;)
4798 *relptr
++ = tblptr
++;
4803 return section
->reloc_count
;
4808 coff_sym_filepos (abfd
)
4811 return obj_sym_filepos (abfd
);
4815 #ifndef coff_reloc16_estimate
4816 #define coff_reloc16_estimate dummy_reloc16_estimate
4818 static int dummy_reloc16_estimate
4819 PARAMS ((bfd
*, asection
*, arelent
*, unsigned int,
4820 struct bfd_link_info
*));
4823 dummy_reloc16_estimate (abfd
, input_section
, reloc
, shrink
, link_info
)
4824 bfd
*abfd ATTRIBUTE_UNUSED
;
4825 asection
*input_section ATTRIBUTE_UNUSED
;
4826 arelent
*reloc ATTRIBUTE_UNUSED
;
4827 unsigned int shrink ATTRIBUTE_UNUSED
;
4828 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
4836 #ifndef coff_reloc16_extra_cases
4838 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
4840 /* This works even if abort is not declared in any header file. */
4842 static void dummy_reloc16_extra_cases
4843 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*, arelent
*,
4844 bfd_byte
*, unsigned int *, unsigned int *));
4847 dummy_reloc16_extra_cases (abfd
, link_info
, link_order
, reloc
, data
, src_ptr
,
4849 bfd
*abfd ATTRIBUTE_UNUSED
;
4850 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
4851 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
;
4852 arelent
*reloc ATTRIBUTE_UNUSED
;
4853 bfd_byte
*data ATTRIBUTE_UNUSED
;
4854 unsigned int *src_ptr ATTRIBUTE_UNUSED
;
4855 unsigned int *dst_ptr ATTRIBUTE_UNUSED
;
4861 /* If coff_relocate_section is defined, we can use the optimized COFF
4862 backend linker. Otherwise we must continue to use the old linker. */
4863 #ifdef coff_relocate_section
4864 #ifndef coff_bfd_link_hash_table_create
4865 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
4867 #ifndef coff_bfd_link_add_symbols
4868 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
4870 #ifndef coff_bfd_final_link
4871 #define coff_bfd_final_link _bfd_coff_final_link
4873 #else /* ! defined (coff_relocate_section) */
4874 #define coff_relocate_section NULL
4875 #ifndef coff_bfd_link_hash_table_create
4876 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
4878 #ifndef coff_bfd_link_add_symbols
4879 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
4881 #define coff_bfd_final_link _bfd_generic_final_link
4882 #endif /* ! defined (coff_relocate_section) */
4884 #define coff_bfd_link_split_section _bfd_generic_link_split_section
4886 #ifndef coff_start_final_link
4887 #define coff_start_final_link NULL
4890 #ifndef coff_adjust_symndx
4891 #define coff_adjust_symndx NULL
4894 #ifndef coff_link_add_one_symbol
4895 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
4898 #ifndef coff_link_output_has_begun
4900 static boolean coff_link_output_has_begun
4901 PARAMS ((bfd
*, struct coff_final_link_info
*));
4904 coff_link_output_has_begun (abfd
, info
)
4906 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
;
4908 return abfd
->output_has_begun
;
4912 #ifndef coff_final_link_postscript
4914 static boolean coff_final_link_postscript
4915 PARAMS ((bfd
*, struct coff_final_link_info
*));
4918 coff_final_link_postscript (abfd
, pfinfo
)
4919 bfd
* abfd ATTRIBUTE_UNUSED
;
4920 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
;
4926 #ifndef coff_SWAP_aux_in
4927 #define coff_SWAP_aux_in coff_swap_aux_in
4929 #ifndef coff_SWAP_sym_in
4930 #define coff_SWAP_sym_in coff_swap_sym_in
4932 #ifndef coff_SWAP_lineno_in
4933 #define coff_SWAP_lineno_in coff_swap_lineno_in
4935 #ifndef coff_SWAP_aux_out
4936 #define coff_SWAP_aux_out coff_swap_aux_out
4938 #ifndef coff_SWAP_sym_out
4939 #define coff_SWAP_sym_out coff_swap_sym_out
4941 #ifndef coff_SWAP_lineno_out
4942 #define coff_SWAP_lineno_out coff_swap_lineno_out
4944 #ifndef coff_SWAP_reloc_out
4945 #define coff_SWAP_reloc_out coff_swap_reloc_out
4947 #ifndef coff_SWAP_filehdr_out
4948 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
4950 #ifndef coff_SWAP_aouthdr_out
4951 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
4953 #ifndef coff_SWAP_scnhdr_out
4954 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
4956 #ifndef coff_SWAP_reloc_in
4957 #define coff_SWAP_reloc_in coff_swap_reloc_in
4959 #ifndef coff_SWAP_filehdr_in
4960 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
4962 #ifndef coff_SWAP_aouthdr_in
4963 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
4965 #ifndef coff_SWAP_scnhdr_in
4966 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
4969 static const bfd_coff_backend_data bfd_coff_std_swap_table
=
4971 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
4972 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
4973 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
4974 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
4975 coff_SWAP_scnhdr_out
,
4976 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
4977 #ifdef COFF_LONG_FILENAMES
4982 #ifdef COFF_LONG_SECTION_NAMES
4987 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
4988 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
4989 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
4990 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
4991 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
4992 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
4993 coff_classify_symbol
, coff_compute_section_file_positions
,
4994 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
4995 coff_adjust_symndx
, coff_link_add_one_symbol
,
4996 coff_link_output_has_begun
, coff_final_link_postscript
4999 #ifndef coff_close_and_cleanup
5000 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5003 #ifndef coff_bfd_free_cached_info
5004 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5007 #ifndef coff_get_section_contents
5008 #define coff_get_section_contents _bfd_generic_get_section_contents
5011 #ifndef coff_bfd_copy_private_symbol_data
5012 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5015 #ifndef coff_bfd_copy_private_section_data
5016 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5019 #ifndef coff_bfd_copy_private_bfd_data
5020 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5023 #ifndef coff_bfd_merge_private_bfd_data
5024 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5027 #ifndef coff_bfd_set_private_flags
5028 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5031 #ifndef coff_bfd_print_private_bfd_data
5032 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5035 #ifndef coff_bfd_is_local_label_name
5036 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5039 #ifndef coff_read_minisymbols
5040 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5043 #ifndef coff_minisymbol_to_symbol
5044 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5047 /* The reloc lookup routine must be supplied by each individual COFF
5049 #ifndef coff_bfd_reloc_type_lookup
5050 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5053 #ifndef coff_bfd_get_relocated_section_contents
5054 #define coff_bfd_get_relocated_section_contents \
5055 bfd_generic_get_relocated_section_contents
5058 #ifndef coff_bfd_relax_section
5059 #define coff_bfd_relax_section bfd_generic_relax_section
5062 #ifndef coff_bfd_gc_sections
5063 #define coff_bfd_gc_sections bfd_generic_gc_sections
5066 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
5067 const bfd_target VAR = \
5070 bfd_target_coff_flavour, \
5071 BFD_ENDIAN_BIG, /* data byte order is big */ \
5072 BFD_ENDIAN_BIG, /* header byte order is big */ \
5073 /* object flags */ \
5074 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5075 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5076 /* section flags */ \
5077 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5078 UNDER, /* leading symbol underscore */ \
5079 '/', /* ar_pad_char */ \
5080 15, /* ar_max_namelen */ \
5082 /* Data conversion functions. */ \
5083 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5084 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5085 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5087 /* Header conversion functions. */ \
5088 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5089 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5090 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5092 /* bfd_check_format */ \
5093 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5094 _bfd_dummy_target }, \
5095 /* bfd_set_format */ \
5096 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5097 /* bfd_write_contents */ \
5098 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5101 BFD_JUMP_TABLE_GENERIC (coff), \
5102 BFD_JUMP_TABLE_COPY (coff), \
5103 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5104 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5105 BFD_JUMP_TABLE_SYMBOLS (coff), \
5106 BFD_JUMP_TABLE_RELOCS (coff), \
5107 BFD_JUMP_TABLE_WRITE (coff), \
5108 BFD_JUMP_TABLE_LINK (coff), \
5109 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5116 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
5117 const bfd_target VAR = \
5120 bfd_target_coff_flavour, \
5121 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
5122 BFD_ENDIAN_LITTLE, /* header byte order is little */ \
5123 /* object flags */ \
5124 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5125 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5126 /* section flags */ \
5127 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5128 UNDER, /* leading symbol underscore */ \
5129 '/', /* ar_pad_char */ \
5130 15, /* ar_max_namelen */ \
5132 /* Data conversion functions. */ \
5133 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5134 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5135 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5136 /* Header conversion functions. */ \
5137 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5138 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5139 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5140 /* bfd_check_format */ \
5141 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5142 _bfd_dummy_target }, \
5143 /* bfd_set_format */ \
5144 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5145 /* bfd_write_contents */ \
5146 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5149 BFD_JUMP_TABLE_GENERIC (coff), \
5150 BFD_JUMP_TABLE_COPY (coff), \
5151 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5152 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5153 BFD_JUMP_TABLE_SYMBOLS (coff), \
5154 BFD_JUMP_TABLE_RELOCS (coff), \
5155 BFD_JUMP_TABLE_WRITE (coff), \
5156 BFD_JUMP_TABLE_LINK (coff), \
5157 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \