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 styp_flags
= STYP_INFO
;
404 else if (!strcmp (sec_name
, _PAD
))
406 styp_flags
= STYP_PAD
;
408 else if (!strcmp (sec_name
, _LOADER
))
410 styp_flags
= STYP_LOADER
;
413 /* Try and figure out what it should be */
414 else if (sec_flags
& SEC_CODE
)
416 styp_flags
= STYP_TEXT
;
418 else if (sec_flags
& SEC_DATA
)
420 styp_flags
= STYP_DATA
;
422 else if (sec_flags
& SEC_READONLY
)
424 #ifdef STYP_LIT /* 29k readonly text/data section */
425 styp_flags
= STYP_LIT
;
427 styp_flags
= STYP_TEXT
;
428 #endif /* STYP_LIT */
430 else if (sec_flags
& SEC_LOAD
)
432 styp_flags
= STYP_TEXT
;
434 else if (sec_flags
& SEC_ALLOC
)
436 styp_flags
= STYP_BSS
;
440 if (sec_flags
& SEC_CLINK
)
441 styp_flags
|= STYP_CLINK
;
445 if (sec_flags
& SEC_BLOCK
)
446 styp_flags
|= STYP_BLOCK
;
450 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
451 styp_flags
|= STYP_NOLOAD
;
457 #else /* COFF_WITH_PE */
459 /* The PE version; see above for the general comments. The non-PE
460 case seems to be more guessing, and breaks PE format; specifically,
461 .rdata is readonly, but it sure ain't text. Really, all this
462 should be set up properly in gas (or whatever assembler is in use),
463 and honor whatever objcopy/strip, etc. sent us as input. */
466 sec_to_styp_flags (sec_name
, sec_flags
)
467 const char *sec_name ATTRIBUTE_UNUSED
;
472 /* caution: there are at least three groups of symbols that have
473 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
474 SEC_* are the BFD internal flags, used for generic BFD
475 information. STYP_* are the COFF section flags which appear in
476 COFF files. IMAGE_SCN_* are the PE section flags which appear in
477 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
478 but there are more IMAGE_SCN_* flags. */
483 if ((sec_flags
& SEC_CODE
) != 0)
484 styp_flags
|= IMAGE_SCN_CNT_CODE
;
485 if ((sec_flags
& SEC_DATA
) != 0)
486 styp_flags
|= IMAGE_SCN_CNT_INITIALIZED_DATA
;
487 if ((sec_flags
& SEC_ALLOC
) != 0 && (sec_flags
& SEC_LOAD
) == 0)
488 styp_flags
|= IMAGE_SCN_CNT_UNINITIALIZED_DATA
; /* ==STYP_BSS */
490 /* skip CONSTRUCTOR */
493 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
494 styp_flags
|= STYP_NOLOAD
;
496 if ((sec_flags
& SEC_IS_COMMON
) != 0)
497 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
498 if ((sec_flags
& SEC_DEBUGGING
) != 0)
499 styp_flags
|= IMAGE_SCN_MEM_DISCARDABLE
;
500 if ((sec_flags
& SEC_EXCLUDE
) != 0)
501 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
502 if ((sec_flags
& SEC_NEVER_LOAD
) != 0)
503 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
506 if (sec_flags
& SEC_LINK_ONCE
)
507 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
508 /* skip LINK_DUPLICATES */
509 /* skip LINKER_CREATED */
511 /* For now, the read/write bits are mapped onto SEC_READONLY, even
512 though the semantics don't quite match. The bits from the input
513 are retained in pei_section_data(abfd, section)->pe_flags */
515 styp_flags
|= IMAGE_SCN_MEM_READ
; /* always readable. */
516 if ((sec_flags
& SEC_READONLY
) == 0)
517 styp_flags
|= IMAGE_SCN_MEM_WRITE
; /* Invert READONLY for write */
518 if (sec_flags
& SEC_CODE
)
519 styp_flags
|= IMAGE_SCN_MEM_EXECUTE
; /* CODE->EXECUTE */
520 if (sec_flags
& SEC_SHARED
)
521 styp_flags
|= IMAGE_SCN_MEM_SHARED
; /* Shared remains meaningful */
526 #endif /* COFF_WITH_PE */
528 /* Return a word with SEC_* flags set to represent the incoming STYP_*
529 flags (from scnhdr.s_flags). The inverse of this function is
530 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
531 should probably mirror the changes in sec_to_styp_flags(). */
536 styp_to_sec_flags (abfd
, hdr
, name
, section
)
537 bfd
*abfd ATTRIBUTE_UNUSED
;
540 asection
*section ATTRIBUTE_UNUSED
;
542 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
543 long styp_flags
= internal_s
->s_flags
;
544 flagword sec_flags
= 0;
547 if (styp_flags
& STYP_BLOCK
)
548 sec_flags
|= SEC_BLOCK
;
552 if (styp_flags
& STYP_CLINK
)
553 sec_flags
|= SEC_CLINK
;
557 if (styp_flags
& STYP_NOLOAD
)
559 sec_flags
|= SEC_NEVER_LOAD
;
561 #endif /* STYP_NOLOAD */
563 /* For 386 COFF, at least, an unloadable text or data section is
564 actually a shared library section. */
565 if (styp_flags
& STYP_TEXT
)
567 if (sec_flags
& SEC_NEVER_LOAD
)
568 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
570 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
572 else if (styp_flags
& STYP_DATA
)
574 if (sec_flags
& SEC_NEVER_LOAD
)
575 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
577 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
579 else if (styp_flags
& STYP_BSS
)
581 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
582 if (sec_flags
& SEC_NEVER_LOAD
)
583 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
586 sec_flags
|= SEC_ALLOC
;
588 else if (styp_flags
& STYP_INFO
)
590 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
591 defined. coff_compute_section_file_positions uses
592 COFF_PAGE_SIZE to ensure that the low order bits of the
593 section VMA and the file offset match. If we don't know
594 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
595 and demand page loading of the file will fail. */
596 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
597 sec_flags
|= SEC_DEBUGGING
;
600 else if (styp_flags
& STYP_PAD
)
604 else if (strcmp (name
, _TEXT
) == 0)
606 if (sec_flags
& SEC_NEVER_LOAD
)
607 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
609 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
611 else if (strcmp (name
, _DATA
) == 0)
613 if (sec_flags
& SEC_NEVER_LOAD
)
614 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
616 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
618 else if (strcmp (name
, _BSS
) == 0)
620 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
621 if (sec_flags
& SEC_NEVER_LOAD
)
622 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
625 sec_flags
|= SEC_ALLOC
;
627 else if (strcmp (name
, ".debug") == 0
629 || strcmp (name
, _COMMENT
) == 0
631 || strncmp (name
, ".stab", 5) == 0)
633 #ifdef COFF_PAGE_SIZE
634 sec_flags
|= SEC_DEBUGGING
;
638 else if (strcmp (name
, _LIB
) == 0)
642 else if (strcmp (name
, _LIT
) == 0)
644 sec_flags
= SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
649 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
652 #ifdef STYP_LIT /* A29k readonly text/data section type */
653 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
655 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
657 #endif /* STYP_LIT */
658 #ifdef STYP_OTHER_LOAD /* Other loaded sections */
659 if (styp_flags
& STYP_OTHER_LOAD
)
661 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
663 #endif /* STYP_SDATA */
665 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
666 /* As a GNU extension, if the name begins with .gnu.linkonce, we
667 only link a single copy of the section. This is used to support
668 g++. g++ will emit each template expansion in its own section.
669 The symbols will be defined as weak, so that multiple definitions
670 are permitted. The GNU linker extension is to actually discard
671 all but one of the sections. */
672 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
673 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
679 #else /* COFF_WITH_PE */
681 /* The PE version; see above for the general comments.
683 Since to set the SEC_LINK_ONCE and associated flags, we have to
684 look at the symbol table anyway, we return the symbol table index
685 of the symbol being used as the COMDAT symbol. This is admittedly
686 ugly, but there's really nowhere else that we have access to the
687 required information. FIXME: Is the COMDAT symbol index used for
688 any purpose other than objdump? */
691 styp_to_sec_flags (abfd
, hdr
, name
, section
)
692 bfd
*abfd ATTRIBUTE_UNUSED
;
697 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
698 long styp_flags
= internal_s
->s_flags
;
699 flagword sec_flags
= 0;
701 if (styp_flags
& STYP_DSECT
)
702 abort (); /* Don't know what to do */
703 #ifdef SEC_NEVER_LOAD
704 if (styp_flags
& STYP_NOLOAD
)
705 sec_flags
|= SEC_NEVER_LOAD
;
707 if (styp_flags
& STYP_GROUP
)
708 abort (); /* Don't know what to do */
709 /* skip IMAGE_SCN_TYPE_NO_PAD */
710 if (styp_flags
& STYP_COPY
)
711 abort (); /* Don't know what to do */
712 if (styp_flags
& IMAGE_SCN_CNT_CODE
)
713 sec_flags
|= SEC_CODE
| SEC_ALLOC
| SEC_LOAD
;
714 if (styp_flags
& IMAGE_SCN_CNT_INITIALIZED_DATA
)
715 sec_flags
|= SEC_DATA
| SEC_ALLOC
| SEC_LOAD
;
716 if (styp_flags
& IMAGE_SCN_CNT_UNINITIALIZED_DATA
)
717 sec_flags
|= SEC_ALLOC
;
718 if (styp_flags
& IMAGE_SCN_LNK_OTHER
)
719 abort (); /* Don't know what to do */
720 if (styp_flags
& IMAGE_SCN_LNK_INFO
)
722 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
723 defined. coff_compute_section_file_positions uses
724 COFF_PAGE_SIZE to ensure that the low order bits of the
725 section VMA and the file offset match. If we don't know
726 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
727 and demand page loading of the file will fail. */
728 #ifdef COFF_PAGE_SIZE
729 sec_flags
|= SEC_DEBUGGING
;
732 if (styp_flags
& STYP_OVER
)
733 abort (); /* Don't know what to do */
734 if (styp_flags
& IMAGE_SCN_LNK_REMOVE
)
735 sec_flags
|= SEC_EXCLUDE
;
737 if (styp_flags
& IMAGE_SCN_MEM_SHARED
)
738 sec_flags
|= SEC_SHARED
;
739 /* COMDAT: see below */
740 if (styp_flags
& IMAGE_SCN_MEM_DISCARDABLE
)
741 sec_flags
|= SEC_DEBUGGING
;
742 if (styp_flags
& IMAGE_SCN_MEM_NOT_CACHED
)
743 abort ();/* Don't know what to do */
744 if (styp_flags
& IMAGE_SCN_MEM_NOT_PAGED
)
745 abort (); /* Don't know what to do */
747 /* We infer from the distinct read/write/execute bits the settings
748 of some of the bfd flags; the actual values, should we need them,
749 are also in pei_section_data (abfd, section)->pe_flags. */
751 if (styp_flags
& IMAGE_SCN_MEM_EXECUTE
)
752 sec_flags
|= SEC_CODE
; /* Probably redundant */
753 /* IMAGE_SCN_MEM_READ is simply ignored, assuming it always to be true. */
754 if ((styp_flags
& IMAGE_SCN_MEM_WRITE
) == 0)
755 sec_flags
|= SEC_READONLY
;
757 /* COMDAT gets very special treatment. */
758 if (styp_flags
& IMAGE_SCN_LNK_COMDAT
)
760 sec_flags
|= SEC_LINK_ONCE
;
762 /* Unfortunately, the PE format stores essential information in
763 the symbol table, of all places. We need to extract that
764 information now, so that objdump and the linker will know how
765 to handle the section without worrying about the symbols. We
766 can't call slurp_symtab, because the linker doesn't want the
769 /* COMDAT sections are special. The first symbol is the section
770 symbol, which tells what kind of COMDAT section it is. The
771 second symbol is the "comdat symbol" - the one with the
772 unique name. GNU uses the section symbol for the unique
773 name; MS uses ".text" for every comdat section. Sigh. - DJ */
775 /* This is not mirrored in sec_to_styp_flags(), but there
776 doesn't seem to be a need to, either, and it would at best be
779 if (_bfd_coff_get_external_symbols (abfd
))
781 bfd_byte
*esymstart
, *esym
, *esymend
;
783 char *target_name
= NULL
;
785 esymstart
= esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
786 esymend
= esym
+ obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
788 while (esym
< esymend
)
790 struct internal_syment isym
;
791 char buf
[SYMNMLEN
+ 1];
794 bfd_coff_swap_sym_in (abfd
, (PTR
) esym
, (PTR
) &isym
);
796 if (sizeof (internal_s
->s_name
) > SYMNMLEN
)
798 /* This case implies that the matching symbol name
799 will be in the string table. */
803 if (isym
.n_scnum
== section
->target_index
)
805 /* According to the MSVC documentation, the first
806 TWO entries with the section # are both of
807 interest to us. The first one is the "section
808 symbol" (section name). The second is the comdat
809 symbol name. Here, we've found the first
810 qualifying entry; we distinguish it from the
811 second with a state flag.
813 In the case of gas-generated (at least until that
814 is fixed) .o files, it isn't necessarily the
815 second one. It may be some other later symbol.
817 Since gas also doesn't follow MS conventions and
818 emits the section similar to .text$<name>, where
819 <something> is the name we're looking for, we
820 distinguish the two as follows:
822 If the section name is simply a section name (no
823 $) we presume it's MS-generated, and look at
824 precisely the second symbol for the comdat name.
825 If the section name has a $, we assume it's
826 gas-generated, and look for <something> (whatever
827 follows the $) as the comdat symbol. */
829 /* All 3 branches use this */
830 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
, buf
);
839 /* The first time we've seen the symbol. */
840 union internal_auxent aux
;
844 /* If it isn't the stuff we're expecting, die;
845 The MS documentation is vague, but it
846 appears that the second entry serves BOTH
847 as the comdat symbol and the defining
848 symbol record (either C_STAT or C_EXT,
849 possibly with an aux entry with debug
850 information if it's a function.) It
851 appears the only way to find the second one
852 is to count. (On Intel, they appear to be
853 adjacent, but on Alpha, they have been
856 Here, we think we've found the first one,
857 but there's some checking we can do to be
860 if (! (isym
.n_sclass
== C_STAT
861 && isym
.n_type
== T_NULL
862 && isym
.n_value
== 0))
865 /* FIXME LATER: MSVC generates section names
866 like .text for comdats. Gas generates
867 names like .text$foo__Fv (in the case of a
868 function). See comment above for more. */
870 if (strcmp (name
, symname
) != 0)
873 /* This is the section symbol. */
875 bfd_coff_swap_aux_in (abfd
, (PTR
) (esym
+ bfd_coff_symesz (abfd
)),
876 isym
.n_type
, isym
.n_sclass
,
877 0, isym
.n_numaux
, (PTR
) &aux
);
879 target_name
= strchr (name
, '$');
880 if (target_name
!= NULL
)
888 /* FIXME: Microsoft uses NODUPLICATES and
889 ASSOCIATIVE, but gnu uses ANY and
890 SAME_SIZE. Unfortunately, gnu doesn't do
891 the comdat symbols right. So, until we can
892 fix it to do the right thing, we are
893 temporarily disabling comdats for the MS
894 types (they're used in DLLs and C++, but we
895 don't support *their* C++ libraries anyway
898 /* Cygwin does not follow the MS style, and
899 uses ANY and SAME_SIZE where NODUPLICATES
900 and ASSOCIATIVE should be used. For
901 Interix, we just do the right thing up
904 switch (aux
.x_scn
.x_comdat
)
906 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
907 #ifdef STRICT_PE_FORMAT
908 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
910 sec_flags
&= ~SEC_LINK_ONCE
;
914 case IMAGE_COMDAT_SELECT_ANY
:
915 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
918 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
919 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
922 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
923 /* Not yet fully implemented ??? */
924 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
927 /* debug$S gets this case; other
930 /* There may be no symbol... we'll search
931 the whole table... Is this the right
932 place to play this game? Or should we do
933 it when reading it in. */
934 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
935 #ifdef STRICT_PE_FORMAT
936 /* FIXME: This is not currently implemented. */
937 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
939 sec_flags
&= ~SEC_LINK_ONCE
;
943 default: /* 0 means "no symbol" */
944 /* debug$F gets this case; other
946 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
953 /* Gas mode: the first matching on partial name. */
955 #ifndef TARGET_UNDERSCORE
956 #define TARGET_UNDERSCORE 0
958 /* Is this the name we're looking for? */
959 if (strcmp (target_name
,
960 symname
+ (TARGET_UNDERSCORE
? 1 : 0)) != 0)
962 /* Not the name we're looking for */
963 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
968 /* MSVC mode: the lexically second symbol (or
969 drop through from the above). */
973 /* This must the the second symbol with the
974 section #. It is the actual symbol name.
975 Intel puts the two adjacent, but Alpha (at
976 least) spreads them out. */
979 bfd_alloc (abfd
, sizeof (struct bfd_comdat_info
));
980 if (section
->comdat
== NULL
)
982 section
->comdat
->symbol
=
983 (esym
- esymstart
) / bfd_coff_symesz (abfd
);
985 newname
= bfd_alloc (abfd
, strlen (symname
) + 1);
989 strcpy (newname
, symname
);
990 section
->comdat
->name
= newname
;
998 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1004 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1005 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1006 only link a single copy of the section. This is used to support
1007 g++. g++ will emit each template expansion in its own section.
1008 The symbols will be defined as weak, so that multiple definitions
1009 are permitted. The GNU linker extension is to actually discard
1010 all but one of the sections. */
1011 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
1012 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1018 #endif /* COFF_WITH_PE */
1020 #define get_index(symbol) ((symbol)->udata.i)
1024 bfd_coff_backend_data
1028 .{* COFF symbol classifications. *}
1030 .enum coff_symbol_classification
1032 . {* Global symbol. *}
1033 . COFF_SYMBOL_GLOBAL,
1034 . {* Common symbol. *}
1035 . COFF_SYMBOL_COMMON,
1036 . {* Undefined symbol. *}
1037 . COFF_SYMBOL_UNDEFINED,
1038 . {* Local symbol. *}
1039 . COFF_SYMBOL_LOCAL,
1040 . {* PE section symbol. *}
1041 . COFF_SYMBOL_PE_SECTION
1044 Special entry points for gdb to swap in coff symbol table parts:
1047 . void (*_bfd_coff_swap_aux_in) PARAMS ((
1056 . void (*_bfd_coff_swap_sym_in) PARAMS ((
1061 . void (*_bfd_coff_swap_lineno_in) PARAMS ((
1067 Special entry points for gas to swap out coff parts:
1069 . unsigned int (*_bfd_coff_swap_aux_out) PARAMS ((
1078 . unsigned int (*_bfd_coff_swap_sym_out) PARAMS ((
1083 . unsigned int (*_bfd_coff_swap_lineno_out) PARAMS ((
1088 . unsigned int (*_bfd_coff_swap_reloc_out) PARAMS ((
1093 . unsigned int (*_bfd_coff_swap_filehdr_out) PARAMS ((
1098 . unsigned int (*_bfd_coff_swap_aouthdr_out) PARAMS ((
1103 . unsigned int (*_bfd_coff_swap_scnhdr_out) PARAMS ((
1109 Special entry points for generic COFF routines to call target
1110 dependent COFF routines:
1112 . unsigned int _bfd_filhsz;
1113 . unsigned int _bfd_aoutsz;
1114 . unsigned int _bfd_scnhsz;
1115 . unsigned int _bfd_symesz;
1116 . unsigned int _bfd_auxesz;
1117 . unsigned int _bfd_relsz;
1118 . unsigned int _bfd_linesz;
1119 . unsigned int _bfd_filnmlen;
1120 . boolean _bfd_coff_long_filenames;
1121 . boolean _bfd_coff_long_section_names;
1122 . unsigned int _bfd_coff_default_section_alignment_power;
1123 . void (*_bfd_coff_swap_filehdr_in) PARAMS ((
1127 . void (*_bfd_coff_swap_aouthdr_in) PARAMS ((
1131 . void (*_bfd_coff_swap_scnhdr_in) PARAMS ((
1135 . void (*_bfd_coff_swap_reloc_in) PARAMS ((
1139 . boolean (*_bfd_coff_bad_format_hook) PARAMS ((
1141 . PTR internal_filehdr));
1142 . boolean (*_bfd_coff_set_arch_mach_hook) PARAMS ((
1144 . PTR internal_filehdr));
1145 . PTR (*_bfd_coff_mkobject_hook) PARAMS ((
1147 . PTR internal_filehdr,
1148 . PTR internal_aouthdr));
1149 . flagword (*_bfd_styp_to_sec_flags_hook) PARAMS ((
1151 . PTR internal_scnhdr,
1153 . asection *section));
1154 . void (*_bfd_set_alignment_hook) PARAMS ((
1157 . PTR internal_scnhdr));
1158 . boolean (*_bfd_coff_slurp_symbol_table) PARAMS ((
1160 . boolean (*_bfd_coff_symname_in_debug) PARAMS ((
1162 . struct internal_syment *sym));
1163 . boolean (*_bfd_coff_pointerize_aux_hook) PARAMS ((
1165 . combined_entry_type *table_base,
1166 . combined_entry_type *symbol,
1167 . unsigned int indaux,
1168 . combined_entry_type *aux));
1169 . boolean (*_bfd_coff_print_aux) PARAMS ((
1172 . combined_entry_type *table_base,
1173 . combined_entry_type *symbol,
1174 . combined_entry_type *aux,
1175 . unsigned int indaux));
1176 . void (*_bfd_coff_reloc16_extra_cases) PARAMS ((
1178 . struct bfd_link_info *link_info,
1179 . struct bfd_link_order *link_order,
1182 . unsigned int *src_ptr,
1183 . unsigned int *dst_ptr));
1184 . int (*_bfd_coff_reloc16_estimate) PARAMS ((
1186 . asection *input_section,
1188 . unsigned int shrink,
1189 . struct bfd_link_info *link_info));
1190 . enum coff_symbol_classification (*_bfd_coff_classify_symbol) PARAMS ((
1192 . struct internal_syment *));
1193 . boolean (*_bfd_coff_compute_section_file_positions) PARAMS ((
1195 . boolean (*_bfd_coff_start_final_link) PARAMS ((
1197 . struct bfd_link_info *info));
1198 . boolean (*_bfd_coff_relocate_section) PARAMS ((
1200 . struct bfd_link_info *info,
1202 . asection *input_section,
1203 . bfd_byte *contents,
1204 . struct internal_reloc *relocs,
1205 . struct internal_syment *syms,
1206 . asection **sections));
1207 . reloc_howto_type *(*_bfd_coff_rtype_to_howto) PARAMS ((
1210 . struct internal_reloc *rel,
1211 . struct coff_link_hash_entry *h,
1212 . struct internal_syment *sym,
1213 . bfd_vma *addendp));
1214 . boolean (*_bfd_coff_adjust_symndx) PARAMS ((
1216 . struct bfd_link_info *info,
1219 . struct internal_reloc *reloc,
1220 . boolean *adjustedp));
1221 . boolean (*_bfd_coff_link_add_one_symbol) PARAMS ((
1222 . struct bfd_link_info *info,
1226 . asection *section,
1228 . const char *string,
1231 . struct bfd_link_hash_entry **hashp));
1233 . boolean (*_bfd_coff_link_output_has_begun) PARAMS ((
1235 . struct coff_final_link_info * pfinfo));
1236 . boolean (*_bfd_coff_final_link_postscript) PARAMS ((
1238 . struct coff_final_link_info * pfinfo));
1240 .} bfd_coff_backend_data;
1242 .#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1244 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1245 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1247 .#define bfd_coff_swap_sym_in(a,e,i) \
1248 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1250 .#define bfd_coff_swap_lineno_in(a,e,i) \
1251 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1253 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1254 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1256 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1257 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1259 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1260 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1262 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1263 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1265 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1266 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1268 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1269 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1271 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1272 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1274 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1275 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1276 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1277 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1278 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1279 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1280 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1281 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1282 .#define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1283 .#define bfd_coff_long_section_names(abfd) \
1284 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1285 .#define bfd_coff_default_section_alignment_power(abfd) \
1286 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1287 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1288 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1290 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1291 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1293 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1294 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1296 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1297 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1299 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1300 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1302 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1303 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1304 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1305 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
1307 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section)\
1308 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1309 . (abfd, scnhdr, name, section))
1311 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1312 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1314 .#define bfd_coff_slurp_symbol_table(abfd)\
1315 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1317 .#define bfd_coff_symname_in_debug(abfd, sym)\
1318 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1320 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1321 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1322 . (abfd, file, base, symbol, aux, indaux))
1324 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
1325 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1326 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1328 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1329 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1330 . (abfd, section, reloc, shrink, link_info))
1332 .#define bfd_coff_classify_symbol(abfd, sym)\
1333 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1336 .#define bfd_coff_compute_section_file_positions(abfd)\
1337 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1340 .#define bfd_coff_start_final_link(obfd, info)\
1341 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1343 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1344 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1345 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1346 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1347 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1348 . (abfd, sec, rel, h, sym, addendp))
1349 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1350 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1351 . (obfd, info, ibfd, sec, rel, adjustedp))
1352 .#define bfd_coff_link_add_one_symbol(info,abfd,name,flags,section,value,string,cp,coll,hashp)\
1353 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1354 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1356 .#define bfd_coff_link_output_has_begun(a,p) \
1357 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p))
1358 .#define bfd_coff_final_link_postscript(a,p) \
1359 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
1363 /* See whether the magic number matches. */
1366 coff_bad_format_hook (abfd
, filehdr
)
1367 bfd
* abfd ATTRIBUTE_UNUSED
;
1370 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1372 if (BADMAG (*internal_f
))
1375 /* if the optional header is NULL or not the correct size then
1376 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1377 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1378 optional header is of a different size.
1380 But the mips keeps extra stuff in it's opthdr, so dont check
1384 #if defined(M88) || defined(I960)
1385 if (internal_f
->f_opthdr
!= 0 && bfd_coff_aoutsz (abfd
) != internal_f
->f_opthdr
)
1392 /* Check whether this section uses an alignment other than the
1396 coff_set_custom_section_alignment (abfd
, section
, alignment_table
, table_size
)
1397 bfd
*abfd ATTRIBUTE_UNUSED
;
1399 const struct coff_section_alignment_entry
*alignment_table
;
1400 const unsigned int table_size
;
1402 const unsigned int default_alignment
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1405 for (i
= 0; i
< table_size
; ++i
)
1407 const char *secname
= bfd_get_section_name (abfd
, section
);
1408 if (alignment_table
[i
].comparison_length
== (unsigned int) -1
1409 ? strcmp (alignment_table
[i
].name
, secname
) == 0
1410 : strncmp (alignment_table
[i
].name
, secname
,
1411 alignment_table
[i
].comparison_length
) == 0)
1414 if (i
>= table_size
)
1417 if (alignment_table
[i
].default_alignment_min
!= COFF_ALIGNMENT_FIELD_EMPTY
1418 && default_alignment
< alignment_table
[i
].default_alignment_min
)
1421 if (alignment_table
[i
].default_alignment_max
!= COFF_ALIGNMENT_FIELD_EMPTY
1422 && default_alignment
> alignment_table
[i
].default_alignment_max
)
1425 section
->alignment_power
= alignment_table
[i
].alignment_power
;
1428 /* Custom section alignment records. */
1430 static const struct coff_section_alignment_entry
1431 coff_section_alignment_table
[] =
1433 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1434 COFF_SECTION_ALIGNMENT_ENTRIES
,
1436 /* There must not be any gaps between .stabstr sections. */
1437 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1438 1, COFF_ALIGNMENT_FIELD_EMPTY
, 0 },
1439 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1440 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1441 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1442 /* Similarly for the .ctors and .dtors sections. */
1443 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1444 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1445 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1446 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 }
1449 static const unsigned int coff_section_alignment_table_size
=
1450 sizeof coff_section_alignment_table
/ sizeof coff_section_alignment_table
[0];
1452 /* Initialize a section structure with information peculiar to this
1453 particular implementation of COFF. */
1456 coff_new_section_hook (abfd
, section
)
1460 combined_entry_type
*native
;
1462 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1465 if (xcoff_data (abfd
)->text_align_power
!= 0
1466 && strcmp (bfd_get_section_name (abfd
, section
), ".text") == 0)
1467 section
->alignment_power
= xcoff_data (abfd
)->text_align_power
;
1468 if (xcoff_data (abfd
)->data_align_power
!= 0
1469 && strcmp (bfd_get_section_name (abfd
, section
), ".data") == 0)
1470 section
->alignment_power
= xcoff_data (abfd
)->data_align_power
;
1473 /* Allocate aux records for section symbols, to store size and
1476 @@ The 10 is a guess at a plausible maximum number of aux entries
1477 (but shouldn't be a constant). */
1478 native
= ((combined_entry_type
*)
1479 bfd_zalloc (abfd
, sizeof (combined_entry_type
) * 10));
1483 /* We don't need to set up n_name, n_value, or n_scnum in the native
1484 symbol information, since they'll be overriden by the BFD symbol
1485 anyhow. However, we do need to set the type and storage class,
1486 in case this symbol winds up getting written out. The value 0
1487 for n_numaux is already correct. */
1489 native
->u
.syment
.n_type
= T_NULL
;
1490 native
->u
.syment
.n_sclass
= C_STAT
;
1492 coffsymbol (section
->symbol
)->native
= native
;
1494 coff_set_custom_section_alignment (abfd
, section
,
1495 coff_section_alignment_table
,
1496 coff_section_alignment_table_size
);
1501 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1503 /* Set the alignment of a BFD section. */
1505 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1508 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1509 bfd
* abfd ATTRIBUTE_UNUSED
;
1513 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1517 /* Extract ALIGN from 2**ALIGN stored in section header */
1518 for (i
= 0; i
< 32; i
++)
1519 if ((1 << i
) >= hdr
->s_align
)
1523 /* TI tools hijack bits 8-11 for the alignment */
1524 i
= (hdr
->s_flags
>> 8) & 0xF ;
1526 section
->alignment_power
= i
;
1529 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1532 /* a couple of macros to help setting the alignment power field */
1533 #define ALIGN_SET(field,x,y) \
1534 if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1536 section->alignment_power = y;\
1539 #define ELIFALIGN_SET(field,x,y) \
1540 else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1542 section->alignment_power = y;\
1545 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1548 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1549 bfd
* abfd ATTRIBUTE_UNUSED
;
1553 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1555 ALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_64BYTES
, 6)
1556 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_32BYTES
, 5)
1557 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_16BYTES
, 4)
1558 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_8BYTES
, 3)
1559 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_4BYTES
, 2)
1560 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_2BYTES
, 1)
1561 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_1BYTES
, 0)
1563 /* In a PE image file, the s_paddr field holds the virtual size of a
1564 section, while the s_size field holds the raw size. We also keep
1565 the original section flag value, since not every bit can be
1566 mapped onto a generic BFD section bit. */
1567 if (coff_section_data (abfd
, section
) == NULL
)
1569 section
->used_by_bfd
=
1570 (PTR
) bfd_zalloc (abfd
, sizeof (struct coff_section_tdata
));
1571 if (section
->used_by_bfd
== NULL
)
1573 /* FIXME: Return error. */
1577 if (pei_section_data (abfd
, section
) == NULL
)
1579 coff_section_data (abfd
, section
)->tdata
=
1580 (PTR
) bfd_zalloc (abfd
, sizeof (struct pei_section_tdata
));
1581 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1583 /* FIXME: Return error. */
1587 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1588 pei_section_data (abfd
, section
)->pe_flags
= hdr
->s_flags
;
1590 section
->lma
= hdr
->s_vaddr
;
1593 #undef ELIFALIGN_SET
1595 #else /* ! COFF_WITH_PE */
1598 /* We grossly abuse this function to handle XCOFF overflow headers.
1599 When we see one, we correct the reloc and line number counts in the
1600 real header, and remove the section we just created. */
1602 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1605 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1610 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1614 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1617 real_sec
= coff_section_from_bfd_index (abfd
, hdr
->s_nreloc
);
1618 if (real_sec
== NULL
)
1621 real_sec
->reloc_count
= hdr
->s_paddr
;
1622 real_sec
->lineno_count
= hdr
->s_vaddr
;
1624 for (ps
= &abfd
->sections
; *ps
!= NULL
; ps
= &(*ps
)->next
)
1629 --abfd
->section_count
;
1635 #else /* ! RS6000COFF_C */
1637 #define coff_set_alignment_hook \
1638 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1640 #endif /* ! RS6000COFF_C */
1641 #endif /* ! COFF_WITH_PE */
1642 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1644 #ifndef coff_mkobject
1646 static boolean coff_mkobject
PARAMS ((bfd
*));
1649 coff_mkobject (abfd
)
1652 coff_data_type
*coff
;
1654 abfd
->tdata
.coff_obj_data
= (struct coff_tdata
*) bfd_zalloc (abfd
, sizeof (coff_data_type
));
1655 if (abfd
->tdata
.coff_obj_data
== 0)
1657 coff
= coff_data (abfd
);
1658 coff
->symbols
= (coff_symbol_type
*) NULL
;
1659 coff
->conversion_table
= (unsigned int *) NULL
;
1660 coff
->raw_syments
= (struct coff_ptr_struct
*) NULL
;
1661 coff
->relocbase
= 0;
1662 coff
->local_toc_sym_map
= 0;
1664 /* make_abs_section(abfd);*/
1670 /* Create the COFF backend specific information. */
1671 #ifndef coff_mkobject_hook
1673 coff_mkobject_hook (abfd
, filehdr
, aouthdr
)
1676 PTR aouthdr ATTRIBUTE_UNUSED
;
1678 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1679 coff_data_type
*coff
;
1681 if (coff_mkobject (abfd
) == false)
1684 coff
= coff_data (abfd
);
1686 coff
->sym_filepos
= internal_f
->f_symptr
;
1688 /* These members communicate important constants about the symbol
1689 table to GDB's symbol-reading code. These `constants'
1690 unfortunately vary among coff implementations... */
1691 coff
->local_n_btmask
= N_BTMASK
;
1692 coff
->local_n_btshft
= N_BTSHFT
;
1693 coff
->local_n_tmask
= N_TMASK
;
1694 coff
->local_n_tshift
= N_TSHIFT
;
1695 coff
->local_symesz
= bfd_coff_symesz (abfd
);
1696 coff
->local_auxesz
= bfd_coff_auxesz (abfd
);
1697 coff
->local_linesz
= bfd_coff_linesz (abfd
);
1699 coff
->timestamp
= internal_f
->f_timdat
;
1701 obj_raw_syment_count (abfd
) =
1702 obj_conv_table_size (abfd
) =
1703 internal_f
->f_nsyms
;
1706 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
1707 abfd
->flags
|= DYNAMIC
;
1708 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= bfd_coff_aoutsz (abfd
))
1710 struct internal_aouthdr
*internal_a
=
1711 (struct internal_aouthdr
*) aouthdr
;
1712 struct xcoff_tdata
*xcoff
;
1714 xcoff
= xcoff_data (abfd
);
1715 xcoff
->full_aouthdr
= true;
1716 xcoff
->toc
= internal_a
->o_toc
;
1717 xcoff
->sntoc
= internal_a
->o_sntoc
;
1718 xcoff
->snentry
= internal_a
->o_snentry
;
1719 xcoff
->text_align_power
= internal_a
->o_algntext
;
1720 xcoff
->data_align_power
= internal_a
->o_algndata
;
1721 xcoff
->modtype
= internal_a
->o_modtype
;
1722 xcoff
->cputype
= internal_a
->o_cputype
;
1723 xcoff
->maxdata
= internal_a
->o_maxdata
;
1724 xcoff
->maxstack
= internal_a
->o_maxstack
;
1729 /* Set the flags field from the COFF header read in */
1730 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
1735 /* FIXME: I'm not sure this is ever executed, since peicode.h
1736 defines coff_mkobject_hook. */
1737 if ((internal_f
->f_flags
& IMAGE_FILE_DEBUG_STRIPPED
) == 0)
1738 abfd
->flags
|= HAS_DEBUG
;
1745 /* Determine the machine architecture and type. FIXME: This is target
1746 dependent because the magic numbers are defined in the target
1747 dependent header files. But there is no particular need for this.
1748 If the magic numbers were moved to a separate file, this function
1749 would be target independent and would also be much more successful
1750 at linking together COFF files for different architectures. */
1753 coff_set_arch_mach_hook (abfd
, filehdr
)
1758 enum bfd_architecture arch
;
1759 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1762 switch (internal_f
->f_magic
)
1766 arch
= bfd_arch_powerpc
;
1767 machine
= 0; /* what does this mean? (krk) */
1773 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler */
1774 case LYNXCOFFMAGIC
: /* shadows the m68k Lynx number below, sigh */
1775 arch
= bfd_arch_i386
;
1779 #ifdef A29K_MAGIC_BIG
1780 case A29K_MAGIC_BIG
:
1781 case A29K_MAGIC_LITTLE
:
1782 arch
= bfd_arch_a29k
;
1790 arch
= bfd_arch_arm
;
1791 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
1793 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
1794 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
1795 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
1797 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
1798 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
1799 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
1800 case F_ARM_5
: machine
= bfd_mach_arm_5
; break;
1807 #ifdef MC68KBCSMAGIC
1810 #ifdef APOLLOM68KMAGIC
1811 case APOLLOM68KMAGIC
:
1813 #ifdef LYNXCOFFMAGIC
1816 arch
= bfd_arch_m68k
;
1817 machine
= bfd_mach_m68020
;
1824 arch
= bfd_arch_m88k
;
1830 arch
= bfd_arch_z8k
;
1831 switch (internal_f
->f_flags
& F_MACHMASK
)
1834 machine
= bfd_mach_z8001
;
1837 machine
= bfd_mach_z8002
;
1846 arch
= bfd_arch_i860
;
1853 arch
= bfd_arch_i960
;
1854 switch (F_I960TYPE
& internal_f
->f_flags
)
1858 machine
= bfd_mach_i960_core
;
1861 machine
= bfd_mach_i960_kb_sb
;
1864 machine
= bfd_mach_i960_mc
;
1867 machine
= bfd_mach_i960_xa
;
1870 machine
= bfd_mach_i960_ca
;
1873 machine
= bfd_mach_i960_ka_sa
;
1876 machine
= bfd_mach_i960_jx
;
1879 machine
= bfd_mach_i960_hx
;
1893 if (xcoff_data (abfd
)->cputype
!= -1)
1894 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
1897 /* We did not get a value from the a.out header. If the
1898 file has not been stripped, we may be able to get the
1899 architecture information from the first symbol, if it
1900 is a .file symbol. */
1901 if (obj_raw_syment_count (abfd
) == 0)
1906 struct internal_syment sym
;
1908 buf
= (bfd_byte
*) bfd_malloc (bfd_coff_symesz (abfd
));
1909 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1910 || (bfd_read (buf
, 1, bfd_coff_symesz (abfd
), abfd
)
1911 != bfd_coff_symesz (abfd
)))
1916 coff_swap_sym_in (abfd
, (PTR
) buf
, (PTR
) &sym
);
1917 if (sym
.n_sclass
== C_FILE
)
1918 cputype
= sym
.n_type
& 0xff;
1925 /* FIXME: We don't handle all cases here. */
1931 /* PowerPC Macs use the same magic numbers as RS/6000
1932 (because that's how they were bootstrapped originally),
1933 but they are always PowerPC architecture. */
1934 arch
= bfd_arch_powerpc
;
1937 arch
= bfd_arch_rs6000
;
1939 #endif /* POWERMAC */
1943 arch
= bfd_arch_powerpc
;
1946 case 2: /* 64 bit PowerPC */
1947 arch
= bfd_arch_powerpc
;
1951 arch
= bfd_arch_powerpc
;
1955 arch
= bfd_arch_rs6000
;
1965 arch
= bfd_arch_we32k
;
1972 arch
= bfd_arch_h8300
;
1973 machine
= bfd_mach_h8300
;
1974 /* !! FIXME this probably isn't the right place for this */
1975 abfd
->flags
|= BFD_IS_RELAXABLE
;
1981 arch
= bfd_arch_h8300
;
1982 machine
= bfd_mach_h8300h
;
1983 /* !! FIXME this probably isn't the right place for this */
1984 abfd
->flags
|= BFD_IS_RELAXABLE
;
1990 arch
= bfd_arch_h8300
;
1991 machine
= bfd_mach_h8300s
;
1992 /* !! FIXME this probably isn't the right place for this */
1993 abfd
->flags
|= BFD_IS_RELAXABLE
;
1997 #ifdef SH_ARCH_MAGIC_BIG
1998 case SH_ARCH_MAGIC_BIG
:
1999 case SH_ARCH_MAGIC_LITTLE
:
2001 case SH_ARCH_MAGIC_WINCE
:
2008 #ifdef MIPS_ARCH_MAGIC_WINCE
2009 case MIPS_ARCH_MAGIC_WINCE
:
2010 arch
= bfd_arch_mips
;
2017 arch
= bfd_arch_h8500
;
2024 #ifdef LYNXCOFFMAGIC
2027 arch
= bfd_arch_sparc
;
2034 arch
= bfd_arch_tic30
;
2038 #ifdef TIC80_ARCH_MAGIC
2039 case TIC80_ARCH_MAGIC
:
2040 arch
= bfd_arch_tic80
;
2046 arch
= bfd_arch_mcore
;
2049 default: /* Unreadable input file type */
2050 arch
= bfd_arch_obscure
;
2054 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2058 #ifdef SYMNAME_IN_DEBUG
2060 static boolean symname_in_debug_hook
2061 PARAMS ((bfd
*, struct internal_syment
*));
2064 symname_in_debug_hook (abfd
, sym
)
2065 bfd
* abfd ATTRIBUTE_UNUSED
;
2066 struct internal_syment
*sym
;
2068 return SYMNAME_IN_DEBUG (sym
) ? true : false;
2073 #define symname_in_debug_hook \
2074 (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
2080 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
2082 static boolean coff_pointerize_aux_hook
2083 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
2084 unsigned int, combined_entry_type
*));
2088 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
2089 bfd
*abfd ATTRIBUTE_UNUSED
;
2090 combined_entry_type
*table_base
;
2091 combined_entry_type
*symbol
;
2092 unsigned int indaux
;
2093 combined_entry_type
*aux
;
2095 int class = symbol
->u
.syment
.n_sclass
;
2097 if ((class == C_EXT
|| class == C_HIDEXT
)
2098 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2100 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2102 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2103 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2104 aux
->fix_scnlen
= 1;
2107 /* Return true to indicate that the caller should not do any
2108 further work on this auxent. */
2112 /* Return false to indicate that this auxent should be handled by
2120 /* We don't want to pointerize bal entries. */
2122 static boolean coff_pointerize_aux_hook
2123 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
2124 unsigned int, combined_entry_type
*));
2128 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
2129 bfd
*abfd ATTRIBUTE_UNUSED
;
2130 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
2131 combined_entry_type
*symbol
;
2132 unsigned int indaux
;
2133 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
2135 /* Return true if we don't want to pointerize this aux entry, which
2136 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2138 && (symbol
->u
.syment
.n_sclass
== C_LEAFPROC
2139 || symbol
->u
.syment
.n_sclass
== C_LEAFSTAT
2140 || symbol
->u
.syment
.n_sclass
== C_LEAFEXT
));
2145 #define coff_pointerize_aux_hook 0
2148 #endif /* ! RS6000COFF_C */
2150 /* Print an aux entry. This returns true if it has printed it. */
2152 static boolean coff_print_aux
2153 PARAMS ((bfd
*, FILE *, combined_entry_type
*, combined_entry_type
*,
2154 combined_entry_type
*, unsigned int));
2157 coff_print_aux (abfd
, file
, table_base
, symbol
, aux
, indaux
)
2158 bfd
*abfd ATTRIBUTE_UNUSED
;
2159 FILE *file ATTRIBUTE_UNUSED
;
2160 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
2161 combined_entry_type
*symbol ATTRIBUTE_UNUSED
;
2162 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
2163 unsigned int indaux ATTRIBUTE_UNUSED
;
2166 if ((symbol
->u
.syment
.n_sclass
== C_EXT
2167 || symbol
->u
.syment
.n_sclass
== C_HIDEXT
)
2168 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2170 /* This is a csect entry. */
2171 fprintf (file
, "AUX ");
2172 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2174 BFD_ASSERT (! aux
->fix_scnlen
);
2175 fprintf (file
, "val %5ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2179 fprintf (file
, "indx ");
2180 if (! aux
->fix_scnlen
)
2181 fprintf (file
, "%4ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2183 fprintf (file
, "%4ld",
2184 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2187 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2188 aux
->u
.auxent
.x_csect
.x_parmhash
,
2189 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2190 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2191 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2192 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2193 aux
->u
.auxent
.x_csect
.x_stab
,
2194 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2199 /* Return false to indicate that no special action was taken. */
2207 To write relocations, the back end steps though the
2208 canonical relocation table and create an
2209 @code{internal_reloc}. The symbol index to use is removed from
2210 the @code{offset} field in the symbol table supplied. The
2211 address comes directly from the sum of the section base
2212 address and the relocation offset; the type is dug directly
2213 from the howto field. Then the @code{internal_reloc} is
2214 swapped into the shape of an @code{external_reloc} and written
2221 static int compare_arelent_ptr
PARAMS ((const PTR
, const PTR
));
2223 /* AUX's ld wants relocations to be sorted */
2225 compare_arelent_ptr (x
, y
)
2229 const arelent
**a
= (const arelent
**) x
;
2230 const arelent
**b
= (const arelent
**) y
;
2231 bfd_size_type aadr
= (*a
)->address
;
2232 bfd_size_type badr
= (*b
)->address
;
2234 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2237 #endif /* TARG_AUX */
2240 coff_write_relocs (abfd
, first_undef
)
2246 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
2249 struct external_reloc dst
;
2255 /* sort relocations before we write them out */
2256 p
= (arelent
**) bfd_malloc (s
->reloc_count
* sizeof (arelent
*));
2257 if (p
== NULL
&& s
->reloc_count
> 0)
2259 memcpy (p
, s
->orelocation
, s
->reloc_count
* sizeof (arelent
*));
2260 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2263 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2265 for (i
= 0; i
< s
->reloc_count
; i
++)
2267 struct internal_reloc n
;
2269 memset ((PTR
) & n
, 0, sizeof (n
));
2271 /* Now we've renumbered the symbols we know where the
2272 undefined symbols live in the table. Check the reloc
2273 entries for symbols who's output bfd isn't the right one.
2274 This is because the symbol was undefined (which means
2275 that all the pointers are never made to point to the same
2276 place). This is a bad thing,'cause the symbols attached
2277 to the output bfd are indexed, so that the relocation
2278 entries know which symbol index they point to. So we
2279 have to look up the output symbol here. */
2281 if (q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2284 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2285 asymbol
**outsyms
= abfd
->outsymbols
;
2286 for (i
= first_undef
; outsyms
[i
]; i
++)
2288 const char *intable
= outsyms
[i
]->name
;
2289 if (strcmp (intable
, sname
) == 0) {
2290 /* got a hit, so repoint the reloc */
2291 q
->sym_ptr_ptr
= outsyms
+ i
;
2297 n
.r_vaddr
= q
->address
+ s
->vma
;
2300 /* The 29k const/consth reloc pair is a real kludge. The consth
2301 part doesn't have a symbol; it has an offset. So rebuilt
2303 if (q
->howto
->type
== R_IHCONST
)
2304 n
.r_symndx
= q
->addend
;
2309 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2310 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
,s
))
2312 if (q
->sym_ptr_ptr
== bfd_abs_section_ptr
->symbol_ptr_ptr
)
2314 /* This is a relocation relative to the absolute symbol. */
2318 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2319 /* Take notice if the symbol reloc points to a symbol
2320 we don't have in our symbol table. What should we
2322 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2327 #ifdef SWAP_OUT_RELOC_OFFSET
2328 n
.r_offset
= q
->addend
;
2332 /* Work out reloc type from what is required */
2333 SELECT_RELOC (n
, q
->howto
);
2335 n
.r_type
= q
->howto
->type
;
2337 coff_swap_reloc_out (abfd
, &n
, &dst
);
2338 if (bfd_write ((PTR
) & dst
, 1, bfd_coff_relsz (abfd
), abfd
)
2339 != bfd_coff_relsz (abfd
))
2352 /* Set flags and magic number of a coff file from architecture and machine
2353 type. Result is true if we can represent the arch&type, false if not. */
2356 coff_set_flags (abfd
, magicp
, flagsp
)
2358 unsigned int *magicp ATTRIBUTE_UNUSED
;
2359 unsigned short *flagsp ATTRIBUTE_UNUSED
;
2361 switch (bfd_get_arch (abfd
))
2366 switch (bfd_get_mach (abfd
))
2368 case bfd_mach_z8001
:
2371 case bfd_mach_z8002
:
2385 *magicp
= I960ROMAGIC
;
2387 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2388 I960RWMAGIC); FIXME???
2390 switch (bfd_get_mach (abfd
))
2392 case bfd_mach_i960_core
:
2395 case bfd_mach_i960_kb_sb
:
2398 case bfd_mach_i960_mc
:
2401 case bfd_mach_i960_xa
:
2404 case bfd_mach_i960_ca
:
2407 case bfd_mach_i960_ka_sa
:
2410 case bfd_mach_i960_jx
:
2413 case bfd_mach_i960_hx
:
2426 case bfd_arch_tic30
:
2427 *magicp
= TIC30MAGIC
;
2430 #ifdef TIC80_ARCH_MAGIC
2431 case bfd_arch_tic80
:
2432 *magicp
= TIC80_ARCH_MAGIC
;
2438 * magicp
= ARMPEMAGIC
;
2440 * magicp
= ARMMAGIC
;
2443 if (APCS_SET (abfd
))
2445 if (APCS_26_FLAG (abfd
))
2446 * flagsp
|= F_APCS26
;
2448 if (APCS_FLOAT_FLAG (abfd
))
2449 * flagsp
|= F_APCS_FLOAT
;
2451 if (PIC_FLAG (abfd
))
2454 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2455 * flagsp
|= F_INTERWORK
;
2456 switch (bfd_get_mach (abfd
))
2458 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2459 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2460 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2461 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2462 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2463 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2464 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2465 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break; /* XXX - we do not have an F_ARM_5T */
2470 case bfd_arch_powerpc
:
2477 *magicp
= I386MAGIC
;
2479 /* Just overwrite the usual value if we're doing Lynx. */
2480 *magicp
= LYNXCOFFMAGIC
;
2487 *magicp
= I860MAGIC
;
2493 #ifdef APOLLOM68KMAGIC
2494 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
2496 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2497 #ifdef NAMES_HAVE_UNDERSCORE
2498 *magicp
= MC68KBCSMAGIC
;
2500 *magicp
= MC68MAGIC
;
2504 /* Just overwrite the usual value if we're doing Lynx. */
2505 *magicp
= LYNXCOFFMAGIC
;
2513 *magicp
= MC88OMAGIC
;
2518 case bfd_arch_h8300
:
2519 switch (bfd_get_mach (abfd
))
2521 case bfd_mach_h8300
:
2522 *magicp
= H8300MAGIC
;
2524 case bfd_mach_h8300h
:
2525 *magicp
= H8300HMAGIC
;
2527 case bfd_mach_h8300s
:
2528 *magicp
= H8300SMAGIC
;
2534 #ifdef SH_ARCH_MAGIC_BIG
2536 #ifdef COFF_IMAGE_WITH_PE
2537 *magicp
= SH_ARCH_MAGIC_WINCE
;
2539 if (bfd_big_endian (abfd
))
2540 *magicp
= SH_ARCH_MAGIC_BIG
;
2542 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2548 #ifdef MIPS_ARCH_MAGIC_WINCE
2550 *magicp
= MIPS_ARCH_MAGIC_WINCE
;
2556 case bfd_arch_sparc
:
2557 *magicp
= SPARCMAGIC
;
2559 /* Just overwrite the usual value if we're doing Lynx. */
2560 *magicp
= LYNXCOFFMAGIC
;
2567 case bfd_arch_h8500
:
2568 *magicp
= H8500MAGIC
;
2572 #ifdef A29K_MAGIC_BIG
2574 if (bfd_big_endian (abfd
))
2575 *magicp
= A29K_MAGIC_BIG
;
2577 *magicp
= A29K_MAGIC_LITTLE
;
2583 case bfd_arch_we32k
:
2584 *magicp
= WE32KMAGIC
;
2590 case bfd_arch_rs6000
:
2592 case bfd_arch_powerpc
:
2594 *magicp
= U802TOCMAGIC
;
2600 case bfd_arch_mcore
:
2601 * magicp
= MCOREMAGIC
;
2605 default: /* Unknown architecture */
2606 /* return false; -- fall through to "return false" below, to avoid
2607 "statement never reached" errors on the one below. */
2616 coff_set_arch_mach (abfd
, arch
, machine
)
2618 enum bfd_architecture arch
;
2619 unsigned long machine
;
2622 unsigned short dummy2
;
2624 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
2627 if (arch
!= bfd_arch_unknown
&&
2628 coff_set_flags (abfd
, &dummy1
, &dummy2
) != true)
2629 return false; /* We can't represent this type */
2631 return true; /* We're easy ... */
2634 #ifdef COFF_IMAGE_WITH_PE
2636 /* This is used to sort sections by VMA, as required by PE image
2639 static int sort_by_secaddr
PARAMS ((const PTR
, const PTR
));
2642 sort_by_secaddr (arg1
, arg2
)
2646 const asection
*a
= *(const asection
**) arg1
;
2647 const asection
*b
= *(const asection
**) arg2
;
2649 if (a
->vma
< b
->vma
)
2651 else if (a
->vma
> b
->vma
)
2657 #endif /* COFF_IMAGE_WITH_PE */
2659 /* Calculate the file position for each section. */
2662 #define ALIGN_SECTIONS_IN_FILE
2665 #undef ALIGN_SECTIONS_IN_FILE
2669 coff_compute_section_file_positions (abfd
)
2673 asection
*previous
= (asection
*) NULL
;
2674 file_ptr sofar
= bfd_coff_filhsz (abfd
);
2675 boolean align_adjust
;
2676 #ifdef ALIGN_SECTIONS_IN_FILE
2681 /* On XCOFF, if we have symbols, set up the .debug section. */
2682 if (bfd_get_symcount (abfd
) > 0)
2685 bfd_size_type i
, symcount
;
2689 symcount
= bfd_get_symcount (abfd
);
2690 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
2692 coff_symbol_type
*cf
;
2694 cf
= coff_symbol_from (abfd
, *symp
);
2696 && cf
->native
!= NULL
2697 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
2701 len
= strlen (bfd_asymbol_name (*symp
));
2710 dsec
= bfd_make_section_old_way (abfd
, ".debug");
2713 dsec
->_raw_size
= sz
;
2714 dsec
->flags
|= SEC_HAS_CONTENTS
;
2719 #ifdef COFF_IMAGE_WITH_PE
2721 if (coff_data (abfd
)->link_info
)
2723 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
2726 page_size
= PE_DEF_FILE_ALIGNMENT
;
2728 #ifdef COFF_PAGE_SIZE
2729 int page_size
= COFF_PAGE_SIZE
;
2733 if (bfd_get_start_address (abfd
))
2735 /* A start address may have been added to the original file. In this
2736 case it will need an optional header to record it. */
2737 abfd
->flags
|= EXEC_P
;
2740 if (abfd
->flags
& EXEC_P
)
2741 sofar
+= bfd_coff_aoutsz (abfd
);
2743 else if (xcoff_data (abfd
)->full_aouthdr
)
2744 sofar
+= bfd_coff_aoutsz (abfd
);
2746 sofar
+= SMALL_AOUTSZ
;
2749 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2752 /* XCOFF handles overflows in the reloc and line number count fields
2753 by allocating a new section header to hold the correct counts. */
2754 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2755 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
2756 sofar
+= bfd_coff_scnhsz (abfd
);
2759 #ifdef COFF_IMAGE_WITH_PE
2761 /* PE requires the sections to be in memory order when listed in
2762 the section headers. It also does not like empty loadable
2763 sections. The sections apparently do not have to be in the
2764 right order in the image file itself, but we do need to get the
2765 target_index values right. */
2768 asection
**section_list
;
2773 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2776 /* We allocate an extra cell to simplify the final loop. */
2777 section_list
= bfd_malloc (sizeof (struct asection
*) * (count
+ 1));
2778 if (section_list
== NULL
)
2782 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2784 section_list
[i
] = current
;
2787 section_list
[i
] = NULL
;
2789 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
2791 /* Rethread the linked list into sorted order; at the same time,
2792 assign target_index values. */
2794 abfd
->sections
= section_list
[0];
2795 for (i
= 0; i
< count
; i
++)
2797 current
= section_list
[i
];
2798 current
->next
= section_list
[i
+ 1];
2800 /* Later, if the section has zero size, we'll be throwing it
2801 away, so we don't want to number it now. Note that having
2802 a zero size and having real contents are different
2803 concepts: .bss has no contents, but (usually) non-zero
2805 if (current
->_raw_size
== 0)
2807 /* Discard. However, it still might have (valid) symbols
2808 in it, so arbitrarily set it to section 1 (indexing is
2809 1-based here; usually .text). __end__ and other
2810 contents of .endsection really have this happen.
2811 FIXME: This seems somewhat dubious. */
2812 current
->target_index
= 1;
2815 current
->target_index
= target_index
++;
2818 free (section_list
);
2820 #else /* ! COFF_IMAGE_WITH_PE */
2822 /* Set the target_index field. */
2826 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2827 current
->target_index
= target_index
++;
2829 #endif /* ! COFF_IMAGE_WITH_PE */
2831 align_adjust
= false;
2832 for (current
= abfd
->sections
;
2833 current
!= (asection
*) NULL
;
2834 current
= current
->next
)
2836 #ifdef COFF_IMAGE_WITH_PE
2837 /* With PE we have to pad each section to be a multiple of its
2838 page size too, and remember both sizes. */
2839 if (coff_section_data (abfd
, current
) == NULL
)
2841 current
->used_by_bfd
=
2842 (PTR
) bfd_zalloc (abfd
, sizeof (struct coff_section_tdata
));
2843 if (current
->used_by_bfd
== NULL
)
2846 if (pei_section_data (abfd
, current
) == NULL
)
2848 coff_section_data (abfd
, current
)->tdata
=
2849 (PTR
) bfd_zalloc (abfd
, sizeof (struct pei_section_tdata
));
2850 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
2853 if (pei_section_data (abfd
, current
)->virt_size
== 0)
2854 pei_section_data (abfd
, current
)->virt_size
= current
->_raw_size
;
2857 /* Only deal with sections which have contents. */
2858 if (!(current
->flags
& SEC_HAS_CONTENTS
))
2861 #ifdef COFF_IMAGE_WITH_PE
2862 /* Make sure we skip empty sections in a PE image. */
2863 if (current
->_raw_size
== 0)
2867 /* Align the sections in the file to the same boundary on
2868 which they are aligned in virtual memory. I960 doesn't
2869 do this (FIXME) so we can stay in sync with Intel. 960
2870 doesn't yet page from files... */
2871 #ifdef ALIGN_SECTIONS_IN_FILE
2872 if ((abfd
->flags
& EXEC_P
) != 0)
2874 /* make sure this section is aligned on the right boundary - by
2875 padding the previous section up if necessary */
2878 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
2879 if (previous
!= (asection
*) NULL
)
2881 previous
->_raw_size
+= sofar
- old_sofar
;
2887 /* In demand paged files the low order bits of the file offset
2888 must match the low order bits of the virtual address. */
2889 #ifdef COFF_PAGE_SIZE
2890 if ((abfd
->flags
& D_PAGED
) != 0
2891 && (current
->flags
& SEC_ALLOC
) != 0)
2892 sofar
+= (current
->vma
- sofar
) % page_size
;
2894 current
->filepos
= sofar
;
2896 #ifdef COFF_IMAGE_WITH_PE
2897 /* Set the padded size. */
2898 current
->_raw_size
= (current
->_raw_size
+ page_size
-1) & -page_size
;
2901 sofar
+= current
->_raw_size
;
2903 #ifdef ALIGN_SECTIONS_IN_FILE
2904 /* make sure that this section is of the right size too */
2905 if ((abfd
->flags
& EXEC_P
) == 0)
2907 bfd_size_type old_size
;
2909 old_size
= current
->_raw_size
;
2910 current
->_raw_size
= BFD_ALIGN (current
->_raw_size
,
2911 1 << current
->alignment_power
);
2912 align_adjust
= current
->_raw_size
!= old_size
;
2913 sofar
+= current
->_raw_size
- old_size
;
2918 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
2919 align_adjust
= sofar
!= old_sofar
;
2920 current
->_raw_size
+= sofar
- old_sofar
;
2924 #ifdef COFF_IMAGE_WITH_PE
2925 /* For PE we need to make sure we pad out to the aligned
2926 _raw_size, in case the caller only writes out data to the
2927 unaligned _raw_size. */
2928 if (pei_section_data (abfd
, current
)->virt_size
< current
->_raw_size
)
2929 align_adjust
= true;
2933 /* Force .lib sections to start at zero. The vma is then
2934 incremented in coff_set_section_contents. This is right for
2936 if (strcmp (current
->name
, _LIB
) == 0)
2937 bfd_set_section_vma (abfd
, current
, 0);
2943 /* It is now safe to write to the output file. If we needed an
2944 alignment adjustment for the last section, then make sure that
2945 there is a byte at offset sofar. If there are no symbols and no
2946 relocs, then nothing follows the last section. If we don't force
2947 the last byte out, then the file may appear to be truncated. */
2953 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
2954 || bfd_write (&b
, 1, 1, abfd
) != 1)
2958 /* Make sure the relocations are aligned. We don't need to make
2959 sure that this byte exists, because it will only matter if there
2960 really are relocs. */
2961 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
2963 obj_relocbase (abfd
) = sofar
;
2964 abfd
->output_has_begun
= true;
2971 /* This can never work, because it is called too late--after the
2972 section positions have been set. I can't figure out what it is
2973 for, so I am going to disable it--Ian Taylor 20 March 1996. */
2975 /* If .file, .text, .data, .bss symbols are missing, add them. */
2976 /* @@ Should we only be adding missing symbols, or overriding the aux
2977 values for existing section symbols? */
2979 coff_add_missing_symbols (abfd
)
2982 unsigned int nsyms
= bfd_get_symcount (abfd
);
2983 asymbol
**sympp
= abfd
->outsymbols
;
2986 int need_text
= 1, need_data
= 1, need_bss
= 1, need_file
= 1;
2988 for (i
= 0; i
< nsyms
; i
++)
2990 coff_symbol_type
*csym
= coff_symbol_from (abfd
, sympp
[i
]);
2994 /* only do this if there is a coff representation of the input
2996 if (csym
->native
&& csym
->native
->u
.syment
.n_sclass
== C_FILE
)
3001 name
= csym
->symbol
.name
;
3004 if (!strcmp (name
, _TEXT
))
3007 else if (!strcmp (name
, ".wtext"))
3010 else if (!strcmp (name
, _DATA
))
3012 else if (!strcmp (name
, _BSS
))
3016 /* Now i == bfd_get_symcount (abfd). */
3017 /* @@ For now, don't deal with .file symbol. */
3020 if (!need_text
&& !need_data
&& !need_bss
&& !need_file
)
3022 nsyms
+= need_text
+ need_data
+ need_bss
+ need_file
;
3023 sympp2
= (asymbol
**) bfd_alloc (abfd
, nsyms
* sizeof (asymbol
*));
3026 memcpy (sympp2
, sympp
, i
* sizeof (asymbol
*));
3029 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
3033 sympp2
[i
++] = coff_section_symbol (abfd
, _TEXT
);
3035 sympp2
[i
++] = coff_section_symbol (abfd
, _DATA
);
3037 sympp2
[i
++] = coff_section_symbol (abfd
, _BSS
);
3038 BFD_ASSERT (i
== nsyms
);
3039 bfd_set_symtab (abfd
, sympp2
, nsyms
);
3048 coff_write_object_contents (abfd
)
3052 boolean hasrelocs
= false;
3053 boolean haslinno
= false;
3054 boolean hasdebug
= false;
3056 file_ptr reloc_base
;
3057 file_ptr lineno_base
;
3059 unsigned long reloc_size
= 0;
3060 unsigned long lnno_size
= 0;
3061 boolean long_section_names
;
3062 asection
*text_sec
= NULL
;
3063 asection
*data_sec
= NULL
;
3064 asection
*bss_sec
= NULL
;
3065 struct internal_filehdr internal_f
;
3066 struct internal_aouthdr internal_a
;
3067 #ifdef COFF_LONG_SECTION_NAMES
3068 size_t string_size
= STRING_SIZE_SIZE
;
3071 bfd_set_error (bfd_error_system_call
);
3073 /* Make a pass through the symbol table to count line number entries and
3074 put them into the correct asections */
3076 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3078 if (abfd
->output_has_begun
== false)
3080 if (! coff_compute_section_file_positions (abfd
))
3084 reloc_base
= obj_relocbase (abfd
);
3086 /* Work out the size of the reloc and linno areas */
3088 for (current
= abfd
->sections
; current
!= NULL
; current
=
3090 reloc_size
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3092 lineno_base
= reloc_base
+ reloc_size
;
3093 sym_base
= lineno_base
+ lnno_size
;
3095 /* Indicate in each section->line_filepos its actual file address */
3096 for (current
= abfd
->sections
; current
!= NULL
; current
=
3099 if (current
->lineno_count
)
3101 current
->line_filepos
= lineno_base
;
3102 current
->moving_line_filepos
= lineno_base
;
3103 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3107 current
->line_filepos
= 0;
3109 if (current
->reloc_count
)
3111 current
->rel_filepos
= reloc_base
;
3112 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3116 current
->rel_filepos
= 0;
3120 /* Write section headers to the file. */
3121 internal_f
.f_nscns
= 0;
3123 if ((abfd
->flags
& EXEC_P
) != 0)
3124 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3127 scn_base
= bfd_coff_filhsz (abfd
);
3129 if (xcoff_data (abfd
)->full_aouthdr
)
3130 scn_base
+= bfd_coff_aoutsz (abfd
);
3132 scn_base
+= SMALL_AOUTSZ
;
3136 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3139 long_section_names
= false;
3140 for (current
= abfd
->sections
;
3142 current
= current
->next
)
3144 struct internal_scnhdr section
;
3145 boolean is_reloc_section
= false;
3147 #ifdef COFF_IMAGE_WITH_PE
3148 if (strcmp (current
->name
, ".reloc") == 0)
3150 is_reloc_section
= true;
3152 pe_data (abfd
)->has_reloc_section
= 1;
3156 internal_f
.f_nscns
++;
3158 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3160 #ifdef COFF_LONG_SECTION_NAMES
3161 /* Handle long section names as in PE. This must be compatible
3162 with the code in coff_write_symbols and _bfd_coff_final_link. */
3166 len
= strlen (current
->name
);
3169 memset (section
.s_name
, 0, SCNNMLEN
);
3170 sprintf (section
.s_name
, "/%lu", (unsigned long) string_size
);
3171 string_size
+= len
+ 1;
3172 long_section_names
= true;
3178 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3179 Ian Taylor <ian@cygnus.com>. */
3180 if (strcmp (current
->name
, _LIB
) == 0)
3181 section
.s_vaddr
= 0;
3184 section
.s_vaddr
= current
->vma
;
3185 section
.s_paddr
= current
->lma
;
3186 section
.s_size
= current
->_raw_size
;
3189 section
.s_paddr
= 0;
3191 #ifdef COFF_IMAGE_WITH_PE
3192 /* Reminder: s_paddr holds the virtual size of the section. */
3193 if (coff_section_data (abfd
, current
) != NULL
3194 && pei_section_data (abfd
, current
) != NULL
)
3195 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3197 section
.s_paddr
= 0;
3201 If this section has no size or is unloadable then the scnptr
3204 if (current
->_raw_size
== 0 ||
3205 (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3207 section
.s_scnptr
= 0;
3211 section
.s_scnptr
= current
->filepos
;
3213 section
.s_relptr
= current
->rel_filepos
;
3214 section
.s_lnnoptr
= current
->line_filepos
;
3215 section
.s_nreloc
= current
->reloc_count
;
3216 section
.s_nlnno
= current
->lineno_count
;
3217 #ifndef COFF_IMAGE_WITH_PE
3218 /* In PEI, relocs come in the .reloc section. */
3219 if (current
->reloc_count
!= 0)
3222 if (current
->lineno_count
!= 0)
3224 if ((current
->flags
& SEC_DEBUGGING
) != 0
3225 && ! is_reloc_section
)
3229 /* Indicate the use of an XCOFF overflow section header. */
3230 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3232 section
.s_nreloc
= 0xffff;
3233 section
.s_nlnno
= 0xffff;
3237 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3239 if (!strcmp (current
->name
, _TEXT
))
3243 else if (!strcmp (current
->name
, _DATA
))
3247 else if (!strcmp (current
->name
, _BSS
))
3253 section
.s_align
= (current
->alignment_power
3254 ? 1 << current
->alignment_power
3258 section
.s_flags
|= (current
->alignment_power
& 0xF) << 8;
3262 #ifdef COFF_IMAGE_WITH_PE
3263 /* Suppress output of the sections if they are null. ld
3264 includes the bss and data sections even if there is no size
3265 assigned to them. NT loader doesn't like it if these section
3266 headers are included if the sections themselves are not
3267 needed. See also coff_compute_section_file_positions. */
3268 if (section
.s_size
== 0)
3269 internal_f
.f_nscns
--;
3274 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3275 || bfd_write ((PTR
) (&buff
), 1, bfd_coff_scnhsz (abfd
), abfd
)
3276 != bfd_coff_scnhsz (abfd
))
3281 /* PE stores COMDAT section information in the symbol table. If
3282 this section is supposed to have some COMDAT info, track down
3283 the symbol in the symbol table and modify it. */
3284 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3286 unsigned int i
, count
;
3288 coff_symbol_type
*csym
= NULL
;
3292 count
= bfd_get_symcount (abfd
);
3293 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3295 if ((*psym
)->section
!= current
)
3298 /* Remember the location of the first symbol in this
3300 if (psymsec
== NULL
)
3303 /* See if this is the section symbol. */
3304 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3306 csym
= coff_symbol_from (abfd
, *psym
);
3308 || csym
->native
== NULL
3309 || csym
->native
->u
.syment
.n_numaux
< 1
3310 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3311 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3314 /* Here *PSYM is the section symbol for CURRENT. */
3321 Note that we might not if we're converting the file from
3322 some other object file format. */
3325 combined_entry_type
*aux
;
3327 /* We don't touch the x_checksum field. The
3328 x_associated field is not currently supported. */
3330 aux
= csym
->native
+ 1;
3331 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3333 case SEC_LINK_DUPLICATES_DISCARD
:
3334 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3337 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3338 aux
->u
.auxent
.x_scn
.x_comdat
=
3339 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3342 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3343 aux
->u
.auxent
.x_scn
.x_comdat
=
3344 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3347 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3348 aux
->u
.auxent
.x_scn
.x_comdat
=
3349 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3353 /* The COMDAT symbol must be the first symbol from this
3354 section in the symbol table. In order to make this
3355 work, we move the COMDAT symbol before the first
3356 symbol we found in the search above. It's OK to
3357 rearrange the symbol table at this point, because
3358 coff_renumber_symbols is going to rearrange it
3359 further and fix up all the aux entries. */
3360 if (psym
!= psymsec
)
3366 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3367 pcopy
[0] = pcopy
[-1];
3372 #endif /* COFF_WITH_PE */
3376 /* XCOFF handles overflows in the reloc and line number count fields
3377 by creating a new section header to hold the correct values. */
3378 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3380 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3382 struct internal_scnhdr scnhdr
;
3385 internal_f
.f_nscns
++;
3386 strncpy (&(scnhdr
.s_name
[0]), current
->name
, 8);
3387 scnhdr
.s_paddr
= current
->reloc_count
;
3388 scnhdr
.s_vaddr
= current
->lineno_count
;
3390 scnhdr
.s_scnptr
= 0;
3391 scnhdr
.s_relptr
= current
->rel_filepos
;
3392 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3393 scnhdr
.s_nreloc
= current
->target_index
;
3394 scnhdr
.s_nlnno
= current
->target_index
;
3395 scnhdr
.s_flags
= STYP_OVRFLO
;
3396 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3397 || bfd_write ((PTR
) &buff
, 1, bfd_coff_scnhsz (abfd
), abfd
)
3398 != bfd_coff_scnhsz (abfd
))
3404 /* OK, now set up the filehdr... */
3406 /* Don't include the internal abs section in the section count */
3409 We will NOT put a fucking timestamp in the header here. Every time you
3410 put it back, I will come in and take it out again. I'm sorry. This
3411 field does not belong here. We fill it with a 0 so it compares the
3412 same but is not a reasonable time. -- gnu@cygnus.com
3414 internal_f
.f_timdat
= 0;
3416 internal_f
.f_flags
= 0;
3418 if (abfd
->flags
& EXEC_P
)
3419 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3422 internal_f
.f_opthdr
= 0;
3424 if (xcoff_data (abfd
)->full_aouthdr
)
3425 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3427 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
3432 internal_f
.f_flags
|= F_RELFLG
;
3434 internal_f
.f_flags
|= F_LNNO
;
3435 if (abfd
->flags
& EXEC_P
)
3436 internal_f
.f_flags
|= F_EXEC
;
3437 #ifdef COFF_IMAGE_WITH_PE
3439 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
3442 #ifndef COFF_WITH_PE
3443 if (bfd_little_endian (abfd
))
3444 internal_f
.f_flags
|= F_AR32WR
;
3446 internal_f
.f_flags
|= F_AR32W
;
3449 #ifdef TIC80_TARGET_ID
3450 internal_f
.f_target_id
= TIC80_TARGET_ID
;
3454 FIXME, should do something about the other byte orders and
3459 if ((abfd
->flags
& DYNAMIC
) != 0)
3460 internal_f
.f_flags
|= F_SHROBJ
;
3461 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
3462 internal_f
.f_flags
|= F_DYNLOAD
;
3465 memset (&internal_a
, 0, sizeof internal_a
);
3467 /* Set up architecture-dependent stuff */
3470 unsigned int magic
= 0;
3471 unsigned short flags
= 0;
3472 coff_set_flags (abfd
, &magic
, &flags
);
3473 internal_f
.f_magic
= magic
;
3474 internal_f
.f_flags
|= flags
;
3475 /* ...and the "opt"hdr... */
3478 #ifdef ULTRA3 /* NYU's machine */
3479 /* FIXME: This is a bogus check. I really want to see if there
3480 * is a .shbss or a .shdata section, if so then set the magic
3481 * number to indicate a shared data executable.
3483 if (internal_f
.f_nscns
>= 7)
3484 internal_a
.magic
= SHMAGIC
; /* Shared magic */
3487 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
3488 #define __A_MAGIC_SET__
3491 internal_a
.magic
= TIC80_ARCH_MAGIC
;
3492 #define __A_MAGIC_SET__
3495 /* FIXME: What are the a.out magic numbers for the i860? */
3496 internal_a
.magic
= 0;
3497 #define __A_MAGIC_SET__
3500 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
3501 #define __A_MAGIC_SET__
3504 #define __A_MAGIC_SET__
3505 internal_a
.magic
= PAGEMAGICBCS
;
3509 #define __A_MAGIC_SET__
3510 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
3513 #if defined(M68) || defined(WE32K) || defined(M68K)
3514 #define __A_MAGIC_SET__
3516 internal_a
.magic
= LYNXCOFFMAGIC
;
3518 #if defined(TARG_AUX)
3519 internal_a
.magic
= (abfd
->flags
& D_PAGED
? PAGEMAGICPEXECPAGED
:
3520 abfd
->flags
& WP_TEXT
? PAGEMAGICPEXECSWAPPED
:
3521 PAGEMAGICEXECSWAPPED
);
3523 #if defined (PAGEMAGICPEXECPAGED)
3524 internal_a
.magic
= PAGEMAGICPEXECPAGED
;
3526 #endif /* TARG_AUX */
3528 #endif /* M68 || WE32K || M68K */
3531 #define __A_MAGIC_SET__
3532 internal_a
.magic
= ZMAGIC
;
3536 #define __A_MAGIC_SET__
3537 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3540 #if defined MCORE_PE
3541 #define __A_MAGIC_SET__
3542 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3546 #define __A_MAGIC_SET__
3548 internal_a
.magic
= LYNXCOFFMAGIC
;
3550 internal_a
.magic
= ZMAGIC
;
3555 #define __A_MAGIC_SET__
3557 internal_a
.magic
= LYNXCOFFMAGIC
;
3562 #define __A_MAGIC_SET__
3563 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
3564 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
3565 RS6K_AOUTHDR_OMAGIC
;
3568 #if defined(SH) && defined(COFF_WITH_PE)
3569 #define __A_MAGIC_SET__
3570 internal_a
.magic
= SH_PE_MAGIC
;
3573 #if defined(MIPS) && defined(COFF_WITH_PE)
3574 #define __A_MAGIC_SET__
3575 internal_a
.magic
= MIPS_PE_MAGIC
;
3578 #ifndef __A_MAGIC_SET__
3579 #include "Your aouthdr magic number is not being set!"
3581 #undef __A_MAGIC_SET__
3585 /* FIXME: Does anybody ever set this to another value? */
3586 internal_a
.vstamp
= 0;
3588 /* Now should write relocs, strings, syms */
3589 obj_sym_filepos (abfd
) = sym_base
;
3591 if (bfd_get_symcount (abfd
) != 0)
3595 if (!coff_add_missing_symbols (abfd
))
3598 if (!coff_renumber_symbols (abfd
, &firstundef
))
3600 coff_mangle_symbols (abfd
);
3601 if (! coff_write_symbols (abfd
))
3603 if (! coff_write_linenumbers (abfd
))
3605 if (! coff_write_relocs (abfd
, firstundef
))
3608 #ifdef COFF_LONG_SECTION_NAMES
3609 else if (long_section_names
)
3611 /* If we have long section names we have to write out the string
3612 table even if there are no symbols. */
3613 if (! coff_write_symbols (abfd
))
3617 #ifdef COFF_IMAGE_WITH_PE
3619 else if ((abfd
->flags
& EXEC_P
) != 0)
3623 /* PowerPC PE appears to require that all executable files be
3624 rounded up to the page size. */
3627 BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
3629 || bfd_write (&b
, 1, 1, abfd
) != 1)
3635 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3636 backend linker, and obj_raw_syment_count is not valid until after
3637 coff_write_symbols is called. */
3638 if (obj_raw_syment_count (abfd
) != 0)
3640 internal_f
.f_symptr
= sym_base
;
3642 /* AIX appears to require that F_RELFLG not be set if there are
3643 local symbols but no relocations. */
3644 internal_f
.f_flags
&=~ F_RELFLG
;
3649 if (long_section_names
)
3650 internal_f
.f_symptr
= sym_base
;
3652 internal_f
.f_symptr
= 0;
3653 internal_f
.f_flags
|= F_LSYMS
;
3658 internal_a
.tsize
= bfd_get_section_size_before_reloc (text_sec
);
3659 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
3663 internal_a
.dsize
= bfd_get_section_size_before_reloc (data_sec
);
3664 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
3668 internal_a
.bsize
= bfd_get_section_size_before_reloc (bss_sec
);
3669 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
3670 internal_a
.data_start
= bss_sec
->vma
;
3673 internal_a
.entry
= bfd_get_start_address (abfd
);
3674 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
3677 if (xcoff_data (abfd
)->full_aouthdr
)
3680 asection
*loader_sec
;
3682 internal_a
.vstamp
= 1;
3684 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
3685 if (internal_a
.o_snentry
== 0)
3686 internal_a
.entry
= (bfd_vma
) -1;
3688 if (text_sec
!= NULL
)
3690 internal_a
.o_sntext
= text_sec
->target_index
;
3691 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
3695 internal_a
.o_sntext
= 0;
3696 internal_a
.o_algntext
= 0;
3698 if (data_sec
!= NULL
)
3700 internal_a
.o_sndata
= data_sec
->target_index
;
3701 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
3705 internal_a
.o_sndata
= 0;
3706 internal_a
.o_algndata
= 0;
3708 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
3709 if (loader_sec
!= NULL
)
3710 internal_a
.o_snloader
= loader_sec
->target_index
;
3712 internal_a
.o_snloader
= 0;
3713 if (bss_sec
!= NULL
)
3714 internal_a
.o_snbss
= bss_sec
->target_index
;
3716 internal_a
.o_snbss
= 0;
3718 toc
= xcoff_data (abfd
)->toc
;
3719 internal_a
.o_toc
= toc
;
3720 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
3722 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
3723 if (xcoff_data (abfd
)->cputype
!= -1)
3724 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
3727 switch (bfd_get_arch (abfd
))
3729 case bfd_arch_rs6000
:
3730 internal_a
.o_cputype
= 4;
3732 case bfd_arch_powerpc
:
3733 if (bfd_get_mach (abfd
) == 0)
3734 internal_a
.o_cputype
= 3;
3736 internal_a
.o_cputype
= 1;
3742 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
3743 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
3747 /* now write them */
3748 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
3753 bfd_size_type amount
;
3755 buff
= bfd_malloc (bfd_coff_filhsz (abfd
));
3759 coff_swap_filehdr_out (abfd
, (PTR
) & internal_f
, (PTR
) buff
);
3760 amount
= bfd_write ((PTR
) buff
, 1, bfd_coff_filhsz (abfd
), abfd
);
3764 if (amount
!= bfd_coff_filhsz (abfd
))
3768 if (abfd
->flags
& EXEC_P
)
3770 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
3771 include/coff/pe.h sets AOUTSZ == sizeof(PEAOUTHDR)) */
3773 bfd_size_type amount
;
3775 buff
= bfd_malloc (bfd_coff_aoutsz (abfd
));
3779 coff_swap_aouthdr_out (abfd
, (PTR
) & internal_a
, (PTR
) buff
);
3780 amount
= bfd_write ((PTR
) buff
, 1, bfd_coff_aoutsz (abfd
), abfd
);
3784 if (amount
!= bfd_coff_aoutsz (abfd
))
3793 /* XCOFF seems to always write at least a small a.out header. */
3794 coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, (PTR
) &buff
);
3795 if (xcoff_data (abfd
)->full_aouthdr
)
3796 size
= bfd_coff_aoutsz (abfd
);
3798 size
= SMALL_AOUTSZ
;
3799 if (bfd_write ((PTR
) &buff
, 1, size
, abfd
) != size
)
3808 coff_set_section_contents (abfd
, section
, location
, offset
, count
)
3813 bfd_size_type count
;
3815 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
3817 if (! coff_compute_section_file_positions (abfd
))
3821 #if defined(_LIB) && !defined(TARG_AUX)
3823 /* The physical address field of a .lib section is used to hold the
3824 number of shared libraries in the section. This code counts the
3825 number of sections being written, and increments the lma field
3828 I have found no documentation on the contents of this section.
3829 Experimentation indicates that the section contains zero or more
3830 records, each of which has the following structure:
3832 - a (four byte) word holding the length of this record, in words,
3833 - a word that always seems to be set to "2",
3834 - the path to a shared library, null-terminated and then padded
3835 to a whole word boundary.
3837 bfd_assert calls have been added to alert if an attempt is made
3838 to write a section which doesn't follow these assumptions. The
3839 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
3840 <robertl@arnet.com> (Thanks!).
3842 Gvran Uddeborg <gvran@uddeborg.pp.se> */
3844 if (strcmp (section
->name
, _LIB
) == 0)
3846 bfd_byte
*rec
, *recend
;
3848 rec
= (bfd_byte
*) location
;
3849 recend
= rec
+ count
;
3850 while (rec
< recend
)
3853 rec
+= bfd_get_32 (abfd
, rec
) * 4;
3856 BFD_ASSERT (rec
== recend
);
3861 /* Don't write out bss sections - one way to do this is to
3862 see if the filepos has not been set. */
3863 if (section
->filepos
== 0)
3866 if (bfd_seek (abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
) != 0)
3871 return (bfd_write (location
, 1, count
, abfd
) == count
) ? true : false;
3877 coff_close_and_cleanup (abfd
)
3880 if (!bfd_read_p (abfd
))
3881 switch (abfd
->format
)
3884 if (!_bfd_write_archive_contents (abfd
))
3888 if (!coff_write_object_contents (abfd
))
3892 bfd_set_error (bfd_error_invalid_operation
);
3896 /* We depend on bfd_close to free all the memory on the objalloc. */
3903 buy_and_read (abfd
, where
, seek_direction
, size
)
3909 PTR area
= (PTR
) bfd_alloc (abfd
, size
);
3912 if (bfd_seek (abfd
, where
, seek_direction
) != 0
3913 || bfd_read (area
, 1, size
, abfd
) != size
)
3916 } /* buy_and_read() */
3922 Creating the linenumber table is done by reading in the entire
3923 coff linenumber table, and creating another table for internal use.
3925 A coff linenumber table is structured so that each function
3926 is marked as having a line number of 0. Each line within the
3927 function is an offset from the first line in the function. The
3928 base of the line number information for the table is stored in
3929 the symbol associated with the function.
3931 Note: The PE format uses line number 0 for a flag indicating a
3934 The information is copied from the external to the internal
3935 table, and each symbol which marks a function is marked by
3938 How does this work ?
3943 coff_slurp_line_table (abfd
, asect
)
3947 LINENO
*native_lineno
;
3948 alent
*lineno_cache
;
3950 BFD_ASSERT (asect
->lineno
== (alent
*) NULL
);
3952 native_lineno
= (LINENO
*) buy_and_read (abfd
,
3953 asect
->line_filepos
,
3955 (size_t) (bfd_coff_linesz (abfd
) *
3956 asect
->lineno_count
));
3958 (alent
*) bfd_alloc (abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof (alent
)));
3959 if (lineno_cache
== NULL
)
3963 unsigned int counter
= 0;
3964 alent
*cache_ptr
= lineno_cache
;
3965 LINENO
*src
= native_lineno
;
3967 while (counter
< asect
->lineno_count
)
3969 struct internal_lineno dst
;
3970 coff_swap_lineno_in (abfd
, src
, &dst
);
3971 cache_ptr
->line_number
= dst
.l_lnno
;
3973 if (cache_ptr
->line_number
== 0)
3977 coff_symbol_type
*sym
;
3980 symndx
= dst
.l_addr
.l_symndx
;
3982 || (unsigned long) symndx
>= obj_raw_syment_count (abfd
))
3984 (*_bfd_error_handler
)
3985 (_("%s: warning: illegal symbol index %ld in line numbers"),
3986 bfd_get_filename (abfd
), dst
.l_addr
.l_symndx
);
3990 /* FIXME: We should not be casting between ints and
3991 pointers like this. */
3992 sym
= ((coff_symbol_type
*)
3993 ((symndx
+ obj_raw_syments (abfd
))
3994 ->u
.syment
._n
._n_n
._n_zeroes
));
3995 cache_ptr
->u
.sym
= (asymbol
*) sym
;
3996 if (sym
->lineno
!= NULL
&& ! warned
)
3998 (*_bfd_error_handler
)
3999 (_("%s: warning: duplicate line number information for `%s'"),
4000 bfd_get_filename (abfd
),
4001 bfd_asymbol_name (&sym
->symbol
));
4003 sym
->lineno
= cache_ptr
;
4007 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
4008 - bfd_section_vma (abfd
, asect
);
4009 } /* If no linenumber expect a symbol index */
4015 cache_ptr
->line_number
= 0;
4018 asect
->lineno
= lineno_cache
;
4019 /* FIXME, free native_lineno here, or use alloca or something. */
4023 /* Slurp in the symbol table, converting it to generic form. Note
4024 that if coff_relocate_section is defined, the linker will read
4025 symbols via coff_link_add_symbols, rather than via this routine. */
4028 coff_slurp_symbol_table (abfd
)
4031 combined_entry_type
*native_symbols
;
4032 coff_symbol_type
*cached_area
;
4033 unsigned int *table_ptr
;
4035 unsigned int number_of_symbols
= 0;
4037 if (obj_symbols (abfd
))
4040 /* Read in the symbol table */
4041 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4046 /* Allocate enough room for all the symbols in cached form */
4047 cached_area
= ((coff_symbol_type
*)
4049 (obj_raw_syment_count (abfd
)
4050 * sizeof (coff_symbol_type
))));
4052 if (cached_area
== NULL
)
4054 table_ptr
= ((unsigned int *)
4056 (obj_raw_syment_count (abfd
)
4057 * sizeof (unsigned int))));
4059 if (table_ptr
== NULL
)
4063 coff_symbol_type
*dst
= cached_area
;
4064 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4065 unsigned int this_index
= 0;
4066 while (this_index
< last_native_index
)
4068 combined_entry_type
*src
= native_symbols
+ this_index
;
4069 table_ptr
[this_index
] = number_of_symbols
;
4070 dst
->symbol
.the_bfd
= abfd
;
4072 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4073 /* We use the native name field to point to the cached field. */
4074 src
->u
.syment
._n
._n_n
._n_zeroes
= (long) dst
;
4075 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4076 src
->u
.syment
.n_scnum
);
4077 dst
->symbol
.flags
= 0;
4078 dst
->done_lineno
= false;
4080 switch (src
->u
.syment
.n_sclass
)
4085 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
4086 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4087 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4089 /* Fall through to next case */
4097 case C_THUMBEXTFUNC
:
4103 case C_SYSTEM
: /* System Wide variable */
4106 /* In PE, 0x68 (104) denotes a section symbol */
4108 /* In PE, 0x69 (105) denotes a weak external symbol. */
4111 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4113 case COFF_SYMBOL_GLOBAL
:
4114 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4115 #if defined COFF_WITH_PE
4116 /* PE sets the symbol to a value relative to the
4117 start of the section. */
4118 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4120 dst
->symbol
.value
= (src
->u
.syment
.n_value
4121 - dst
->symbol
.section
->vma
);
4123 if (ISFCN ((src
->u
.syment
.n_type
)))
4125 /* A function ext does not go at the end of a
4127 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4131 case COFF_SYMBOL_COMMON
:
4132 dst
->symbol
.section
= bfd_com_section_ptr
;
4133 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4136 case COFF_SYMBOL_UNDEFINED
:
4137 dst
->symbol
.section
= bfd_und_section_ptr
;
4138 dst
->symbol
.value
= 0;
4141 case COFF_SYMBOL_PE_SECTION
:
4142 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4143 dst
->symbol
.value
= 0;
4146 case COFF_SYMBOL_LOCAL
:
4147 dst
->symbol
.flags
= BSF_LOCAL
;
4148 #if defined COFF_WITH_PE
4149 /* PE sets the symbol to a value relative to the
4150 start of the section. */
4151 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4153 dst
->symbol
.value
= (src
->u
.syment
.n_value
4154 - dst
->symbol
.section
->vma
);
4156 if (ISFCN ((src
->u
.syment
.n_type
)))
4157 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4162 /* A symbol with a csect entry should not go at the end. */
4163 if (src
->u
.syment
.n_numaux
> 0)
4164 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4168 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4169 dst
->symbol
.flags
= BSF_WEAK
;
4170 if (src
->u
.syment
.n_sclass
== C_SECTION
4171 && src
->u
.syment
.n_scnum
> 0)
4173 dst
->symbol
.flags
= BSF_LOCAL
;
4177 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
)
4178 dst
->symbol
.flags
= BSF_WEAK
;
4182 case C_STAT
: /* static */
4184 case C_LEAFSTAT
: /* static leaf procedure */
4187 case C_THUMBSTAT
: /* Thumb static */
4188 case C_THUMBLABEL
: /* Thumb label */
4189 case C_THUMBSTATFUNC
:/* Thumb static function */
4191 case C_LABEL
: /* label */
4192 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4193 dst
->symbol
.flags
= BSF_DEBUGGING
;
4195 dst
->symbol
.flags
= BSF_LOCAL
;
4197 /* Base the value as an index from the base of the
4198 section, if there is one. */
4199 if (dst
->symbol
.section
)
4201 #if defined COFF_WITH_PE
4202 /* PE sets the symbol to a value relative to the
4203 start of the section. */
4204 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4206 dst
->symbol
.value
= (src
->u
.syment
.n_value
4207 - dst
->symbol
.section
->vma
);
4211 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4214 case C_MOS
: /* member of structure */
4215 case C_EOS
: /* end of structure */
4216 #ifdef NOTDEF /* C_AUTOARG has the same value */
4218 case C_GLBLREG
: /* A29k-specific storage class */
4221 case C_REGPARM
: /* register parameter */
4222 case C_REG
: /* register variable */
4225 case C_AUTOARG
: /* 960-specific storage class */
4228 case C_TPDEF
: /* type definition */
4230 case C_AUTO
: /* automatic variable */
4231 case C_FIELD
: /* bit field */
4232 case C_ENTAG
: /* enumeration tag */
4233 case C_MOE
: /* member of enumeration */
4234 case C_MOU
: /* member of union */
4235 case C_UNTAG
: /* union tag */
4236 dst
->symbol
.flags
= BSF_DEBUGGING
;
4237 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4240 case C_FILE
: /* file name */
4241 case C_STRTAG
: /* structure tag */
4256 dst
->symbol
.flags
= BSF_DEBUGGING
;
4257 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4261 case C_BINCL
: /* beginning of include file */
4262 case C_EINCL
: /* ending of include file */
4263 /* The value is actually a pointer into the line numbers
4264 of the file. We locate the line number entry, and
4265 set the section to the section which contains it, and
4266 the value to the index in that section. */
4270 dst
->symbol
.flags
= BSF_DEBUGGING
;
4271 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4272 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4273 && ((file_ptr
) (sec
->line_filepos
4274 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4275 > (file_ptr
) src
->u
.syment
.n_value
))
4278 dst
->symbol
.value
= 0;
4281 dst
->symbol
.section
= sec
;
4282 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4283 - sec
->line_filepos
)
4284 / bfd_coff_linesz (abfd
));
4291 dst
->symbol
.flags
= BSF_DEBUGGING
;
4293 /* The value is actually a symbol index. Save a pointer
4294 to the symbol instead of the index. FIXME: This
4295 should use a union. */
4296 src
->u
.syment
.n_value
=
4297 (long) (native_symbols
+ src
->u
.syment
.n_value
);
4298 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4303 case C_BLOCK
: /* ".bb" or ".eb" */
4304 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf") */
4305 case C_EFCN
: /* physical end of function */
4306 #if defined COFF_WITH_PE
4307 /* PE sets the symbol to a value relative to the start
4309 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4310 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4312 /* PE uses funny values for .ef and .lf; don't
4314 dst
->symbol
.flags
= BSF_DEBUGGING
;
4317 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4319 /* Base the value as an index from the base of the
4321 dst
->symbol
.flags
= BSF_LOCAL
;
4322 dst
->symbol
.value
= (src
->u
.syment
.n_value
4323 - dst
->symbol
.section
->vma
);
4327 case C_STATLAB
: /* Static load time label */
4328 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4329 dst
->symbol
.flags
= BSF_GLOBAL
;
4333 /* PE DLLs sometimes have zeroed out symbols for some
4334 reason. Just ignore them without a warning. */
4335 if (src
->u
.syment
.n_type
== 0
4336 && src
->u
.syment
.n_value
== 0
4337 && src
->u
.syment
.n_scnum
== 0)
4340 case C_EXTDEF
: /* external definition */
4341 case C_ULABEL
: /* undefined label */
4342 case C_USTATIC
: /* undefined static */
4343 #ifndef COFF_WITH_PE
4344 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4345 class to represent a section symbol */
4346 case C_LINE
: /* line # reformatted as symbol table entry */
4347 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4348 case C_ALIAS
: /* duplicate tag */
4350 /* New storage classes for TIc80 */
4352 case C_UEXT
: /* Tentative external definition */
4354 case C_EXTLAB
: /* External load time label */
4355 case C_HIDDEN
: /* ext symbol in dmert public lib */
4357 (*_bfd_error_handler
)
4358 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
4359 bfd_get_filename (abfd
), src
->u
.syment
.n_sclass
,
4360 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4361 dst
->symbol
.flags
= BSF_DEBUGGING
;
4362 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4366 /* BFD_ASSERT(dst->symbol.flags != 0);*/
4370 dst
->symbol
.udata
.i
= 0;
4371 dst
->lineno
= (alent
*) NULL
;
4372 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
4374 number_of_symbols
++;
4375 } /* walk the native symtab */
4376 } /* bfdize the native symtab */
4378 obj_symbols (abfd
) = cached_area
;
4379 obj_raw_syments (abfd
) = native_symbols
;
4381 bfd_get_symcount (abfd
) = number_of_symbols
;
4382 obj_convert (abfd
) = table_ptr
;
4383 /* Slurp the line tables for each section too */
4389 coff_slurp_line_table (abfd
, p
);
4394 } /* coff_slurp_symbol_table() */
4396 /* Classify a COFF symbol. A couple of targets have globally visible
4397 symbols which are not class C_EXT, and this handles those. It also
4398 recognizes some special PE cases. */
4400 static enum coff_symbol_classification
4401 coff_classify_symbol (abfd
, syment
)
4403 struct internal_syment
*syment
;
4405 /* FIXME: This partially duplicates the switch in
4406 coff_slurp_symbol_table. */
4407 switch (syment
->n_sclass
)
4416 case C_THUMBEXTFUNC
:
4424 if (syment
->n_scnum
== 0)
4426 if (syment
->n_value
== 0)
4427 return COFF_SYMBOL_UNDEFINED
;
4429 return COFF_SYMBOL_COMMON
;
4431 return COFF_SYMBOL_GLOBAL
;
4438 if (syment
->n_sclass
== C_STAT
)
4440 if (syment
->n_scnum
== 0)
4442 /* The Microsoft compiler sometimes generates these if a
4443 small static function is inlined every time it is used.
4444 The function is discarded, but the symbol table entry
4446 return COFF_SYMBOL_LOCAL
;
4449 #ifdef STRICT_PE_FORMAT
4450 /* This is correct for Microsoft generated objects, but it
4451 breaks gas generated objects. */
4453 if (syment
->n_value
== 0)
4456 char buf
[SYMNMLEN
+ 1];
4458 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
4460 && (strcmp (bfd_get_section_name (abfd
, sec
),
4461 _bfd_coff_internal_syment_name (abfd
, syment
, buf
))
4463 return COFF_SYMBOL_PE_SECTION
;
4467 return COFF_SYMBOL_LOCAL
;
4470 if (syment
->n_sclass
== C_SECTION
)
4472 /* In some cases in a DLL generated by the Microsoft linker, the
4473 n_value field will contain garbage. FIXME: This should
4474 probably be handled by the swapping function instead. */
4475 syment
->n_value
= 0;
4476 if (syment
->n_scnum
== 0)
4477 return COFF_SYMBOL_UNDEFINED
;
4478 return COFF_SYMBOL_PE_SECTION
;
4480 #endif /* COFF_WITH_PE */
4482 /* If it is not a global symbol, we presume it is a local symbol. */
4484 if (syment
->n_scnum
== 0)
4486 char buf
[SYMNMLEN
+ 1];
4488 (*_bfd_error_handler
)
4489 (_("warning: %s: local symbol `%s' has no section"),
4490 bfd_get_filename (abfd
),
4491 _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
4494 return COFF_SYMBOL_LOCAL
;
4501 Coff relocations are easily transformed into the internal BFD form
4504 Reading a coff relocation table is done in the following stages:
4506 o Read the entire coff relocation table into memory.
4508 o Process each relocation in turn; first swap it from the
4509 external to the internal form.
4511 o Turn the symbol referenced in the relocation's symbol index
4512 into a pointer into the canonical symbol table.
4513 This table is the same as the one returned by a call to
4514 @code{bfd_canonicalize_symtab}. The back end will call that
4515 routine and save the result if a canonicalization hasn't been done.
4517 o The reloc index is turned into a pointer to a howto
4518 structure, in a back end specific way. For instance, the 386
4519 and 960 use the @code{r_type} to directly produce an index
4520 into a howto table vector; the 88k subtracts a number from the
4521 @code{r_type} field and creates an addend field.
4527 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
4529 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
4530 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
4531 coffsym = (obj_symbols (abfd) \
4532 + (cache_ptr->sym_ptr_ptr - symbols)); \
4534 coffsym = coff_symbol_from (abfd, ptr); \
4535 if (coffsym != (coff_symbol_type *) NULL \
4536 && coffsym->native->u.syment.n_scnum == 0) \
4537 cache_ptr->addend = 0; \
4538 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
4539 && ptr->section != (asection *) NULL) \
4540 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
4542 cache_ptr->addend = 0; \
4547 coff_slurp_reloc_table (abfd
, asect
, symbols
)
4552 RELOC
*native_relocs
;
4553 arelent
*reloc_cache
;
4558 if (asect
->relocation
)
4560 if (asect
->reloc_count
== 0)
4562 if (asect
->flags
& SEC_CONSTRUCTOR
)
4564 if (!coff_slurp_symbol_table (abfd
))
4567 (RELOC
*) buy_and_read (abfd
,
4570 (size_t) (bfd_coff_relsz (abfd
) *
4571 asect
->reloc_count
));
4572 reloc_cache
= (arelent
*)
4573 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
4575 if (reloc_cache
== NULL
)
4579 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
4581 struct internal_reloc dst
;
4582 struct external_reloc
*src
;
4583 #ifndef RELOC_PROCESSING
4587 cache_ptr
= reloc_cache
+ idx
;
4588 src
= native_relocs
+ idx
;
4590 coff_swap_reloc_in (abfd
, src
, &dst
);
4592 #ifdef RELOC_PROCESSING
4593 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
4595 cache_ptr
->address
= dst
.r_vaddr
;
4597 if (dst
.r_symndx
!= -1)
4599 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
4601 (*_bfd_error_handler
)
4602 (_("%s: warning: illegal symbol index %ld in relocs"),
4603 bfd_get_filename (abfd
), dst
.r_symndx
);
4604 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
4609 cache_ptr
->sym_ptr_ptr
= (symbols
4610 + obj_convert (abfd
)[dst
.r_symndx
]);
4611 ptr
= *(cache_ptr
->sym_ptr_ptr
);
4616 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
4620 /* The symbols definitions that we have read in have been
4621 relocated as if their sections started at 0. But the offsets
4622 refering to the symbols in the raw data have not been
4623 modified, so we have to have a negative addend to compensate.
4625 Note that symbols which used to be common must be left alone */
4627 /* Calculate any reloc addend by looking at the symbol */
4628 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
4630 cache_ptr
->address
-= asect
->vma
;
4631 /* !! cache_ptr->section = (asection *) NULL;*/
4633 /* Fill in the cache_ptr->howto field from dst.r_type */
4634 RTYPE2HOWTO (cache_ptr
, &dst
);
4635 #endif /* RELOC_PROCESSING */
4637 if (cache_ptr
->howto
== NULL
)
4639 (*_bfd_error_handler
)
4640 (_("%s: illegal relocation type %d at address 0x%lx"),
4641 bfd_get_filename (abfd
), dst
.r_type
, (long) dst
.r_vaddr
);
4642 bfd_set_error (bfd_error_bad_value
);
4647 asect
->relocation
= reloc_cache
;
4651 #ifndef coff_rtype_to_howto
4654 /* Get the howto structure for a reloc. This is only used if the file
4655 including this one defines coff_relocate_section to be
4656 _bfd_coff_generic_relocate_section, so it is OK if it does not
4657 always work. It is the responsibility of the including file to
4658 make sure it is reasonable if it is needed. */
4660 static reloc_howto_type
*coff_rtype_to_howto
4661 PARAMS ((bfd
*, asection
*, struct internal_reloc
*,
4662 struct coff_link_hash_entry
*, struct internal_syment
*,
4666 static reloc_howto_type
*
4667 coff_rtype_to_howto (abfd
, sec
, rel
, h
, sym
, addendp
)
4668 bfd
*abfd ATTRIBUTE_UNUSED
;
4669 asection
*sec ATTRIBUTE_UNUSED
;
4670 struct internal_reloc
*rel
;
4671 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
;
4672 struct internal_syment
*sym ATTRIBUTE_UNUSED
;
4673 bfd_vma
*addendp ATTRIBUTE_UNUSED
;
4677 RTYPE2HOWTO (&genrel
, rel
);
4678 return genrel
.howto
;
4681 #else /* ! defined (RTYPE2HOWTO) */
4683 #define coff_rtype_to_howto NULL
4685 #endif /* ! defined (RTYPE2HOWTO) */
4686 #endif /* ! defined (coff_rtype_to_howto) */
4688 /* This is stupid. This function should be a boolean predicate. */
4690 coff_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
4696 arelent
*tblptr
= section
->relocation
;
4697 unsigned int count
= 0;
4700 if (section
->flags
& SEC_CONSTRUCTOR
)
4702 /* this section has relocs made up by us, they are not in the
4703 file, so take them out of their chain and place them into
4704 the data area provided */
4705 arelent_chain
*chain
= section
->constructor_chain
;
4706 for (count
= 0; count
< section
->reloc_count
; count
++)
4708 *relptr
++ = &chain
->relent
;
4709 chain
= chain
->next
;
4715 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
4718 tblptr
= section
->relocation
;
4720 for (; count
++ < section
->reloc_count
;)
4721 *relptr
++ = tblptr
++;
4726 return section
->reloc_count
;
4731 coff_sym_filepos (abfd
)
4734 return obj_sym_filepos (abfd
);
4738 #ifndef coff_reloc16_estimate
4739 #define coff_reloc16_estimate dummy_reloc16_estimate
4741 static int dummy_reloc16_estimate
4742 PARAMS ((bfd
*, asection
*, arelent
*, unsigned int,
4743 struct bfd_link_info
*));
4746 dummy_reloc16_estimate (abfd
, input_section
, reloc
, shrink
, link_info
)
4747 bfd
*abfd ATTRIBUTE_UNUSED
;
4748 asection
*input_section ATTRIBUTE_UNUSED
;
4749 arelent
*reloc ATTRIBUTE_UNUSED
;
4750 unsigned int shrink ATTRIBUTE_UNUSED
;
4751 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
4759 #ifndef coff_reloc16_extra_cases
4761 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
4763 /* This works even if abort is not declared in any header file. */
4765 static void dummy_reloc16_extra_cases
4766 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*, arelent
*,
4767 bfd_byte
*, unsigned int *, unsigned int *));
4770 dummy_reloc16_extra_cases (abfd
, link_info
, link_order
, reloc
, data
, src_ptr
,
4772 bfd
*abfd ATTRIBUTE_UNUSED
;
4773 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
4774 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
;
4775 arelent
*reloc ATTRIBUTE_UNUSED
;
4776 bfd_byte
*data ATTRIBUTE_UNUSED
;
4777 unsigned int *src_ptr ATTRIBUTE_UNUSED
;
4778 unsigned int *dst_ptr ATTRIBUTE_UNUSED
;
4784 /* If coff_relocate_section is defined, we can use the optimized COFF
4785 backend linker. Otherwise we must continue to use the old linker. */
4786 #ifdef coff_relocate_section
4787 #ifndef coff_bfd_link_hash_table_create
4788 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
4790 #ifndef coff_bfd_link_add_symbols
4791 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
4793 #ifndef coff_bfd_final_link
4794 #define coff_bfd_final_link _bfd_coff_final_link
4796 #else /* ! defined (coff_relocate_section) */
4797 #define coff_relocate_section NULL
4798 #ifndef coff_bfd_link_hash_table_create
4799 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
4801 #ifndef coff_bfd_link_add_symbols
4802 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
4804 #define coff_bfd_final_link _bfd_generic_final_link
4805 #endif /* ! defined (coff_relocate_section) */
4807 #define coff_bfd_link_split_section _bfd_generic_link_split_section
4809 #ifndef coff_start_final_link
4810 #define coff_start_final_link NULL
4813 #ifndef coff_adjust_symndx
4814 #define coff_adjust_symndx NULL
4817 #ifndef coff_link_add_one_symbol
4818 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
4821 #ifndef coff_link_output_has_begun
4823 static boolean coff_link_output_has_begun
4824 PARAMS ((bfd
*, struct coff_final_link_info
*));
4827 coff_link_output_has_begun (abfd
, info
)
4829 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
;
4831 return abfd
->output_has_begun
;
4835 #ifndef coff_final_link_postscript
4837 static boolean coff_final_link_postscript
4838 PARAMS ((bfd
*, struct coff_final_link_info
*));
4841 coff_final_link_postscript (abfd
, pfinfo
)
4842 bfd
* abfd ATTRIBUTE_UNUSED
;
4843 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
;
4849 #ifndef coff_SWAP_aux_in
4850 #define coff_SWAP_aux_in coff_swap_aux_in
4852 #ifndef coff_SWAP_sym_in
4853 #define coff_SWAP_sym_in coff_swap_sym_in
4855 #ifndef coff_SWAP_lineno_in
4856 #define coff_SWAP_lineno_in coff_swap_lineno_in
4858 #ifndef coff_SWAP_aux_out
4859 #define coff_SWAP_aux_out coff_swap_aux_out
4861 #ifndef coff_SWAP_sym_out
4862 #define coff_SWAP_sym_out coff_swap_sym_out
4864 #ifndef coff_SWAP_lineno_out
4865 #define coff_SWAP_lineno_out coff_swap_lineno_out
4867 #ifndef coff_SWAP_reloc_out
4868 #define coff_SWAP_reloc_out coff_swap_reloc_out
4870 #ifndef coff_SWAP_filehdr_out
4871 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
4873 #ifndef coff_SWAP_aouthdr_out
4874 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
4876 #ifndef coff_SWAP_scnhdr_out
4877 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
4879 #ifndef coff_SWAP_reloc_in
4880 #define coff_SWAP_reloc_in coff_swap_reloc_in
4882 #ifndef coff_SWAP_filehdr_in
4883 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
4885 #ifndef coff_SWAP_aouthdr_in
4886 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
4888 #ifndef coff_SWAP_scnhdr_in
4889 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
4892 static const bfd_coff_backend_data bfd_coff_std_swap_table
=
4894 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
4895 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
4896 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
4897 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
4898 coff_SWAP_scnhdr_out
,
4899 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
4900 #ifdef COFF_LONG_FILENAMES
4905 #ifdef COFF_LONG_SECTION_NAMES
4910 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
4911 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
4912 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
4913 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
4914 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
4915 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
4916 coff_classify_symbol
, coff_compute_section_file_positions
,
4917 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
4918 coff_adjust_symndx
, coff_link_add_one_symbol
,
4919 coff_link_output_has_begun
, coff_final_link_postscript
4922 #ifndef coff_close_and_cleanup
4923 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
4926 #ifndef coff_bfd_free_cached_info
4927 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
4930 #ifndef coff_get_section_contents
4931 #define coff_get_section_contents _bfd_generic_get_section_contents
4934 #ifndef coff_bfd_copy_private_symbol_data
4935 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
4938 #ifndef coff_bfd_copy_private_section_data
4939 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
4942 #ifndef coff_bfd_copy_private_bfd_data
4943 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
4946 #ifndef coff_bfd_merge_private_bfd_data
4947 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
4950 #ifndef coff_bfd_set_private_flags
4951 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
4954 #ifndef coff_bfd_print_private_bfd_data
4955 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
4958 #ifndef coff_bfd_is_local_label_name
4959 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
4962 #ifndef coff_read_minisymbols
4963 #define coff_read_minisymbols _bfd_generic_read_minisymbols
4966 #ifndef coff_minisymbol_to_symbol
4967 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
4970 /* The reloc lookup routine must be supplied by each individual COFF
4972 #ifndef coff_bfd_reloc_type_lookup
4973 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4976 #ifndef coff_bfd_get_relocated_section_contents
4977 #define coff_bfd_get_relocated_section_contents \
4978 bfd_generic_get_relocated_section_contents
4981 #ifndef coff_bfd_relax_section
4982 #define coff_bfd_relax_section bfd_generic_relax_section
4985 #ifndef coff_bfd_gc_sections
4986 #define coff_bfd_gc_sections bfd_generic_gc_sections
4989 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
4990 const bfd_target VAR = \
4993 bfd_target_coff_flavour, \
4994 BFD_ENDIAN_BIG, /* data byte order is big */ \
4995 BFD_ENDIAN_BIG, /* header byte order is big */ \
4996 /* object flags */ \
4997 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
4998 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
4999 /* section flags */ \
5000 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5001 UNDER, /* leading symbol underscore */ \
5002 '/', /* ar_pad_char */ \
5003 15, /* ar_max_namelen */ \
5005 /* Data conversion functions. */ \
5006 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5007 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5008 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5010 /* Header conversion functions. */ \
5011 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5012 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5013 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5015 /* bfd_check_format */ \
5016 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5017 _bfd_dummy_target }, \
5018 /* bfd_set_format */ \
5019 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5020 /* bfd_write_contents */ \
5021 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5024 BFD_JUMP_TABLE_GENERIC (coff), \
5025 BFD_JUMP_TABLE_COPY (coff), \
5026 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5027 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5028 BFD_JUMP_TABLE_SYMBOLS (coff), \
5029 BFD_JUMP_TABLE_RELOCS (coff), \
5030 BFD_JUMP_TABLE_WRITE (coff), \
5031 BFD_JUMP_TABLE_LINK (coff), \
5032 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5039 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
5040 const bfd_target VAR = \
5043 bfd_target_coff_flavour, \
5044 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
5045 BFD_ENDIAN_LITTLE, /* header byte order is little */ \
5046 /* object flags */ \
5047 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5048 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5049 /* section flags */ \
5050 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5051 UNDER, /* leading symbol underscore */ \
5052 '/', /* ar_pad_char */ \
5053 15, /* ar_max_namelen */ \
5055 /* Data conversion functions. */ \
5056 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5057 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5058 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5059 /* Header conversion functions. */ \
5060 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5061 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5062 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5063 /* bfd_check_format */ \
5064 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5065 _bfd_dummy_target }, \
5066 /* bfd_set_format */ \
5067 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5068 /* bfd_write_contents */ \
5069 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5072 BFD_JUMP_TABLE_GENERIC (coff), \
5073 BFD_JUMP_TABLE_COPY (coff), \
5074 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5075 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5076 BFD_JUMP_TABLE_SYMBOLS (coff), \
5077 BFD_JUMP_TABLE_RELOCS (coff), \
5078 BFD_JUMP_TABLE_WRITE (coff), \
5079 BFD_JUMP_TABLE_LINK (coff), \
5080 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \