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 arch
= bfd_arch_obscure
;
2068 (*_bfd_error_handler
)
2069 (_("Unrecognized TI COFF target id '0x%x'"),
2070 internal_f
->f_target_id
);
2076 #ifdef TIC80_ARCH_MAGIC
2077 case TIC80_ARCH_MAGIC
:
2078 arch
= bfd_arch_tic80
;
2084 arch
= bfd_arch_mcore
;
2087 default: /* Unreadable input file type */
2088 arch
= bfd_arch_obscure
;
2092 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2096 #ifdef SYMNAME_IN_DEBUG
2098 static boolean symname_in_debug_hook
2099 PARAMS ((bfd
*, struct internal_syment
*));
2102 symname_in_debug_hook (abfd
, sym
)
2103 bfd
* abfd ATTRIBUTE_UNUSED
;
2104 struct internal_syment
*sym
;
2106 return SYMNAME_IN_DEBUG (sym
) ? true : false;
2111 #define symname_in_debug_hook \
2112 (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
2118 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
2120 static boolean coff_pointerize_aux_hook
2121 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
2122 unsigned int, combined_entry_type
*));
2126 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
2127 bfd
*abfd ATTRIBUTE_UNUSED
;
2128 combined_entry_type
*table_base
;
2129 combined_entry_type
*symbol
;
2130 unsigned int indaux
;
2131 combined_entry_type
*aux
;
2133 int class = symbol
->u
.syment
.n_sclass
;
2135 if ((class == C_EXT
|| class == C_HIDEXT
)
2136 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2138 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2140 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2141 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2142 aux
->fix_scnlen
= 1;
2145 /* Return true to indicate that the caller should not do any
2146 further work on this auxent. */
2150 /* Return false to indicate that this auxent should be handled by
2158 /* We don't want to pointerize bal entries. */
2160 static boolean coff_pointerize_aux_hook
2161 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
2162 unsigned int, combined_entry_type
*));
2166 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
2167 bfd
*abfd ATTRIBUTE_UNUSED
;
2168 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
2169 combined_entry_type
*symbol
;
2170 unsigned int indaux
;
2171 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
2173 /* Return true if we don't want to pointerize this aux entry, which
2174 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2176 && (symbol
->u
.syment
.n_sclass
== C_LEAFPROC
2177 || symbol
->u
.syment
.n_sclass
== C_LEAFSTAT
2178 || symbol
->u
.syment
.n_sclass
== C_LEAFEXT
));
2183 #define coff_pointerize_aux_hook 0
2186 #endif /* ! RS6000COFF_C */
2188 /* Print an aux entry. This returns true if it has printed it. */
2190 static boolean coff_print_aux
2191 PARAMS ((bfd
*, FILE *, combined_entry_type
*, combined_entry_type
*,
2192 combined_entry_type
*, unsigned int));
2195 coff_print_aux (abfd
, file
, table_base
, symbol
, aux
, indaux
)
2196 bfd
*abfd ATTRIBUTE_UNUSED
;
2197 FILE *file ATTRIBUTE_UNUSED
;
2198 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
2199 combined_entry_type
*symbol ATTRIBUTE_UNUSED
;
2200 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
2201 unsigned int indaux ATTRIBUTE_UNUSED
;
2204 if ((symbol
->u
.syment
.n_sclass
== C_EXT
2205 || symbol
->u
.syment
.n_sclass
== C_HIDEXT
)
2206 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2208 /* This is a csect entry. */
2209 fprintf (file
, "AUX ");
2210 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2212 BFD_ASSERT (! aux
->fix_scnlen
);
2213 fprintf (file
, "val %5ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2217 fprintf (file
, "indx ");
2218 if (! aux
->fix_scnlen
)
2219 fprintf (file
, "%4ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2221 fprintf (file
, "%4ld",
2222 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2225 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2226 aux
->u
.auxent
.x_csect
.x_parmhash
,
2227 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2228 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2229 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2230 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2231 aux
->u
.auxent
.x_csect
.x_stab
,
2232 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2237 /* Return false to indicate that no special action was taken. */
2245 To write relocations, the back end steps though the
2246 canonical relocation table and create an
2247 @code{internal_reloc}. The symbol index to use is removed from
2248 the @code{offset} field in the symbol table supplied. The
2249 address comes directly from the sum of the section base
2250 address and the relocation offset; the type is dug directly
2251 from the howto field. Then the @code{internal_reloc} is
2252 swapped into the shape of an @code{external_reloc} and written
2259 static int compare_arelent_ptr
PARAMS ((const PTR
, const PTR
));
2261 /* AUX's ld wants relocations to be sorted */
2263 compare_arelent_ptr (x
, y
)
2267 const arelent
**a
= (const arelent
**) x
;
2268 const arelent
**b
= (const arelent
**) y
;
2269 bfd_size_type aadr
= (*a
)->address
;
2270 bfd_size_type badr
= (*b
)->address
;
2272 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2275 #endif /* TARG_AUX */
2278 coff_write_relocs (abfd
, first_undef
)
2284 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
2287 struct external_reloc dst
;
2293 /* sort relocations before we write them out */
2294 p
= (arelent
**) bfd_malloc (s
->reloc_count
* sizeof (arelent
*));
2295 if (p
== NULL
&& s
->reloc_count
> 0)
2297 memcpy (p
, s
->orelocation
, s
->reloc_count
* sizeof (arelent
*));
2298 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2301 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2303 for (i
= 0; i
< s
->reloc_count
; i
++)
2305 struct internal_reloc n
;
2307 memset ((PTR
) & n
, 0, sizeof (n
));
2309 /* Now we've renumbered the symbols we know where the
2310 undefined symbols live in the table. Check the reloc
2311 entries for symbols who's output bfd isn't the right one.
2312 This is because the symbol was undefined (which means
2313 that all the pointers are never made to point to the same
2314 place). This is a bad thing,'cause the symbols attached
2315 to the output bfd are indexed, so that the relocation
2316 entries know which symbol index they point to. So we
2317 have to look up the output symbol here. */
2319 if (q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2322 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2323 asymbol
**outsyms
= abfd
->outsymbols
;
2324 for (i
= first_undef
; outsyms
[i
]; i
++)
2326 const char *intable
= outsyms
[i
]->name
;
2327 if (strcmp (intable
, sname
) == 0) {
2328 /* got a hit, so repoint the reloc */
2329 q
->sym_ptr_ptr
= outsyms
+ i
;
2335 n
.r_vaddr
= q
->address
+ s
->vma
;
2338 /* The 29k const/consth reloc pair is a real kludge. The consth
2339 part doesn't have a symbol; it has an offset. So rebuilt
2341 if (q
->howto
->type
== R_IHCONST
)
2342 n
.r_symndx
= q
->addend
;
2347 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2348 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
,s
))
2350 if (q
->sym_ptr_ptr
== bfd_abs_section_ptr
->symbol_ptr_ptr
)
2352 /* This is a relocation relative to the absolute symbol. */
2356 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2357 /* Take notice if the symbol reloc points to a symbol
2358 we don't have in our symbol table. What should we
2360 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2365 #ifdef SWAP_OUT_RELOC_OFFSET
2366 n
.r_offset
= q
->addend
;
2370 /* Work out reloc type from what is required */
2371 SELECT_RELOC (n
, q
->howto
);
2373 n
.r_type
= q
->howto
->type
;
2375 coff_swap_reloc_out (abfd
, &n
, &dst
);
2376 if (bfd_write ((PTR
) & dst
, 1, bfd_coff_relsz (abfd
), abfd
)
2377 != bfd_coff_relsz (abfd
))
2390 /* Set flags and magic number of a coff file from architecture and machine
2391 type. Result is true if we can represent the arch&type, false if not. */
2394 coff_set_flags (abfd
, magicp
, flagsp
)
2396 unsigned int *magicp ATTRIBUTE_UNUSED
;
2397 unsigned short *flagsp ATTRIBUTE_UNUSED
;
2399 switch (bfd_get_arch (abfd
))
2404 switch (bfd_get_mach (abfd
))
2406 case bfd_mach_z8001
:
2409 case bfd_mach_z8002
:
2423 *magicp
= I960ROMAGIC
;
2425 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2426 I960RWMAGIC); FIXME???
2428 switch (bfd_get_mach (abfd
))
2430 case bfd_mach_i960_core
:
2433 case bfd_mach_i960_kb_sb
:
2436 case bfd_mach_i960_mc
:
2439 case bfd_mach_i960_xa
:
2442 case bfd_mach_i960_ca
:
2445 case bfd_mach_i960_ka_sa
:
2448 case bfd_mach_i960_jx
:
2451 case bfd_mach_i960_hx
:
2464 case bfd_arch_tic30
:
2465 *magicp
= TIC30MAGIC
;
2469 #ifdef TICOFF_DEFAULT_MAGIC
2470 case TICOFF_TARGET_ARCH
:
2471 /* if there's no indication of which version we want, use the default */
2473 *magicp
= TICOFF_DEFAULT_MAGIC
;
2476 /* we may want to output in a different COFF version */
2477 switch (abfd
->xvec
->name
[4])
2480 *magicp
= TICOFF0MAGIC
;
2483 *magicp
= TICOFF1MAGIC
;
2486 *magicp
= TICOFF2MAGIC
;
2495 #ifdef TIC80_ARCH_MAGIC
2496 case bfd_arch_tic80
:
2497 *magicp
= TIC80_ARCH_MAGIC
;
2503 * magicp
= ARMPEMAGIC
;
2505 * magicp
= ARMMAGIC
;
2508 if (APCS_SET (abfd
))
2510 if (APCS_26_FLAG (abfd
))
2511 * flagsp
|= F_APCS26
;
2513 if (APCS_FLOAT_FLAG (abfd
))
2514 * flagsp
|= F_APCS_FLOAT
;
2516 if (PIC_FLAG (abfd
))
2519 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2520 * flagsp
|= F_INTERWORK
;
2521 switch (bfd_get_mach (abfd
))
2523 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2524 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2525 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2526 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2527 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2528 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2529 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2530 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break; /* XXX - we do not have an F_ARM_5T */
2535 case bfd_arch_powerpc
:
2542 *magicp
= I386MAGIC
;
2544 /* Just overwrite the usual value if we're doing Lynx. */
2545 *magicp
= LYNXCOFFMAGIC
;
2552 *magicp
= I860MAGIC
;
2558 #ifdef APOLLOM68KMAGIC
2559 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
2561 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2562 #ifdef NAMES_HAVE_UNDERSCORE
2563 *magicp
= MC68KBCSMAGIC
;
2565 *magicp
= MC68MAGIC
;
2569 /* Just overwrite the usual value if we're doing Lynx. */
2570 *magicp
= LYNXCOFFMAGIC
;
2578 *magicp
= MC88OMAGIC
;
2583 case bfd_arch_h8300
:
2584 switch (bfd_get_mach (abfd
))
2586 case bfd_mach_h8300
:
2587 *magicp
= H8300MAGIC
;
2589 case bfd_mach_h8300h
:
2590 *magicp
= H8300HMAGIC
;
2592 case bfd_mach_h8300s
:
2593 *magicp
= H8300SMAGIC
;
2599 #ifdef SH_ARCH_MAGIC_BIG
2601 #ifdef COFF_IMAGE_WITH_PE
2602 *magicp
= SH_ARCH_MAGIC_WINCE
;
2604 if (bfd_big_endian (abfd
))
2605 *magicp
= SH_ARCH_MAGIC_BIG
;
2607 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2613 #ifdef MIPS_ARCH_MAGIC_WINCE
2615 *magicp
= MIPS_ARCH_MAGIC_WINCE
;
2621 case bfd_arch_sparc
:
2622 *magicp
= SPARCMAGIC
;
2624 /* Just overwrite the usual value if we're doing Lynx. */
2625 *magicp
= LYNXCOFFMAGIC
;
2632 case bfd_arch_h8500
:
2633 *magicp
= H8500MAGIC
;
2637 #ifdef A29K_MAGIC_BIG
2639 if (bfd_big_endian (abfd
))
2640 *magicp
= A29K_MAGIC_BIG
;
2642 *magicp
= A29K_MAGIC_LITTLE
;
2648 case bfd_arch_we32k
:
2649 *magicp
= WE32KMAGIC
;
2655 case bfd_arch_rs6000
:
2657 case bfd_arch_powerpc
:
2659 *magicp
= U802TOCMAGIC
;
2665 case bfd_arch_mcore
:
2666 * magicp
= MCOREMAGIC
;
2670 default: /* Unknown architecture */
2671 /* return false; -- fall through to "return false" below, to avoid
2672 "statement never reached" errors on the one below. */
2681 coff_set_arch_mach (abfd
, arch
, machine
)
2683 enum bfd_architecture arch
;
2684 unsigned long machine
;
2687 unsigned short dummy2
;
2689 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
2692 if (arch
!= bfd_arch_unknown
&&
2693 coff_set_flags (abfd
, &dummy1
, &dummy2
) != true)
2694 return false; /* We can't represent this type */
2696 return true; /* We're easy ... */
2699 #ifdef COFF_IMAGE_WITH_PE
2701 /* This is used to sort sections by VMA, as required by PE image
2704 static int sort_by_secaddr
PARAMS ((const PTR
, const PTR
));
2707 sort_by_secaddr (arg1
, arg2
)
2711 const asection
*a
= *(const asection
**) arg1
;
2712 const asection
*b
= *(const asection
**) arg2
;
2714 if (a
->vma
< b
->vma
)
2716 else if (a
->vma
> b
->vma
)
2722 #endif /* COFF_IMAGE_WITH_PE */
2724 /* Calculate the file position for each section. */
2727 #define ALIGN_SECTIONS_IN_FILE
2729 #if defined(TIC80COFF) || defined(TICOFF)
2730 #undef ALIGN_SECTIONS_IN_FILE
2734 coff_compute_section_file_positions (abfd
)
2738 asection
*previous
= (asection
*) NULL
;
2739 file_ptr sofar
= bfd_coff_filhsz (abfd
);
2740 boolean align_adjust
;
2741 #ifdef ALIGN_SECTIONS_IN_FILE
2746 /* On XCOFF, if we have symbols, set up the .debug section. */
2747 if (bfd_get_symcount (abfd
) > 0)
2750 bfd_size_type i
, symcount
;
2754 symcount
= bfd_get_symcount (abfd
);
2755 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
2757 coff_symbol_type
*cf
;
2759 cf
= coff_symbol_from (abfd
, *symp
);
2761 && cf
->native
!= NULL
2762 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
2766 len
= strlen (bfd_asymbol_name (*symp
));
2775 dsec
= bfd_make_section_old_way (abfd
, ".debug");
2778 dsec
->_raw_size
= sz
;
2779 dsec
->flags
|= SEC_HAS_CONTENTS
;
2784 #ifdef COFF_IMAGE_WITH_PE
2786 if (coff_data (abfd
)->link_info
)
2788 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
2791 page_size
= PE_DEF_FILE_ALIGNMENT
;
2793 #ifdef COFF_PAGE_SIZE
2794 int page_size
= COFF_PAGE_SIZE
;
2798 if (bfd_get_start_address (abfd
))
2800 /* A start address may have been added to the original file. In this
2801 case it will need an optional header to record it. */
2802 abfd
->flags
|= EXEC_P
;
2805 if (abfd
->flags
& EXEC_P
)
2806 sofar
+= bfd_coff_aoutsz (abfd
);
2808 else if (xcoff_data (abfd
)->full_aouthdr
)
2809 sofar
+= bfd_coff_aoutsz (abfd
);
2811 sofar
+= SMALL_AOUTSZ
;
2814 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2817 /* XCOFF handles overflows in the reloc and line number count fields
2818 by allocating a new section header to hold the correct counts. */
2819 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2820 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
2821 sofar
+= bfd_coff_scnhsz (abfd
);
2824 #ifdef COFF_IMAGE_WITH_PE
2826 /* PE requires the sections to be in memory order when listed in
2827 the section headers. It also does not like empty loadable
2828 sections. The sections apparently do not have to be in the
2829 right order in the image file itself, but we do need to get the
2830 target_index values right. */
2833 asection
**section_list
;
2838 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2841 /* We allocate an extra cell to simplify the final loop. */
2842 section_list
= bfd_malloc (sizeof (struct asection
*) * (count
+ 1));
2843 if (section_list
== NULL
)
2847 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2849 section_list
[i
] = current
;
2852 section_list
[i
] = NULL
;
2854 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
2856 /* Rethread the linked list into sorted order; at the same time,
2857 assign target_index values. */
2859 abfd
->sections
= section_list
[0];
2860 for (i
= 0; i
< count
; i
++)
2862 current
= section_list
[i
];
2863 current
->next
= section_list
[i
+ 1];
2865 /* Later, if the section has zero size, we'll be throwing it
2866 away, so we don't want to number it now. Note that having
2867 a zero size and having real contents are different
2868 concepts: .bss has no contents, but (usually) non-zero
2870 if (current
->_raw_size
== 0)
2872 /* Discard. However, it still might have (valid) symbols
2873 in it, so arbitrarily set it to section 1 (indexing is
2874 1-based here; usually .text). __end__ and other
2875 contents of .endsection really have this happen.
2876 FIXME: This seems somewhat dubious. */
2877 current
->target_index
= 1;
2880 current
->target_index
= target_index
++;
2883 free (section_list
);
2885 #else /* ! COFF_IMAGE_WITH_PE */
2887 /* Set the target_index field. */
2891 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2892 current
->target_index
= target_index
++;
2894 #endif /* ! COFF_IMAGE_WITH_PE */
2896 align_adjust
= false;
2897 for (current
= abfd
->sections
;
2898 current
!= (asection
*) NULL
;
2899 current
= current
->next
)
2901 #ifdef COFF_IMAGE_WITH_PE
2902 /* With PE we have to pad each section to be a multiple of its
2903 page size too, and remember both sizes. */
2904 if (coff_section_data (abfd
, current
) == NULL
)
2906 current
->used_by_bfd
=
2907 (PTR
) bfd_zalloc (abfd
, sizeof (struct coff_section_tdata
));
2908 if (current
->used_by_bfd
== NULL
)
2911 if (pei_section_data (abfd
, current
) == NULL
)
2913 coff_section_data (abfd
, current
)->tdata
=
2914 (PTR
) bfd_zalloc (abfd
, sizeof (struct pei_section_tdata
));
2915 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
2918 if (pei_section_data (abfd
, current
)->virt_size
== 0)
2919 pei_section_data (abfd
, current
)->virt_size
= current
->_raw_size
;
2922 /* Only deal with sections which have contents. */
2923 if (!(current
->flags
& SEC_HAS_CONTENTS
))
2926 #ifdef COFF_IMAGE_WITH_PE
2927 /* Make sure we skip empty sections in a PE image. */
2928 if (current
->_raw_size
== 0)
2932 /* Align the sections in the file to the same boundary on
2933 which they are aligned in virtual memory. I960 doesn't
2934 do this (FIXME) so we can stay in sync with Intel. 960
2935 doesn't yet page from files... */
2936 #ifdef ALIGN_SECTIONS_IN_FILE
2937 if ((abfd
->flags
& EXEC_P
) != 0)
2939 /* make sure this section is aligned on the right boundary - by
2940 padding the previous section up if necessary */
2943 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
2944 if (previous
!= (asection
*) NULL
)
2946 previous
->_raw_size
+= sofar
- old_sofar
;
2952 /* In demand paged files the low order bits of the file offset
2953 must match the low order bits of the virtual address. */
2954 #ifdef COFF_PAGE_SIZE
2955 if ((abfd
->flags
& D_PAGED
) != 0
2956 && (current
->flags
& SEC_ALLOC
) != 0)
2957 sofar
+= (current
->vma
- sofar
) % page_size
;
2959 current
->filepos
= sofar
;
2961 #ifdef COFF_IMAGE_WITH_PE
2962 /* Set the padded size. */
2963 current
->_raw_size
= (current
->_raw_size
+ page_size
-1) & -page_size
;
2966 sofar
+= current
->_raw_size
;
2968 #ifdef ALIGN_SECTIONS_IN_FILE
2969 /* make sure that this section is of the right size too */
2970 if ((abfd
->flags
& EXEC_P
) == 0)
2972 bfd_size_type old_size
;
2974 old_size
= current
->_raw_size
;
2975 current
->_raw_size
= BFD_ALIGN (current
->_raw_size
,
2976 1 << current
->alignment_power
);
2977 align_adjust
= current
->_raw_size
!= old_size
;
2978 sofar
+= current
->_raw_size
- old_size
;
2983 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
2984 align_adjust
= sofar
!= old_sofar
;
2985 current
->_raw_size
+= sofar
- old_sofar
;
2989 #ifdef COFF_IMAGE_WITH_PE
2990 /* For PE we need to make sure we pad out to the aligned
2991 _raw_size, in case the caller only writes out data to the
2992 unaligned _raw_size. */
2993 if (pei_section_data (abfd
, current
)->virt_size
< current
->_raw_size
)
2994 align_adjust
= true;
2998 /* Force .lib sections to start at zero. The vma is then
2999 incremented in coff_set_section_contents. This is right for
3001 if (strcmp (current
->name
, _LIB
) == 0)
3002 bfd_set_section_vma (abfd
, current
, 0);
3008 /* It is now safe to write to the output file. If we needed an
3009 alignment adjustment for the last section, then make sure that
3010 there is a byte at offset sofar. If there are no symbols and no
3011 relocs, then nothing follows the last section. If we don't force
3012 the last byte out, then the file may appear to be truncated. */
3018 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
3019 || bfd_write (&b
, 1, 1, abfd
) != 1)
3023 /* Make sure the relocations are aligned. We don't need to make
3024 sure that this byte exists, because it will only matter if there
3025 really are relocs. */
3026 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
3028 obj_relocbase (abfd
) = sofar
;
3029 abfd
->output_has_begun
= true;
3036 /* This can never work, because it is called too late--after the
3037 section positions have been set. I can't figure out what it is
3038 for, so I am going to disable it--Ian Taylor 20 March 1996. */
3040 /* If .file, .text, .data, .bss symbols are missing, add them. */
3041 /* @@ Should we only be adding missing symbols, or overriding the aux
3042 values for existing section symbols? */
3044 coff_add_missing_symbols (abfd
)
3047 unsigned int nsyms
= bfd_get_symcount (abfd
);
3048 asymbol
**sympp
= abfd
->outsymbols
;
3051 int need_text
= 1, need_data
= 1, need_bss
= 1, need_file
= 1;
3053 for (i
= 0; i
< nsyms
; i
++)
3055 coff_symbol_type
*csym
= coff_symbol_from (abfd
, sympp
[i
]);
3059 /* only do this if there is a coff representation of the input
3061 if (csym
->native
&& csym
->native
->u
.syment
.n_sclass
== C_FILE
)
3066 name
= csym
->symbol
.name
;
3069 if (!strcmp (name
, _TEXT
))
3072 else if (!strcmp (name
, ".wtext"))
3075 else if (!strcmp (name
, _DATA
))
3077 else if (!strcmp (name
, _BSS
))
3081 /* Now i == bfd_get_symcount (abfd). */
3082 /* @@ For now, don't deal with .file symbol. */
3085 if (!need_text
&& !need_data
&& !need_bss
&& !need_file
)
3087 nsyms
+= need_text
+ need_data
+ need_bss
+ need_file
;
3088 sympp2
= (asymbol
**) bfd_alloc (abfd
, nsyms
* sizeof (asymbol
*));
3091 memcpy (sympp2
, sympp
, i
* sizeof (asymbol
*));
3094 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
3098 sympp2
[i
++] = coff_section_symbol (abfd
, _TEXT
);
3100 sympp2
[i
++] = coff_section_symbol (abfd
, _DATA
);
3102 sympp2
[i
++] = coff_section_symbol (abfd
, _BSS
);
3103 BFD_ASSERT (i
== nsyms
);
3104 bfd_set_symtab (abfd
, sympp2
, nsyms
);
3113 coff_write_object_contents (abfd
)
3117 boolean hasrelocs
= false;
3118 boolean haslinno
= false;
3119 boolean hasdebug
= false;
3121 file_ptr reloc_base
;
3122 file_ptr lineno_base
;
3124 unsigned long reloc_size
= 0;
3125 unsigned long lnno_size
= 0;
3126 boolean long_section_names
;
3127 asection
*text_sec
= NULL
;
3128 asection
*data_sec
= NULL
;
3129 asection
*bss_sec
= NULL
;
3130 struct internal_filehdr internal_f
;
3131 struct internal_aouthdr internal_a
;
3132 #ifdef COFF_LONG_SECTION_NAMES
3133 size_t string_size
= STRING_SIZE_SIZE
;
3136 bfd_set_error (bfd_error_system_call
);
3138 /* Make a pass through the symbol table to count line number entries and
3139 put them into the correct asections */
3141 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3143 if (abfd
->output_has_begun
== false)
3145 if (! coff_compute_section_file_positions (abfd
))
3149 reloc_base
= obj_relocbase (abfd
);
3151 /* Work out the size of the reloc and linno areas */
3153 for (current
= abfd
->sections
; current
!= NULL
; current
=
3155 reloc_size
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3157 lineno_base
= reloc_base
+ reloc_size
;
3158 sym_base
= lineno_base
+ lnno_size
;
3160 /* Indicate in each section->line_filepos its actual file address */
3161 for (current
= abfd
->sections
; current
!= NULL
; current
=
3164 if (current
->lineno_count
)
3166 current
->line_filepos
= lineno_base
;
3167 current
->moving_line_filepos
= lineno_base
;
3168 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3172 current
->line_filepos
= 0;
3174 if (current
->reloc_count
)
3176 current
->rel_filepos
= reloc_base
;
3177 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3181 current
->rel_filepos
= 0;
3185 /* Write section headers to the file. */
3186 internal_f
.f_nscns
= 0;
3188 if ((abfd
->flags
& EXEC_P
) != 0)
3189 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3192 scn_base
= bfd_coff_filhsz (abfd
);
3194 if (xcoff_data (abfd
)->full_aouthdr
)
3195 scn_base
+= bfd_coff_aoutsz (abfd
);
3197 scn_base
+= SMALL_AOUTSZ
;
3201 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3204 long_section_names
= false;
3205 for (current
= abfd
->sections
;
3207 current
= current
->next
)
3209 struct internal_scnhdr section
;
3210 boolean is_reloc_section
= false;
3212 #ifdef COFF_IMAGE_WITH_PE
3213 if (strcmp (current
->name
, ".reloc") == 0)
3215 is_reloc_section
= true;
3217 pe_data (abfd
)->has_reloc_section
= 1;
3221 internal_f
.f_nscns
++;
3223 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3225 #ifdef COFF_LONG_SECTION_NAMES
3226 /* Handle long section names as in PE. This must be compatible
3227 with the code in coff_write_symbols and _bfd_coff_final_link. */
3231 len
= strlen (current
->name
);
3234 memset (section
.s_name
, 0, SCNNMLEN
);
3235 sprintf (section
.s_name
, "/%lu", (unsigned long) string_size
);
3236 string_size
+= len
+ 1;
3237 long_section_names
= true;
3243 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3244 Ian Taylor <ian@cygnus.com>. */
3245 if (strcmp (current
->name
, _LIB
) == 0)
3246 section
.s_vaddr
= 0;
3249 section
.s_vaddr
= current
->vma
;
3250 section
.s_paddr
= current
->lma
;
3251 section
.s_size
= current
->_raw_size
;
3254 section
.s_paddr
= 0;
3256 #ifdef COFF_IMAGE_WITH_PE
3257 /* Reminder: s_paddr holds the virtual size of the section. */
3258 if (coff_section_data (abfd
, current
) != NULL
3259 && pei_section_data (abfd
, current
) != NULL
)
3260 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3262 section
.s_paddr
= 0;
3266 If this section has no size or is unloadable then the scnptr
3269 if (current
->_raw_size
== 0 ||
3270 (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3272 section
.s_scnptr
= 0;
3276 section
.s_scnptr
= current
->filepos
;
3278 section
.s_relptr
= current
->rel_filepos
;
3279 section
.s_lnnoptr
= current
->line_filepos
;
3280 section
.s_nreloc
= current
->reloc_count
;
3281 section
.s_nlnno
= current
->lineno_count
;
3282 #ifndef COFF_IMAGE_WITH_PE
3283 /* In PEI, relocs come in the .reloc section. */
3284 if (current
->reloc_count
!= 0)
3287 if (current
->lineno_count
!= 0)
3289 if ((current
->flags
& SEC_DEBUGGING
) != 0
3290 && ! is_reloc_section
)
3294 /* Indicate the use of an XCOFF overflow section header. */
3295 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3297 section
.s_nreloc
= 0xffff;
3298 section
.s_nlnno
= 0xffff;
3302 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3304 if (!strcmp (current
->name
, _TEXT
))
3308 else if (!strcmp (current
->name
, _DATA
))
3312 else if (!strcmp (current
->name
, _BSS
))
3318 section
.s_align
= (current
->alignment_power
3319 ? 1 << current
->alignment_power
3323 /* TI COFF puts the alignment power in bits 8-11 of the flags */
3324 section
.s_flags
|= (current
->alignment_power
& 0xF) << 8;
3326 #ifdef COFF_ENCODE_ALIGNMENT
3327 COFF_ENCODE_ALIGNMENT(section
, current
->alignment_power
);
3330 #ifdef COFF_IMAGE_WITH_PE
3331 /* Suppress output of the sections if they are null. ld
3332 includes the bss and data sections even if there is no size
3333 assigned to them. NT loader doesn't like it if these section
3334 headers are included if the sections themselves are not
3335 needed. See also coff_compute_section_file_positions. */
3336 if (section
.s_size
== 0)
3337 internal_f
.f_nscns
--;
3342 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3343 || bfd_write ((PTR
) (&buff
), 1, bfd_coff_scnhsz (abfd
), abfd
)
3344 != bfd_coff_scnhsz (abfd
))
3349 /* PE stores COMDAT section information in the symbol table. If
3350 this section is supposed to have some COMDAT info, track down
3351 the symbol in the symbol table and modify it. */
3352 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3354 unsigned int i
, count
;
3356 coff_symbol_type
*csym
= NULL
;
3360 count
= bfd_get_symcount (abfd
);
3361 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3363 if ((*psym
)->section
!= current
)
3366 /* Remember the location of the first symbol in this
3368 if (psymsec
== NULL
)
3371 /* See if this is the section symbol. */
3372 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3374 csym
= coff_symbol_from (abfd
, *psym
);
3376 || csym
->native
== NULL
3377 || csym
->native
->u
.syment
.n_numaux
< 1
3378 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3379 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3382 /* Here *PSYM is the section symbol for CURRENT. */
3389 Note that we might not if we're converting the file from
3390 some other object file format. */
3393 combined_entry_type
*aux
;
3395 /* We don't touch the x_checksum field. The
3396 x_associated field is not currently supported. */
3398 aux
= csym
->native
+ 1;
3399 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3401 case SEC_LINK_DUPLICATES_DISCARD
:
3402 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3405 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3406 aux
->u
.auxent
.x_scn
.x_comdat
=
3407 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3410 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3411 aux
->u
.auxent
.x_scn
.x_comdat
=
3412 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3415 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3416 aux
->u
.auxent
.x_scn
.x_comdat
=
3417 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3421 /* The COMDAT symbol must be the first symbol from this
3422 section in the symbol table. In order to make this
3423 work, we move the COMDAT symbol before the first
3424 symbol we found in the search above. It's OK to
3425 rearrange the symbol table at this point, because
3426 coff_renumber_symbols is going to rearrange it
3427 further and fix up all the aux entries. */
3428 if (psym
!= psymsec
)
3434 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3435 pcopy
[0] = pcopy
[-1];
3440 #endif /* COFF_WITH_PE */
3444 /* XCOFF handles overflows in the reloc and line number count fields
3445 by creating a new section header to hold the correct values. */
3446 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3448 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3450 struct internal_scnhdr scnhdr
;
3453 internal_f
.f_nscns
++;
3454 strncpy (&(scnhdr
.s_name
[0]), current
->name
, 8);
3455 scnhdr
.s_paddr
= current
->reloc_count
;
3456 scnhdr
.s_vaddr
= current
->lineno_count
;
3458 scnhdr
.s_scnptr
= 0;
3459 scnhdr
.s_relptr
= current
->rel_filepos
;
3460 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3461 scnhdr
.s_nreloc
= current
->target_index
;
3462 scnhdr
.s_nlnno
= current
->target_index
;
3463 scnhdr
.s_flags
= STYP_OVRFLO
;
3464 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3465 || bfd_write ((PTR
) &buff
, 1, bfd_coff_scnhsz (abfd
), abfd
)
3466 != bfd_coff_scnhsz (abfd
))
3472 /* OK, now set up the filehdr... */
3474 /* Don't include the internal abs section in the section count */
3477 We will NOT put a fucking timestamp in the header here. Every time you
3478 put it back, I will come in and take it out again. I'm sorry. This
3479 field does not belong here. We fill it with a 0 so it compares the
3480 same but is not a reasonable time. -- gnu@cygnus.com
3482 internal_f
.f_timdat
= 0;
3484 internal_f
.f_flags
= 0;
3486 if (abfd
->flags
& EXEC_P
)
3487 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3490 internal_f
.f_opthdr
= 0;
3492 if (xcoff_data (abfd
)->full_aouthdr
)
3493 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3495 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
3500 internal_f
.f_flags
|= F_RELFLG
;
3502 internal_f
.f_flags
|= F_LNNO
;
3503 if (abfd
->flags
& EXEC_P
)
3504 internal_f
.f_flags
|= F_EXEC
;
3505 #ifdef COFF_IMAGE_WITH_PE
3507 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
3510 #ifndef COFF_WITH_PE
3511 if (bfd_little_endian (abfd
))
3512 internal_f
.f_flags
|= F_AR32WR
;
3514 internal_f
.f_flags
|= F_AR32W
;
3518 /* target id is used in TI COFF v1 and later; COFF0 won't use this field,
3519 but it doesn't hurt to set it internally */
3520 internal_f
.f_target_id
= TI_TARGET_ID
;
3522 #ifdef TIC80_TARGET_ID
3523 internal_f
.f_target_id
= TIC80_TARGET_ID
;
3527 FIXME, should do something about the other byte orders and
3532 if ((abfd
->flags
& DYNAMIC
) != 0)
3533 internal_f
.f_flags
|= F_SHROBJ
;
3534 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
3535 internal_f
.f_flags
|= F_DYNLOAD
;
3538 memset (&internal_a
, 0, sizeof internal_a
);
3540 /* Set up architecture-dependent stuff */
3543 unsigned int magic
= 0;
3544 unsigned short flags
= 0;
3545 coff_set_flags (abfd
, &magic
, &flags
);
3546 internal_f
.f_magic
= magic
;
3547 internal_f
.f_flags
|= flags
;
3548 /* ...and the "opt"hdr... */
3551 #ifdef ULTRA3 /* NYU's machine */
3552 /* FIXME: This is a bogus check. I really want to see if there
3553 * is a .shbss or a .shdata section, if so then set the magic
3554 * number to indicate a shared data executable.
3556 if (internal_f
.f_nscns
>= 7)
3557 internal_a
.magic
= SHMAGIC
; /* Shared magic */
3560 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
3561 #define __A_MAGIC_SET__
3563 #ifdef TICOFF_AOUT_MAGIC
3564 internal_a
.magic
= TICOFF_AOUT_MAGIC
;
3565 #define __A_MAGIC_SET__
3568 internal_a
.magic
= TIC80_ARCH_MAGIC
;
3569 #define __A_MAGIC_SET__
3572 /* FIXME: What are the a.out magic numbers for the i860? */
3573 internal_a
.magic
= 0;
3574 #define __A_MAGIC_SET__
3577 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
3578 #define __A_MAGIC_SET__
3581 #define __A_MAGIC_SET__
3582 internal_a
.magic
= PAGEMAGICBCS
;
3586 #define __A_MAGIC_SET__
3587 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
3590 #if defined(M68) || defined(WE32K) || defined(M68K)
3591 #define __A_MAGIC_SET__
3593 internal_a
.magic
= LYNXCOFFMAGIC
;
3595 #if defined(TARG_AUX)
3596 internal_a
.magic
= (abfd
->flags
& D_PAGED
? PAGEMAGICPEXECPAGED
:
3597 abfd
->flags
& WP_TEXT
? PAGEMAGICPEXECSWAPPED
:
3598 PAGEMAGICEXECSWAPPED
);
3600 #if defined (PAGEMAGICPEXECPAGED)
3601 internal_a
.magic
= PAGEMAGICPEXECPAGED
;
3603 #endif /* TARG_AUX */
3605 #endif /* M68 || WE32K || M68K */
3608 #define __A_MAGIC_SET__
3609 internal_a
.magic
= ZMAGIC
;
3613 #define __A_MAGIC_SET__
3614 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3617 #if defined MCORE_PE
3618 #define __A_MAGIC_SET__
3619 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3623 #define __A_MAGIC_SET__
3625 internal_a
.magic
= LYNXCOFFMAGIC
;
3627 internal_a
.magic
= ZMAGIC
;
3632 #define __A_MAGIC_SET__
3634 internal_a
.magic
= LYNXCOFFMAGIC
;
3639 #define __A_MAGIC_SET__
3640 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
3641 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
3642 RS6K_AOUTHDR_OMAGIC
;
3645 #if defined(SH) && defined(COFF_WITH_PE)
3646 #define __A_MAGIC_SET__
3647 internal_a
.magic
= SH_PE_MAGIC
;
3650 #if defined(MIPS) && defined(COFF_WITH_PE)
3651 #define __A_MAGIC_SET__
3652 internal_a
.magic
= MIPS_PE_MAGIC
;
3655 #ifndef __A_MAGIC_SET__
3656 #include "Your aouthdr magic number is not being set!"
3658 #undef __A_MAGIC_SET__
3662 /* FIXME: Does anybody ever set this to another value? */
3663 internal_a
.vstamp
= 0;
3665 /* Now should write relocs, strings, syms */
3666 obj_sym_filepos (abfd
) = sym_base
;
3668 if (bfd_get_symcount (abfd
) != 0)
3672 if (!coff_add_missing_symbols (abfd
))
3675 if (!coff_renumber_symbols (abfd
, &firstundef
))
3677 coff_mangle_symbols (abfd
);
3678 if (! coff_write_symbols (abfd
))
3680 if (! coff_write_linenumbers (abfd
))
3682 if (! coff_write_relocs (abfd
, firstundef
))
3685 #ifdef COFF_LONG_SECTION_NAMES
3686 else if (long_section_names
)
3688 /* If we have long section names we have to write out the string
3689 table even if there are no symbols. */
3690 if (! coff_write_symbols (abfd
))
3694 #ifdef COFF_IMAGE_WITH_PE
3696 else if ((abfd
->flags
& EXEC_P
) != 0)
3700 /* PowerPC PE appears to require that all executable files be
3701 rounded up to the page size. */
3704 BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
3706 || bfd_write (&b
, 1, 1, abfd
) != 1)
3712 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3713 backend linker, and obj_raw_syment_count is not valid until after
3714 coff_write_symbols is called. */
3715 if (obj_raw_syment_count (abfd
) != 0)
3717 internal_f
.f_symptr
= sym_base
;
3719 /* AIX appears to require that F_RELFLG not be set if there are
3720 local symbols but no relocations. */
3721 internal_f
.f_flags
&=~ F_RELFLG
;
3726 if (long_section_names
)
3727 internal_f
.f_symptr
= sym_base
;
3729 internal_f
.f_symptr
= 0;
3730 internal_f
.f_flags
|= F_LSYMS
;
3735 internal_a
.tsize
= bfd_get_section_size_before_reloc (text_sec
);
3736 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
3740 internal_a
.dsize
= bfd_get_section_size_before_reloc (data_sec
);
3741 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
3745 internal_a
.bsize
= bfd_get_section_size_before_reloc (bss_sec
);
3746 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
3747 internal_a
.data_start
= bss_sec
->vma
;
3750 internal_a
.entry
= bfd_get_start_address (abfd
);
3751 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
3754 if (xcoff_data (abfd
)->full_aouthdr
)
3757 asection
*loader_sec
;
3759 internal_a
.vstamp
= 1;
3761 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
3762 if (internal_a
.o_snentry
== 0)
3763 internal_a
.entry
= (bfd_vma
) -1;
3765 if (text_sec
!= NULL
)
3767 internal_a
.o_sntext
= text_sec
->target_index
;
3768 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
3772 internal_a
.o_sntext
= 0;
3773 internal_a
.o_algntext
= 0;
3775 if (data_sec
!= NULL
)
3777 internal_a
.o_sndata
= data_sec
->target_index
;
3778 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
3782 internal_a
.o_sndata
= 0;
3783 internal_a
.o_algndata
= 0;
3785 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
3786 if (loader_sec
!= NULL
)
3787 internal_a
.o_snloader
= loader_sec
->target_index
;
3789 internal_a
.o_snloader
= 0;
3790 if (bss_sec
!= NULL
)
3791 internal_a
.o_snbss
= bss_sec
->target_index
;
3793 internal_a
.o_snbss
= 0;
3795 toc
= xcoff_data (abfd
)->toc
;
3796 internal_a
.o_toc
= toc
;
3797 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
3799 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
3800 if (xcoff_data (abfd
)->cputype
!= -1)
3801 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
3804 switch (bfd_get_arch (abfd
))
3806 case bfd_arch_rs6000
:
3807 internal_a
.o_cputype
= 4;
3809 case bfd_arch_powerpc
:
3810 if (bfd_get_mach (abfd
) == 0)
3811 internal_a
.o_cputype
= 3;
3813 internal_a
.o_cputype
= 1;
3819 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
3820 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
3824 /* now write them */
3825 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
3830 bfd_size_type amount
;
3832 buff
= bfd_malloc (bfd_coff_filhsz (abfd
));
3836 coff_swap_filehdr_out (abfd
, (PTR
) & internal_f
, (PTR
) buff
);
3837 amount
= bfd_write ((PTR
) buff
, 1, bfd_coff_filhsz (abfd
), abfd
);
3841 if (amount
!= bfd_coff_filhsz (abfd
))
3845 if (abfd
->flags
& EXEC_P
)
3847 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
3848 include/coff/pe.h sets AOUTSZ == sizeof(PEAOUTHDR)) */
3850 bfd_size_type amount
;
3852 buff
= bfd_malloc (bfd_coff_aoutsz (abfd
));
3856 coff_swap_aouthdr_out (abfd
, (PTR
) & internal_a
, (PTR
) buff
);
3857 amount
= bfd_write ((PTR
) buff
, 1, bfd_coff_aoutsz (abfd
), abfd
);
3861 if (amount
!= bfd_coff_aoutsz (abfd
))
3870 /* XCOFF seems to always write at least a small a.out header. */
3871 coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, (PTR
) &buff
);
3872 if (xcoff_data (abfd
)->full_aouthdr
)
3873 size
= bfd_coff_aoutsz (abfd
);
3875 size
= SMALL_AOUTSZ
;
3876 if (bfd_write ((PTR
) &buff
, 1, size
, abfd
) != size
)
3885 coff_set_section_contents (abfd
, section
, location
, offset
, count
)
3890 bfd_size_type count
;
3892 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
3894 if (! coff_compute_section_file_positions (abfd
))
3898 #if defined(_LIB) && !defined(TARG_AUX)
3900 /* The physical address field of a .lib section is used to hold the
3901 number of shared libraries in the section. This code counts the
3902 number of sections being written, and increments the lma field
3905 I have found no documentation on the contents of this section.
3906 Experimentation indicates that the section contains zero or more
3907 records, each of which has the following structure:
3909 - a (four byte) word holding the length of this record, in words,
3910 - a word that always seems to be set to "2",
3911 - the path to a shared library, null-terminated and then padded
3912 to a whole word boundary.
3914 bfd_assert calls have been added to alert if an attempt is made
3915 to write a section which doesn't follow these assumptions. The
3916 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
3917 <robertl@arnet.com> (Thanks!).
3919 Gvran Uddeborg <gvran@uddeborg.pp.se> */
3921 if (strcmp (section
->name
, _LIB
) == 0)
3923 bfd_byte
*rec
, *recend
;
3925 rec
= (bfd_byte
*) location
;
3926 recend
= rec
+ count
;
3927 while (rec
< recend
)
3930 rec
+= bfd_get_32 (abfd
, rec
) * 4;
3933 BFD_ASSERT (rec
== recend
);
3938 /* Don't write out bss sections - one way to do this is to
3939 see if the filepos has not been set. */
3940 if (section
->filepos
== 0)
3943 if (bfd_seek (abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
) != 0)
3948 return (bfd_write (location
, 1, count
, abfd
) == count
) ? true : false;
3954 coff_close_and_cleanup (abfd
)
3957 if (!bfd_read_p (abfd
))
3958 switch (abfd
->format
)
3961 if (!_bfd_write_archive_contents (abfd
))
3965 if (!coff_write_object_contents (abfd
))
3969 bfd_set_error (bfd_error_invalid_operation
);
3973 /* We depend on bfd_close to free all the memory on the objalloc. */
3980 buy_and_read (abfd
, where
, seek_direction
, size
)
3986 PTR area
= (PTR
) bfd_alloc (abfd
, size
);
3989 if (bfd_seek (abfd
, where
, seek_direction
) != 0
3990 || bfd_read (area
, 1, size
, abfd
) != size
)
3993 } /* buy_and_read() */
3999 Creating the linenumber table is done by reading in the entire
4000 coff linenumber table, and creating another table for internal use.
4002 A coff linenumber table is structured so that each function
4003 is marked as having a line number of 0. Each line within the
4004 function is an offset from the first line in the function. The
4005 base of the line number information for the table is stored in
4006 the symbol associated with the function.
4008 Note: The PE format uses line number 0 for a flag indicating a
4011 The information is copied from the external to the internal
4012 table, and each symbol which marks a function is marked by
4015 How does this work ?
4020 coff_slurp_line_table (abfd
, asect
)
4024 LINENO
*native_lineno
;
4025 alent
*lineno_cache
;
4027 BFD_ASSERT (asect
->lineno
== (alent
*) NULL
);
4029 native_lineno
= (LINENO
*) buy_and_read (abfd
,
4030 asect
->line_filepos
,
4032 (size_t) (bfd_coff_linesz (abfd
) *
4033 asect
->lineno_count
));
4035 (alent
*) bfd_alloc (abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof (alent
)));
4036 if (lineno_cache
== NULL
)
4040 unsigned int counter
= 0;
4041 alent
*cache_ptr
= lineno_cache
;
4042 LINENO
*src
= native_lineno
;
4044 while (counter
< asect
->lineno_count
)
4046 struct internal_lineno dst
;
4047 coff_swap_lineno_in (abfd
, src
, &dst
);
4048 cache_ptr
->line_number
= dst
.l_lnno
;
4050 if (cache_ptr
->line_number
== 0)
4054 coff_symbol_type
*sym
;
4057 symndx
= dst
.l_addr
.l_symndx
;
4059 || (unsigned long) symndx
>= obj_raw_syment_count (abfd
))
4061 (*_bfd_error_handler
)
4062 (_("%s: warning: illegal symbol index %ld in line numbers"),
4063 bfd_get_filename (abfd
), dst
.l_addr
.l_symndx
);
4067 /* FIXME: We should not be casting between ints and
4068 pointers like this. */
4069 sym
= ((coff_symbol_type
*)
4070 ((symndx
+ obj_raw_syments (abfd
))
4071 ->u
.syment
._n
._n_n
._n_zeroes
));
4072 cache_ptr
->u
.sym
= (asymbol
*) sym
;
4073 if (sym
->lineno
!= NULL
&& ! warned
)
4075 (*_bfd_error_handler
)
4076 (_("%s: warning: duplicate line number information for `%s'"),
4077 bfd_get_filename (abfd
),
4078 bfd_asymbol_name (&sym
->symbol
));
4080 sym
->lineno
= cache_ptr
;
4084 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
4085 - bfd_section_vma (abfd
, asect
);
4086 } /* If no linenumber expect a symbol index */
4092 cache_ptr
->line_number
= 0;
4095 asect
->lineno
= lineno_cache
;
4096 /* FIXME, free native_lineno here, or use alloca or something. */
4100 /* Slurp in the symbol table, converting it to generic form. Note
4101 that if coff_relocate_section is defined, the linker will read
4102 symbols via coff_link_add_symbols, rather than via this routine. */
4105 coff_slurp_symbol_table (abfd
)
4108 combined_entry_type
*native_symbols
;
4109 coff_symbol_type
*cached_area
;
4110 unsigned int *table_ptr
;
4112 unsigned int number_of_symbols
= 0;
4114 if (obj_symbols (abfd
))
4117 /* Read in the symbol table */
4118 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4123 /* Allocate enough room for all the symbols in cached form */
4124 cached_area
= ((coff_symbol_type
*)
4126 (obj_raw_syment_count (abfd
)
4127 * sizeof (coff_symbol_type
))));
4129 if (cached_area
== NULL
)
4131 table_ptr
= ((unsigned int *)
4133 (obj_raw_syment_count (abfd
)
4134 * sizeof (unsigned int))));
4136 if (table_ptr
== NULL
)
4140 coff_symbol_type
*dst
= cached_area
;
4141 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4142 unsigned int this_index
= 0;
4143 while (this_index
< last_native_index
)
4145 combined_entry_type
*src
= native_symbols
+ this_index
;
4146 table_ptr
[this_index
] = number_of_symbols
;
4147 dst
->symbol
.the_bfd
= abfd
;
4149 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4150 /* We use the native name field to point to the cached field. */
4151 src
->u
.syment
._n
._n_n
._n_zeroes
= (long) dst
;
4152 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4153 src
->u
.syment
.n_scnum
);
4154 dst
->symbol
.flags
= 0;
4155 dst
->done_lineno
= false;
4157 switch (src
->u
.syment
.n_sclass
)
4162 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
4163 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4164 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4166 /* Fall through to next case */
4174 case C_THUMBEXTFUNC
:
4180 case C_SYSTEM
: /* System Wide variable */
4183 /* In PE, 0x68 (104) denotes a section symbol */
4185 /* In PE, 0x69 (105) denotes a weak external symbol. */
4188 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4190 case COFF_SYMBOL_GLOBAL
:
4191 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4192 #if defined COFF_WITH_PE
4193 /* PE sets the symbol to a value relative to the
4194 start of the section. */
4195 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4197 dst
->symbol
.value
= (src
->u
.syment
.n_value
4198 - dst
->symbol
.section
->vma
);
4200 if (ISFCN ((src
->u
.syment
.n_type
)))
4202 /* A function ext does not go at the end of a
4204 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4208 case COFF_SYMBOL_COMMON
:
4209 dst
->symbol
.section
= bfd_com_section_ptr
;
4210 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4213 case COFF_SYMBOL_UNDEFINED
:
4214 dst
->symbol
.section
= bfd_und_section_ptr
;
4215 dst
->symbol
.value
= 0;
4218 case COFF_SYMBOL_PE_SECTION
:
4219 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4220 dst
->symbol
.value
= 0;
4223 case COFF_SYMBOL_LOCAL
:
4224 dst
->symbol
.flags
= BSF_LOCAL
;
4225 #if defined COFF_WITH_PE
4226 /* PE sets the symbol to a value relative to the
4227 start of the section. */
4228 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4230 dst
->symbol
.value
= (src
->u
.syment
.n_value
4231 - dst
->symbol
.section
->vma
);
4233 if (ISFCN ((src
->u
.syment
.n_type
)))
4234 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4239 /* A symbol with a csect entry should not go at the end. */
4240 if (src
->u
.syment
.n_numaux
> 0)
4241 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4245 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4246 dst
->symbol
.flags
= BSF_WEAK
;
4247 if (src
->u
.syment
.n_sclass
== C_SECTION
4248 && src
->u
.syment
.n_scnum
> 0)
4250 dst
->symbol
.flags
= BSF_LOCAL
;
4254 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
)
4255 dst
->symbol
.flags
= BSF_WEAK
;
4259 case C_STAT
: /* static */
4261 case C_LEAFSTAT
: /* static leaf procedure */
4264 case C_THUMBSTAT
: /* Thumb static */
4265 case C_THUMBLABEL
: /* Thumb label */
4266 case C_THUMBSTATFUNC
:/* Thumb static function */
4268 case C_LABEL
: /* label */
4269 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4270 dst
->symbol
.flags
= BSF_DEBUGGING
;
4272 dst
->symbol
.flags
= BSF_LOCAL
;
4274 /* Base the value as an index from the base of the
4275 section, if there is one. */
4276 if (dst
->symbol
.section
)
4278 #if defined COFF_WITH_PE
4279 /* PE sets the symbol to a value relative to the
4280 start of the section. */
4281 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4283 dst
->symbol
.value
= (src
->u
.syment
.n_value
4284 - dst
->symbol
.section
->vma
);
4288 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4291 case C_MOS
: /* member of structure */
4292 case C_EOS
: /* end of structure */
4293 #ifdef NOTDEF /* C_AUTOARG has the same value */
4295 case C_GLBLREG
: /* A29k-specific storage class */
4298 case C_REGPARM
: /* register parameter */
4299 case C_REG
: /* register variable */
4300 /* C_AUTOARG conflictes with TI COFF C_UEXT */
4301 #if !defined (TIC80COFF) && !defined (TICOFF)
4303 case C_AUTOARG
: /* 960-specific storage class */
4306 case C_TPDEF
: /* type definition */
4308 case C_AUTO
: /* automatic variable */
4309 case C_FIELD
: /* bit field */
4310 case C_ENTAG
: /* enumeration tag */
4311 case C_MOE
: /* member of enumeration */
4312 case C_MOU
: /* member of union */
4313 case C_UNTAG
: /* union tag */
4314 dst
->symbol
.flags
= BSF_DEBUGGING
;
4315 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4318 case C_FILE
: /* file name */
4319 case C_STRTAG
: /* structure tag */
4334 dst
->symbol
.flags
= BSF_DEBUGGING
;
4335 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4339 case C_BINCL
: /* beginning of include file */
4340 case C_EINCL
: /* ending of include file */
4341 /* The value is actually a pointer into the line numbers
4342 of the file. We locate the line number entry, and
4343 set the section to the section which contains it, and
4344 the value to the index in that section. */
4348 dst
->symbol
.flags
= BSF_DEBUGGING
;
4349 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4350 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4351 && ((file_ptr
) (sec
->line_filepos
4352 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4353 > (file_ptr
) src
->u
.syment
.n_value
))
4356 dst
->symbol
.value
= 0;
4359 dst
->symbol
.section
= sec
;
4360 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4361 - sec
->line_filepos
)
4362 / bfd_coff_linesz (abfd
));
4369 dst
->symbol
.flags
= BSF_DEBUGGING
;
4371 /* The value is actually a symbol index. Save a pointer
4372 to the symbol instead of the index. FIXME: This
4373 should use a union. */
4374 src
->u
.syment
.n_value
=
4375 (long) (native_symbols
+ src
->u
.syment
.n_value
);
4376 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4381 case C_BLOCK
: /* ".bb" or ".eb" */
4382 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf") */
4383 case C_EFCN
: /* physical end of function */
4384 #if defined COFF_WITH_PE
4385 /* PE sets the symbol to a value relative to the start
4387 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4388 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4390 /* PE uses funny values for .ef and .lf; don't
4392 dst
->symbol
.flags
= BSF_DEBUGGING
;
4395 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4397 /* Base the value as an index from the base of the
4399 dst
->symbol
.flags
= BSF_LOCAL
;
4400 dst
->symbol
.value
= (src
->u
.syment
.n_value
4401 - dst
->symbol
.section
->vma
);
4405 case C_STATLAB
: /* Static load time label */
4406 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4407 dst
->symbol
.flags
= BSF_GLOBAL
;
4411 /* PE DLLs sometimes have zeroed out symbols for some
4412 reason. Just ignore them without a warning. */
4413 if (src
->u
.syment
.n_type
== 0
4414 && src
->u
.syment
.n_value
== 0
4415 && src
->u
.syment
.n_scnum
== 0)
4418 case C_EXTDEF
: /* external definition */
4419 case C_ULABEL
: /* undefined label */
4420 case C_USTATIC
: /* undefined static */
4421 #ifndef COFF_WITH_PE
4422 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4423 class to represent a section symbol */
4424 case C_LINE
: /* line # reformatted as symbol table entry */
4425 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4426 case C_ALIAS
: /* duplicate tag */
4428 /* New storage classes for TI COFF */
4429 #if defined(TIC80COFF) || defined(TICOFF)
4430 case C_UEXT
: /* Tentative external definition */
4432 case C_EXTLAB
: /* External load time label */
4433 case C_HIDDEN
: /* ext symbol in dmert public lib */
4435 (*_bfd_error_handler
)
4436 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
4437 bfd_get_filename (abfd
), src
->u
.syment
.n_sclass
,
4438 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4439 dst
->symbol
.flags
= BSF_DEBUGGING
;
4440 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4444 /* BFD_ASSERT(dst->symbol.flags != 0);*/
4448 dst
->symbol
.udata
.i
= 0;
4449 dst
->lineno
= (alent
*) NULL
;
4450 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
4452 number_of_symbols
++;
4453 } /* walk the native symtab */
4454 } /* bfdize the native symtab */
4456 obj_symbols (abfd
) = cached_area
;
4457 obj_raw_syments (abfd
) = native_symbols
;
4459 bfd_get_symcount (abfd
) = number_of_symbols
;
4460 obj_convert (abfd
) = table_ptr
;
4461 /* Slurp the line tables for each section too */
4467 coff_slurp_line_table (abfd
, p
);
4472 } /* coff_slurp_symbol_table() */
4474 /* Classify a COFF symbol. A couple of targets have globally visible
4475 symbols which are not class C_EXT, and this handles those. It also
4476 recognizes some special PE cases. */
4478 static enum coff_symbol_classification
4479 coff_classify_symbol (abfd
, syment
)
4481 struct internal_syment
*syment
;
4483 /* FIXME: This partially duplicates the switch in
4484 coff_slurp_symbol_table. */
4485 switch (syment
->n_sclass
)
4494 case C_THUMBEXTFUNC
:
4502 if (syment
->n_scnum
== 0)
4504 if (syment
->n_value
== 0)
4505 return COFF_SYMBOL_UNDEFINED
;
4507 return COFF_SYMBOL_COMMON
;
4509 return COFF_SYMBOL_GLOBAL
;
4516 if (syment
->n_sclass
== C_STAT
)
4518 if (syment
->n_scnum
== 0)
4520 /* The Microsoft compiler sometimes generates these if a
4521 small static function is inlined every time it is used.
4522 The function is discarded, but the symbol table entry
4524 return COFF_SYMBOL_LOCAL
;
4527 #ifdef STRICT_PE_FORMAT
4528 /* This is correct for Microsoft generated objects, but it
4529 breaks gas generated objects. */
4531 if (syment
->n_value
== 0)
4534 char buf
[SYMNMLEN
+ 1];
4536 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
4538 && (strcmp (bfd_get_section_name (abfd
, sec
),
4539 _bfd_coff_internal_syment_name (abfd
, syment
, buf
))
4541 return COFF_SYMBOL_PE_SECTION
;
4545 return COFF_SYMBOL_LOCAL
;
4548 if (syment
->n_sclass
== C_SECTION
)
4550 /* In some cases in a DLL generated by the Microsoft linker, the
4551 n_value field will contain garbage. FIXME: This should
4552 probably be handled by the swapping function instead. */
4553 syment
->n_value
= 0;
4554 if (syment
->n_scnum
== 0)
4555 return COFF_SYMBOL_UNDEFINED
;
4556 return COFF_SYMBOL_PE_SECTION
;
4558 #endif /* COFF_WITH_PE */
4560 /* If it is not a global symbol, we presume it is a local symbol. */
4562 if (syment
->n_scnum
== 0)
4564 char buf
[SYMNMLEN
+ 1];
4566 (*_bfd_error_handler
)
4567 (_("warning: %s: local symbol `%s' has no section"),
4568 bfd_get_filename (abfd
),
4569 _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
4572 return COFF_SYMBOL_LOCAL
;
4579 Coff relocations are easily transformed into the internal BFD form
4582 Reading a coff relocation table is done in the following stages:
4584 o Read the entire coff relocation table into memory.
4586 o Process each relocation in turn; first swap it from the
4587 external to the internal form.
4589 o Turn the symbol referenced in the relocation's symbol index
4590 into a pointer into the canonical symbol table.
4591 This table is the same as the one returned by a call to
4592 @code{bfd_canonicalize_symtab}. The back end will call that
4593 routine and save the result if a canonicalization hasn't been done.
4595 o The reloc index is turned into a pointer to a howto
4596 structure, in a back end specific way. For instance, the 386
4597 and 960 use the @code{r_type} to directly produce an index
4598 into a howto table vector; the 88k subtracts a number from the
4599 @code{r_type} field and creates an addend field.
4605 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
4607 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
4608 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
4609 coffsym = (obj_symbols (abfd) \
4610 + (cache_ptr->sym_ptr_ptr - symbols)); \
4612 coffsym = coff_symbol_from (abfd, ptr); \
4613 if (coffsym != (coff_symbol_type *) NULL \
4614 && coffsym->native->u.syment.n_scnum == 0) \
4615 cache_ptr->addend = 0; \
4616 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
4617 && ptr->section != (asection *) NULL) \
4618 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
4620 cache_ptr->addend = 0; \
4625 coff_slurp_reloc_table (abfd
, asect
, symbols
)
4630 RELOC
*native_relocs
;
4631 arelent
*reloc_cache
;
4636 if (asect
->relocation
)
4638 if (asect
->reloc_count
== 0)
4640 if (asect
->flags
& SEC_CONSTRUCTOR
)
4642 if (!coff_slurp_symbol_table (abfd
))
4645 (RELOC
*) buy_and_read (abfd
,
4648 (size_t) (bfd_coff_relsz (abfd
) *
4649 asect
->reloc_count
));
4650 reloc_cache
= (arelent
*)
4651 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
4653 if (reloc_cache
== NULL
)
4657 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
4659 struct internal_reloc dst
;
4660 struct external_reloc
*src
;
4661 #ifndef RELOC_PROCESSING
4665 cache_ptr
= reloc_cache
+ idx
;
4666 src
= native_relocs
+ idx
;
4668 coff_swap_reloc_in (abfd
, src
, &dst
);
4670 #ifdef RELOC_PROCESSING
4671 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
4673 cache_ptr
->address
= dst
.r_vaddr
;
4675 if (dst
.r_symndx
!= -1)
4677 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
4679 (*_bfd_error_handler
)
4680 (_("%s: warning: illegal symbol index %ld in relocs"),
4681 bfd_get_filename (abfd
), dst
.r_symndx
);
4682 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
4687 cache_ptr
->sym_ptr_ptr
= (symbols
4688 + obj_convert (abfd
)[dst
.r_symndx
]);
4689 ptr
= *(cache_ptr
->sym_ptr_ptr
);
4694 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
4698 /* The symbols definitions that we have read in have been
4699 relocated as if their sections started at 0. But the offsets
4700 refering to the symbols in the raw data have not been
4701 modified, so we have to have a negative addend to compensate.
4703 Note that symbols which used to be common must be left alone */
4705 /* Calculate any reloc addend by looking at the symbol */
4706 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
4708 cache_ptr
->address
-= asect
->vma
;
4709 /* !! cache_ptr->section = (asection *) NULL;*/
4711 /* Fill in the cache_ptr->howto field from dst.r_type */
4712 RTYPE2HOWTO (cache_ptr
, &dst
);
4713 #endif /* RELOC_PROCESSING */
4715 if (cache_ptr
->howto
== NULL
)
4717 (*_bfd_error_handler
)
4718 (_("%s: illegal relocation type %d at address 0x%lx"),
4719 bfd_get_filename (abfd
), dst
.r_type
, (long) dst
.r_vaddr
);
4720 bfd_set_error (bfd_error_bad_value
);
4725 asect
->relocation
= reloc_cache
;
4729 #ifndef coff_rtype_to_howto
4732 /* Get the howto structure for a reloc. This is only used if the file
4733 including this one defines coff_relocate_section to be
4734 _bfd_coff_generic_relocate_section, so it is OK if it does not
4735 always work. It is the responsibility of the including file to
4736 make sure it is reasonable if it is needed. */
4738 static reloc_howto_type
*coff_rtype_to_howto
4739 PARAMS ((bfd
*, asection
*, struct internal_reloc
*,
4740 struct coff_link_hash_entry
*, struct internal_syment
*,
4744 static reloc_howto_type
*
4745 coff_rtype_to_howto (abfd
, sec
, rel
, h
, sym
, addendp
)
4746 bfd
*abfd ATTRIBUTE_UNUSED
;
4747 asection
*sec ATTRIBUTE_UNUSED
;
4748 struct internal_reloc
*rel
;
4749 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
;
4750 struct internal_syment
*sym ATTRIBUTE_UNUSED
;
4751 bfd_vma
*addendp ATTRIBUTE_UNUSED
;
4755 RTYPE2HOWTO (&genrel
, rel
);
4756 return genrel
.howto
;
4759 #else /* ! defined (RTYPE2HOWTO) */
4761 #define coff_rtype_to_howto NULL
4763 #endif /* ! defined (RTYPE2HOWTO) */
4764 #endif /* ! defined (coff_rtype_to_howto) */
4766 /* This is stupid. This function should be a boolean predicate. */
4768 coff_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
4774 arelent
*tblptr
= section
->relocation
;
4775 unsigned int count
= 0;
4778 if (section
->flags
& SEC_CONSTRUCTOR
)
4780 /* this section has relocs made up by us, they are not in the
4781 file, so take them out of their chain and place them into
4782 the data area provided */
4783 arelent_chain
*chain
= section
->constructor_chain
;
4784 for (count
= 0; count
< section
->reloc_count
; count
++)
4786 *relptr
++ = &chain
->relent
;
4787 chain
= chain
->next
;
4793 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
4796 tblptr
= section
->relocation
;
4798 for (; count
++ < section
->reloc_count
;)
4799 *relptr
++ = tblptr
++;
4804 return section
->reloc_count
;
4809 coff_sym_filepos (abfd
)
4812 return obj_sym_filepos (abfd
);
4816 #ifndef coff_reloc16_estimate
4817 #define coff_reloc16_estimate dummy_reloc16_estimate
4819 static int dummy_reloc16_estimate
4820 PARAMS ((bfd
*, asection
*, arelent
*, unsigned int,
4821 struct bfd_link_info
*));
4824 dummy_reloc16_estimate (abfd
, input_section
, reloc
, shrink
, link_info
)
4825 bfd
*abfd ATTRIBUTE_UNUSED
;
4826 asection
*input_section ATTRIBUTE_UNUSED
;
4827 arelent
*reloc ATTRIBUTE_UNUSED
;
4828 unsigned int shrink ATTRIBUTE_UNUSED
;
4829 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
4837 #ifndef coff_reloc16_extra_cases
4839 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
4841 /* This works even if abort is not declared in any header file. */
4843 static void dummy_reloc16_extra_cases
4844 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*, arelent
*,
4845 bfd_byte
*, unsigned int *, unsigned int *));
4848 dummy_reloc16_extra_cases (abfd
, link_info
, link_order
, reloc
, data
, src_ptr
,
4850 bfd
*abfd ATTRIBUTE_UNUSED
;
4851 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
4852 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
;
4853 arelent
*reloc ATTRIBUTE_UNUSED
;
4854 bfd_byte
*data ATTRIBUTE_UNUSED
;
4855 unsigned int *src_ptr ATTRIBUTE_UNUSED
;
4856 unsigned int *dst_ptr ATTRIBUTE_UNUSED
;
4862 /* If coff_relocate_section is defined, we can use the optimized COFF
4863 backend linker. Otherwise we must continue to use the old linker. */
4864 #ifdef coff_relocate_section
4865 #ifndef coff_bfd_link_hash_table_create
4866 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
4868 #ifndef coff_bfd_link_add_symbols
4869 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
4871 #ifndef coff_bfd_final_link
4872 #define coff_bfd_final_link _bfd_coff_final_link
4874 #else /* ! defined (coff_relocate_section) */
4875 #define coff_relocate_section NULL
4876 #ifndef coff_bfd_link_hash_table_create
4877 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
4879 #ifndef coff_bfd_link_add_symbols
4880 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
4882 #define coff_bfd_final_link _bfd_generic_final_link
4883 #endif /* ! defined (coff_relocate_section) */
4885 #define coff_bfd_link_split_section _bfd_generic_link_split_section
4887 #ifndef coff_start_final_link
4888 #define coff_start_final_link NULL
4891 #ifndef coff_adjust_symndx
4892 #define coff_adjust_symndx NULL
4895 #ifndef coff_link_add_one_symbol
4896 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
4899 #ifndef coff_link_output_has_begun
4901 static boolean coff_link_output_has_begun
4902 PARAMS ((bfd
*, struct coff_final_link_info
*));
4905 coff_link_output_has_begun (abfd
, info
)
4907 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
;
4909 return abfd
->output_has_begun
;
4913 #ifndef coff_final_link_postscript
4915 static boolean coff_final_link_postscript
4916 PARAMS ((bfd
*, struct coff_final_link_info
*));
4919 coff_final_link_postscript (abfd
, pfinfo
)
4920 bfd
* abfd ATTRIBUTE_UNUSED
;
4921 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
;
4927 #ifndef coff_SWAP_aux_in
4928 #define coff_SWAP_aux_in coff_swap_aux_in
4930 #ifndef coff_SWAP_sym_in
4931 #define coff_SWAP_sym_in coff_swap_sym_in
4933 #ifndef coff_SWAP_lineno_in
4934 #define coff_SWAP_lineno_in coff_swap_lineno_in
4936 #ifndef coff_SWAP_aux_out
4937 #define coff_SWAP_aux_out coff_swap_aux_out
4939 #ifndef coff_SWAP_sym_out
4940 #define coff_SWAP_sym_out coff_swap_sym_out
4942 #ifndef coff_SWAP_lineno_out
4943 #define coff_SWAP_lineno_out coff_swap_lineno_out
4945 #ifndef coff_SWAP_reloc_out
4946 #define coff_SWAP_reloc_out coff_swap_reloc_out
4948 #ifndef coff_SWAP_filehdr_out
4949 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
4951 #ifndef coff_SWAP_aouthdr_out
4952 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
4954 #ifndef coff_SWAP_scnhdr_out
4955 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
4957 #ifndef coff_SWAP_reloc_in
4958 #define coff_SWAP_reloc_in coff_swap_reloc_in
4960 #ifndef coff_SWAP_filehdr_in
4961 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
4963 #ifndef coff_SWAP_aouthdr_in
4964 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
4966 #ifndef coff_SWAP_scnhdr_in
4967 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
4970 static const bfd_coff_backend_data bfd_coff_std_swap_table
=
4972 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
4973 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
4974 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
4975 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
4976 coff_SWAP_scnhdr_out
,
4977 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
4978 #ifdef COFF_LONG_FILENAMES
4983 #ifdef COFF_LONG_SECTION_NAMES
4988 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
4989 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
4990 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
4991 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
4992 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
4993 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
4994 coff_classify_symbol
, coff_compute_section_file_positions
,
4995 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
4996 coff_adjust_symndx
, coff_link_add_one_symbol
,
4997 coff_link_output_has_begun
, coff_final_link_postscript
5000 #ifndef coff_close_and_cleanup
5001 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5004 #ifndef coff_bfd_free_cached_info
5005 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5008 #ifndef coff_get_section_contents
5009 #define coff_get_section_contents _bfd_generic_get_section_contents
5012 #ifndef coff_bfd_copy_private_symbol_data
5013 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5016 #ifndef coff_bfd_copy_private_section_data
5017 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5020 #ifndef coff_bfd_copy_private_bfd_data
5021 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5024 #ifndef coff_bfd_merge_private_bfd_data
5025 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5028 #ifndef coff_bfd_set_private_flags
5029 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5032 #ifndef coff_bfd_print_private_bfd_data
5033 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5036 #ifndef coff_bfd_is_local_label_name
5037 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5040 #ifndef coff_read_minisymbols
5041 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5044 #ifndef coff_minisymbol_to_symbol
5045 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5048 /* The reloc lookup routine must be supplied by each individual COFF
5050 #ifndef coff_bfd_reloc_type_lookup
5051 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5054 #ifndef coff_bfd_get_relocated_section_contents
5055 #define coff_bfd_get_relocated_section_contents \
5056 bfd_generic_get_relocated_section_contents
5059 #ifndef coff_bfd_relax_section
5060 #define coff_bfd_relax_section bfd_generic_relax_section
5063 #ifndef coff_bfd_gc_sections
5064 #define coff_bfd_gc_sections bfd_generic_gc_sections
5067 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
5068 const bfd_target VAR = \
5071 bfd_target_coff_flavour, \
5072 BFD_ENDIAN_BIG, /* data byte order is big */ \
5073 BFD_ENDIAN_BIG, /* header byte order is big */ \
5074 /* object flags */ \
5075 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5076 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5077 /* section flags */ \
5078 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5079 UNDER, /* leading symbol underscore */ \
5080 '/', /* ar_pad_char */ \
5081 15, /* ar_max_namelen */ \
5083 /* Data conversion functions. */ \
5084 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5085 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5086 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5088 /* Header conversion functions. */ \
5089 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5090 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5091 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5093 /* bfd_check_format */ \
5094 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5095 _bfd_dummy_target }, \
5096 /* bfd_set_format */ \
5097 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5098 /* bfd_write_contents */ \
5099 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5102 BFD_JUMP_TABLE_GENERIC (coff), \
5103 BFD_JUMP_TABLE_COPY (coff), \
5104 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5105 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5106 BFD_JUMP_TABLE_SYMBOLS (coff), \
5107 BFD_JUMP_TABLE_RELOCS (coff), \
5108 BFD_JUMP_TABLE_WRITE (coff), \
5109 BFD_JUMP_TABLE_LINK (coff), \
5110 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5117 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
5118 const bfd_target VAR = \
5121 bfd_target_coff_flavour, \
5122 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
5123 BFD_ENDIAN_LITTLE, /* header byte order is little */ \
5124 /* object flags */ \
5125 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5126 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5127 /* section flags */ \
5128 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5129 UNDER, /* leading symbol underscore */ \
5130 '/', /* ar_pad_char */ \
5131 15, /* ar_max_namelen */ \
5133 /* Data conversion functions. */ \
5134 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5135 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5136 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5137 /* Header conversion functions. */ \
5138 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5139 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5140 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5141 /* bfd_check_format */ \
5142 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5143 _bfd_dummy_target }, \
5144 /* bfd_set_format */ \
5145 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5146 /* bfd_write_contents */ \
5147 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5150 BFD_JUMP_TABLE_GENERIC (coff), \
5151 BFD_JUMP_TABLE_COPY (coff), \
5152 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5153 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5154 BFD_JUMP_TABLE_SYMBOLS (coff), \
5155 BFD_JUMP_TABLE_RELOCS (coff), \
5156 BFD_JUMP_TABLE_WRITE (coff), \
5157 BFD_JUMP_TABLE_LINK (coff), \
5158 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \