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.
178 The symbol table is massaged once again, this time to create
179 the canonical table used by the BFD application. Each symbol
180 is inspected in turn, and a decision made (using the
181 @code{sclass} field) about the various flags to set in the
182 @code{asymbol}. @xref{Symbols}. The generated canonical table
183 shares strings with the hidden internal symbol table.
185 Any linenumbers are read from the coff file too, and attached
186 to the symbols which own the functions the linenumbers belong to.
191 Writing a symbol to a coff file which didn't come from a coff
192 file will lose any debugging information. The @code{asymbol}
193 structure remembers the BFD from which the symbol was taken, and on
194 output the back end makes sure that the same destination target as
195 source target is present.
197 When the symbols have come from a coff file then all the
198 debugging information is preserved.
200 Symbol tables are provided for writing to the back end in a
201 vector of pointers to pointers. This allows applications like
202 the linker to accumulate and output large symbol tables
203 without having to do too much byte copying.
205 This function runs through the provided symbol table and
206 patches each symbol marked as a file place holder
207 (@code{C_FILE}) to point to the next file place holder in the
208 list. It also marks each @code{offset} field in the list with
209 the offset from the first symbol of the current symbol.
211 Another function of this procedure is to turn the canonical
212 value form of BFD into the form used by coff. Internally, BFD
213 expects symbol values to be offsets from a section base; so a
214 symbol physically at 0x120, but in a section starting at
215 0x100, would have the value 0x20. Coff expects symbols to
216 contain their final value, so symbols have their values
217 changed at this point to reflect their sum with their owning
218 section. This transformation uses the
219 <<output_section>> field of the @code{asymbol}'s
220 @code{asection} @xref{Sections}.
222 o <<coff_mangle_symbols>>
224 This routine runs though the provided symbol table and uses
225 the offsets generated by the previous pass and the pointers
226 generated when the symbol table was read in to create the
227 structured hierachy required by coff. It changes each pointer
228 to a symbol into the index into the symbol table of the asymbol.
230 o <<coff_write_symbols>>
232 This routine runs through the symbol table and patches up the
233 symbols from their internal form into the coff way, calls the
234 bit twiddlers, and writes out the table to the file.
243 The hidden information for an <<asymbol>> is described in a
244 <<combined_entry_type>>:
248 .typedef struct coff_ptr_struct
251 . {* Remembers the offset from the first symbol in the file for
252 . this symbol. Generated by coff_renumber_symbols. *}
253 .unsigned int offset;
255 . {* Should the value of this symbol be renumbered. Used for
256 . XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
257 .unsigned int fix_value : 1;
259 . {* Should the tag field of this symbol be renumbered.
260 . Created by coff_pointerize_aux. *}
261 .unsigned int fix_tag : 1;
263 . {* Should the endidx field of this symbol be renumbered.
264 . Created by coff_pointerize_aux. *}
265 .unsigned int fix_end : 1;
267 . {* Should the x_csect.x_scnlen field be renumbered.
268 . Created by coff_pointerize_aux. *}
269 .unsigned int fix_scnlen : 1;
271 . {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
272 . index into the line number entries. Set by
273 . coff_slurp_symbol_table. *}
274 .unsigned int fix_line : 1;
276 . {* The container for the symbol structure as read and translated
280 . union internal_auxent auxent;
281 . struct internal_syment syment;
283 .} combined_entry_type;
286 .{* Each canonical asymbol really looks like this: *}
288 .typedef struct coff_symbol_struct
290 . {* The actual symbol which the rest of BFD works with *}
293 . {* A pointer to the hidden information for this symbol *}
294 .combined_entry_type *native;
296 . {* A pointer to the linenumber information for this symbol *}
297 .struct lineno_cache_entry *lineno;
299 . {* Have the line numbers been relocated yet ? *}
300 .boolean done_lineno;
308 #include "coffswap.h"
311 #define STRING_SIZE_SIZE (4)
313 static long sec_to_styp_flags
PARAMS ((const char *, flagword
));
314 static flagword styp_to_sec_flags
315 PARAMS ((bfd
*, PTR
, const char *, asection
*));
316 static boolean coff_bad_format_hook
PARAMS ((bfd
*, PTR
));
317 static void coff_set_custom_section_alignment
318 PARAMS ((bfd
*, asection
*, const struct coff_section_alignment_entry
*,
319 const unsigned int));
320 static boolean coff_new_section_hook
PARAMS ((bfd
*, asection
*));
321 static boolean coff_set_arch_mach_hook
PARAMS ((bfd
*, PTR
));
322 static boolean coff_write_relocs
PARAMS ((bfd
*, int));
323 static boolean coff_set_flags
324 PARAMS ((bfd
*, unsigned int *, unsigned short *));
325 static boolean coff_set_arch_mach
326 PARAMS ((bfd
*, enum bfd_architecture
, unsigned long));
327 static boolean coff_compute_section_file_positions
PARAMS ((bfd
*));
328 static boolean coff_write_object_contents
PARAMS ((bfd
*));
329 static boolean coff_set_section_contents
330 PARAMS ((bfd
*, asection
*, PTR
, file_ptr
, bfd_size_type
));
331 static PTR buy_and_read
PARAMS ((bfd
*, file_ptr
, int, size_t));
332 static boolean coff_slurp_line_table
PARAMS ((bfd
*, asection
*));
333 static boolean coff_slurp_symbol_table
PARAMS ((bfd
*));
334 static enum coff_symbol_classification coff_classify_symbol
335 PARAMS ((bfd
*, struct internal_syment
*));
336 static boolean coff_slurp_reloc_table
PARAMS ((bfd
*, asection
*, asymbol
**));
337 static long coff_canonicalize_reloc
338 PARAMS ((bfd
*, asection
*, arelent
**, asymbol
**));
339 #ifndef coff_mkobject_hook
340 static PTR coff_mkobject_hook
PARAMS ((bfd
*, PTR
, PTR
));
343 /* void warning(); */
345 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
346 the incoming SEC_* flags. The inverse of this function is
347 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
348 should probably mirror the changes in styp_to_sec_flags(). */
353 sec_to_styp_flags (sec_name
, sec_flags
)
354 CONST
char *sec_name
;
359 if (!strcmp (sec_name
, _TEXT
))
361 styp_flags
= STYP_TEXT
;
363 else if (!strcmp (sec_name
, _DATA
))
365 styp_flags
= STYP_DATA
;
367 else if (!strcmp (sec_name
, _BSS
))
369 styp_flags
= STYP_BSS
;
372 else if (!strcmp (sec_name
, _COMMENT
))
374 styp_flags
= STYP_INFO
;
375 #endif /* _COMMENT */
378 else if (!strcmp (sec_name
, _LIB
))
380 styp_flags
= STYP_LIB
;
384 else if (!strcmp (sec_name
, _LIT
))
386 styp_flags
= STYP_LIT
;
389 else if (!strcmp (sec_name
, ".debug"))
392 styp_flags
= STYP_DEBUG
;
394 styp_flags
= STYP_INFO
;
397 else if (!strncmp (sec_name
, ".stab", 5))
399 #ifdef COFF_ALIGN_IN_S_FLAGS
400 styp_flags
= STYP_DSECT
;
402 styp_flags
= STYP_INFO
;
406 else if (!strcmp (sec_name
, _PAD
))
408 styp_flags
= STYP_PAD
;
410 else if (!strcmp (sec_name
, _LOADER
))
412 styp_flags
= STYP_LOADER
;
415 /* Try and figure out what it should be */
416 else if (sec_flags
& SEC_CODE
)
418 styp_flags
= STYP_TEXT
;
420 else if (sec_flags
& SEC_DATA
)
422 styp_flags
= STYP_DATA
;
424 else if (sec_flags
& SEC_READONLY
)
426 #ifdef STYP_LIT /* 29k readonly text/data section */
427 styp_flags
= STYP_LIT
;
429 styp_flags
= STYP_TEXT
;
430 #endif /* STYP_LIT */
432 else if (sec_flags
& SEC_LOAD
)
434 styp_flags
= STYP_TEXT
;
436 else if (sec_flags
& SEC_ALLOC
)
438 styp_flags
= STYP_BSS
;
442 if (sec_flags
& SEC_CLINK
)
443 styp_flags
|= STYP_CLINK
;
447 if (sec_flags
& SEC_BLOCK
)
448 styp_flags
|= STYP_BLOCK
;
452 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
453 styp_flags
|= STYP_NOLOAD
;
459 #else /* COFF_WITH_PE */
461 /* The PE version; see above for the general comments. The non-PE
462 case seems to be more guessing, and breaks PE format; specifically,
463 .rdata is readonly, but it sure ain't text. Really, all this
464 should be set up properly in gas (or whatever assembler is in use),
465 and honor whatever objcopy/strip, etc. sent us as input. */
468 sec_to_styp_flags (sec_name
, sec_flags
)
469 const char *sec_name ATTRIBUTE_UNUSED
;
474 /* caution: there are at least three groups of symbols that have
475 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
476 SEC_* are the BFD internal flags, used for generic BFD
477 information. STYP_* are the COFF section flags which appear in
478 COFF files. IMAGE_SCN_* are the PE section flags which appear in
479 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
480 but there are more IMAGE_SCN_* flags. */
485 if ((sec_flags
& SEC_CODE
) != 0)
486 styp_flags
|= IMAGE_SCN_CNT_CODE
;
487 if ((sec_flags
& SEC_DATA
) != 0)
488 styp_flags
|= IMAGE_SCN_CNT_INITIALIZED_DATA
;
489 if ((sec_flags
& SEC_ALLOC
) != 0 && (sec_flags
& SEC_LOAD
) == 0)
490 styp_flags
|= IMAGE_SCN_CNT_UNINITIALIZED_DATA
; /* ==STYP_BSS */
492 /* skip CONSTRUCTOR */
495 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
496 styp_flags
|= STYP_NOLOAD
;
498 if ((sec_flags
& SEC_IS_COMMON
) != 0)
499 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
500 if ((sec_flags
& SEC_DEBUGGING
) != 0)
501 styp_flags
|= IMAGE_SCN_MEM_DISCARDABLE
;
502 if ((sec_flags
& SEC_EXCLUDE
) != 0)
503 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
504 if ((sec_flags
& SEC_NEVER_LOAD
) != 0)
505 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
508 if (sec_flags
& SEC_LINK_ONCE
)
509 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
510 /* skip LINK_DUPLICATES */
511 /* skip LINKER_CREATED */
513 /* For now, the read/write bits are mapped onto SEC_READONLY, even
514 though the semantics don't quite match. The bits from the input
515 are retained in pei_section_data(abfd, section)->pe_flags */
517 styp_flags
|= IMAGE_SCN_MEM_READ
; /* always readable. */
518 if ((sec_flags
& SEC_READONLY
) == 0)
519 styp_flags
|= IMAGE_SCN_MEM_WRITE
; /* Invert READONLY for write */
520 if (sec_flags
& SEC_CODE
)
521 styp_flags
|= IMAGE_SCN_MEM_EXECUTE
; /* CODE->EXECUTE */
522 if (sec_flags
& SEC_SHARED
)
523 styp_flags
|= IMAGE_SCN_MEM_SHARED
; /* Shared remains meaningful */
528 #endif /* COFF_WITH_PE */
530 /* Return a word with SEC_* flags set to represent the incoming STYP_*
531 flags (from scnhdr.s_flags). The inverse of this function is
532 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
533 should probably mirror the changes in sec_to_styp_flags(). */
538 styp_to_sec_flags (abfd
, hdr
, name
, section
)
539 bfd
*abfd ATTRIBUTE_UNUSED
;
542 asection
*section ATTRIBUTE_UNUSED
;
544 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
545 long styp_flags
= internal_s
->s_flags
;
546 flagword sec_flags
= 0;
549 if (styp_flags
& STYP_BLOCK
)
550 sec_flags
|= SEC_BLOCK
;
554 if (styp_flags
& STYP_CLINK
)
555 sec_flags
|= SEC_CLINK
;
559 if (styp_flags
& STYP_NOLOAD
)
561 sec_flags
|= SEC_NEVER_LOAD
;
563 #endif /* STYP_NOLOAD */
565 /* For 386 COFF, at least, an unloadable text or data section is
566 actually a shared library section. */
567 if (styp_flags
& STYP_TEXT
)
569 if (sec_flags
& SEC_NEVER_LOAD
)
570 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
572 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
574 else if (styp_flags
& STYP_DATA
)
576 if (sec_flags
& SEC_NEVER_LOAD
)
577 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
579 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
581 else if (styp_flags
& STYP_BSS
)
583 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
584 if (sec_flags
& SEC_NEVER_LOAD
)
585 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
588 sec_flags
|= SEC_ALLOC
;
590 else if (styp_flags
& STYP_INFO
)
592 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
593 defined. coff_compute_section_file_positions uses
594 COFF_PAGE_SIZE to ensure that the low order bits of the
595 section VMA and the file offset match. If we don't know
596 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
597 and demand page loading of the file will fail. */
598 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
599 sec_flags
|= SEC_DEBUGGING
;
602 else if (styp_flags
& STYP_PAD
)
606 else if (strcmp (name
, _TEXT
) == 0)
608 if (sec_flags
& SEC_NEVER_LOAD
)
609 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
611 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
613 else if (strcmp (name
, _DATA
) == 0)
615 if (sec_flags
& SEC_NEVER_LOAD
)
616 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
618 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
620 else if (strcmp (name
, _BSS
) == 0)
622 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
623 if (sec_flags
& SEC_NEVER_LOAD
)
624 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
627 sec_flags
|= SEC_ALLOC
;
629 else if (strcmp (name
, ".debug") == 0
631 || strcmp (name
, _COMMENT
) == 0
633 || strncmp (name
, ".stab", 5) == 0)
635 #ifdef COFF_PAGE_SIZE
636 sec_flags
|= SEC_DEBUGGING
;
640 else if (strcmp (name
, _LIB
) == 0)
644 else if (strcmp (name
, _LIT
) == 0)
646 sec_flags
= SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
651 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
654 #ifdef STYP_LIT /* A29k readonly text/data section type */
655 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
657 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
659 #endif /* STYP_LIT */
660 #ifdef STYP_OTHER_LOAD /* Other loaded sections */
661 if (styp_flags
& STYP_OTHER_LOAD
)
663 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
665 #endif /* STYP_SDATA */
667 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
668 /* As a GNU extension, if the name begins with .gnu.linkonce, we
669 only link a single copy of the section. This is used to support
670 g++. g++ will emit each template expansion in its own section.
671 The symbols will be defined as weak, so that multiple definitions
672 are permitted. The GNU linker extension is to actually discard
673 all but one of the sections. */
674 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
675 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
681 #else /* COFF_WITH_PE */
683 /* The PE version; see above for the general comments.
685 Since to set the SEC_LINK_ONCE and associated flags, we have to
686 look at the symbol table anyway, we return the symbol table index
687 of the symbol being used as the COMDAT symbol. This is admittedly
688 ugly, but there's really nowhere else that we have access to the
689 required information. FIXME: Is the COMDAT symbol index used for
690 any purpose other than objdump? */
693 styp_to_sec_flags (abfd
, hdr
, name
, section
)
694 bfd
*abfd ATTRIBUTE_UNUSED
;
699 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
700 long styp_flags
= internal_s
->s_flags
;
701 flagword sec_flags
= 0;
703 if (styp_flags
& STYP_DSECT
)
704 abort (); /* Don't know what to do */
705 #ifdef SEC_NEVER_LOAD
706 if (styp_flags
& STYP_NOLOAD
)
707 sec_flags
|= SEC_NEVER_LOAD
;
709 if (styp_flags
& STYP_GROUP
)
710 abort (); /* Don't know what to do */
711 /* skip IMAGE_SCN_TYPE_NO_PAD */
712 if (styp_flags
& STYP_COPY
)
713 abort (); /* Don't know what to do */
714 if (styp_flags
& IMAGE_SCN_CNT_CODE
)
715 sec_flags
|= SEC_CODE
| SEC_ALLOC
| SEC_LOAD
;
716 if (styp_flags
& IMAGE_SCN_CNT_INITIALIZED_DATA
)
717 sec_flags
|= SEC_DATA
| SEC_ALLOC
| SEC_LOAD
;
718 if (styp_flags
& IMAGE_SCN_CNT_UNINITIALIZED_DATA
)
719 sec_flags
|= SEC_ALLOC
;
720 if (styp_flags
& IMAGE_SCN_LNK_OTHER
)
721 abort (); /* Don't know what to do */
722 if (styp_flags
& IMAGE_SCN_LNK_INFO
)
724 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
725 defined. coff_compute_section_file_positions uses
726 COFF_PAGE_SIZE to ensure that the low order bits of the
727 section VMA and the file offset match. If we don't know
728 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
729 and demand page loading of the file will fail. */
730 #ifdef COFF_PAGE_SIZE
731 sec_flags
|= SEC_DEBUGGING
;
734 if (styp_flags
& STYP_OVER
)
735 abort (); /* Don't know what to do */
736 if (styp_flags
& IMAGE_SCN_LNK_REMOVE
)
737 sec_flags
|= SEC_EXCLUDE
;
739 if (styp_flags
& IMAGE_SCN_MEM_SHARED
)
740 sec_flags
|= SEC_SHARED
;
741 /* COMDAT: see below */
742 if (styp_flags
& IMAGE_SCN_MEM_DISCARDABLE
)
743 sec_flags
|= SEC_DEBUGGING
;
744 if (styp_flags
& IMAGE_SCN_MEM_NOT_CACHED
)
745 abort ();/* Don't know what to do */
746 if (styp_flags
& IMAGE_SCN_MEM_NOT_PAGED
)
747 abort (); /* Don't know what to do */
749 /* We infer from the distinct read/write/execute bits the settings
750 of some of the bfd flags; the actual values, should we need them,
751 are also in pei_section_data (abfd, section)->pe_flags. */
753 if (styp_flags
& IMAGE_SCN_MEM_EXECUTE
)
754 sec_flags
|= SEC_CODE
; /* Probably redundant */
755 /* IMAGE_SCN_MEM_READ is simply ignored, assuming it always to be true. */
756 if ((styp_flags
& IMAGE_SCN_MEM_WRITE
) == 0)
757 sec_flags
|= SEC_READONLY
;
759 /* COMDAT gets very special treatment. */
760 if (styp_flags
& IMAGE_SCN_LNK_COMDAT
)
762 sec_flags
|= SEC_LINK_ONCE
;
764 /* Unfortunately, the PE format stores essential information in
765 the symbol table, of all places. We need to extract that
766 information now, so that objdump and the linker will know how
767 to handle the section without worrying about the symbols. We
768 can't call slurp_symtab, because the linker doesn't want the
771 /* COMDAT sections are special. The first symbol is the section
772 symbol, which tells what kind of COMDAT section it is. The
773 second symbol is the "comdat symbol" - the one with the
774 unique name. GNU uses the section symbol for the unique
775 name; MS uses ".text" for every comdat section. Sigh. - DJ */
777 /* This is not mirrored in sec_to_styp_flags(), but there
778 doesn't seem to be a need to, either, and it would at best be
781 if (_bfd_coff_get_external_symbols (abfd
))
783 bfd_byte
*esymstart
, *esym
, *esymend
;
785 char *target_name
= NULL
;
787 esymstart
= esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
788 esymend
= esym
+ obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
790 while (esym
< esymend
)
792 struct internal_syment isym
;
793 char buf
[SYMNMLEN
+ 1];
796 bfd_coff_swap_sym_in (abfd
, (PTR
) esym
, (PTR
) &isym
);
798 if (sizeof (internal_s
->s_name
) > SYMNMLEN
)
800 /* This case implies that the matching symbol name
801 will be in the string table. */
805 if (isym
.n_scnum
== section
->target_index
)
807 /* According to the MSVC documentation, the first
808 TWO entries with the section # are both of
809 interest to us. The first one is the "section
810 symbol" (section name). The second is the comdat
811 symbol name. Here, we've found the first
812 qualifying entry; we distinguish it from the
813 second with a state flag.
815 In the case of gas-generated (at least until that
816 is fixed) .o files, it isn't necessarily the
817 second one. It may be some other later symbol.
819 Since gas also doesn't follow MS conventions and
820 emits the section similar to .text$<name>, where
821 <something> is the name we're looking for, we
822 distinguish the two as follows:
824 If the section name is simply a section name (no
825 $) we presume it's MS-generated, and look at
826 precisely the second symbol for the comdat name.
827 If the section name has a $, we assume it's
828 gas-generated, and look for <something> (whatever
829 follows the $) as the comdat symbol. */
831 /* All 3 branches use this */
832 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
, buf
);
841 /* The first time we've seen the symbol. */
842 union internal_auxent aux
;
846 /* If it isn't the stuff we're expecting, die;
847 The MS documentation is vague, but it
848 appears that the second entry serves BOTH
849 as the comdat symbol and the defining
850 symbol record (either C_STAT or C_EXT,
851 possibly with an aux entry with debug
852 information if it's a function.) It
853 appears the only way to find the second one
854 is to count. (On Intel, they appear to be
855 adjacent, but on Alpha, they have been
858 Here, we think we've found the first one,
859 but there's some checking we can do to be
862 if (! (isym
.n_sclass
== C_STAT
863 && isym
.n_type
== T_NULL
864 && isym
.n_value
== 0))
867 /* FIXME LATER: MSVC generates section names
868 like .text for comdats. Gas generates
869 names like .text$foo__Fv (in the case of a
870 function). See comment above for more. */
872 if (strcmp (name
, symname
) != 0)
875 /* This is the section symbol. */
877 bfd_coff_swap_aux_in (abfd
, (PTR
) (esym
+ bfd_coff_symesz (abfd
)),
878 isym
.n_type
, isym
.n_sclass
,
879 0, isym
.n_numaux
, (PTR
) &aux
);
881 target_name
= strchr (name
, '$');
882 if (target_name
!= NULL
)
890 /* FIXME: Microsoft uses NODUPLICATES and
891 ASSOCIATIVE, but gnu uses ANY and
892 SAME_SIZE. Unfortunately, gnu doesn't do
893 the comdat symbols right. So, until we can
894 fix it to do the right thing, we are
895 temporarily disabling comdats for the MS
896 types (they're used in DLLs and C++, but we
897 don't support *their* C++ libraries anyway
900 /* Cygwin does not follow the MS style, and
901 uses ANY and SAME_SIZE where NODUPLICATES
902 and ASSOCIATIVE should be used. For
903 Interix, we just do the right thing up
906 switch (aux
.x_scn
.x_comdat
)
908 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
909 #ifdef STRICT_PE_FORMAT
910 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
912 sec_flags
&= ~SEC_LINK_ONCE
;
916 case IMAGE_COMDAT_SELECT_ANY
:
917 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
920 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
921 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
924 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
925 /* Not yet fully implemented ??? */
926 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
929 /* debug$S gets this case; other
932 /* There may be no symbol... we'll search
933 the whole table... Is this the right
934 place to play this game? Or should we do
935 it when reading it in. */
936 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
937 #ifdef STRICT_PE_FORMAT
938 /* FIXME: This is not currently implemented. */
939 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
941 sec_flags
&= ~SEC_LINK_ONCE
;
945 default: /* 0 means "no symbol" */
946 /* debug$F gets this case; other
948 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
955 /* Gas mode: the first matching on partial name. */
957 #ifndef TARGET_UNDERSCORE
958 #define TARGET_UNDERSCORE 0
960 /* Is this the name we're looking for? */
961 if (strcmp (target_name
,
962 symname
+ (TARGET_UNDERSCORE
? 1 : 0)) != 0)
964 /* Not the name we're looking for */
965 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
970 /* MSVC mode: the lexically second symbol (or
971 drop through from the above). */
975 /* This must the the second symbol with the
976 section #. It is the actual symbol name.
977 Intel puts the two adjacent, but Alpha (at
978 least) spreads them out. */
981 bfd_alloc (abfd
, sizeof (struct bfd_comdat_info
));
982 if (section
->comdat
== NULL
)
984 section
->comdat
->symbol
=
985 (esym
- esymstart
) / bfd_coff_symesz (abfd
);
987 newname
= bfd_alloc (abfd
, strlen (symname
) + 1);
991 strcpy (newname
, symname
);
992 section
->comdat
->name
= newname
;
1000 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1006 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1007 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1008 only link a single copy of the section. This is used to support
1009 g++. g++ will emit each template expansion in its own section.
1010 The symbols will be defined as weak, so that multiple definitions
1011 are permitted. The GNU linker extension is to actually discard
1012 all but one of the sections. */
1013 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
1014 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1020 #endif /* COFF_WITH_PE */
1022 #define get_index(symbol) ((symbol)->udata.i)
1026 bfd_coff_backend_data
1030 .{* COFF symbol classifications. *}
1032 .enum coff_symbol_classification
1034 . {* Global symbol. *}
1035 . COFF_SYMBOL_GLOBAL,
1036 . {* Common symbol. *}
1037 . COFF_SYMBOL_COMMON,
1038 . {* Undefined symbol. *}
1039 . COFF_SYMBOL_UNDEFINED,
1040 . {* Local symbol. *}
1041 . COFF_SYMBOL_LOCAL,
1042 . {* PE section symbol. *}
1043 . COFF_SYMBOL_PE_SECTION
1046 Special entry points for gdb to swap in coff symbol table parts:
1049 . void (*_bfd_coff_swap_aux_in) PARAMS ((
1058 . void (*_bfd_coff_swap_sym_in) PARAMS ((
1063 . void (*_bfd_coff_swap_lineno_in) PARAMS ((
1069 Special entry points for gas to swap out coff parts:
1071 . unsigned int (*_bfd_coff_swap_aux_out) PARAMS ((
1080 . unsigned int (*_bfd_coff_swap_sym_out) PARAMS ((
1085 . unsigned int (*_bfd_coff_swap_lineno_out) PARAMS ((
1090 . unsigned int (*_bfd_coff_swap_reloc_out) PARAMS ((
1095 . unsigned int (*_bfd_coff_swap_filehdr_out) PARAMS ((
1100 . unsigned int (*_bfd_coff_swap_aouthdr_out) PARAMS ((
1105 . unsigned int (*_bfd_coff_swap_scnhdr_out) PARAMS ((
1111 Special entry points for generic COFF routines to call target
1112 dependent COFF routines:
1114 . unsigned int _bfd_filhsz;
1115 . unsigned int _bfd_aoutsz;
1116 . unsigned int _bfd_scnhsz;
1117 . unsigned int _bfd_symesz;
1118 . unsigned int _bfd_auxesz;
1119 . unsigned int _bfd_relsz;
1120 . unsigned int _bfd_linesz;
1121 . unsigned int _bfd_filnmlen;
1122 . boolean _bfd_coff_long_filenames;
1123 . boolean _bfd_coff_long_section_names;
1124 . unsigned int _bfd_coff_default_section_alignment_power;
1125 . boolean _bfd_coff_force_symnames_in_strings;
1126 . unsigned int _bfd_coff_debug_string_prefix_length;
1127 . void (*_bfd_coff_swap_filehdr_in) PARAMS ((
1131 . void (*_bfd_coff_swap_aouthdr_in) PARAMS ((
1135 . void (*_bfd_coff_swap_scnhdr_in) PARAMS ((
1139 . void (*_bfd_coff_swap_reloc_in) PARAMS ((
1143 . boolean (*_bfd_coff_bad_format_hook) PARAMS ((
1145 . PTR internal_filehdr));
1146 . boolean (*_bfd_coff_set_arch_mach_hook) PARAMS ((
1148 . PTR internal_filehdr));
1149 . PTR (*_bfd_coff_mkobject_hook) PARAMS ((
1151 . PTR internal_filehdr,
1152 . PTR internal_aouthdr));
1153 . flagword (*_bfd_styp_to_sec_flags_hook) PARAMS ((
1155 . PTR internal_scnhdr,
1157 . asection *section));
1158 . void (*_bfd_set_alignment_hook) PARAMS ((
1161 . PTR internal_scnhdr));
1162 . boolean (*_bfd_coff_slurp_symbol_table) PARAMS ((
1164 . boolean (*_bfd_coff_symname_in_debug) PARAMS ((
1166 . struct internal_syment *sym));
1167 . boolean (*_bfd_coff_pointerize_aux_hook) PARAMS ((
1169 . combined_entry_type *table_base,
1170 . combined_entry_type *symbol,
1171 . unsigned int indaux,
1172 . combined_entry_type *aux));
1173 . boolean (*_bfd_coff_print_aux) PARAMS ((
1176 . combined_entry_type *table_base,
1177 . combined_entry_type *symbol,
1178 . combined_entry_type *aux,
1179 . unsigned int indaux));
1180 . void (*_bfd_coff_reloc16_extra_cases) PARAMS ((
1182 . struct bfd_link_info *link_info,
1183 . struct bfd_link_order *link_order,
1186 . unsigned int *src_ptr,
1187 . unsigned int *dst_ptr));
1188 . int (*_bfd_coff_reloc16_estimate) PARAMS ((
1190 . asection *input_section,
1192 . unsigned int shrink,
1193 . struct bfd_link_info *link_info));
1194 . enum coff_symbol_classification (*_bfd_coff_classify_symbol) PARAMS ((
1196 . struct internal_syment *));
1197 . boolean (*_bfd_coff_compute_section_file_positions) PARAMS ((
1199 . boolean (*_bfd_coff_start_final_link) PARAMS ((
1201 . struct bfd_link_info *info));
1202 . boolean (*_bfd_coff_relocate_section) PARAMS ((
1204 . struct bfd_link_info *info,
1206 . asection *input_section,
1207 . bfd_byte *contents,
1208 . struct internal_reloc *relocs,
1209 . struct internal_syment *syms,
1210 . asection **sections));
1211 . reloc_howto_type *(*_bfd_coff_rtype_to_howto) PARAMS ((
1214 . struct internal_reloc *rel,
1215 . struct coff_link_hash_entry *h,
1216 . struct internal_syment *sym,
1217 . bfd_vma *addendp));
1218 . boolean (*_bfd_coff_adjust_symndx) PARAMS ((
1220 . struct bfd_link_info *info,
1223 . struct internal_reloc *reloc,
1224 . boolean *adjustedp));
1225 . boolean (*_bfd_coff_link_add_one_symbol) PARAMS ((
1226 . struct bfd_link_info *info,
1230 . asection *section,
1232 . const char *string,
1235 . struct bfd_link_hash_entry **hashp));
1237 . boolean (*_bfd_coff_link_output_has_begun) PARAMS ((
1239 . struct coff_final_link_info * pfinfo));
1240 . boolean (*_bfd_coff_final_link_postscript) PARAMS ((
1242 . struct coff_final_link_info * pfinfo));
1244 .} bfd_coff_backend_data;
1246 .#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1248 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1249 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1251 .#define bfd_coff_swap_sym_in(a,e,i) \
1252 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1254 .#define bfd_coff_swap_lineno_in(a,e,i) \
1255 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1257 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1258 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1260 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1261 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1263 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1264 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1266 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1267 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1269 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1270 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1272 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1273 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1275 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1276 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1278 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1279 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1280 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1281 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1282 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1283 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1284 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1285 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1286 .#define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1287 .#define bfd_coff_long_section_names(abfd) \
1288 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1289 .#define bfd_coff_default_section_alignment_power(abfd) \
1290 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1291 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1292 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1294 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1295 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1297 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1298 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1300 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1301 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1303 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1304 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1306 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1307 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1308 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1309 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
1311 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section)\
1312 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1313 . (abfd, scnhdr, name, section))
1315 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1316 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1318 .#define bfd_coff_slurp_symbol_table(abfd)\
1319 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1321 .#define bfd_coff_symname_in_debug(abfd, sym)\
1322 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1324 .#define bfd_coff_force_symnames_in_strings(abfd)\
1325 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1327 .#define bfd_coff_debug_string_prefix_length(abfd)\
1328 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1330 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1331 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1332 . (abfd, file, base, symbol, aux, indaux))
1334 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
1335 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1336 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1338 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1339 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1340 . (abfd, section, reloc, shrink, link_info))
1342 .#define bfd_coff_classify_symbol(abfd, sym)\
1343 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1346 .#define bfd_coff_compute_section_file_positions(abfd)\
1347 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1350 .#define bfd_coff_start_final_link(obfd, info)\
1351 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1353 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1354 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1355 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1356 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1357 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1358 . (abfd, sec, rel, h, sym, addendp))
1359 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1360 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1361 . (obfd, info, ibfd, sec, rel, adjustedp))
1362 .#define bfd_coff_link_add_one_symbol(info,abfd,name,flags,section,value,string,cp,coll,hashp)\
1363 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1364 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1366 .#define bfd_coff_link_output_has_begun(a,p) \
1367 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p))
1368 .#define bfd_coff_final_link_postscript(a,p) \
1369 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
1373 /* See whether the magic number matches. */
1376 coff_bad_format_hook (abfd
, filehdr
)
1377 bfd
* abfd ATTRIBUTE_UNUSED
;
1380 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1382 if (BADMAG (*internal_f
))
1385 /* if the optional header is NULL or not the correct size then
1386 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1387 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1388 optional header is of a different size.
1390 But the mips keeps extra stuff in it's opthdr, so dont check
1394 #if defined(M88) || defined(I960)
1395 if (internal_f
->f_opthdr
!= 0 && bfd_coff_aoutsz (abfd
) != internal_f
->f_opthdr
)
1402 /* Check whether this section uses an alignment other than the
1406 coff_set_custom_section_alignment (abfd
, section
, alignment_table
, table_size
)
1407 bfd
*abfd ATTRIBUTE_UNUSED
;
1409 const struct coff_section_alignment_entry
*alignment_table
;
1410 const unsigned int table_size
;
1412 const unsigned int default_alignment
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1415 for (i
= 0; i
< table_size
; ++i
)
1417 const char *secname
= bfd_get_section_name (abfd
, section
);
1418 if (alignment_table
[i
].comparison_length
== (unsigned int) -1
1419 ? strcmp (alignment_table
[i
].name
, secname
) == 0
1420 : strncmp (alignment_table
[i
].name
, secname
,
1421 alignment_table
[i
].comparison_length
) == 0)
1424 if (i
>= table_size
)
1427 if (alignment_table
[i
].default_alignment_min
!= COFF_ALIGNMENT_FIELD_EMPTY
1428 && default_alignment
< alignment_table
[i
].default_alignment_min
)
1431 if (alignment_table
[i
].default_alignment_max
!= COFF_ALIGNMENT_FIELD_EMPTY
1432 && default_alignment
> alignment_table
[i
].default_alignment_max
)
1435 section
->alignment_power
= alignment_table
[i
].alignment_power
;
1438 /* Custom section alignment records. */
1440 static const struct coff_section_alignment_entry
1441 coff_section_alignment_table
[] =
1443 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1444 COFF_SECTION_ALIGNMENT_ENTRIES
,
1446 /* There must not be any gaps between .stabstr sections. */
1447 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1448 1, COFF_ALIGNMENT_FIELD_EMPTY
, 0 },
1449 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1450 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1451 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1452 /* Similarly for the .ctors and .dtors sections. */
1453 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1454 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1455 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1456 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 }
1459 static const unsigned int coff_section_alignment_table_size
=
1460 sizeof coff_section_alignment_table
/ sizeof coff_section_alignment_table
[0];
1462 /* Initialize a section structure with information peculiar to this
1463 particular implementation of COFF. */
1466 coff_new_section_hook (abfd
, section
)
1470 combined_entry_type
*native
;
1472 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1475 if (xcoff_data (abfd
)->text_align_power
!= 0
1476 && strcmp (bfd_get_section_name (abfd
, section
), ".text") == 0)
1477 section
->alignment_power
= xcoff_data (abfd
)->text_align_power
;
1478 if (xcoff_data (abfd
)->data_align_power
!= 0
1479 && strcmp (bfd_get_section_name (abfd
, section
), ".data") == 0)
1480 section
->alignment_power
= xcoff_data (abfd
)->data_align_power
;
1483 /* Allocate aux records for section symbols, to store size and
1486 @@ The 10 is a guess at a plausible maximum number of aux entries
1487 (but shouldn't be a constant). */
1488 native
= ((combined_entry_type
*)
1489 bfd_zalloc (abfd
, sizeof (combined_entry_type
) * 10));
1493 /* We don't need to set up n_name, n_value, or n_scnum in the native
1494 symbol information, since they'll be overriden by the BFD symbol
1495 anyhow. However, we do need to set the type and storage class,
1496 in case this symbol winds up getting written out. The value 0
1497 for n_numaux is already correct. */
1499 native
->u
.syment
.n_type
= T_NULL
;
1500 native
->u
.syment
.n_sclass
= C_STAT
;
1502 coffsymbol (section
->symbol
)->native
= native
;
1504 coff_set_custom_section_alignment (abfd
, section
,
1505 coff_section_alignment_table
,
1506 coff_section_alignment_table_size
);
1511 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1513 /* Set the alignment of a BFD section. */
1515 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1518 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1519 bfd
* abfd ATTRIBUTE_UNUSED
;
1523 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1527 /* Extract ALIGN from 2**ALIGN stored in section header */
1528 for (i
= 0; i
< 32; i
++)
1529 if ((1 << i
) >= hdr
->s_align
)
1533 /* TI tools puts the alignment power in bits 8-11 */
1534 i
= (hdr
->s_flags
>> 8) & 0xF ;
1536 #ifdef COFF_DECODE_ALIGNMENT
1537 i
= COFF_DECODE_ALIGNMENT(hdr
->s_flags
);
1539 section
->alignment_power
= i
;
1541 #ifdef coff_set_section_load_page
1542 coff_set_section_load_page (section
, hdr
->s_page
);
1546 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1549 /* a couple of macros to help setting the alignment power field */
1550 #define ALIGN_SET(field,x,y) \
1551 if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1553 section->alignment_power = y;\
1556 #define ELIFALIGN_SET(field,x,y) \
1557 else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1559 section->alignment_power = y;\
1562 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1565 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1566 bfd
* abfd ATTRIBUTE_UNUSED
;
1570 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1572 ALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_64BYTES
, 6)
1573 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_32BYTES
, 5)
1574 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_16BYTES
, 4)
1575 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_8BYTES
, 3)
1576 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_4BYTES
, 2)
1577 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_2BYTES
, 1)
1578 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_1BYTES
, 0)
1580 /* In a PE image file, the s_paddr field holds the virtual size of a
1581 section, while the s_size field holds the raw size. We also keep
1582 the original section flag value, since not every bit can be
1583 mapped onto a generic BFD section bit. */
1584 if (coff_section_data (abfd
, section
) == NULL
)
1586 section
->used_by_bfd
=
1587 (PTR
) bfd_zalloc (abfd
, sizeof (struct coff_section_tdata
));
1588 if (section
->used_by_bfd
== NULL
)
1590 /* FIXME: Return error. */
1594 if (pei_section_data (abfd
, section
) == NULL
)
1596 coff_section_data (abfd
, section
)->tdata
=
1597 (PTR
) bfd_zalloc (abfd
, sizeof (struct pei_section_tdata
));
1598 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1600 /* FIXME: Return error. */
1604 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1605 pei_section_data (abfd
, section
)->pe_flags
= hdr
->s_flags
;
1607 section
->lma
= hdr
->s_vaddr
;
1609 /* check for extended relocs */
1610 if (hdr
->s_flags
& IMAGE_SCN_LNK_NRELOC_OVFL
)
1612 struct external_reloc dst
;
1613 struct internal_reloc n
;
1614 int oldpos
= bfd_tell (abfd
);
1615 bfd_seek (abfd
, hdr
->s_relptr
, 0);
1616 if (bfd_read ((PTR
) & dst
, 1, bfd_coff_relsz (abfd
), abfd
)
1617 != bfd_coff_relsz (abfd
))
1620 coff_swap_reloc_in (abfd
, &dst
, &n
);
1621 bfd_seek (abfd
, oldpos
, 0);
1622 section
->reloc_count
=
1623 hdr
->s_nreloc
= n
.r_vaddr
;
1627 #undef ELIFALIGN_SET
1629 #else /* ! COFF_WITH_PE */
1632 /* We grossly abuse this function to handle XCOFF overflow headers.
1633 When we see one, we correct the reloc and line number counts in the
1634 real header, and remove the section we just created. */
1636 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1639 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1644 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1648 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1651 real_sec
= coff_section_from_bfd_index (abfd
, hdr
->s_nreloc
);
1652 if (real_sec
== NULL
)
1655 real_sec
->reloc_count
= hdr
->s_paddr
;
1656 real_sec
->lineno_count
= hdr
->s_vaddr
;
1658 for (ps
= &abfd
->sections
; *ps
!= NULL
; ps
= &(*ps
)->next
)
1663 --abfd
->section_count
;
1669 #else /* ! RS6000COFF_C */
1671 #define coff_set_alignment_hook \
1672 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1674 #endif /* ! RS6000COFF_C */
1675 #endif /* ! COFF_WITH_PE */
1676 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1678 #ifndef coff_mkobject
1680 static boolean coff_mkobject
PARAMS ((bfd
*));
1683 coff_mkobject (abfd
)
1686 coff_data_type
*coff
;
1688 abfd
->tdata
.coff_obj_data
= (struct coff_tdata
*) bfd_zalloc (abfd
, sizeof (coff_data_type
));
1689 if (abfd
->tdata
.coff_obj_data
== 0)
1691 coff
= coff_data (abfd
);
1692 coff
->symbols
= (coff_symbol_type
*) NULL
;
1693 coff
->conversion_table
= (unsigned int *) NULL
;
1694 coff
->raw_syments
= (struct coff_ptr_struct
*) NULL
;
1695 coff
->relocbase
= 0;
1696 coff
->local_toc_sym_map
= 0;
1698 /* make_abs_section(abfd);*/
1704 /* Create the COFF backend specific information. */
1705 #ifndef coff_mkobject_hook
1707 coff_mkobject_hook (abfd
, filehdr
, aouthdr
)
1710 PTR aouthdr ATTRIBUTE_UNUSED
;
1712 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1713 coff_data_type
*coff
;
1715 if (coff_mkobject (abfd
) == false)
1718 coff
= coff_data (abfd
);
1720 coff
->sym_filepos
= internal_f
->f_symptr
;
1722 /* These members communicate important constants about the symbol
1723 table to GDB's symbol-reading code. These `constants'
1724 unfortunately vary among coff implementations... */
1725 coff
->local_n_btmask
= N_BTMASK
;
1726 coff
->local_n_btshft
= N_BTSHFT
;
1727 coff
->local_n_tmask
= N_TMASK
;
1728 coff
->local_n_tshift
= N_TSHIFT
;
1729 coff
->local_symesz
= bfd_coff_symesz (abfd
);
1730 coff
->local_auxesz
= bfd_coff_auxesz (abfd
);
1731 coff
->local_linesz
= bfd_coff_linesz (abfd
);
1733 coff
->timestamp
= internal_f
->f_timdat
;
1735 obj_raw_syment_count (abfd
) =
1736 obj_conv_table_size (abfd
) =
1737 internal_f
->f_nsyms
;
1740 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
1741 abfd
->flags
|= DYNAMIC
;
1742 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= bfd_coff_aoutsz (abfd
))
1744 struct internal_aouthdr
*internal_a
=
1745 (struct internal_aouthdr
*) aouthdr
;
1746 struct xcoff_tdata
*xcoff
;
1748 xcoff
= xcoff_data (abfd
);
1749 # ifdef U803XTOCMAGIC
1750 xcoff
->xcoff64
= internal_f
->f_magic
== U803XTOCMAGIC
;
1754 xcoff
->full_aouthdr
= true;
1755 xcoff
->toc
= internal_a
->o_toc
;
1756 xcoff
->sntoc
= internal_a
->o_sntoc
;
1757 xcoff
->snentry
= internal_a
->o_snentry
;
1758 xcoff
->text_align_power
= internal_a
->o_algntext
;
1759 xcoff
->data_align_power
= internal_a
->o_algndata
;
1760 xcoff
->modtype
= internal_a
->o_modtype
;
1761 xcoff
->cputype
= internal_a
->o_cputype
;
1762 xcoff
->maxdata
= internal_a
->o_maxdata
;
1763 xcoff
->maxstack
= internal_a
->o_maxstack
;
1768 /* Set the flags field from the COFF header read in */
1769 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
1774 /* FIXME: I'm not sure this is ever executed, since peicode.h
1775 defines coff_mkobject_hook. */
1776 if ((internal_f
->f_flags
& IMAGE_FILE_DEBUG_STRIPPED
) == 0)
1777 abfd
->flags
|= HAS_DEBUG
;
1784 /* Determine the machine architecture and type. FIXME: This is target
1785 dependent because the magic numbers are defined in the target
1786 dependent header files. But there is no particular need for this.
1787 If the magic numbers were moved to a separate file, this function
1788 would be target independent and would also be much more successful
1789 at linking together COFF files for different architectures. */
1792 coff_set_arch_mach_hook (abfd
, filehdr
)
1797 enum bfd_architecture arch
;
1798 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1801 switch (internal_f
->f_magic
)
1805 arch
= bfd_arch_powerpc
;
1806 machine
= 0; /* what does this mean? (krk) */
1812 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler */
1813 case LYNXCOFFMAGIC
: /* shadows the m68k Lynx number below, sigh */
1814 arch
= bfd_arch_i386
;
1820 arch
= bfd_arch_ia64
;
1824 #ifdef A29K_MAGIC_BIG
1825 case A29K_MAGIC_BIG
:
1826 case A29K_MAGIC_LITTLE
:
1827 arch
= bfd_arch_a29k
;
1835 arch
= bfd_arch_arm
;
1836 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
1838 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
1839 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
1840 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
1842 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
1843 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
1844 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
1845 case F_ARM_5
: machine
= bfd_mach_arm_5
; break;
1852 #ifdef MC68KBCSMAGIC
1855 #ifdef APOLLOM68KMAGIC
1856 case APOLLOM68KMAGIC
:
1858 #ifdef LYNXCOFFMAGIC
1861 arch
= bfd_arch_m68k
;
1862 machine
= bfd_mach_m68020
;
1869 arch
= bfd_arch_m88k
;
1875 arch
= bfd_arch_z8k
;
1876 switch (internal_f
->f_flags
& F_MACHMASK
)
1879 machine
= bfd_mach_z8001
;
1882 machine
= bfd_mach_z8002
;
1891 arch
= bfd_arch_i860
;
1898 arch
= bfd_arch_i960
;
1899 switch (F_I960TYPE
& internal_f
->f_flags
)
1903 machine
= bfd_mach_i960_core
;
1906 machine
= bfd_mach_i960_kb_sb
;
1909 machine
= bfd_mach_i960_mc
;
1912 machine
= bfd_mach_i960_xa
;
1915 machine
= bfd_mach_i960_ca
;
1918 machine
= bfd_mach_i960_ka_sa
;
1921 machine
= bfd_mach_i960_jx
;
1924 machine
= bfd_mach_i960_hx
;
1942 if (xcoff_data (abfd
)->cputype
!= -1)
1943 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
1946 /* We did not get a value from the a.out header. If the
1947 file has not been stripped, we may be able to get the
1948 architecture information from the first symbol, if it
1949 is a .file symbol. */
1950 if (obj_raw_syment_count (abfd
) == 0)
1955 struct internal_syment sym
;
1957 buf
= (bfd_byte
*) bfd_malloc (bfd_coff_symesz (abfd
));
1958 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1959 || (bfd_read (buf
, 1, bfd_coff_symesz (abfd
), abfd
)
1960 != bfd_coff_symesz (abfd
)))
1965 bfd_coff_swap_sym_in (abfd
, (PTR
) buf
, (PTR
) &sym
);
1966 if (sym
.n_sclass
== C_FILE
)
1967 cputype
= sym
.n_type
& 0xff;
1974 /* FIXME: We don't handle all cases here. */
1980 /* PowerPC Macs use the same magic numbers as RS/6000
1981 (because that's how they were bootstrapped originally),
1982 but they are always PowerPC architecture. */
1983 arch
= bfd_arch_powerpc
;
1984 machine
= bfd_mach_ppc
;
1987 arch
= bfd_arch_powerpc
;
1988 machine
= bfd_mach_ppc_620
;
1990 arch
= bfd_arch_rs6000
;
1991 machine
= bfd_mach_rs6k
;
1993 #endif /* POWERMAC */
1997 arch
= bfd_arch_powerpc
;
1998 machine
= bfd_mach_ppc_601
;
2000 case 2: /* 64 bit PowerPC */
2001 arch
= bfd_arch_powerpc
;
2002 machine
= bfd_mach_ppc_620
;
2005 arch
= bfd_arch_powerpc
;
2006 machine
= bfd_mach_ppc
;
2009 arch
= bfd_arch_rs6000
;
2010 machine
= bfd_mach_rs6k
;
2019 arch
= bfd_arch_we32k
;
2026 arch
= bfd_arch_h8300
;
2027 machine
= bfd_mach_h8300
;
2028 /* !! FIXME this probably isn't the right place for this */
2029 abfd
->flags
|= BFD_IS_RELAXABLE
;
2035 arch
= bfd_arch_h8300
;
2036 machine
= bfd_mach_h8300h
;
2037 /* !! FIXME this probably isn't the right place for this */
2038 abfd
->flags
|= BFD_IS_RELAXABLE
;
2044 arch
= bfd_arch_h8300
;
2045 machine
= bfd_mach_h8300s
;
2046 /* !! FIXME this probably isn't the right place for this */
2047 abfd
->flags
|= BFD_IS_RELAXABLE
;
2051 #ifdef SH_ARCH_MAGIC_BIG
2052 case SH_ARCH_MAGIC_BIG
:
2053 case SH_ARCH_MAGIC_LITTLE
:
2055 case SH_ARCH_MAGIC_WINCE
:
2062 #ifdef MIPS_ARCH_MAGIC_WINCE
2063 case MIPS_ARCH_MAGIC_WINCE
:
2064 arch
= bfd_arch_mips
;
2071 arch
= bfd_arch_h8500
;
2078 #ifdef LYNXCOFFMAGIC
2081 arch
= bfd_arch_sparc
;
2088 arch
= bfd_arch_tic30
;
2093 #ifdef TICOFF_TARGET_ARCH
2094 /* this TI COFF section should be used by all new TI COFF v0 targets */
2096 arch
= TICOFF_TARGET_ARCH
;
2102 /* this TI COFF section should be used by all new TI COFF v1/2 targets */
2103 /* TI COFF1 and COFF2 use the target_id field to specify which arch */
2106 switch (internal_f
->f_target_id
)
2110 arch
= TICOFF_TARGET_ARCH
;
2114 arch
= bfd_arch_obscure
;
2115 (*_bfd_error_handler
)
2116 (_("Unrecognized TI COFF target id '0x%x'"),
2117 internal_f
->f_target_id
);
2123 #ifdef TIC80_ARCH_MAGIC
2124 case TIC80_ARCH_MAGIC
:
2125 arch
= bfd_arch_tic80
;
2131 arch
= bfd_arch_mcore
;
2134 default: /* Unreadable input file type */
2135 arch
= bfd_arch_obscure
;
2139 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2143 #ifdef SYMNAME_IN_DEBUG
2145 static boolean symname_in_debug_hook
2146 PARAMS ((bfd
*, struct internal_syment
*));
2149 symname_in_debug_hook (abfd
, sym
)
2150 bfd
* abfd ATTRIBUTE_UNUSED
;
2151 struct internal_syment
*sym
;
2153 return SYMNAME_IN_DEBUG (sym
) ? true : false;
2158 #define symname_in_debug_hook \
2159 (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
2166 #define FORCE_SYMNAMES_IN_STRINGS
2169 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
2171 static boolean coff_pointerize_aux_hook
2172 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
2173 unsigned int, combined_entry_type
*));
2177 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
2178 bfd
*abfd ATTRIBUTE_UNUSED
;
2179 combined_entry_type
*table_base
;
2180 combined_entry_type
*symbol
;
2181 unsigned int indaux
;
2182 combined_entry_type
*aux
;
2184 int class = symbol
->u
.syment
.n_sclass
;
2186 if ((class == C_EXT
|| class == C_HIDEXT
)
2187 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2189 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2191 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2192 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2193 aux
->fix_scnlen
= 1;
2196 /* Return true to indicate that the caller should not do any
2197 further work on this auxent. */
2201 /* Return false to indicate that this auxent should be handled by
2209 /* We don't want to pointerize bal entries. */
2211 static boolean coff_pointerize_aux_hook
2212 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
2213 unsigned int, combined_entry_type
*));
2217 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
2218 bfd
*abfd ATTRIBUTE_UNUSED
;
2219 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
2220 combined_entry_type
*symbol
;
2221 unsigned int indaux
;
2222 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
2224 /* Return true if we don't want to pointerize this aux entry, which
2225 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2227 && (symbol
->u
.syment
.n_sclass
== C_LEAFPROC
2228 || symbol
->u
.syment
.n_sclass
== C_LEAFSTAT
2229 || symbol
->u
.syment
.n_sclass
== C_LEAFEXT
));
2234 #define coff_pointerize_aux_hook 0
2237 #endif /* ! RS6000COFF_C */
2239 /* Print an aux entry. This returns true if it has printed it. */
2241 static boolean coff_print_aux
2242 PARAMS ((bfd
*, FILE *, combined_entry_type
*, combined_entry_type
*,
2243 combined_entry_type
*, unsigned int));
2246 coff_print_aux (abfd
, file
, table_base
, symbol
, aux
, indaux
)
2247 bfd
*abfd ATTRIBUTE_UNUSED
;
2248 FILE *file ATTRIBUTE_UNUSED
;
2249 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
2250 combined_entry_type
*symbol ATTRIBUTE_UNUSED
;
2251 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
2252 unsigned int indaux ATTRIBUTE_UNUSED
;
2255 if ((symbol
->u
.syment
.n_sclass
== C_EXT
2256 || symbol
->u
.syment
.n_sclass
== C_HIDEXT
)
2257 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2259 /* This is a csect entry. */
2260 fprintf (file
, "AUX ");
2261 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2263 BFD_ASSERT (! aux
->fix_scnlen
);
2264 fprintf (file
, "val %5ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2268 fprintf (file
, "indx ");
2269 if (! aux
->fix_scnlen
)
2270 fprintf (file
, "%4ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2272 fprintf (file
, "%4ld",
2273 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2276 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2277 aux
->u
.auxent
.x_csect
.x_parmhash
,
2278 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2279 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2280 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2281 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2282 aux
->u
.auxent
.x_csect
.x_stab
,
2283 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2288 /* Return false to indicate that no special action was taken. */
2296 To write relocations, the back end steps though the
2297 canonical relocation table and create an
2298 @code{internal_reloc}. The symbol index to use is removed from
2299 the @code{offset} field in the symbol table supplied. The
2300 address comes directly from the sum of the section base
2301 address and the relocation offset; the type is dug directly
2302 from the howto field. Then the @code{internal_reloc} is
2303 swapped into the shape of an @code{external_reloc} and written
2310 static int compare_arelent_ptr
PARAMS ((const PTR
, const PTR
));
2312 /* AUX's ld wants relocations to be sorted */
2314 compare_arelent_ptr (x
, y
)
2318 const arelent
**a
= (const arelent
**) x
;
2319 const arelent
**b
= (const arelent
**) y
;
2320 bfd_size_type aadr
= (*a
)->address
;
2321 bfd_size_type badr
= (*b
)->address
;
2323 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2326 #endif /* TARG_AUX */
2329 coff_write_relocs (abfd
, first_undef
)
2335 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
2338 struct external_reloc dst
;
2344 /* sort relocations before we write them out */
2345 p
= (arelent
**) bfd_malloc (s
->reloc_count
* sizeof (arelent
*));
2346 if (p
== NULL
&& s
->reloc_count
> 0)
2348 memcpy (p
, s
->orelocation
, s
->reloc_count
* sizeof (arelent
*));
2349 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2352 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2356 if (s
->reloc_count
> 0xffff)
2358 /* encode real count here as first reloc */
2359 struct internal_reloc n
;
2360 memset ((PTR
) & n
, 0, sizeof (n
));
2361 /* add one to count *this* reloc (grr) */
2362 n
.r_vaddr
= s
->reloc_count
+ 1;
2363 coff_swap_reloc_out (abfd
, &n
, &dst
);
2364 if (bfd_write ((PTR
) & dst
, 1, bfd_coff_relsz (abfd
), abfd
)
2365 != bfd_coff_relsz (abfd
))
2370 for (i
= 0; i
< s
->reloc_count
; i
++)
2372 struct internal_reloc n
;
2374 memset ((PTR
) & n
, 0, sizeof (n
));
2376 /* Now we've renumbered the symbols we know where the
2377 undefined symbols live in the table. Check the reloc
2378 entries for symbols who's output bfd isn't the right one.
2379 This is because the symbol was undefined (which means
2380 that all the pointers are never made to point to the same
2381 place). This is a bad thing,'cause the symbols attached
2382 to the output bfd are indexed, so that the relocation
2383 entries know which symbol index they point to. So we
2384 have to look up the output symbol here. */
2386 if (q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2389 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2390 asymbol
**outsyms
= abfd
->outsymbols
;
2391 for (i
= first_undef
; outsyms
[i
]; i
++)
2393 const char *intable
= outsyms
[i
]->name
;
2394 if (strcmp (intable
, sname
) == 0) {
2395 /* got a hit, so repoint the reloc */
2396 q
->sym_ptr_ptr
= outsyms
+ i
;
2402 n
.r_vaddr
= q
->address
+ s
->vma
;
2405 /* The 29k const/consth reloc pair is a real kludge. The consth
2406 part doesn't have a symbol; it has an offset. So rebuilt
2408 if (q
->howto
->type
== R_IHCONST
)
2409 n
.r_symndx
= q
->addend
;
2414 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2415 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
,s
))
2417 if (q
->sym_ptr_ptr
== bfd_abs_section_ptr
->symbol_ptr_ptr
)
2419 /* This is a relocation relative to the absolute symbol. */
2423 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2424 /* Take notice if the symbol reloc points to a symbol
2425 we don't have in our symbol table. What should we
2427 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2432 #ifdef SWAP_OUT_RELOC_OFFSET
2433 n
.r_offset
= q
->addend
;
2437 /* Work out reloc type from what is required */
2438 SELECT_RELOC (n
, q
->howto
);
2440 n
.r_type
= q
->howto
->type
;
2442 coff_swap_reloc_out (abfd
, &n
, &dst
);
2443 if (bfd_write ((PTR
) & dst
, 1, bfd_coff_relsz (abfd
), abfd
)
2444 != bfd_coff_relsz (abfd
))
2457 /* Set flags and magic number of a coff file from architecture and machine
2458 type. Result is true if we can represent the arch&type, false if not. */
2461 coff_set_flags (abfd
, magicp
, flagsp
)
2463 unsigned int *magicp ATTRIBUTE_UNUSED
;
2464 unsigned short *flagsp ATTRIBUTE_UNUSED
;
2466 switch (bfd_get_arch (abfd
))
2471 switch (bfd_get_mach (abfd
))
2473 case bfd_mach_z8001
:
2476 case bfd_mach_z8002
:
2490 *magicp
= I960ROMAGIC
;
2492 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2493 I960RWMAGIC); FIXME???
2495 switch (bfd_get_mach (abfd
))
2497 case bfd_mach_i960_core
:
2500 case bfd_mach_i960_kb_sb
:
2503 case bfd_mach_i960_mc
:
2506 case bfd_mach_i960_xa
:
2509 case bfd_mach_i960_ca
:
2512 case bfd_mach_i960_ka_sa
:
2515 case bfd_mach_i960_jx
:
2518 case bfd_mach_i960_hx
:
2531 case bfd_arch_tic30
:
2532 *magicp
= TIC30MAGIC
;
2536 #ifdef TICOFF_DEFAULT_MAGIC
2537 case TICOFF_TARGET_ARCH
:
2538 /* if there's no indication of which version we want, use the default */
2540 *magicp
= TICOFF_DEFAULT_MAGIC
;
2543 /* we may want to output in a different COFF version */
2544 switch (abfd
->xvec
->name
[4])
2547 *magicp
= TICOFF0MAGIC
;
2550 *magicp
= TICOFF1MAGIC
;
2553 *magicp
= TICOFF2MAGIC
;
2562 #ifdef TIC80_ARCH_MAGIC
2563 case bfd_arch_tic80
:
2564 *magicp
= TIC80_ARCH_MAGIC
;
2570 * magicp
= ARMPEMAGIC
;
2572 * magicp
= ARMMAGIC
;
2575 if (APCS_SET (abfd
))
2577 if (APCS_26_FLAG (abfd
))
2578 * flagsp
|= F_APCS26
;
2580 if (APCS_FLOAT_FLAG (abfd
))
2581 * flagsp
|= F_APCS_FLOAT
;
2583 if (PIC_FLAG (abfd
))
2586 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2587 * flagsp
|= F_INTERWORK
;
2588 switch (bfd_get_mach (abfd
))
2590 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2591 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2592 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2593 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2594 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2595 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2596 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2597 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5. */
2598 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break;
2599 case bfd_mach_arm_5TE
: * flagsp
|= F_ARM_5
; break;
2600 case bfd_mach_arm_XScale
: * flagsp
|= F_ARM_5
; break;
2605 case bfd_arch_powerpc
:
2612 *magicp
= I386MAGIC
;
2614 /* Just overwrite the usual value if we're doing Lynx. */
2615 *magicp
= LYNXCOFFMAGIC
;
2622 *magicp
= I860MAGIC
;
2628 *magicp
= IA64MAGIC
;
2634 #ifdef APOLLOM68KMAGIC
2635 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
2637 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2638 #ifdef NAMES_HAVE_UNDERSCORE
2639 *magicp
= MC68KBCSMAGIC
;
2641 *magicp
= MC68MAGIC
;
2645 /* Just overwrite the usual value if we're doing Lynx. */
2646 *magicp
= LYNXCOFFMAGIC
;
2654 *magicp
= MC88OMAGIC
;
2659 case bfd_arch_h8300
:
2660 switch (bfd_get_mach (abfd
))
2662 case bfd_mach_h8300
:
2663 *magicp
= H8300MAGIC
;
2665 case bfd_mach_h8300h
:
2666 *magicp
= H8300HMAGIC
;
2668 case bfd_mach_h8300s
:
2669 *magicp
= H8300SMAGIC
;
2675 #ifdef SH_ARCH_MAGIC_BIG
2677 #ifdef COFF_IMAGE_WITH_PE
2678 *magicp
= SH_ARCH_MAGIC_WINCE
;
2680 if (bfd_big_endian (abfd
))
2681 *magicp
= SH_ARCH_MAGIC_BIG
;
2683 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2689 #ifdef MIPS_ARCH_MAGIC_WINCE
2691 *magicp
= MIPS_ARCH_MAGIC_WINCE
;
2697 case bfd_arch_sparc
:
2698 *magicp
= SPARCMAGIC
;
2700 /* Just overwrite the usual value if we're doing Lynx. */
2701 *magicp
= LYNXCOFFMAGIC
;
2708 case bfd_arch_h8500
:
2709 *magicp
= H8500MAGIC
;
2713 #ifdef A29K_MAGIC_BIG
2715 if (bfd_big_endian (abfd
))
2716 *magicp
= A29K_MAGIC_BIG
;
2718 *magicp
= A29K_MAGIC_LITTLE
;
2724 case bfd_arch_we32k
:
2725 *magicp
= WE32KMAGIC
;
2731 case bfd_arch_rs6000
:
2733 case bfd_arch_powerpc
:
2736 if (bfd_get_mach (abfd
) == bfd_mach_ppc_620
2737 && !strncmp (abfd
->xvec
->name
,"aix", 3))
2738 *magicp
= U803XTOCMAGIC
;
2741 *magicp
= U802TOCMAGIC
;
2748 case bfd_arch_mcore
:
2749 * magicp
= MCOREMAGIC
;
2759 default: /* Unknown architecture. */
2760 /* Fall through to "return false" below, to avoid
2761 "statement never reached" errors on the one below. */
2769 coff_set_arch_mach (abfd
, arch
, machine
)
2771 enum bfd_architecture arch
;
2772 unsigned long machine
;
2775 unsigned short dummy2
;
2777 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
2780 if (arch
!= bfd_arch_unknown
&&
2781 coff_set_flags (abfd
, &dummy1
, &dummy2
) != true)
2782 return false; /* We can't represent this type */
2784 return true; /* We're easy ... */
2787 #ifdef COFF_IMAGE_WITH_PE
2789 /* This is used to sort sections by VMA, as required by PE image
2792 static int sort_by_secaddr
PARAMS ((const PTR
, const PTR
));
2795 sort_by_secaddr (arg1
, arg2
)
2799 const asection
*a
= *(const asection
**) arg1
;
2800 const asection
*b
= *(const asection
**) arg2
;
2802 if (a
->vma
< b
->vma
)
2804 else if (a
->vma
> b
->vma
)
2810 #endif /* COFF_IMAGE_WITH_PE */
2812 /* Calculate the file position for each section. */
2815 #define ALIGN_SECTIONS_IN_FILE
2817 #if defined(TIC80COFF) || defined(TICOFF)
2818 #undef ALIGN_SECTIONS_IN_FILE
2822 coff_compute_section_file_positions (abfd
)
2826 asection
*previous
= (asection
*) NULL
;
2827 file_ptr sofar
= bfd_coff_filhsz (abfd
);
2828 boolean align_adjust
;
2829 #ifdef ALIGN_SECTIONS_IN_FILE
2834 /* On XCOFF, if we have symbols, set up the .debug section. */
2835 if (bfd_get_symcount (abfd
) > 0)
2838 bfd_size_type i
, symcount
;
2842 symcount
= bfd_get_symcount (abfd
);
2843 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
2845 coff_symbol_type
*cf
;
2847 cf
= coff_symbol_from (abfd
, *symp
);
2849 && cf
->native
!= NULL
2850 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
2854 len
= strlen (bfd_asymbol_name (*symp
));
2855 if (len
> SYMNMLEN
|| bfd_coff_force_symnames_in_strings (abfd
))
2856 sz
+= len
+ 1 + bfd_coff_debug_string_prefix_length (abfd
);
2863 dsec
= bfd_make_section_old_way (abfd
, ".debug");
2866 dsec
->_raw_size
= sz
;
2867 dsec
->flags
|= SEC_HAS_CONTENTS
;
2872 #ifdef COFF_IMAGE_WITH_PE
2874 if (coff_data (abfd
)->link_info
)
2876 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
2879 page_size
= PE_DEF_FILE_ALIGNMENT
;
2881 #ifdef COFF_PAGE_SIZE
2882 int page_size
= COFF_PAGE_SIZE
;
2886 if (bfd_get_start_address (abfd
))
2888 /* A start address may have been added to the original file. In this
2889 case it will need an optional header to record it. */
2890 abfd
->flags
|= EXEC_P
;
2893 if (abfd
->flags
& EXEC_P
)
2894 sofar
+= bfd_coff_aoutsz (abfd
);
2896 else if (xcoff_data (abfd
)->full_aouthdr
)
2897 sofar
+= bfd_coff_aoutsz (abfd
);
2899 sofar
+= SMALL_AOUTSZ
;
2902 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2905 /* XCOFF handles overflows in the reloc and line number count fields
2906 by allocating a new section header to hold the correct counts. */
2907 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2908 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
2909 sofar
+= bfd_coff_scnhsz (abfd
);
2912 #ifdef COFF_IMAGE_WITH_PE
2914 /* PE requires the sections to be in memory order when listed in
2915 the section headers. It also does not like empty loadable
2916 sections. The sections apparently do not have to be in the
2917 right order in the image file itself, but we do need to get the
2918 target_index values right. */
2921 asection
**section_list
;
2926 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2929 /* We allocate an extra cell to simplify the final loop. */
2930 section_list
= bfd_malloc (sizeof (struct asection
*) * (count
+ 1));
2931 if (section_list
== NULL
)
2935 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2937 section_list
[i
] = current
;
2940 section_list
[i
] = NULL
;
2942 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
2944 /* Rethread the linked list into sorted order; at the same time,
2945 assign target_index values. */
2947 abfd
->sections
= section_list
[0];
2948 for (i
= 0; i
< count
; i
++)
2950 current
= section_list
[i
];
2951 current
->next
= section_list
[i
+ 1];
2953 /* Later, if the section has zero size, we'll be throwing it
2954 away, so we don't want to number it now. Note that having
2955 a zero size and having real contents are different
2956 concepts: .bss has no contents, but (usually) non-zero
2958 if (current
->_raw_size
== 0)
2960 /* Discard. However, it still might have (valid) symbols
2961 in it, so arbitrarily set it to section 1 (indexing is
2962 1-based here; usually .text). __end__ and other
2963 contents of .endsection really have this happen.
2964 FIXME: This seems somewhat dubious. */
2965 current
->target_index
= 1;
2968 current
->target_index
= target_index
++;
2971 free (section_list
);
2973 #else /* ! COFF_IMAGE_WITH_PE */
2975 /* Set the target_index field. */
2979 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2980 current
->target_index
= target_index
++;
2982 #endif /* ! COFF_IMAGE_WITH_PE */
2984 align_adjust
= false;
2985 for (current
= abfd
->sections
;
2986 current
!= (asection
*) NULL
;
2987 current
= current
->next
)
2989 #ifdef COFF_IMAGE_WITH_PE
2990 /* With PE we have to pad each section to be a multiple of its
2991 page size too, and remember both sizes. */
2992 if (coff_section_data (abfd
, current
) == NULL
)
2994 current
->used_by_bfd
=
2995 (PTR
) bfd_zalloc (abfd
, sizeof (struct coff_section_tdata
));
2996 if (current
->used_by_bfd
== NULL
)
2999 if (pei_section_data (abfd
, current
) == NULL
)
3001 coff_section_data (abfd
, current
)->tdata
=
3002 (PTR
) bfd_zalloc (abfd
, sizeof (struct pei_section_tdata
));
3003 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
3006 if (pei_section_data (abfd
, current
)->virt_size
== 0)
3007 pei_section_data (abfd
, current
)->virt_size
= current
->_raw_size
;
3010 /* Only deal with sections which have contents. */
3011 if (!(current
->flags
& SEC_HAS_CONTENTS
))
3014 #ifdef COFF_IMAGE_WITH_PE
3015 /* Make sure we skip empty sections in a PE image. */
3016 if (current
->_raw_size
== 0)
3020 /* Align the sections in the file to the same boundary on
3021 which they are aligned in virtual memory. I960 doesn't
3022 do this (FIXME) so we can stay in sync with Intel. 960
3023 doesn't yet page from files... */
3024 #ifdef ALIGN_SECTIONS_IN_FILE
3025 if ((abfd
->flags
& EXEC_P
) != 0)
3027 /* make sure this section is aligned on the right boundary - by
3028 padding the previous section up if necessary */
3031 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3032 if (previous
!= (asection
*) NULL
)
3034 previous
->_raw_size
+= sofar
- old_sofar
;
3040 /* In demand paged files the low order bits of the file offset
3041 must match the low order bits of the virtual address. */
3042 #ifdef COFF_PAGE_SIZE
3043 if ((abfd
->flags
& D_PAGED
) != 0
3044 && (current
->flags
& SEC_ALLOC
) != 0)
3045 sofar
+= (current
->vma
- sofar
) % page_size
;
3047 current
->filepos
= sofar
;
3049 #ifdef COFF_IMAGE_WITH_PE
3050 /* Set the padded size. */
3051 current
->_raw_size
= (current
->_raw_size
+ page_size
-1) & -page_size
;
3054 sofar
+= current
->_raw_size
;
3056 #ifdef ALIGN_SECTIONS_IN_FILE
3057 /* make sure that this section is of the right size too */
3058 if ((abfd
->flags
& EXEC_P
) == 0)
3060 bfd_size_type old_size
;
3062 old_size
= current
->_raw_size
;
3063 current
->_raw_size
= BFD_ALIGN (current
->_raw_size
,
3064 1 << current
->alignment_power
);
3065 align_adjust
= current
->_raw_size
!= old_size
;
3066 sofar
+= current
->_raw_size
- old_size
;
3071 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3072 align_adjust
= sofar
!= old_sofar
;
3073 current
->_raw_size
+= sofar
- old_sofar
;
3077 #ifdef COFF_IMAGE_WITH_PE
3078 /* For PE we need to make sure we pad out to the aligned
3079 _raw_size, in case the caller only writes out data to the
3080 unaligned _raw_size. */
3081 if (pei_section_data (abfd
, current
)->virt_size
< current
->_raw_size
)
3082 align_adjust
= true;
3086 /* Force .lib sections to start at zero. The vma is then
3087 incremented in coff_set_section_contents. This is right for
3089 if (strcmp (current
->name
, _LIB
) == 0)
3090 bfd_set_section_vma (abfd
, current
, 0);
3096 /* It is now safe to write to the output file. If we needed an
3097 alignment adjustment for the last section, then make sure that
3098 there is a byte at offset sofar. If there are no symbols and no
3099 relocs, then nothing follows the last section. If we don't force
3100 the last byte out, then the file may appear to be truncated. */
3106 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
3107 || bfd_write (&b
, 1, 1, abfd
) != 1)
3111 /* Make sure the relocations are aligned. We don't need to make
3112 sure that this byte exists, because it will only matter if there
3113 really are relocs. */
3114 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
3116 obj_relocbase (abfd
) = sofar
;
3117 abfd
->output_has_begun
= true;
3124 /* This can never work, because it is called too late--after the
3125 section positions have been set. I can't figure out what it is
3126 for, so I am going to disable it--Ian Taylor 20 March 1996. */
3128 /* If .file, .text, .data, .bss symbols are missing, add them. */
3129 /* @@ Should we only be adding missing symbols, or overriding the aux
3130 values for existing section symbols? */
3132 coff_add_missing_symbols (abfd
)
3135 unsigned int nsyms
= bfd_get_symcount (abfd
);
3136 asymbol
**sympp
= abfd
->outsymbols
;
3139 int need_text
= 1, need_data
= 1, need_bss
= 1, need_file
= 1;
3141 for (i
= 0; i
< nsyms
; i
++)
3143 coff_symbol_type
*csym
= coff_symbol_from (abfd
, sympp
[i
]);
3147 /* only do this if there is a coff representation of the input
3149 if (csym
->native
&& csym
->native
->u
.syment
.n_sclass
== C_FILE
)
3154 name
= csym
->symbol
.name
;
3157 if (!strcmp (name
, _TEXT
))
3160 else if (!strcmp (name
, ".wtext"))
3163 else if (!strcmp (name
, _DATA
))
3165 else if (!strcmp (name
, _BSS
))
3169 /* Now i == bfd_get_symcount (abfd). */
3170 /* @@ For now, don't deal with .file symbol. */
3173 if (!need_text
&& !need_data
&& !need_bss
&& !need_file
)
3175 nsyms
+= need_text
+ need_data
+ need_bss
+ need_file
;
3176 sympp2
= (asymbol
**) bfd_alloc (abfd
, nsyms
* sizeof (asymbol
*));
3179 memcpy (sympp2
, sympp
, i
* sizeof (asymbol
*));
3182 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
3186 sympp2
[i
++] = coff_section_symbol (abfd
, _TEXT
);
3188 sympp2
[i
++] = coff_section_symbol (abfd
, _DATA
);
3190 sympp2
[i
++] = coff_section_symbol (abfd
, _BSS
);
3191 BFD_ASSERT (i
== nsyms
);
3192 bfd_set_symtab (abfd
, sympp2
, nsyms
);
3201 coff_write_object_contents (abfd
)
3205 boolean hasrelocs
= false;
3206 boolean haslinno
= false;
3207 boolean hasdebug
= false;
3209 file_ptr reloc_base
;
3210 file_ptr lineno_base
;
3212 unsigned long reloc_size
= 0, reloc_count
= 0;
3213 unsigned long lnno_size
= 0;
3214 boolean long_section_names
;
3215 asection
*text_sec
= NULL
;
3216 asection
*data_sec
= NULL
;
3217 asection
*bss_sec
= NULL
;
3218 struct internal_filehdr internal_f
;
3219 struct internal_aouthdr internal_a
;
3220 #ifdef COFF_LONG_SECTION_NAMES
3221 size_t string_size
= STRING_SIZE_SIZE
;
3224 bfd_set_error (bfd_error_system_call
);
3226 /* Make a pass through the symbol table to count line number entries and
3227 put them into the correct asections */
3229 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3231 if (abfd
->output_has_begun
== false)
3233 if (! coff_compute_section_file_positions (abfd
))
3237 reloc_base
= obj_relocbase (abfd
);
3239 /* Work out the size of the reloc and linno areas */
3241 for (current
= abfd
->sections
; current
!= NULL
; current
=
3245 /* we store the actual reloc count in the first reloc's addr */
3246 if (current
->reloc_count
> 0xffff)
3249 reloc_count
+= current
->reloc_count
;
3252 reloc_size
= reloc_count
* bfd_coff_relsz (abfd
);
3254 lineno_base
= reloc_base
+ reloc_size
;
3255 sym_base
= lineno_base
+ lnno_size
;
3257 /* Indicate in each section->line_filepos its actual file address */
3258 for (current
= abfd
->sections
; current
!= NULL
; current
=
3261 if (current
->lineno_count
)
3263 current
->line_filepos
= lineno_base
;
3264 current
->moving_line_filepos
= lineno_base
;
3265 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3269 current
->line_filepos
= 0;
3271 if (current
->reloc_count
)
3273 current
->rel_filepos
= reloc_base
;
3274 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3276 /* extra reloc to hold real count */
3277 if (current
->reloc_count
> 0xffff)
3278 reloc_base
+= bfd_coff_relsz (abfd
);
3283 current
->rel_filepos
= 0;
3287 /* Write section headers to the file. */
3288 internal_f
.f_nscns
= 0;
3290 if ((abfd
->flags
& EXEC_P
) != 0)
3291 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3294 scn_base
= bfd_coff_filhsz (abfd
);
3296 if (xcoff_data (abfd
)->full_aouthdr
)
3297 scn_base
+= bfd_coff_aoutsz (abfd
);
3299 scn_base
+= SMALL_AOUTSZ
;
3303 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3306 long_section_names
= false;
3307 for (current
= abfd
->sections
;
3309 current
= current
->next
)
3311 struct internal_scnhdr section
;
3312 boolean is_reloc_section
= false;
3314 #ifdef COFF_IMAGE_WITH_PE
3315 if (strcmp (current
->name
, ".reloc") == 0)
3317 is_reloc_section
= true;
3319 pe_data (abfd
)->has_reloc_section
= 1;
3323 internal_f
.f_nscns
++;
3325 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3327 #ifdef COFF_LONG_SECTION_NAMES
3328 /* Handle long section names as in PE. This must be compatible
3329 with the code in coff_write_symbols and _bfd_coff_final_link. */
3333 len
= strlen (current
->name
);
3336 memset (section
.s_name
, 0, SCNNMLEN
);
3337 sprintf (section
.s_name
, "/%lu", (unsigned long) string_size
);
3338 string_size
+= len
+ 1;
3339 long_section_names
= true;
3345 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3346 Ian Taylor <ian@cygnus.com>. */
3347 if (strcmp (current
->name
, _LIB
) == 0)
3348 section
.s_vaddr
= 0;
3351 section
.s_vaddr
= current
->vma
;
3352 section
.s_paddr
= current
->lma
;
3353 section
.s_size
= current
->_raw_size
;
3354 #ifdef coff_get_section_load_page
3355 section
.s_page
= coff_get_section_load_page (current
);
3359 section
.s_paddr
= 0;
3361 #ifdef COFF_IMAGE_WITH_PE
3362 /* Reminder: s_paddr holds the virtual size of the section. */
3363 if (coff_section_data (abfd
, current
) != NULL
3364 && pei_section_data (abfd
, current
) != NULL
)
3365 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3367 section
.s_paddr
= 0;
3371 If this section has no size or is unloadable then the scnptr
3374 if (current
->_raw_size
== 0 ||
3375 (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3377 section
.s_scnptr
= 0;
3381 section
.s_scnptr
= current
->filepos
;
3383 section
.s_relptr
= current
->rel_filepos
;
3384 section
.s_lnnoptr
= current
->line_filepos
;
3385 section
.s_nreloc
= current
->reloc_count
;
3386 section
.s_nlnno
= current
->lineno_count
;
3387 #ifndef COFF_IMAGE_WITH_PE
3388 /* In PEI, relocs come in the .reloc section. */
3389 if (current
->reloc_count
!= 0)
3392 if (current
->lineno_count
!= 0)
3394 if ((current
->flags
& SEC_DEBUGGING
) != 0
3395 && ! is_reloc_section
)
3400 /* Indicate the use of an XCOFF overflow section header. */
3401 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3403 section
.s_nreloc
= 0xffff;
3404 section
.s_nlnno
= 0xffff;
3409 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3411 if (!strcmp (current
->name
, _TEXT
))
3415 else if (!strcmp (current
->name
, _DATA
))
3419 else if (!strcmp (current
->name
, _BSS
))
3425 section
.s_align
= (current
->alignment_power
3426 ? 1 << current
->alignment_power
3430 /* TI COFF puts the alignment power in bits 8-11 of the flags */
3431 section
.s_flags
|= (current
->alignment_power
& 0xF) << 8;
3433 #ifdef COFF_ENCODE_ALIGNMENT
3434 COFF_ENCODE_ALIGNMENT(section
, current
->alignment_power
);
3437 #ifdef COFF_IMAGE_WITH_PE
3438 /* Suppress output of the sections if they are null. ld
3439 includes the bss and data sections even if there is no size
3440 assigned to them. NT loader doesn't like it if these section
3441 headers are included if the sections themselves are not
3442 needed. See also coff_compute_section_file_positions. */
3443 if (section
.s_size
== 0)
3444 internal_f
.f_nscns
--;
3449 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3450 || bfd_write ((PTR
) (&buff
), 1, bfd_coff_scnhsz (abfd
), abfd
)
3451 != bfd_coff_scnhsz (abfd
))
3456 /* PE stores COMDAT section information in the symbol table. If
3457 this section is supposed to have some COMDAT info, track down
3458 the symbol in the symbol table and modify it. */
3459 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3461 unsigned int i
, count
;
3463 coff_symbol_type
*csym
= NULL
;
3467 count
= bfd_get_symcount (abfd
);
3468 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3470 if ((*psym
)->section
!= current
)
3473 /* Remember the location of the first symbol in this
3475 if (psymsec
== NULL
)
3478 /* See if this is the section symbol. */
3479 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3481 csym
= coff_symbol_from (abfd
, *psym
);
3483 || csym
->native
== NULL
3484 || csym
->native
->u
.syment
.n_numaux
< 1
3485 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3486 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3489 /* Here *PSYM is the section symbol for CURRENT. */
3496 Note that we might not if we're converting the file from
3497 some other object file format. */
3500 combined_entry_type
*aux
;
3502 /* We don't touch the x_checksum field. The
3503 x_associated field is not currently supported. */
3505 aux
= csym
->native
+ 1;
3506 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3508 case SEC_LINK_DUPLICATES_DISCARD
:
3509 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3512 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3513 aux
->u
.auxent
.x_scn
.x_comdat
=
3514 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3517 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3518 aux
->u
.auxent
.x_scn
.x_comdat
=
3519 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3522 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3523 aux
->u
.auxent
.x_scn
.x_comdat
=
3524 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3528 /* The COMDAT symbol must be the first symbol from this
3529 section in the symbol table. In order to make this
3530 work, we move the COMDAT symbol before the first
3531 symbol we found in the search above. It's OK to
3532 rearrange the symbol table at this point, because
3533 coff_renumber_symbols is going to rearrange it
3534 further and fix up all the aux entries. */
3535 if (psym
!= psymsec
)
3541 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3542 pcopy
[0] = pcopy
[-1];
3547 #endif /* COFF_WITH_PE */
3551 /* XCOFF handles overflows in the reloc and line number count fields
3552 by creating a new section header to hold the correct values. */
3553 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3555 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3557 struct internal_scnhdr scnhdr
;
3560 internal_f
.f_nscns
++;
3561 strncpy (&(scnhdr
.s_name
[0]), current
->name
, 8);
3562 scnhdr
.s_paddr
= current
->reloc_count
;
3563 scnhdr
.s_vaddr
= current
->lineno_count
;
3565 scnhdr
.s_scnptr
= 0;
3566 scnhdr
.s_relptr
= current
->rel_filepos
;
3567 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3568 scnhdr
.s_nreloc
= current
->target_index
;
3569 scnhdr
.s_nlnno
= current
->target_index
;
3570 scnhdr
.s_flags
= STYP_OVRFLO
;
3571 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3572 || bfd_write ((PTR
) &buff
, 1, bfd_coff_scnhsz (abfd
), abfd
)
3573 != bfd_coff_scnhsz (abfd
))
3579 /* OK, now set up the filehdr... */
3581 /* Don't include the internal abs section in the section count */
3584 We will NOT put a fucking timestamp in the header here. Every time you
3585 put it back, I will come in and take it out again. I'm sorry. This
3586 field does not belong here. We fill it with a 0 so it compares the
3587 same but is not a reasonable time. -- gnu@cygnus.com
3589 internal_f
.f_timdat
= 0;
3591 internal_f
.f_flags
= 0;
3593 if (abfd
->flags
& EXEC_P
)
3594 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3597 internal_f
.f_opthdr
= 0;
3599 if (xcoff_data (abfd
)->full_aouthdr
)
3600 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3602 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
3607 internal_f
.f_flags
|= F_RELFLG
;
3609 internal_f
.f_flags
|= F_LNNO
;
3610 if (abfd
->flags
& EXEC_P
)
3611 internal_f
.f_flags
|= F_EXEC
;
3612 #ifdef COFF_IMAGE_WITH_PE
3614 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
3617 #ifndef COFF_WITH_PE
3618 if (bfd_little_endian (abfd
))
3619 internal_f
.f_flags
|= F_AR32WR
;
3621 internal_f
.f_flags
|= F_AR32W
;
3625 /* target id is used in TI COFF v1 and later; COFF0 won't use this field,
3626 but it doesn't hurt to set it internally */
3627 internal_f
.f_target_id
= TI_TARGET_ID
;
3629 #ifdef TIC80_TARGET_ID
3630 internal_f
.f_target_id
= TIC80_TARGET_ID
;
3634 FIXME, should do something about the other byte orders and
3639 if ((abfd
->flags
& DYNAMIC
) != 0)
3640 internal_f
.f_flags
|= F_SHROBJ
;
3641 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
3642 internal_f
.f_flags
|= F_DYNLOAD
;
3645 memset (&internal_a
, 0, sizeof internal_a
);
3647 /* Set up architecture-dependent stuff */
3650 unsigned int magic
= 0;
3651 unsigned short flags
= 0;
3652 coff_set_flags (abfd
, &magic
, &flags
);
3653 internal_f
.f_magic
= magic
;
3654 internal_f
.f_flags
|= flags
;
3655 /* ...and the "opt"hdr... */
3658 #ifdef ULTRA3 /* NYU's machine */
3659 /* FIXME: This is a bogus check. I really want to see if there
3660 * is a .shbss or a .shdata section, if so then set the magic
3661 * number to indicate a shared data executable.
3663 if (internal_f
.f_nscns
>= 7)
3664 internal_a
.magic
= SHMAGIC
; /* Shared magic */
3667 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
3668 #define __A_MAGIC_SET__
3670 #ifdef TICOFF_AOUT_MAGIC
3671 internal_a
.magic
= TICOFF_AOUT_MAGIC
;
3672 #define __A_MAGIC_SET__
3675 internal_a
.magic
= TIC80_ARCH_MAGIC
;
3676 #define __A_MAGIC_SET__
3679 /* FIXME: What are the a.out magic numbers for the i860? */
3680 internal_a
.magic
= 0;
3681 #define __A_MAGIC_SET__
3684 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
3685 #define __A_MAGIC_SET__
3688 #define __A_MAGIC_SET__
3689 internal_a
.magic
= PAGEMAGICBCS
;
3693 #define __A_MAGIC_SET__
3694 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
3697 #if defined(M68) || defined(WE32K) || defined(M68K)
3698 #define __A_MAGIC_SET__
3700 internal_a
.magic
= LYNXCOFFMAGIC
;
3702 #if defined(TARG_AUX)
3703 internal_a
.magic
= (abfd
->flags
& D_PAGED
? PAGEMAGICPEXECPAGED
:
3704 abfd
->flags
& WP_TEXT
? PAGEMAGICPEXECSWAPPED
:
3705 PAGEMAGICEXECSWAPPED
);
3707 #if defined (PAGEMAGICPEXECPAGED)
3708 internal_a
.magic
= PAGEMAGICPEXECPAGED
;
3710 #endif /* TARG_AUX */
3712 #endif /* M68 || WE32K || M68K */
3715 #define __A_MAGIC_SET__
3716 internal_a
.magic
= ZMAGIC
;
3720 #define __A_MAGIC_SET__
3721 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3724 #if defined MCORE_PE
3725 #define __A_MAGIC_SET__
3726 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3730 #define __A_MAGIC_SET__
3732 internal_a
.magic
= LYNXCOFFMAGIC
;
3734 internal_a
.magic
= ZMAGIC
;
3739 #define __A_MAGIC_SET__
3740 internal_a
.magic
= ZMAGIC
;
3744 #define __A_MAGIC_SET__
3746 internal_a
.magic
= LYNXCOFFMAGIC
;
3751 #define __A_MAGIC_SET__
3752 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
3753 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
3754 RS6K_AOUTHDR_OMAGIC
;
3757 #if defined(SH) && defined(COFF_WITH_PE)
3758 #define __A_MAGIC_SET__
3759 internal_a
.magic
= SH_PE_MAGIC
;
3762 #if defined(MIPS) && defined(COFF_WITH_PE)
3763 #define __A_MAGIC_SET__
3764 internal_a
.magic
= MIPS_PE_MAGIC
;
3767 #ifndef __A_MAGIC_SET__
3768 #include "Your aouthdr magic number is not being set!"
3770 #undef __A_MAGIC_SET__
3774 /* FIXME: Does anybody ever set this to another value? */
3775 internal_a
.vstamp
= 0;
3777 /* Now should write relocs, strings, syms */
3778 obj_sym_filepos (abfd
) = sym_base
;
3780 if (bfd_get_symcount (abfd
) != 0)
3784 if (!coff_add_missing_symbols (abfd
))
3787 if (!coff_renumber_symbols (abfd
, &firstundef
))
3789 coff_mangle_symbols (abfd
);
3790 if (! coff_write_symbols (abfd
))
3792 if (! coff_write_linenumbers (abfd
))
3794 if (! coff_write_relocs (abfd
, firstundef
))
3797 #ifdef COFF_LONG_SECTION_NAMES
3798 else if (long_section_names
&& ! obj_coff_strings_written (abfd
))
3800 /* If we have long section names we have to write out the string
3801 table even if there are no symbols. */
3802 if (! coff_write_symbols (abfd
))
3806 #ifdef COFF_IMAGE_WITH_PE
3808 else if ((abfd
->flags
& EXEC_P
) != 0)
3812 /* PowerPC PE appears to require that all executable files be
3813 rounded up to the page size. */
3816 BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
3818 || bfd_write (&b
, 1, 1, abfd
) != 1)
3824 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3825 backend linker, and obj_raw_syment_count is not valid until after
3826 coff_write_symbols is called. */
3827 if (obj_raw_syment_count (abfd
) != 0)
3829 internal_f
.f_symptr
= sym_base
;
3831 /* AIX appears to require that F_RELFLG not be set if there are
3832 local symbols but no relocations. */
3833 internal_f
.f_flags
&=~ F_RELFLG
;
3838 if (long_section_names
)
3839 internal_f
.f_symptr
= sym_base
;
3841 internal_f
.f_symptr
= 0;
3842 internal_f
.f_flags
|= F_LSYMS
;
3847 internal_a
.tsize
= bfd_get_section_size_before_reloc (text_sec
);
3848 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
3852 internal_a
.dsize
= bfd_get_section_size_before_reloc (data_sec
);
3853 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
3857 internal_a
.bsize
= bfd_get_section_size_before_reloc (bss_sec
);
3858 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
3859 internal_a
.data_start
= bss_sec
->vma
;
3862 internal_a
.entry
= bfd_get_start_address (abfd
);
3863 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
3866 if (xcoff_data (abfd
)->full_aouthdr
)
3869 asection
*loader_sec
;
3871 internal_a
.vstamp
= 1;
3873 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
3874 if (internal_a
.o_snentry
== 0)
3875 internal_a
.entry
= (bfd_vma
) -1;
3877 if (text_sec
!= NULL
)
3879 internal_a
.o_sntext
= text_sec
->target_index
;
3880 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
3884 internal_a
.o_sntext
= 0;
3885 internal_a
.o_algntext
= 0;
3887 if (data_sec
!= NULL
)
3889 internal_a
.o_sndata
= data_sec
->target_index
;
3890 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
3894 internal_a
.o_sndata
= 0;
3895 internal_a
.o_algndata
= 0;
3897 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
3898 if (loader_sec
!= NULL
)
3899 internal_a
.o_snloader
= loader_sec
->target_index
;
3901 internal_a
.o_snloader
= 0;
3902 if (bss_sec
!= NULL
)
3903 internal_a
.o_snbss
= bss_sec
->target_index
;
3905 internal_a
.o_snbss
= 0;
3907 toc
= xcoff_data (abfd
)->toc
;
3908 internal_a
.o_toc
= toc
;
3909 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
3911 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
3912 if (xcoff_data (abfd
)->cputype
!= -1)
3913 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
3916 switch (bfd_get_arch (abfd
))
3918 case bfd_arch_rs6000
:
3919 internal_a
.o_cputype
= 4;
3921 case bfd_arch_powerpc
:
3922 if (bfd_get_mach (abfd
) == 0)
3923 internal_a
.o_cputype
= 3;
3925 internal_a
.o_cputype
= 1;
3931 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
3932 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
3936 /* now write them */
3937 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
3942 bfd_size_type amount
;
3944 buff
= bfd_malloc (bfd_coff_filhsz (abfd
));
3948 coff_swap_filehdr_out (abfd
, (PTR
) & internal_f
, (PTR
) buff
);
3949 amount
= bfd_write ((PTR
) buff
, 1, bfd_coff_filhsz (abfd
), abfd
);
3953 if (amount
!= bfd_coff_filhsz (abfd
))
3957 if (abfd
->flags
& EXEC_P
)
3959 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
3960 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)) */
3962 bfd_size_type amount
;
3964 buff
= bfd_malloc (bfd_coff_aoutsz (abfd
));
3968 coff_swap_aouthdr_out (abfd
, (PTR
) & internal_a
, (PTR
) buff
);
3969 amount
= bfd_write ((PTR
) buff
, 1, bfd_coff_aoutsz (abfd
), abfd
);
3973 if (amount
!= bfd_coff_aoutsz (abfd
))
3982 /* XCOFF seems to always write at least a small a.out header. */
3983 coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, (PTR
) &buff
);
3984 if (xcoff_data (abfd
)->full_aouthdr
)
3985 size
= bfd_coff_aoutsz (abfd
);
3987 size
= SMALL_AOUTSZ
;
3988 if (bfd_write ((PTR
) &buff
, 1, size
, abfd
) != size
)
3997 coff_set_section_contents (abfd
, section
, location
, offset
, count
)
4002 bfd_size_type count
;
4004 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
4006 if (! coff_compute_section_file_positions (abfd
))
4010 #if defined(_LIB) && !defined(TARG_AUX)
4012 /* The physical address field of a .lib section is used to hold the
4013 number of shared libraries in the section. This code counts the
4014 number of sections being written, and increments the lma field
4017 I have found no documentation on the contents of this section.
4018 Experimentation indicates that the section contains zero or more
4019 records, each of which has the following structure:
4021 - a (four byte) word holding the length of this record, in words,
4022 - a word that always seems to be set to "2",
4023 - the path to a shared library, null-terminated and then padded
4024 to a whole word boundary.
4026 bfd_assert calls have been added to alert if an attempt is made
4027 to write a section which doesn't follow these assumptions. The
4028 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4029 <robertl@arnet.com> (Thanks!).
4031 Gvran Uddeborg <gvran@uddeborg.pp.se> */
4033 if (strcmp (section
->name
, _LIB
) == 0)
4035 bfd_byte
*rec
, *recend
;
4037 rec
= (bfd_byte
*) location
;
4038 recend
= rec
+ count
;
4039 while (rec
< recend
)
4042 rec
+= bfd_get_32 (abfd
, rec
) * 4;
4045 BFD_ASSERT (rec
== recend
);
4050 /* Don't write out bss sections - one way to do this is to
4051 see if the filepos has not been set. */
4052 if (section
->filepos
== 0)
4055 if (bfd_seek (abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
) != 0)
4060 return (bfd_write (location
, 1, count
, abfd
) == count
) ? true : false;
4066 coff_close_and_cleanup (abfd
)
4069 if (!bfd_read_p (abfd
))
4070 switch (abfd
->format
)
4073 if (!_bfd_write_archive_contents (abfd
))
4077 if (!coff_write_object_contents (abfd
))
4081 bfd_set_error (bfd_error_invalid_operation
);
4085 /* We depend on bfd_close to free all the memory on the objalloc. */
4092 buy_and_read (abfd
, where
, seek_direction
, size
)
4098 PTR area
= (PTR
) bfd_alloc (abfd
, size
);
4101 if (bfd_seek (abfd
, where
, seek_direction
) != 0
4102 || bfd_read (area
, 1, size
, abfd
) != size
)
4105 } /* buy_and_read() */
4111 Creating the linenumber table is done by reading in the entire
4112 coff linenumber table, and creating another table for internal use.
4114 A coff linenumber table is structured so that each function
4115 is marked as having a line number of 0. Each line within the
4116 function is an offset from the first line in the function. The
4117 base of the line number information for the table is stored in
4118 the symbol associated with the function.
4120 Note: The PE format uses line number 0 for a flag indicating a
4123 The information is copied from the external to the internal
4124 table, and each symbol which marks a function is marked by
4127 How does this work ?
4132 coff_slurp_line_table (abfd
, asect
)
4136 LINENO
*native_lineno
;
4137 alent
*lineno_cache
;
4139 BFD_ASSERT (asect
->lineno
== (alent
*) NULL
);
4141 native_lineno
= (LINENO
*) buy_and_read (abfd
,
4142 asect
->line_filepos
,
4144 (size_t) (bfd_coff_linesz (abfd
) *
4145 asect
->lineno_count
));
4147 (alent
*) bfd_alloc (abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof (alent
)));
4148 if (lineno_cache
== NULL
)
4152 unsigned int counter
= 0;
4153 alent
*cache_ptr
= lineno_cache
;
4154 LINENO
*src
= native_lineno
;
4156 while (counter
< asect
->lineno_count
)
4158 struct internal_lineno dst
;
4159 bfd_coff_swap_lineno_in (abfd
, src
, &dst
);
4160 cache_ptr
->line_number
= dst
.l_lnno
;
4162 if (cache_ptr
->line_number
== 0)
4166 coff_symbol_type
*sym
;
4169 symndx
= dst
.l_addr
.l_symndx
;
4171 || (unsigned long) symndx
>= obj_raw_syment_count (abfd
))
4173 (*_bfd_error_handler
)
4174 (_("%s: warning: illegal symbol index %ld in line numbers"),
4175 bfd_get_filename (abfd
), dst
.l_addr
.l_symndx
);
4179 /* FIXME: We should not be casting between ints and
4180 pointers like this. */
4181 sym
= ((coff_symbol_type
*)
4182 ((symndx
+ obj_raw_syments (abfd
))
4183 ->u
.syment
._n
._n_n
._n_zeroes
));
4184 cache_ptr
->u
.sym
= (asymbol
*) sym
;
4185 if (sym
->lineno
!= NULL
&& ! warned
)
4187 (*_bfd_error_handler
)
4188 (_("%s: warning: duplicate line number information for `%s'"),
4189 bfd_get_filename (abfd
),
4190 bfd_asymbol_name (&sym
->symbol
));
4192 sym
->lineno
= cache_ptr
;
4196 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
4197 - bfd_section_vma (abfd
, asect
);
4198 } /* If no linenumber expect a symbol index */
4204 cache_ptr
->line_number
= 0;
4207 asect
->lineno
= lineno_cache
;
4208 /* FIXME, free native_lineno here, or use alloca or something. */
4212 /* Slurp in the symbol table, converting it to generic form. Note
4213 that if coff_relocate_section is defined, the linker will read
4214 symbols via coff_link_add_symbols, rather than via this routine. */
4217 coff_slurp_symbol_table (abfd
)
4220 combined_entry_type
*native_symbols
;
4221 coff_symbol_type
*cached_area
;
4222 unsigned int *table_ptr
;
4224 unsigned int number_of_symbols
= 0;
4226 if (obj_symbols (abfd
))
4229 /* Read in the symbol table */
4230 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4235 /* Allocate enough room for all the symbols in cached form */
4236 cached_area
= ((coff_symbol_type
*)
4238 (obj_raw_syment_count (abfd
)
4239 * sizeof (coff_symbol_type
))));
4241 if (cached_area
== NULL
)
4243 table_ptr
= ((unsigned int *)
4245 (obj_raw_syment_count (abfd
)
4246 * sizeof (unsigned int))));
4248 if (table_ptr
== NULL
)
4252 coff_symbol_type
*dst
= cached_area
;
4253 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4254 unsigned int this_index
= 0;
4255 while (this_index
< last_native_index
)
4257 combined_entry_type
*src
= native_symbols
+ this_index
;
4258 table_ptr
[this_index
] = number_of_symbols
;
4259 dst
->symbol
.the_bfd
= abfd
;
4261 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4262 /* We use the native name field to point to the cached field. */
4263 src
->u
.syment
._n
._n_n
._n_zeroes
= (long) dst
;
4264 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4265 src
->u
.syment
.n_scnum
);
4266 dst
->symbol
.flags
= 0;
4267 dst
->done_lineno
= false;
4269 switch (src
->u
.syment
.n_sclass
)
4274 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
4275 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4276 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4278 /* Fall through to next case */
4286 case C_THUMBEXTFUNC
:
4292 case C_SYSTEM
: /* System Wide variable */
4295 /* In PE, 0x68 (104) denotes a section symbol */
4297 /* In PE, 0x69 (105) denotes a weak external symbol. */
4300 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4302 case COFF_SYMBOL_GLOBAL
:
4303 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4304 #if defined COFF_WITH_PE
4305 /* PE sets the symbol to a value relative to the
4306 start of the section. */
4307 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4309 dst
->symbol
.value
= (src
->u
.syment
.n_value
4310 - dst
->symbol
.section
->vma
);
4312 if (ISFCN ((src
->u
.syment
.n_type
)))
4314 /* A function ext does not go at the end of a
4316 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4320 case COFF_SYMBOL_COMMON
:
4321 dst
->symbol
.section
= bfd_com_section_ptr
;
4322 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4325 case COFF_SYMBOL_UNDEFINED
:
4326 dst
->symbol
.section
= bfd_und_section_ptr
;
4327 dst
->symbol
.value
= 0;
4330 case COFF_SYMBOL_PE_SECTION
:
4331 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4332 dst
->symbol
.value
= 0;
4335 case COFF_SYMBOL_LOCAL
:
4336 dst
->symbol
.flags
= BSF_LOCAL
;
4337 #if defined COFF_WITH_PE
4338 /* PE sets the symbol to a value relative to the
4339 start of the section. */
4340 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4342 dst
->symbol
.value
= (src
->u
.syment
.n_value
4343 - dst
->symbol
.section
->vma
);
4345 if (ISFCN ((src
->u
.syment
.n_type
)))
4346 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4351 /* A symbol with a csect entry should not go at the end. */
4352 if (src
->u
.syment
.n_numaux
> 0)
4353 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4357 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4358 dst
->symbol
.flags
= BSF_WEAK
;
4359 if (src
->u
.syment
.n_sclass
== C_SECTION
4360 && src
->u
.syment
.n_scnum
> 0)
4362 dst
->symbol
.flags
= BSF_LOCAL
;
4366 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
)
4367 dst
->symbol
.flags
= BSF_WEAK
;
4371 case C_STAT
: /* static */
4373 case C_LEAFSTAT
: /* static leaf procedure */
4376 case C_THUMBSTAT
: /* Thumb static */
4377 case C_THUMBLABEL
: /* Thumb label */
4378 case C_THUMBSTATFUNC
:/* Thumb static function */
4380 case C_LABEL
: /* label */
4381 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4382 dst
->symbol
.flags
= BSF_DEBUGGING
;
4384 dst
->symbol
.flags
= BSF_LOCAL
;
4386 /* Base the value as an index from the base of the
4387 section, if there is one. */
4388 if (dst
->symbol
.section
)
4390 #if defined COFF_WITH_PE
4391 /* PE sets the symbol to a value relative to the
4392 start of the section. */
4393 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4395 dst
->symbol
.value
= (src
->u
.syment
.n_value
4396 - dst
->symbol
.section
->vma
);
4400 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4403 case C_MOS
: /* member of structure */
4404 case C_EOS
: /* end of structure */
4405 #ifdef NOTDEF /* C_AUTOARG has the same value */
4407 case C_GLBLREG
: /* A29k-specific storage class */
4410 case C_REGPARM
: /* register parameter */
4411 case C_REG
: /* register variable */
4412 /* C_AUTOARG conflictes with TI COFF C_UEXT */
4413 #if !defined (TIC80COFF) && !defined (TICOFF)
4415 case C_AUTOARG
: /* 960-specific storage class */
4418 case C_TPDEF
: /* type definition */
4420 case C_AUTO
: /* automatic variable */
4421 case C_FIELD
: /* bit field */
4422 case C_ENTAG
: /* enumeration tag */
4423 case C_MOE
: /* member of enumeration */
4424 case C_MOU
: /* member of union */
4425 case C_UNTAG
: /* union tag */
4426 dst
->symbol
.flags
= BSF_DEBUGGING
;
4427 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4430 case C_FILE
: /* file name */
4431 case C_STRTAG
: /* structure tag */
4446 dst
->symbol
.flags
= BSF_DEBUGGING
;
4447 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4451 case C_BINCL
: /* beginning of include file */
4452 case C_EINCL
: /* ending of include file */
4453 /* The value is actually a pointer into the line numbers
4454 of the file. We locate the line number entry, and
4455 set the section to the section which contains it, and
4456 the value to the index in that section. */
4460 dst
->symbol
.flags
= BSF_DEBUGGING
;
4461 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4462 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4463 && ((file_ptr
) (sec
->line_filepos
4464 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4465 > (file_ptr
) src
->u
.syment
.n_value
))
4468 dst
->symbol
.value
= 0;
4471 dst
->symbol
.section
= sec
;
4472 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4473 - sec
->line_filepos
)
4474 / bfd_coff_linesz (abfd
));
4481 dst
->symbol
.flags
= BSF_DEBUGGING
;
4483 /* The value is actually a symbol index. Save a pointer
4484 to the symbol instead of the index. FIXME: This
4485 should use a union. */
4486 src
->u
.syment
.n_value
=
4487 (long) (native_symbols
+ src
->u
.syment
.n_value
);
4488 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4493 case C_BLOCK
: /* ".bb" or ".eb" */
4494 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf") */
4495 case C_EFCN
: /* physical end of function */
4496 #if defined COFF_WITH_PE
4497 /* PE sets the symbol to a value relative to the start
4499 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4500 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4502 /* PE uses funny values for .ef and .lf; don't
4504 dst
->symbol
.flags
= BSF_DEBUGGING
;
4507 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4509 /* Base the value as an index from the base of the
4511 dst
->symbol
.flags
= BSF_LOCAL
;
4512 dst
->symbol
.value
= (src
->u
.syment
.n_value
4513 - dst
->symbol
.section
->vma
);
4517 case C_STATLAB
: /* Static load time label */
4518 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4519 dst
->symbol
.flags
= BSF_GLOBAL
;
4523 /* PE DLLs sometimes have zeroed out symbols for some
4524 reason. Just ignore them without a warning. */
4525 if (src
->u
.syment
.n_type
== 0
4526 && src
->u
.syment
.n_value
== 0
4527 && src
->u
.syment
.n_scnum
== 0)
4530 case C_EXTDEF
: /* external definition */
4531 case C_ULABEL
: /* undefined label */
4532 case C_USTATIC
: /* undefined static */
4533 #ifndef COFF_WITH_PE
4534 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4535 class to represent a section symbol */
4536 case C_LINE
: /* line # reformatted as symbol table entry */
4537 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4538 case C_ALIAS
: /* duplicate tag */
4540 /* New storage classes for TI COFF */
4541 #if defined(TIC80COFF) || defined(TICOFF)
4542 case C_UEXT
: /* Tentative external definition */
4544 case C_EXTLAB
: /* External load time label */
4545 case C_HIDDEN
: /* ext symbol in dmert public lib */
4547 (*_bfd_error_handler
)
4548 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
4549 bfd_get_filename (abfd
), src
->u
.syment
.n_sclass
,
4550 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4551 dst
->symbol
.flags
= BSF_DEBUGGING
;
4552 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4556 /* BFD_ASSERT(dst->symbol.flags != 0);*/
4560 dst
->symbol
.udata
.i
= 0;
4561 dst
->lineno
= (alent
*) NULL
;
4562 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
4564 number_of_symbols
++;
4565 } /* walk the native symtab */
4566 } /* bfdize the native symtab */
4568 obj_symbols (abfd
) = cached_area
;
4569 obj_raw_syments (abfd
) = native_symbols
;
4571 bfd_get_symcount (abfd
) = number_of_symbols
;
4572 obj_convert (abfd
) = table_ptr
;
4573 /* Slurp the line tables for each section too */
4579 coff_slurp_line_table (abfd
, p
);
4584 } /* coff_slurp_symbol_table() */
4586 /* Classify a COFF symbol. A couple of targets have globally visible
4587 symbols which are not class C_EXT, and this handles those. It also
4588 recognizes some special PE cases. */
4590 static enum coff_symbol_classification
4591 coff_classify_symbol (abfd
, syment
)
4593 struct internal_syment
*syment
;
4595 /* FIXME: This partially duplicates the switch in
4596 coff_slurp_symbol_table. */
4597 switch (syment
->n_sclass
)
4606 case C_THUMBEXTFUNC
:
4614 if (syment
->n_scnum
== 0)
4616 if (syment
->n_value
== 0)
4617 return COFF_SYMBOL_UNDEFINED
;
4619 return COFF_SYMBOL_COMMON
;
4621 return COFF_SYMBOL_GLOBAL
;
4628 if (syment
->n_sclass
== C_STAT
)
4630 if (syment
->n_scnum
== 0)
4632 /* The Microsoft compiler sometimes generates these if a
4633 small static function is inlined every time it is used.
4634 The function is discarded, but the symbol table entry
4636 return COFF_SYMBOL_LOCAL
;
4639 #ifdef STRICT_PE_FORMAT
4640 /* This is correct for Microsoft generated objects, but it
4641 breaks gas generated objects. */
4643 if (syment
->n_value
== 0)
4646 char buf
[SYMNMLEN
+ 1];
4648 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
4650 && (strcmp (bfd_get_section_name (abfd
, sec
),
4651 _bfd_coff_internal_syment_name (abfd
, syment
, buf
))
4653 return COFF_SYMBOL_PE_SECTION
;
4657 return COFF_SYMBOL_LOCAL
;
4660 if (syment
->n_sclass
== C_SECTION
)
4662 /* In some cases in a DLL generated by the Microsoft linker, the
4663 n_value field will contain garbage. FIXME: This should
4664 probably be handled by the swapping function instead. */
4665 syment
->n_value
= 0;
4666 if (syment
->n_scnum
== 0)
4667 return COFF_SYMBOL_UNDEFINED
;
4668 return COFF_SYMBOL_PE_SECTION
;
4670 #endif /* COFF_WITH_PE */
4672 /* If it is not a global symbol, we presume it is a local symbol. */
4674 if (syment
->n_scnum
== 0)
4676 char buf
[SYMNMLEN
+ 1];
4678 (*_bfd_error_handler
)
4679 (_("warning: %s: local symbol `%s' has no section"),
4680 bfd_get_filename (abfd
),
4681 _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
4684 return COFF_SYMBOL_LOCAL
;
4691 Coff relocations are easily transformed into the internal BFD form
4694 Reading a coff relocation table is done in the following stages:
4696 o Read the entire coff relocation table into memory.
4698 o Process each relocation in turn; first swap it from the
4699 external to the internal form.
4701 o Turn the symbol referenced in the relocation's symbol index
4702 into a pointer into the canonical symbol table.
4703 This table is the same as the one returned by a call to
4704 @code{bfd_canonicalize_symtab}. The back end will call that
4705 routine and save the result if a canonicalization hasn't been done.
4707 o The reloc index is turned into a pointer to a howto
4708 structure, in a back end specific way. For instance, the 386
4709 and 960 use the @code{r_type} to directly produce an index
4710 into a howto table vector; the 88k subtracts a number from the
4711 @code{r_type} field and creates an addend field.
4716 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
4718 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
4719 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
4720 coffsym = (obj_symbols (abfd) \
4721 + (cache_ptr->sym_ptr_ptr - symbols)); \
4723 coffsym = coff_symbol_from (abfd, ptr); \
4724 if (coffsym != (coff_symbol_type *) NULL \
4725 && coffsym->native->u.syment.n_scnum == 0) \
4726 cache_ptr->addend = 0; \
4727 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
4728 && ptr->section != (asection *) NULL) \
4729 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
4731 cache_ptr->addend = 0; \
4736 coff_slurp_reloc_table (abfd
, asect
, symbols
)
4741 RELOC
*native_relocs
;
4742 arelent
*reloc_cache
;
4747 if (asect
->relocation
)
4749 if (asect
->reloc_count
== 0)
4751 if (asect
->flags
& SEC_CONSTRUCTOR
)
4753 if (!coff_slurp_symbol_table (abfd
))
4756 (RELOC
*) buy_and_read (abfd
,
4759 (size_t) (bfd_coff_relsz (abfd
) *
4760 asect
->reloc_count
));
4761 reloc_cache
= (arelent
*)
4762 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
4764 if (reloc_cache
== NULL
)
4767 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
4769 struct internal_reloc dst
;
4770 struct external_reloc
*src
;
4771 #ifndef RELOC_PROCESSING
4775 cache_ptr
= reloc_cache
+ idx
;
4776 src
= native_relocs
+ idx
;
4778 coff_swap_reloc_in (abfd
, src
, &dst
);
4780 #ifdef RELOC_PROCESSING
4781 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
4783 cache_ptr
->address
= dst
.r_vaddr
;
4785 if (dst
.r_symndx
!= -1)
4787 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
4789 (*_bfd_error_handler
)
4790 (_("%s: warning: illegal symbol index %ld in relocs"),
4791 bfd_get_filename (abfd
), dst
.r_symndx
);
4792 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
4797 cache_ptr
->sym_ptr_ptr
= (symbols
4798 + obj_convert (abfd
)[dst
.r_symndx
]);
4799 ptr
= *(cache_ptr
->sym_ptr_ptr
);
4804 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
4808 /* The symbols definitions that we have read in have been
4809 relocated as if their sections started at 0. But the offsets
4810 refering to the symbols in the raw data have not been
4811 modified, so we have to have a negative addend to compensate.
4813 Note that symbols which used to be common must be left alone */
4815 /* Calculate any reloc addend by looking at the symbol */
4816 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
4818 cache_ptr
->address
-= asect
->vma
;
4819 /* !! cache_ptr->section = (asection *) NULL;*/
4821 /* Fill in the cache_ptr->howto field from dst.r_type */
4822 RTYPE2HOWTO (cache_ptr
, &dst
);
4823 #endif /* RELOC_PROCESSING */
4825 if (cache_ptr
->howto
== NULL
)
4827 (*_bfd_error_handler
)
4828 (_("%s: illegal relocation type %d at address 0x%lx"),
4829 bfd_get_filename (abfd
), dst
.r_type
, (long) dst
.r_vaddr
);
4830 bfd_set_error (bfd_error_bad_value
);
4835 asect
->relocation
= reloc_cache
;
4839 #ifndef coff_rtype_to_howto
4842 /* Get the howto structure for a reloc. This is only used if the file
4843 including this one defines coff_relocate_section to be
4844 _bfd_coff_generic_relocate_section, so it is OK if it does not
4845 always work. It is the responsibility of the including file to
4846 make sure it is reasonable if it is needed. */
4848 static reloc_howto_type
*coff_rtype_to_howto
4849 PARAMS ((bfd
*, asection
*, struct internal_reloc
*,
4850 struct coff_link_hash_entry
*, struct internal_syment
*,
4854 static reloc_howto_type
*
4855 coff_rtype_to_howto (abfd
, sec
, rel
, h
, sym
, addendp
)
4856 bfd
*abfd ATTRIBUTE_UNUSED
;
4857 asection
*sec ATTRIBUTE_UNUSED
;
4858 struct internal_reloc
*rel
;
4859 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
;
4860 struct internal_syment
*sym ATTRIBUTE_UNUSED
;
4861 bfd_vma
*addendp ATTRIBUTE_UNUSED
;
4865 RTYPE2HOWTO (&genrel
, rel
);
4866 return genrel
.howto
;
4869 #else /* ! defined (RTYPE2HOWTO) */
4871 #define coff_rtype_to_howto NULL
4873 #endif /* ! defined (RTYPE2HOWTO) */
4874 #endif /* ! defined (coff_rtype_to_howto) */
4876 /* This is stupid. This function should be a boolean predicate. */
4878 coff_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
4884 arelent
*tblptr
= section
->relocation
;
4885 unsigned int count
= 0;
4887 if (section
->flags
& SEC_CONSTRUCTOR
)
4889 /* this section has relocs made up by us, they are not in the
4890 file, so take them out of their chain and place them into
4891 the data area provided */
4892 arelent_chain
*chain
= section
->constructor_chain
;
4893 for (count
= 0; count
< section
->reloc_count
; count
++)
4895 *relptr
++ = &chain
->relent
;
4896 chain
= chain
->next
;
4902 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
4905 tblptr
= section
->relocation
;
4907 for (; count
++ < section
->reloc_count
;)
4908 *relptr
++ = tblptr
++;
4912 return section
->reloc_count
;
4917 coff_sym_filepos (abfd
)
4920 return obj_sym_filepos (abfd
);
4924 #ifndef coff_reloc16_estimate
4925 #define coff_reloc16_estimate dummy_reloc16_estimate
4927 static int dummy_reloc16_estimate
4928 PARAMS ((bfd
*, asection
*, arelent
*, unsigned int,
4929 struct bfd_link_info
*));
4932 dummy_reloc16_estimate (abfd
, input_section
, reloc
, shrink
, link_info
)
4933 bfd
*abfd ATTRIBUTE_UNUSED
;
4934 asection
*input_section ATTRIBUTE_UNUSED
;
4935 arelent
*reloc ATTRIBUTE_UNUSED
;
4936 unsigned int shrink ATTRIBUTE_UNUSED
;
4937 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
4945 #ifndef coff_reloc16_extra_cases
4947 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
4949 /* This works even if abort is not declared in any header file. */
4951 static void dummy_reloc16_extra_cases
4952 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*, arelent
*,
4953 bfd_byte
*, unsigned int *, unsigned int *));
4956 dummy_reloc16_extra_cases (abfd
, link_info
, link_order
, reloc
, data
, src_ptr
,
4958 bfd
*abfd ATTRIBUTE_UNUSED
;
4959 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
4960 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
;
4961 arelent
*reloc ATTRIBUTE_UNUSED
;
4962 bfd_byte
*data ATTRIBUTE_UNUSED
;
4963 unsigned int *src_ptr ATTRIBUTE_UNUSED
;
4964 unsigned int *dst_ptr ATTRIBUTE_UNUSED
;
4970 /* If coff_relocate_section is defined, we can use the optimized COFF
4971 backend linker. Otherwise we must continue to use the old linker. */
4972 #ifdef coff_relocate_section
4973 #ifndef coff_bfd_link_hash_table_create
4974 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
4976 #ifndef coff_bfd_link_add_symbols
4977 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
4979 #ifndef coff_bfd_final_link
4980 #define coff_bfd_final_link _bfd_coff_final_link
4982 #else /* ! defined (coff_relocate_section) */
4983 #define coff_relocate_section NULL
4984 #ifndef coff_bfd_link_hash_table_create
4985 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
4987 #ifndef coff_bfd_link_add_symbols
4988 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
4990 #define coff_bfd_final_link _bfd_generic_final_link
4991 #endif /* ! defined (coff_relocate_section) */
4993 #define coff_bfd_link_split_section _bfd_generic_link_split_section
4995 #ifndef coff_start_final_link
4996 #define coff_start_final_link NULL
4999 #ifndef coff_adjust_symndx
5000 #define coff_adjust_symndx NULL
5003 #ifndef coff_link_add_one_symbol
5004 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5007 #ifndef coff_link_output_has_begun
5009 static boolean coff_link_output_has_begun
5010 PARAMS ((bfd
*, struct coff_final_link_info
*));
5013 coff_link_output_has_begun (abfd
, info
)
5015 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
;
5017 return abfd
->output_has_begun
;
5021 #ifndef coff_final_link_postscript
5023 static boolean coff_final_link_postscript
5024 PARAMS ((bfd
*, struct coff_final_link_info
*));
5027 coff_final_link_postscript (abfd
, pfinfo
)
5028 bfd
* abfd ATTRIBUTE_UNUSED
;
5029 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
;
5035 #ifndef coff_SWAP_aux_in
5036 #define coff_SWAP_aux_in coff_swap_aux_in
5038 #ifndef coff_SWAP_sym_in
5039 #define coff_SWAP_sym_in coff_swap_sym_in
5041 #ifndef coff_SWAP_lineno_in
5042 #define coff_SWAP_lineno_in coff_swap_lineno_in
5044 #ifndef coff_SWAP_aux_out
5045 #define coff_SWAP_aux_out coff_swap_aux_out
5047 #ifndef coff_SWAP_sym_out
5048 #define coff_SWAP_sym_out coff_swap_sym_out
5050 #ifndef coff_SWAP_lineno_out
5051 #define coff_SWAP_lineno_out coff_swap_lineno_out
5053 #ifndef coff_SWAP_reloc_out
5054 #define coff_SWAP_reloc_out coff_swap_reloc_out
5056 #ifndef coff_SWAP_filehdr_out
5057 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5059 #ifndef coff_SWAP_aouthdr_out
5060 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5062 #ifndef coff_SWAP_scnhdr_out
5063 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5065 #ifndef coff_SWAP_reloc_in
5066 #define coff_SWAP_reloc_in coff_swap_reloc_in
5068 #ifndef coff_SWAP_filehdr_in
5069 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5071 #ifndef coff_SWAP_aouthdr_in
5072 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5074 #ifndef coff_SWAP_scnhdr_in
5075 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5078 static const bfd_coff_backend_data bfd_coff_std_swap_table
=
5080 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5081 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5082 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5083 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5084 coff_SWAP_scnhdr_out
,
5085 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5086 #ifdef COFF_LONG_FILENAMES
5091 #ifdef COFF_LONG_SECTION_NAMES
5096 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5097 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5102 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5107 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5108 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5109 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5110 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5111 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5112 coff_classify_symbol
, coff_compute_section_file_positions
,
5113 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5114 coff_adjust_symndx
, coff_link_add_one_symbol
,
5115 coff_link_output_has_begun
, coff_final_link_postscript
5118 #ifndef coff_close_and_cleanup
5119 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5122 #ifndef coff_bfd_free_cached_info
5123 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5126 #ifndef coff_get_section_contents
5127 #define coff_get_section_contents _bfd_generic_get_section_contents
5130 #ifndef coff_bfd_copy_private_symbol_data
5131 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5134 #ifndef coff_bfd_copy_private_section_data
5135 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5138 #ifndef coff_bfd_copy_private_bfd_data
5139 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5142 #ifndef coff_bfd_merge_private_bfd_data
5143 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5146 #ifndef coff_bfd_set_private_flags
5147 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5150 #ifndef coff_bfd_print_private_bfd_data
5151 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5154 #ifndef coff_bfd_is_local_label_name
5155 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5158 #ifndef coff_read_minisymbols
5159 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5162 #ifndef coff_minisymbol_to_symbol
5163 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5166 /* The reloc lookup routine must be supplied by each individual COFF
5168 #ifndef coff_bfd_reloc_type_lookup
5169 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5172 #ifndef coff_bfd_get_relocated_section_contents
5173 #define coff_bfd_get_relocated_section_contents \
5174 bfd_generic_get_relocated_section_contents
5177 #ifndef coff_bfd_relax_section
5178 #define coff_bfd_relax_section bfd_generic_relax_section
5181 #ifndef coff_bfd_gc_sections
5182 #define coff_bfd_gc_sections bfd_generic_gc_sections
5185 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
5186 const bfd_target VAR = \
5189 bfd_target_coff_flavour, \
5190 BFD_ENDIAN_BIG, /* data byte order is big */ \
5191 BFD_ENDIAN_BIG, /* header byte order is big */ \
5192 /* object flags */ \
5193 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5194 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5195 /* section flags */ \
5196 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5197 UNDER, /* leading symbol underscore */ \
5198 '/', /* ar_pad_char */ \
5199 15, /* ar_max_namelen */ \
5201 /* Data conversion functions. */ \
5202 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5203 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5204 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5206 /* Header conversion functions. */ \
5207 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5208 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5209 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5211 /* bfd_check_format */ \
5212 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5213 _bfd_dummy_target }, \
5214 /* bfd_set_format */ \
5215 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5216 /* bfd_write_contents */ \
5217 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5220 BFD_JUMP_TABLE_GENERIC (coff), \
5221 BFD_JUMP_TABLE_COPY (coff), \
5222 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5223 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5224 BFD_JUMP_TABLE_SYMBOLS (coff), \
5225 BFD_JUMP_TABLE_RELOCS (coff), \
5226 BFD_JUMP_TABLE_WRITE (coff), \
5227 BFD_JUMP_TABLE_LINK (coff), \
5228 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5235 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
5236 const bfd_target VAR = \
5239 bfd_target_coff_flavour, \
5240 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
5241 BFD_ENDIAN_LITTLE, /* header byte order is little */ \
5242 /* object flags */ \
5243 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5244 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5245 /* section flags */ \
5246 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5247 UNDER, /* leading symbol underscore */ \
5248 '/', /* ar_pad_char */ \
5249 15, /* ar_max_namelen */ \
5251 /* Data conversion functions. */ \
5252 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5253 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5254 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5255 /* Header conversion functions. */ \
5256 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5257 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5258 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5259 /* bfd_check_format */ \
5260 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5261 _bfd_dummy_target }, \
5262 /* bfd_set_format */ \
5263 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5264 /* bfd_write_contents */ \
5265 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5268 BFD_JUMP_TABLE_GENERIC (coff), \
5269 BFD_JUMP_TABLE_COPY (coff), \
5270 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5271 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5272 BFD_JUMP_TABLE_SYMBOLS (coff), \
5273 BFD_JUMP_TABLE_RELOCS (coff), \
5274 BFD_JUMP_TABLE_WRITE (coff), \
5275 BFD_JUMP_TABLE_LINK (coff), \
5276 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \