1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 1999
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_linno_in}. @code{GDB} reads the symbol
135 table on its own, but uses BFD to fix things up. More of the
136 bit twiddlers are exported for @code{gas};
137 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
138 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
139 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
140 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
141 of all the symbol table and reloc drudgery itself, thereby
142 saving the internal BFD overhead, but uses BFD to swap things
143 on the way out, making cross ports much safer. Doing so also
144 allows BFD (and thus the linker) to use the same header files
145 as @code{gas}, which makes one avenue to disaster disappear.
150 The simple canonical form for symbols used by BFD is not rich
151 enough to keep all the information available in a coff symbol
152 table. The back end gets around this problem by keeping the original
153 symbol table around, "behind the scenes".
155 When a symbol table is requested (through a call to
156 @code{bfd_canonicalize_symtab}), a request gets through to
157 @code{coff_get_normalized_symtab}. This reads the symbol table from
158 the coff file and swaps all the structures inside into the
159 internal form. It also fixes up all the pointers in the table
160 (represented in the file by offsets from the first symbol in
161 the table) into physical pointers to elements in the new
162 internal table. This involves some work since the meanings of
163 fields change depending upon context: a field that is a
164 pointer to another structure in the symbol table at one moment
165 may be the size in bytes of a structure at the next. Another
166 pass is made over the table. All symbols which mark file names
167 (<<C_FILE>> symbols) are modified so that the internal
168 string points to the value in the auxent (the real filename)
169 rather than the normal text associated with the symbol
172 At this time the symbol names are moved around. Coff stores
173 all symbols less than nine characters long physically
174 within the symbol table; longer strings are kept at the end of
175 the file in the string table. This pass moves all strings
176 into memory and replaces them with pointers to the strings.
179 The symbol table is massaged once again, this time to create
180 the canonical table used by the BFD application. Each symbol
181 is inspected in turn, and a decision made (using the
182 @code{sclass} field) about the various flags to set in the
183 @code{asymbol}. @xref{Symbols}. The generated canonical table
184 shares strings with the hidden internal symbol table.
186 Any linenumbers are read from the coff file too, and attached
187 to the symbols which own the functions the linenumbers belong to.
192 Writing a symbol to a coff file which didn't come from a coff
193 file will lose any debugging information. The @code{asymbol}
194 structure remembers the BFD from which the symbol was taken, and on
195 output the back end makes sure that the same destination target as
196 source target is present.
198 When the symbols have come from a coff file then all the
199 debugging information is preserved.
201 Symbol tables are provided for writing to the back end in a
202 vector of pointers to pointers. This allows applications like
203 the linker to accumulate and output large symbol tables
204 without having to do too much byte copying.
206 This function runs through the provided symbol table and
207 patches each symbol marked as a file place holder
208 (@code{C_FILE}) to point to the next file place holder in the
209 list. It also marks each @code{offset} field in the list with
210 the offset from the first symbol of the current symbol.
212 Another function of this procedure is to turn the canonical
213 value form of BFD into the form used by coff. Internally, BFD
214 expects symbol values to be offsets from a section base; so a
215 symbol physically at 0x120, but in a section starting at
216 0x100, would have the value 0x20. Coff expects symbols to
217 contain their final value, so symbols have their values
218 changed at this point to reflect their sum with their owning
219 section. This transformation uses the
220 <<output_section>> field of the @code{asymbol}'s
221 @code{asection} @xref{Sections}.
223 o <<coff_mangle_symbols>>
225 This routine runs though the provided symbol table and uses
226 the offsets generated by the previous pass and the pointers
227 generated when the symbol table was read in to create the
228 structured hierachy required by coff. It changes each pointer
229 to a symbol into the index into the symbol table of the asymbol.
231 o <<coff_write_symbols>>
233 This routine runs through the symbol table and patches up the
234 symbols from their internal form into the coff way, calls the
235 bit twiddlers, and writes out the table to the file.
244 The hidden information for an <<asymbol>> is described in a
245 <<combined_entry_type>>:
249 .typedef struct coff_ptr_struct
252 . {* Remembers the offset from the first symbol in the file for
253 . this symbol. Generated by coff_renumber_symbols. *}
254 .unsigned int offset;
256 . {* Should the value of this symbol be renumbered. Used for
257 . XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
258 .unsigned int fix_value : 1;
260 . {* Should the tag field of this symbol be renumbered.
261 . Created by coff_pointerize_aux. *}
262 .unsigned int fix_tag : 1;
264 . {* Should the endidx field of this symbol be renumbered.
265 . Created by coff_pointerize_aux. *}
266 .unsigned int fix_end : 1;
268 . {* Should the x_csect.x_scnlen field be renumbered.
269 . Created by coff_pointerize_aux. *}
270 .unsigned int fix_scnlen : 1;
272 . {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
273 . index into the line number entries. Set by
274 . coff_slurp_symbol_table. *}
275 .unsigned int fix_line : 1;
277 . {* The container for the symbol structure as read and translated
281 . union internal_auxent auxent;
282 . struct internal_syment syment;
284 .} combined_entry_type;
287 .{* Each canonical asymbol really looks like this: *}
289 .typedef struct coff_symbol_struct
291 . {* The actual symbol which the rest of BFD works with *}
294 . {* A pointer to the hidden information for this symbol *}
295 .combined_entry_type *native;
297 . {* A pointer to the linenumber information for this symbol *}
298 .struct lineno_cache_entry *lineno;
300 . {* Have the line numbers been relocated yet ? *}
301 .boolean done_lineno;
310 #include "coffswap.h"
313 #define STRING_SIZE_SIZE (4)
315 static long sec_to_styp_flags
PARAMS ((const char *, flagword
));
316 static flagword styp_to_sec_flags
PARAMS ((bfd
*, PTR
, const char *));
317 static boolean coff_bad_format_hook
PARAMS ((bfd
*, PTR
));
318 static boolean coff_new_section_hook
PARAMS ((bfd
*, asection
*));
319 static boolean coff_set_arch_mach_hook
PARAMS ((bfd
*, PTR
));
320 static boolean coff_write_relocs
PARAMS ((bfd
*, int));
321 static boolean coff_set_flags
322 PARAMS ((bfd
*, unsigned int *, unsigned short *));
323 static boolean coff_set_arch_mach
324 PARAMS ((bfd
*, enum bfd_architecture
, unsigned long));
325 static boolean coff_compute_section_file_positions
PARAMS ((bfd
*));
326 static boolean coff_write_object_contents
PARAMS ((bfd
*));
327 static boolean coff_set_section_contents
328 PARAMS ((bfd
*, asection
*, PTR
, file_ptr
, bfd_size_type
));
329 static PTR buy_and_read
PARAMS ((bfd
*, file_ptr
, int, size_t));
330 static boolean coff_slurp_line_table
PARAMS ((bfd
*, asection
*));
331 static boolean coff_slurp_symbol_table
PARAMS ((bfd
*));
332 static enum coff_symbol_classification coff_classify_symbol
333 PARAMS ((bfd
*, struct internal_syment
*));
334 static boolean coff_slurp_reloc_table
PARAMS ((bfd
*, asection
*, asymbol
**));
335 static long coff_canonicalize_reloc
336 PARAMS ((bfd
*, asection
*, arelent
**, asymbol
**));
337 #ifndef coff_mkobject_hook
338 static PTR coff_mkobject_hook
PARAMS ((bfd
*, PTR
, PTR
));
341 /* void warning(); */
344 * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the
345 * incoming SEC_* flags. The inverse of this function is styp_to_sec_flags().
346 * NOTE: If you add to/change this routine, you should mirror the changes
347 * in styp_to_sec_flags().
350 sec_to_styp_flags (sec_name
, sec_flags
)
351 CONST
char *sec_name
;
356 if (!strcmp (sec_name
, _TEXT
))
358 styp_flags
= STYP_TEXT
;
360 else if (!strcmp (sec_name
, _DATA
))
362 styp_flags
= STYP_DATA
;
364 else if (!strcmp (sec_name
, _BSS
))
366 styp_flags
= STYP_BSS
;
369 else if (!strcmp (sec_name
, _COMMENT
))
371 styp_flags
= STYP_INFO
;
372 #endif /* _COMMENT */
375 else if (!strcmp (sec_name
, _LIB
))
377 styp_flags
= STYP_LIB
;
381 else if (!strcmp (sec_name
, _LIT
))
383 styp_flags
= STYP_LIT
;
386 else if (!strcmp (sec_name
, ".debug"))
389 styp_flags
= STYP_DEBUG
;
391 styp_flags
= STYP_INFO
;
394 else if (!strncmp (sec_name
, ".stab", 5))
396 styp_flags
= STYP_INFO
;
399 else if (!strcmp (sec_name
, ".edata"))
401 styp_flags
= STYP_DATA
;
405 else if (!strcmp (sec_name
, _PAD
))
407 styp_flags
= STYP_PAD
;
409 else if (!strcmp (sec_name
, _LOADER
))
411 styp_flags
= STYP_LOADER
;
414 /* Try and figure out what it should be */
415 else if (sec_flags
& SEC_CODE
)
417 styp_flags
= STYP_TEXT
;
419 else if (sec_flags
& SEC_DATA
)
421 styp_flags
= STYP_DATA
;
423 else if (sec_flags
& SEC_READONLY
)
425 #ifdef STYP_LIT /* 29k readonly text/data section */
426 styp_flags
= STYP_LIT
;
428 styp_flags
= STYP_TEXT
;
429 #endif /* STYP_LIT */
431 else if (sec_flags
& SEC_LOAD
)
433 styp_flags
= STYP_TEXT
;
435 else if (sec_flags
& SEC_ALLOC
)
437 styp_flags
= STYP_BSS
;
441 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
442 styp_flags
|= STYP_NOLOAD
;
446 if (sec_flags
& SEC_LINK_ONCE
)
447 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
448 if (sec_flags
& SEC_SHARED
)
449 styp_flags
|= IMAGE_SCN_MEM_SHARED
;
455 * Return a word with SEC_* flags set to represent the incoming
456 * STYP_* flags (from scnhdr.s_flags). The inverse of this
457 * function is sec_to_styp_flags().
458 * NOTE: If you add to/change this routine, you should mirror the changes
459 * in sec_to_styp_flags().
462 styp_to_sec_flags (abfd
, hdr
, name
)
463 bfd
*abfd ATTRIBUTE_UNUSED
;
467 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
468 long styp_flags
= internal_s
->s_flags
;
469 flagword sec_flags
= 0;
472 if (styp_flags
& STYP_NOLOAD
)
474 sec_flags
|= SEC_NEVER_LOAD
;
476 #endif /* STYP_NOLOAD */
478 /* For 386 COFF, at least, an unloadable text or data section is
479 actually a shared library section. */
480 if (styp_flags
& STYP_TEXT
)
482 if (sec_flags
& SEC_NEVER_LOAD
)
483 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
485 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
487 else if (styp_flags
& STYP_DATA
)
489 if (sec_flags
& SEC_NEVER_LOAD
)
490 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
492 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
494 else if (styp_flags
& STYP_BSS
)
496 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
497 if (sec_flags
& SEC_NEVER_LOAD
)
498 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
501 sec_flags
|= SEC_ALLOC
;
503 else if (styp_flags
& STYP_INFO
)
505 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
506 defined. coff_compute_section_file_positions uses
507 COFF_PAGE_SIZE to ensure that the low order bits of the
508 section VMA and the file offset match. If we don't know
509 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
510 and demand page loading of the file will fail. */
511 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
512 sec_flags
|= SEC_DEBUGGING
;
515 else if (styp_flags
& STYP_PAD
)
519 else if (strcmp (name
, _TEXT
) == 0)
521 if (sec_flags
& SEC_NEVER_LOAD
)
522 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
524 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
526 else if (strcmp (name
, _DATA
) == 0)
528 if (sec_flags
& SEC_NEVER_LOAD
)
529 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
531 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
533 else if (strcmp (name
, _BSS
) == 0)
535 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
536 if (sec_flags
& SEC_NEVER_LOAD
)
537 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
540 sec_flags
|= SEC_ALLOC
;
542 else if (strcmp (name
, ".debug") == 0
544 || strcmp (name
, _COMMENT
) == 0
546 || strncmp (name
, ".stab", 5) == 0)
548 #ifdef COFF_PAGE_SIZE
549 sec_flags
|= SEC_DEBUGGING
;
553 else if (strcmp (name
, _LIB
) == 0)
557 else if (strcmp (name
, _LIT
) == 0)
559 sec_flags
= SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
564 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
567 #ifdef STYP_LIT /* A29k readonly text/data section type */
568 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
570 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
572 #endif /* STYP_LIT */
573 #ifdef STYP_OTHER_LOAD /* Other loaded sections */
574 if (styp_flags
& STYP_OTHER_LOAD
)
576 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
578 #endif /* STYP_SDATA */
581 if (styp_flags
& IMAGE_SCN_LNK_REMOVE
)
582 sec_flags
|= SEC_EXCLUDE
;
584 if (styp_flags
& IMAGE_SCN_MEM_SHARED
)
585 sec_flags
|= SEC_SHARED
;
587 if (styp_flags
& IMAGE_SCN_LNK_COMDAT
)
589 sec_flags
|= SEC_LINK_ONCE
;
591 /* Unfortunately, the PE format stores essential information in
592 the symbol table, of all places. We need to extract that
593 information now, so that objdump and the linker will know how
594 to handle the section without worrying about the symbols. We
595 can't call slurp_symtab, because the linker doesn't want the
598 /* COMDAT sections are special. The first symbol is the section
599 symbol, which tells what kind of COMDAT section it is. The
600 *second* symbol is the "comdat symbol" - the one with the
601 unique name. GNU uses the section symbol for the unique
602 name; MS uses ".text" for every comdat section. Sigh. - DJ */
604 if (_bfd_coff_get_external_symbols (abfd
))
606 bfd_byte
*esym
, *esymend
;
608 esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
609 esymend
= esym
+ obj_raw_syment_count (abfd
) * SYMESZ
;
611 while (esym
< esymend
)
613 struct internal_syment isym
;
615 bfd_coff_swap_sym_in (abfd
, (PTR
) esym
, (PTR
) &isym
);
617 if (sizeof (internal_s
->s_name
) > SYMNMLEN
)
619 /* This case implies that the matching symbol name
620 will be in the string table. */
624 if (isym
.n_sclass
== C_STAT
625 && isym
.n_type
== T_NULL
626 && isym
.n_numaux
== 1)
628 char buf
[SYMNMLEN
+ 1];
631 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
, buf
);
635 if (strcmp (name
, symname
) == 0)
637 union internal_auxent aux
;
639 /* This is the section symbol. */
641 bfd_coff_swap_aux_in (abfd
, (PTR
) (esym
+ SYMESZ
),
642 isym
.n_type
, isym
.n_sclass
,
643 0, isym
.n_numaux
, (PTR
) &aux
);
645 /* FIXME: Microsoft uses NODUPLICATES and
646 ASSOCIATIVE, but gnu uses ANY and SAME_SIZE.
647 Unfortunately, gnu doesn't do the comdat
648 symbols right. So, until we can fix it to do
649 the right thing, we are temporarily disabling
650 comdats for the MS types (they're used in
651 DLLs and C++, but we don't support *their*
652 C++ libraries anyway - DJ */
654 switch (aux
.x_scn
.x_comdat
)
656 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
658 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
660 sec_flags
&= ~SEC_LINK_ONCE
;
665 case IMAGE_COMDAT_SELECT_ANY
:
666 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
669 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
670 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
673 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
674 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
677 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
679 /* FIXME: This is not currently implemented. */
680 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
682 sec_flags
&= ~SEC_LINK_ONCE
;
691 esym
+= (isym
.n_numaux
+ 1) * SYMESZ
;
697 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
698 /* As a GNU extension, if the name begins with .gnu.linkonce, we
699 only link a single copy of the section. This is used to support
700 g++. g++ will emit each template expansion in its own section.
701 The symbols will be defined as weak, so that multiple definitions
702 are permitted. The GNU linker extension is to actually discard
703 all but one of the sections. */
704 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
705 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
711 #define get_index(symbol) ((symbol)->udata.i)
715 bfd_coff_backend_data
719 .{* COFF symbol classifications. *}
721 .enum coff_symbol_classification
723 . {* Global symbol. *}
724 . COFF_SYMBOL_GLOBAL,
725 . {* Common symbol. *}
726 . COFF_SYMBOL_COMMON,
727 . {* Undefined symbol. *}
728 . COFF_SYMBOL_UNDEFINED,
729 . {* Local symbol. *}
731 . {* PE section symbol. *}
732 . COFF_SYMBOL_PE_SECTION
735 Special entry points for gdb to swap in coff symbol table parts:
738 . void (*_bfd_coff_swap_aux_in) PARAMS ((
747 . void (*_bfd_coff_swap_sym_in) PARAMS ((
752 . void (*_bfd_coff_swap_lineno_in) PARAMS ((
758 Special entry points for gas to swap out coff parts:
760 . unsigned int (*_bfd_coff_swap_aux_out) PARAMS ((
769 . unsigned int (*_bfd_coff_swap_sym_out) PARAMS ((
774 . unsigned int (*_bfd_coff_swap_lineno_out) PARAMS ((
779 . unsigned int (*_bfd_coff_swap_reloc_out) PARAMS ((
784 . unsigned int (*_bfd_coff_swap_filehdr_out) PARAMS ((
789 . unsigned int (*_bfd_coff_swap_aouthdr_out) PARAMS ((
794 . unsigned int (*_bfd_coff_swap_scnhdr_out) PARAMS ((
800 Special entry points for generic COFF routines to call target
801 dependent COFF routines:
803 . unsigned int _bfd_filhsz;
804 . unsigned int _bfd_aoutsz;
805 . unsigned int _bfd_scnhsz;
806 . unsigned int _bfd_symesz;
807 . unsigned int _bfd_auxesz;
808 . unsigned int _bfd_relsz;
809 . unsigned int _bfd_linesz;
810 . boolean _bfd_coff_long_filenames;
811 . boolean _bfd_coff_long_section_names;
812 . unsigned int _bfd_coff_default_section_alignment_power;
813 . void (*_bfd_coff_swap_filehdr_in) PARAMS ((
817 . void (*_bfd_coff_swap_aouthdr_in) PARAMS ((
821 . void (*_bfd_coff_swap_scnhdr_in) PARAMS ((
825 . void (*_bfd_coff_swap_reloc_in) PARAMS ((
829 . boolean (*_bfd_coff_bad_format_hook) PARAMS ((
831 . PTR internal_filehdr));
832 . boolean (*_bfd_coff_set_arch_mach_hook) PARAMS ((
834 . PTR internal_filehdr));
835 . PTR (*_bfd_coff_mkobject_hook) PARAMS ((
837 . PTR internal_filehdr,
838 . PTR internal_aouthdr));
839 . flagword (*_bfd_styp_to_sec_flags_hook) PARAMS ((
841 . PTR internal_scnhdr,
842 . const char *name));
843 . void (*_bfd_set_alignment_hook) PARAMS ((
846 . PTR internal_scnhdr));
847 . boolean (*_bfd_coff_slurp_symbol_table) PARAMS ((
849 . boolean (*_bfd_coff_symname_in_debug) PARAMS ((
851 . struct internal_syment *sym));
852 . boolean (*_bfd_coff_pointerize_aux_hook) PARAMS ((
854 . combined_entry_type *table_base,
855 . combined_entry_type *symbol,
856 . unsigned int indaux,
857 . combined_entry_type *aux));
858 . boolean (*_bfd_coff_print_aux) PARAMS ((
861 . combined_entry_type *table_base,
862 . combined_entry_type *symbol,
863 . combined_entry_type *aux,
864 . unsigned int indaux));
865 . void (*_bfd_coff_reloc16_extra_cases) PARAMS ((
867 . struct bfd_link_info *link_info,
868 . struct bfd_link_order *link_order,
871 . unsigned int *src_ptr,
872 . unsigned int *dst_ptr));
873 . int (*_bfd_coff_reloc16_estimate) PARAMS ((
875 . asection *input_section,
877 . unsigned int shrink,
878 . struct bfd_link_info *link_info));
879 . enum coff_symbol_classification (*_bfd_coff_classify_symbol) PARAMS ((
881 . struct internal_syment *));
882 . boolean (*_bfd_coff_compute_section_file_positions) PARAMS ((
884 . boolean (*_bfd_coff_start_final_link) PARAMS ((
886 . struct bfd_link_info *info));
887 . boolean (*_bfd_coff_relocate_section) PARAMS ((
889 . struct bfd_link_info *info,
891 . asection *input_section,
892 . bfd_byte *contents,
893 . struct internal_reloc *relocs,
894 . struct internal_syment *syms,
895 . asection **sections));
896 . reloc_howto_type *(*_bfd_coff_rtype_to_howto) PARAMS ((
899 . struct internal_reloc *rel,
900 . struct coff_link_hash_entry *h,
901 . struct internal_syment *sym,
902 . bfd_vma *addendp));
903 . boolean (*_bfd_coff_adjust_symndx) PARAMS ((
905 . struct bfd_link_info *info,
908 . struct internal_reloc *reloc,
909 . boolean *adjustedp));
910 . boolean (*_bfd_coff_link_add_one_symbol) PARAMS ((
911 . struct bfd_link_info *info,
917 . const char *string,
920 . struct bfd_link_hash_entry **hashp));
922 . boolean (*_bfd_coff_link_output_has_begun) PARAMS ((
924 . struct coff_final_link_info * pfinfo));
925 . boolean (*_bfd_coff_final_link_postscript) PARAMS ((
927 . struct coff_final_link_info * pfinfo));
929 .} bfd_coff_backend_data;
931 .#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
933 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
934 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
936 .#define bfd_coff_swap_sym_in(a,e,i) \
937 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
939 .#define bfd_coff_swap_lineno_in(a,e,i) \
940 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
942 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
943 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
945 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
946 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
948 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
949 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
951 .#define bfd_coff_swap_sym_out(abfd, i,o) \
952 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
954 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
955 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
957 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
958 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
960 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
961 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
963 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
964 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
965 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
966 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
967 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
968 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
969 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
970 .#define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames)
971 .#define bfd_coff_long_section_names(abfd) \
972 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
973 .#define bfd_coff_default_section_alignment_power(abfd) \
974 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
975 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
976 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
978 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
979 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
981 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
982 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
984 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
985 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
987 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
988 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
990 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
991 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
992 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
993 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
995 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name)\
996 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook) (abfd, scnhdr, name))
998 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
999 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1001 .#define bfd_coff_slurp_symbol_table(abfd)\
1002 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1004 .#define bfd_coff_symname_in_debug(abfd, sym)\
1005 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1007 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1008 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1009 . (abfd, file, base, symbol, aux, indaux))
1011 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
1012 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1013 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1015 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1016 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1017 . (abfd, section, reloc, shrink, link_info))
1019 .#define bfd_coff_classify_symbol(abfd, sym)\
1020 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1023 .#define bfd_coff_compute_section_file_positions(abfd)\
1024 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1027 .#define bfd_coff_start_final_link(obfd, info)\
1028 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1030 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1031 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1032 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1033 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1034 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1035 . (abfd, sec, rel, h, sym, addendp))
1036 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1037 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1038 . (obfd, info, ibfd, sec, rel, adjustedp))
1039 .#define bfd_coff_link_add_one_symbol(info,abfd,name,flags,section,value,string,cp,coll,hashp)\
1040 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1041 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1043 .#define bfd_coff_link_output_has_begun(a,p) \
1044 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p))
1045 .#define bfd_coff_final_link_postscript(a,p) \
1046 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
1050 /* See whether the magic number matches. */
1053 coff_bad_format_hook (abfd
, filehdr
)
1054 bfd
* abfd ATTRIBUTE_UNUSED
;
1057 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1059 if (BADMAG (*internal_f
))
1062 /* if the optional header is NULL or not the correct size then
1063 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1064 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1065 optional header is of a different size.
1067 But the mips keeps extra stuff in it's opthdr, so dont check
1071 #if defined(M88) || defined(I960)
1072 if (internal_f
->f_opthdr
!= 0 && AOUTSZ
!= internal_f
->f_opthdr
)
1080 initialize a section structure with information peculiar to this
1081 particular implementation of coff
1085 coff_new_section_hook (abfd
, section
)
1089 combined_entry_type
*native
;
1091 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1094 if (xcoff_data (abfd
)->text_align_power
!= 0
1095 && strcmp (bfd_get_section_name (abfd
, section
), ".text") == 0)
1096 section
->alignment_power
= xcoff_data (abfd
)->text_align_power
;
1097 if (xcoff_data (abfd
)->data_align_power
!= 0
1098 && strcmp (bfd_get_section_name (abfd
, section
), ".data") == 0)
1099 section
->alignment_power
= xcoff_data (abfd
)->data_align_power
;
1102 /* Allocate aux records for section symbols, to store size and
1105 @@ The 10 is a guess at a plausible maximum number of aux entries
1106 (but shouldn't be a constant). */
1107 native
= ((combined_entry_type
*)
1108 bfd_zalloc (abfd
, sizeof (combined_entry_type
) * 10));
1112 /* We don't need to set up n_name, n_value, or n_scnum in the native
1113 symbol information, since they'll be overriden by the BFD symbol
1114 anyhow. However, we do need to set the type and storage class,
1115 in case this symbol winds up getting written out. The value 0
1116 for n_numaux is already correct. */
1118 native
->u
.syment
.n_type
= T_NULL
;
1119 native
->u
.syment
.n_sclass
= C_STAT
;
1121 coffsymbol (section
->symbol
)->native
= native
;
1123 /* The .stab section must be aligned to 2**2 at most, because
1124 otherwise there may be gaps in the section which gdb will not
1125 know how to interpret. Examining the section name is a hack, but
1126 that is also how gdb locates the section.
1127 We need to handle the .ctors and .dtors sections similarly, to
1128 avoid introducing null words in the tables. */
1129 if (COFF_DEFAULT_SECTION_ALIGNMENT_POWER
> 2
1130 && (strncmp (section
->name
, ".stab", 5) == 0
1131 || strcmp (section
->name
, ".ctors") == 0
1132 || strcmp (section
->name
, ".dtors") == 0))
1133 section
->alignment_power
= 2;
1135 /* Similarly, the .stabstr section must be aligned to 2**0 at most. */
1136 if (COFF_DEFAULT_SECTION_ALIGNMENT_POWER
> 0
1137 && strncmp (section
->name
, ".stabstr", 8) == 0)
1138 section
->alignment_power
= 0;
1143 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1145 /* Set the alignment of a BFD section. */
1147 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1150 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1151 bfd
* abfd ATTRIBUTE_UNUSED
;
1155 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1159 /* Extract ALIGN from 2**ALIGN stored in section header */
1160 for (i
= 0; i
< 32; i
++)
1161 if ((1 << i
) >= hdr
->s_align
)
1165 /* TI tools hijack bits 8-11 for the alignment */
1166 i
= (hdr
->s_flags
>> 8) & 0xF ;
1168 section
->alignment_power
= i
;
1171 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1174 /* a couple of macros to help setting the alignment power field */
1175 #define ALIGN_SET(field,x,y) \
1176 if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1178 section->alignment_power = y;\
1181 #define ELIFALIGN_SET(field,x,y) \
1182 else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1184 section->alignment_power = y;\
1187 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1190 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1191 bfd
* abfd ATTRIBUTE_UNUSED
;
1195 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1197 ALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_64BYTES
, 6)
1198 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_32BYTES
, 5)
1199 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_16BYTES
, 4)
1200 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_8BYTES
, 3)
1201 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_4BYTES
, 2)
1202 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_2BYTES
, 1)
1203 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_1BYTES
, 0)
1205 #ifdef POWERPC_LE_PE
1206 if (strcmp (section
->name
, ".idata$2") == 0)
1208 section
->alignment_power
= 0;
1210 else if (strcmp (section
->name
, ".idata$3") == 0)
1212 section
->alignment_power
= 0;
1214 else if (strcmp (section
->name
, ".idata$4") == 0)
1216 section
->alignment_power
= 2;
1218 else if (strcmp (section
->name
, ".idata$5") == 0)
1220 section
->alignment_power
= 2;
1222 else if (strcmp (section
->name
, ".idata$6") == 0)
1224 section
->alignment_power
= 1;
1226 else if (strcmp (section
->name
, ".reloc") == 0)
1228 section
->alignment_power
= 1;
1230 else if (strncmp (section
->name
, ".stab", 5) == 0)
1232 section
->alignment_power
= 2;
1236 #ifdef COFF_IMAGE_WITH_PE
1237 /* In a PE image file, the s_paddr field holds the virtual size of a
1238 section, while the s_size field holds the raw size. */
1239 if (hdr
->s_paddr
!= 0)
1241 if (coff_section_data (abfd
, section
) == NULL
)
1243 section
->used_by_bfd
=
1244 (PTR
) bfd_zalloc (abfd
, sizeof (struct coff_section_tdata
));
1245 if (section
->used_by_bfd
== NULL
)
1247 /* FIXME: Return error. */
1251 if (pei_section_data (abfd
, section
) == NULL
)
1253 coff_section_data (abfd
, section
)->tdata
=
1254 (PTR
) bfd_zalloc (abfd
, sizeof (struct pei_section_tdata
));
1255 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1257 /* FIXME: Return error. */
1261 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1266 section
->lma
= hdr
->s_vaddr
;
1270 #undef ELIFALIGN_SET
1272 #else /* ! COFF_WITH_PE */
1275 /* We grossly abuse this function to handle XCOFF overflow headers.
1276 When we see one, we correct the reloc and line number counts in the
1277 real header, and remove the section we just created. */
1279 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1282 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1287 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1291 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1294 real_sec
= coff_section_from_bfd_index (abfd
, hdr
->s_nreloc
);
1295 if (real_sec
== NULL
)
1298 real_sec
->reloc_count
= hdr
->s_paddr
;
1299 real_sec
->lineno_count
= hdr
->s_vaddr
;
1301 for (ps
= &abfd
->sections
; *ps
!= NULL
; ps
= &(*ps
)->next
)
1306 --abfd
->section_count
;
1312 #else /* ! RS6000COFF_C */
1314 #define coff_set_alignment_hook \
1315 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1317 #endif /* ! RS6000COFF_C */
1318 #endif /* ! COFF_WITH_PE */
1319 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1321 #ifndef coff_mkobject
1323 static boolean coff_mkobject
PARAMS ((bfd
*));
1326 coff_mkobject (abfd
)
1329 coff_data_type
*coff
;
1331 abfd
->tdata
.coff_obj_data
= (struct coff_tdata
*) bfd_zalloc (abfd
, sizeof (coff_data_type
));
1332 if (abfd
->tdata
.coff_obj_data
== 0)
1334 coff
= coff_data (abfd
);
1335 coff
->symbols
= (coff_symbol_type
*) NULL
;
1336 coff
->conversion_table
= (unsigned int *) NULL
;
1337 coff
->raw_syments
= (struct coff_ptr_struct
*) NULL
;
1338 coff
->relocbase
= 0;
1339 coff
->local_toc_sym_map
= 0;
1341 /* make_abs_section(abfd);*/
1347 /* Create the COFF backend specific information. */
1348 #ifndef coff_mkobject_hook
1350 coff_mkobject_hook (abfd
, filehdr
, aouthdr
)
1353 PTR aouthdr ATTRIBUTE_UNUSED
;
1355 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1356 coff_data_type
*coff
;
1358 if (coff_mkobject (abfd
) == false)
1361 coff
= coff_data (abfd
);
1363 coff
->sym_filepos
= internal_f
->f_symptr
;
1365 /* These members communicate important constants about the symbol
1366 table to GDB's symbol-reading code. These `constants'
1367 unfortunately vary among coff implementations... */
1368 coff
->local_n_btmask
= N_BTMASK
;
1369 coff
->local_n_btshft
= N_BTSHFT
;
1370 coff
->local_n_tmask
= N_TMASK
;
1371 coff
->local_n_tshift
= N_TSHIFT
;
1372 coff
->local_symesz
= SYMESZ
;
1373 coff
->local_auxesz
= AUXESZ
;
1374 coff
->local_linesz
= LINESZ
;
1376 obj_raw_syment_count (abfd
) =
1377 obj_conv_table_size (abfd
) =
1378 internal_f
->f_nsyms
;
1381 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
1382 abfd
->flags
|= DYNAMIC
;
1383 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= AOUTSZ
)
1385 struct internal_aouthdr
*internal_a
=
1386 (struct internal_aouthdr
*) aouthdr
;
1387 struct xcoff_tdata
*xcoff
;
1389 xcoff
= xcoff_data (abfd
);
1390 xcoff
->full_aouthdr
= true;
1391 xcoff
->toc
= internal_a
->o_toc
;
1392 xcoff
->sntoc
= internal_a
->o_sntoc
;
1393 xcoff
->snentry
= internal_a
->o_snentry
;
1394 xcoff
->text_align_power
= internal_a
->o_algntext
;
1395 xcoff
->data_align_power
= internal_a
->o_algndata
;
1396 xcoff
->modtype
= internal_a
->o_modtype
;
1397 xcoff
->cputype
= internal_a
->o_cputype
;
1398 xcoff
->maxdata
= internal_a
->o_maxdata
;
1399 xcoff
->maxstack
= internal_a
->o_maxstack
;
1404 /* Set the flags field from the COFF header read in */
1405 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
1413 /* Determine the machine architecture and type. FIXME: This is target
1414 dependent because the magic numbers are defined in the target
1415 dependent header files. But there is no particular need for this.
1416 If the magic numbers were moved to a separate file, this function
1417 would be target independent and would also be much more successful
1418 at linking together COFF files for different architectures. */
1421 coff_set_arch_mach_hook (abfd
, filehdr
)
1426 enum bfd_architecture arch
;
1427 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1430 switch (internal_f
->f_magic
)
1434 arch
= bfd_arch_powerpc
;
1435 machine
= 0; /* what does this mean? (krk) */
1441 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler */
1442 case LYNXCOFFMAGIC
: /* shadows the m68k Lynx number below, sigh */
1443 arch
= bfd_arch_i386
;
1447 #ifdef A29K_MAGIC_BIG
1448 case A29K_MAGIC_BIG
:
1449 case A29K_MAGIC_LITTLE
:
1450 arch
= bfd_arch_a29k
;
1456 arch
= bfd_arch_arm
;
1457 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
1459 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
1460 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
1461 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
1463 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
1464 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
1465 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
1466 case F_ARM_5
: machine
= bfd_mach_arm_5
; break;
1473 #ifdef MC68KBCSMAGIC
1476 #ifdef APOLLOM68KMAGIC
1477 case APOLLOM68KMAGIC
:
1479 #ifdef LYNXCOFFMAGIC
1482 arch
= bfd_arch_m68k
;
1483 machine
= bfd_mach_m68020
;
1490 arch
= bfd_arch_m88k
;
1496 arch
= bfd_arch_z8k
;
1497 switch (internal_f
->f_flags
& F_MACHMASK
)
1500 machine
= bfd_mach_z8001
;
1503 machine
= bfd_mach_z8002
;
1512 arch
= bfd_arch_i860
;
1519 arch
= bfd_arch_i960
;
1520 switch (F_I960TYPE
& internal_f
->f_flags
)
1524 machine
= bfd_mach_i960_core
;
1527 machine
= bfd_mach_i960_kb_sb
;
1530 machine
= bfd_mach_i960_mc
;
1533 machine
= bfd_mach_i960_xa
;
1536 machine
= bfd_mach_i960_ca
;
1539 machine
= bfd_mach_i960_ka_sa
;
1542 machine
= bfd_mach_i960_jx
;
1545 machine
= bfd_mach_i960_hx
;
1559 if (xcoff_data (abfd
)->cputype
!= -1)
1560 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
1563 /* We did not get a value from the a.out header. If the
1564 file has not been stripped, we may be able to get the
1565 architecture information from the first symbol, if it
1566 is a .file symbol. */
1567 if (obj_raw_syment_count (abfd
) == 0)
1571 bfd_byte buf
[SYMESZ
];
1572 struct internal_syment sym
;
1574 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1575 || bfd_read (buf
, 1, SYMESZ
, abfd
) != SYMESZ
)
1577 coff_swap_sym_in (abfd
, (PTR
) buf
, (PTR
) &sym
);
1578 if (sym
.n_sclass
== C_FILE
)
1579 cputype
= sym
.n_type
& 0xff;
1585 /* FIXME: We don't handle all cases here. */
1591 /* PowerPC Macs use the same magic numbers as RS/6000
1592 (because that's how they were bootstrapped originally),
1593 but they are always PowerPC architecture. */
1594 arch
= bfd_arch_powerpc
;
1597 arch
= bfd_arch_rs6000
;
1599 #endif /* POWERMAC */
1603 arch
= bfd_arch_powerpc
;
1606 case 2: /* 64 bit PowerPC */
1607 arch
= bfd_arch_powerpc
;
1611 arch
= bfd_arch_powerpc
;
1615 arch
= bfd_arch_rs6000
;
1625 arch
= bfd_arch_we32k
;
1632 arch
= bfd_arch_h8300
;
1633 machine
= bfd_mach_h8300
;
1634 /* !! FIXME this probably isn't the right place for this */
1635 abfd
->flags
|= BFD_IS_RELAXABLE
;
1641 arch
= bfd_arch_h8300
;
1642 machine
= bfd_mach_h8300h
;
1643 /* !! FIXME this probably isn't the right place for this */
1644 abfd
->flags
|= BFD_IS_RELAXABLE
;
1650 arch
= bfd_arch_h8300
;
1651 machine
= bfd_mach_h8300s
;
1652 /* !! FIXME this probably isn't the right place for this */
1653 abfd
->flags
|= BFD_IS_RELAXABLE
;
1657 #ifdef SH_ARCH_MAGIC_BIG
1658 case SH_ARCH_MAGIC_BIG
:
1659 case SH_ARCH_MAGIC_LITTLE
:
1667 arch
= bfd_arch_h8500
;
1674 #ifdef LYNXCOFFMAGIC
1677 arch
= bfd_arch_sparc
;
1684 arch
= bfd_arch_tic30
;
1688 #ifdef TIC80_ARCH_MAGIC
1689 case TIC80_ARCH_MAGIC
:
1690 arch
= bfd_arch_tic80
;
1696 arch
= bfd_arch_mcore
;
1699 default: /* Unreadable input file type */
1700 arch
= bfd_arch_obscure
;
1704 bfd_default_set_arch_mach (abfd
, arch
, machine
);
1708 #ifdef SYMNAME_IN_DEBUG
1710 static boolean symname_in_debug_hook
1711 PARAMS ((bfd
*, struct internal_syment
*));
1714 symname_in_debug_hook (abfd
, sym
)
1715 bfd
* abfd ATTRIBUTE_UNUSED
;
1716 struct internal_syment
*sym
;
1718 return SYMNAME_IN_DEBUG (sym
) ? true : false;
1723 #define symname_in_debug_hook \
1724 (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
1730 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
1732 static boolean coff_pointerize_aux_hook
1733 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
1734 unsigned int, combined_entry_type
*));
1738 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
1739 bfd
*abfd ATTRIBUTE_UNUSED
;
1740 combined_entry_type
*table_base
;
1741 combined_entry_type
*symbol
;
1742 unsigned int indaux
;
1743 combined_entry_type
*aux
;
1745 int class = symbol
->u
.syment
.n_sclass
;
1747 if ((class == C_EXT
|| class == C_HIDEXT
)
1748 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
1750 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
1752 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
1753 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
1754 aux
->fix_scnlen
= 1;
1757 /* Return true to indicate that the caller should not do any
1758 further work on this auxent. */
1762 /* Return false to indicate that this auxent should be handled by
1770 /* We don't want to pointerize bal entries. */
1772 static boolean coff_pointerize_aux_hook
1773 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
1774 unsigned int, combined_entry_type
*));
1778 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
1779 bfd
*abfd ATTRIBUTE_UNUSED
;
1780 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
1781 combined_entry_type
*symbol
;
1782 unsigned int indaux
;
1783 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
1785 /* Return true if we don't want to pointerize this aux entry, which
1786 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
1788 && (symbol
->u
.syment
.n_sclass
== C_LEAFPROC
1789 || symbol
->u
.syment
.n_sclass
== C_LEAFSTAT
1790 || symbol
->u
.syment
.n_sclass
== C_LEAFEXT
));
1795 #define coff_pointerize_aux_hook 0
1798 #endif /* ! RS6000COFF_C */
1800 /* Print an aux entry. This returns true if it has printed it. */
1802 static boolean coff_print_aux
1803 PARAMS ((bfd
*, FILE *, combined_entry_type
*, combined_entry_type
*,
1804 combined_entry_type
*, unsigned int));
1807 coff_print_aux (abfd
, file
, table_base
, symbol
, aux
, indaux
)
1808 bfd
*abfd ATTRIBUTE_UNUSED
;
1809 FILE *file ATTRIBUTE_UNUSED
;
1810 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
1811 combined_entry_type
*symbol ATTRIBUTE_UNUSED
;
1812 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
1813 unsigned int indaux ATTRIBUTE_UNUSED
;
1816 if ((symbol
->u
.syment
.n_sclass
== C_EXT
1817 || symbol
->u
.syment
.n_sclass
== C_HIDEXT
)
1818 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
1820 /* This is a csect entry. */
1821 fprintf (file
, "AUX ");
1822 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
1824 BFD_ASSERT (! aux
->fix_scnlen
);
1825 fprintf (file
, "val %5ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
1829 fprintf (file
, "indx ");
1830 if (! aux
->fix_scnlen
)
1831 fprintf (file
, "%4ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
1833 fprintf (file
, "%4ld",
1834 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
1837 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
1838 aux
->u
.auxent
.x_csect
.x_parmhash
,
1839 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
1840 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
1841 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
1842 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
1843 aux
->u
.auxent
.x_csect
.x_stab
,
1844 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
1849 /* Return false to indicate that no special action was taken. */
1857 To write relocations, the back end steps though the
1858 canonical relocation table and create an
1859 @code{internal_reloc}. The symbol index to use is removed from
1860 the @code{offset} field in the symbol table supplied. The
1861 address comes directly from the sum of the section base
1862 address and the relocation offset; the type is dug directly
1863 from the howto field. Then the @code{internal_reloc} is
1864 swapped into the shape of an @code{external_reloc} and written
1871 static int compare_arelent_ptr
PARAMS ((const PTR
, const PTR
));
1873 /* AUX's ld wants relocations to be sorted */
1875 compare_arelent_ptr (x
, y
)
1879 const arelent
**a
= (const arelent
**) x
;
1880 const arelent
**b
= (const arelent
**) y
;
1881 bfd_size_type aadr
= (*a
)->address
;
1882 bfd_size_type badr
= (*b
)->address
;
1884 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
1887 #endif /* TARG_AUX */
1890 coff_write_relocs (abfd
, first_undef
)
1896 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
1899 struct external_reloc dst
;
1905 /* sort relocations before we write them out */
1906 p
= (arelent
**) bfd_malloc (s
->reloc_count
* sizeof (arelent
*));
1907 if (p
== NULL
&& s
->reloc_count
> 0)
1909 memcpy (p
, s
->orelocation
, s
->reloc_count
* sizeof (arelent
*));
1910 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
1913 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
1915 for (i
= 0; i
< s
->reloc_count
; i
++)
1917 struct internal_reloc n
;
1919 memset ((PTR
) & n
, 0, sizeof (n
));
1921 /* Now we've renumbered the symbols we know where the
1922 undefined symbols live in the table. Check the reloc
1923 entries for symbols who's output bfd isn't the right one.
1924 This is because the symbol was undefined (which means
1925 that all the pointers are never made to point to the same
1926 place). This is a bad thing,'cause the symbols attached
1927 to the output bfd are indexed, so that the relocation
1928 entries know which symbol index they point to. So we
1929 have to look up the output symbol here. */
1931 if (q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
1934 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
1935 asymbol
**outsyms
= abfd
->outsymbols
;
1936 for (i
= first_undef
; outsyms
[i
]; i
++)
1938 const char *intable
= outsyms
[i
]->name
;
1939 if (strcmp (intable
, sname
) == 0) {
1940 /* got a hit, so repoint the reloc */
1941 q
->sym_ptr_ptr
= outsyms
+ i
;
1947 n
.r_vaddr
= q
->address
+ s
->vma
;
1950 /* The 29k const/consth reloc pair is a real kludge. The consth
1951 part doesn't have a symbol; it has an offset. So rebuilt
1953 if (q
->howto
->type
== R_IHCONST
)
1954 n
.r_symndx
= q
->addend
;
1959 if (q
->sym_ptr_ptr
== bfd_abs_section_ptr
->symbol_ptr_ptr
)
1960 /* This is a relocation relative to the absolute symbol. */
1964 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
1965 /* Take notice if the symbol reloc points to a symbol
1966 we don't have in our symbol table. What should we
1968 if (n
.r_symndx
> obj_conv_table_size (abfd
))
1973 #ifdef SWAP_OUT_RELOC_OFFSET
1974 n
.r_offset
= q
->addend
;
1978 /* Work out reloc type from what is required */
1979 SELECT_RELOC (n
, q
->howto
);
1981 n
.r_type
= q
->howto
->type
;
1983 coff_swap_reloc_out (abfd
, &n
, &dst
);
1984 if (bfd_write ((PTR
) & dst
, 1, RELSZ
, abfd
) != RELSZ
)
1997 /* Set flags and magic number of a coff file from architecture and machine
1998 type. Result is true if we can represent the arch&type, false if not. */
2001 coff_set_flags (abfd
, magicp
, flagsp
)
2003 unsigned int *magicp ATTRIBUTE_UNUSED
;
2004 unsigned short *flagsp ATTRIBUTE_UNUSED
;
2006 switch (bfd_get_arch (abfd
))
2011 switch (bfd_get_mach (abfd
))
2013 case bfd_mach_z8001
:
2016 case bfd_mach_z8002
:
2030 *magicp
= I960ROMAGIC
;
2032 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2033 I960RWMAGIC); FIXME???
2035 switch (bfd_get_mach (abfd
))
2037 case bfd_mach_i960_core
:
2040 case bfd_mach_i960_kb_sb
:
2043 case bfd_mach_i960_mc
:
2046 case bfd_mach_i960_xa
:
2049 case bfd_mach_i960_ca
:
2052 case bfd_mach_i960_ka_sa
:
2055 case bfd_mach_i960_jx
:
2058 case bfd_mach_i960_hx
:
2071 case bfd_arch_tic30
:
2072 *magicp
= TIC30MAGIC
;
2075 #ifdef TIC80_ARCH_MAGIC
2076 case bfd_arch_tic80
:
2077 *magicp
= TIC80_ARCH_MAGIC
;
2082 * magicp
= ARMMAGIC
;
2084 if (APCS_SET (abfd
))
2086 if (APCS_26_FLAG (abfd
))
2087 * flagsp
|= F_APCS26
;
2089 if (APCS_FLOAT_FLAG (abfd
))
2090 * flagsp
|= F_APCS_FLOAT
;
2092 if (PIC_FLAG (abfd
))
2095 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2096 * flagsp
|= F_INTERWORK
;
2097 switch (bfd_get_mach (abfd
))
2099 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2100 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2101 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2102 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2103 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2104 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2105 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2106 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break; /* XXX - we do not have an F_ARM_5T */
2111 case bfd_arch_powerpc
:
2118 *magicp
= I386MAGIC
;
2120 /* Just overwrite the usual value if we're doing Lynx. */
2121 *magicp
= LYNXCOFFMAGIC
;
2128 *magicp
= I860MAGIC
;
2134 #ifdef APOLLOM68KMAGIC
2135 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
2137 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2138 #ifdef NAMES_HAVE_UNDERSCORE
2139 *magicp
= MC68KBCSMAGIC
;
2141 *magicp
= MC68MAGIC
;
2145 /* Just overwrite the usual value if we're doing Lynx. */
2146 *magicp
= LYNXCOFFMAGIC
;
2154 *magicp
= MC88OMAGIC
;
2159 case bfd_arch_h8300
:
2160 switch (bfd_get_mach (abfd
))
2162 case bfd_mach_h8300
:
2163 *magicp
= H8300MAGIC
;
2165 case bfd_mach_h8300h
:
2166 *magicp
= H8300HMAGIC
;
2168 case bfd_mach_h8300s
:
2169 *magicp
= H8300SMAGIC
;
2175 #ifdef SH_ARCH_MAGIC_BIG
2177 if (bfd_big_endian (abfd
))
2178 *magicp
= SH_ARCH_MAGIC_BIG
;
2180 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2186 case bfd_arch_sparc
:
2187 *magicp
= SPARCMAGIC
;
2189 /* Just overwrite the usual value if we're doing Lynx. */
2190 *magicp
= LYNXCOFFMAGIC
;
2197 case bfd_arch_h8500
:
2198 *magicp
= H8500MAGIC
;
2202 #ifdef A29K_MAGIC_BIG
2204 if (bfd_big_endian (abfd
))
2205 *magicp
= A29K_MAGIC_BIG
;
2207 *magicp
= A29K_MAGIC_LITTLE
;
2213 case bfd_arch_we32k
:
2214 *magicp
= WE32KMAGIC
;
2220 case bfd_arch_rs6000
:
2222 case bfd_arch_powerpc
:
2224 *magicp
= U802TOCMAGIC
;
2230 case bfd_arch_mcore
:
2231 * magicp
= MCOREMAGIC
;
2235 default: /* Unknown architecture */
2236 /* return false; -- fall through to "return false" below, to avoid
2237 "statement never reached" errors on the one below. */
2246 coff_set_arch_mach (abfd
, arch
, machine
)
2248 enum bfd_architecture arch
;
2249 unsigned long machine
;
2252 unsigned short dummy2
;
2254 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
2257 if (arch
!= bfd_arch_unknown
&&
2258 coff_set_flags (abfd
, &dummy1
, &dummy2
) != true)
2259 return false; /* We can't represent this type */
2261 return true; /* We're easy ... */
2265 /* Calculate the file position for each section. */
2268 #define ALIGN_SECTIONS_IN_FILE
2271 #undef ALIGN_SECTIONS_IN_FILE
2275 coff_compute_section_file_positions (abfd
)
2279 asection
*previous
= (asection
*) NULL
;
2280 file_ptr sofar
= FILHSZ
;
2281 boolean align_adjust
;
2283 #ifdef ALIGN_SECTIONS_IN_FILE
2288 /* On XCOFF, if we have symbols, set up the .debug section. */
2289 if (bfd_get_symcount (abfd
) > 0)
2292 bfd_size_type i
, symcount
;
2296 symcount
= bfd_get_symcount (abfd
);
2297 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
2299 coff_symbol_type
*cf
;
2301 cf
= coff_symbol_from (abfd
, *symp
);
2303 && cf
->native
!= NULL
2304 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
2308 len
= strlen (bfd_asymbol_name (*symp
));
2317 dsec
= bfd_make_section_old_way (abfd
, ".debug");
2320 dsec
->_raw_size
= sz
;
2321 dsec
->flags
|= SEC_HAS_CONTENTS
;
2326 #ifdef COFF_IMAGE_WITH_PE
2328 if (coff_data (abfd
)->link_info
)
2330 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
2333 page_size
= PE_DEF_FILE_ALIGNMENT
;
2335 #ifdef COFF_PAGE_SIZE
2336 int page_size
= COFF_PAGE_SIZE
;
2340 if (bfd_get_start_address (abfd
))
2342 /* A start address may have been added to the original file. In this
2343 case it will need an optional header to record it. */
2344 abfd
->flags
|= EXEC_P
;
2347 if (abfd
->flags
& EXEC_P
)
2350 else if (xcoff_data (abfd
)->full_aouthdr
)
2353 sofar
+= SMALL_AOUTSZ
;
2356 sofar
+= abfd
->section_count
* SCNHSZ
;
2359 /* XCOFF handles overflows in the reloc and line number count fields
2360 by allocating a new section header to hold the correct counts. */
2361 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2362 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
2366 align_adjust
= false;
2367 for (current
= abfd
->sections
, count
= 1;
2368 current
!= (asection
*) NULL
;
2369 current
= current
->next
, ++count
)
2371 #ifdef COFF_IMAGE_WITH_PE
2372 /* The NT loader does not want empty section headers, so we omit
2373 them. We don't actually remove the section from the BFD,
2374 although we probably should. This matches code in
2375 coff_write_object_contents. */
2376 if (current
->_raw_size
== 0)
2378 current
->target_index
= -1;
2384 current
->target_index
= count
;
2386 /* Only deal with sections which have contents */
2387 if (!(current
->flags
& SEC_HAS_CONTENTS
))
2390 /* Align the sections in the file to the same boundary on
2391 which they are aligned in virtual memory. I960 doesn't
2392 do this (FIXME) so we can stay in sync with Intel. 960
2393 doesn't yet page from files... */
2394 #ifdef ALIGN_SECTIONS_IN_FILE
2395 if ((abfd
->flags
& EXEC_P
) != 0)
2397 /* make sure this section is aligned on the right boundary - by
2398 padding the previous section up if necessary */
2401 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
2402 if (previous
!= (asection
*) NULL
)
2404 previous
->_raw_size
+= sofar
- old_sofar
;
2410 /* In demand paged files the low order bits of the file offset
2411 must match the low order bits of the virtual address. */
2412 #ifdef COFF_PAGE_SIZE
2413 if ((abfd
->flags
& D_PAGED
) != 0
2414 && (current
->flags
& SEC_ALLOC
) != 0)
2415 sofar
+= (current
->vma
- sofar
) % page_size
;
2417 current
->filepos
= sofar
;
2419 #ifdef COFF_IMAGE_WITH_PE
2420 /* With PE we have to pad each section to be a multiple of its
2421 page size too, and remember both sizes. */
2423 if (coff_section_data (abfd
, current
) == NULL
)
2425 current
->used_by_bfd
=
2426 (PTR
) bfd_zalloc (abfd
, sizeof (struct coff_section_tdata
));
2427 if (current
->used_by_bfd
== NULL
)
2430 if (pei_section_data (abfd
, current
) == NULL
)
2432 coff_section_data (abfd
, current
)->tdata
=
2433 (PTR
) bfd_zalloc (abfd
, sizeof (struct pei_section_tdata
));
2434 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
2437 if (pei_section_data (abfd
, current
)->virt_size
== 0)
2438 pei_section_data (abfd
, current
)->virt_size
= current
->_raw_size
;
2440 current
->_raw_size
= (current
->_raw_size
+ page_size
-1) & -page_size
;
2443 sofar
+= current
->_raw_size
;
2445 #ifdef ALIGN_SECTIONS_IN_FILE
2446 /* make sure that this section is of the right size too */
2447 if ((abfd
->flags
& EXEC_P
) == 0)
2449 bfd_size_type old_size
;
2451 old_size
= current
->_raw_size
;
2452 current
->_raw_size
= BFD_ALIGN (current
->_raw_size
,
2453 1 << current
->alignment_power
);
2454 align_adjust
= current
->_raw_size
!= old_size
;
2455 sofar
+= current
->_raw_size
- old_size
;
2460 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
2461 align_adjust
= sofar
!= old_sofar
;
2462 current
->_raw_size
+= sofar
- old_sofar
;
2466 #ifdef COFF_IMAGE_WITH_PE
2467 /* For PE we need to make sure we pad out to the aligned
2468 _raw_size, in case the caller only writes out data to the
2469 unaligned _raw_size. */
2470 if (pei_section_data (abfd
, current
)->virt_size
< current
->_raw_size
)
2471 align_adjust
= true;
2475 /* Force .lib sections to start at zero. The vma is then
2476 incremented in coff_set_section_contents. This is right for
2478 if (strcmp (current
->name
, _LIB
) == 0)
2479 bfd_set_section_vma (abfd
, current
, 0);
2485 /* It is now safe to write to the output file. If we needed an
2486 alignment adjustment for the last section, then make sure that
2487 there is a byte at offset sofar. If there are no symbols and no
2488 relocs, then nothing follows the last section. If we don't force
2489 the last byte out, then the file may appear to be truncated. */
2495 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
2496 || bfd_write (&b
, 1, 1, abfd
) != 1)
2500 /* Make sure the relocations are aligned. We don't need to make
2501 sure that this byte exists, because it will only matter if there
2502 really are relocs. */
2503 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
2505 obj_relocbase (abfd
) = sofar
;
2506 abfd
->output_has_begun
= true;
2513 /* This can never work, because it is called too late--after the
2514 section positions have been set. I can't figure out what it is
2515 for, so I am going to disable it--Ian Taylor 20 March 1996. */
2517 /* If .file, .text, .data, .bss symbols are missing, add them. */
2518 /* @@ Should we only be adding missing symbols, or overriding the aux
2519 values for existing section symbols? */
2521 coff_add_missing_symbols (abfd
)
2524 unsigned int nsyms
= bfd_get_symcount (abfd
);
2525 asymbol
**sympp
= abfd
->outsymbols
;
2528 int need_text
= 1, need_data
= 1, need_bss
= 1, need_file
= 1;
2530 for (i
= 0; i
< nsyms
; i
++)
2532 coff_symbol_type
*csym
= coff_symbol_from (abfd
, sympp
[i
]);
2536 /* only do this if there is a coff representation of the input
2538 if (csym
->native
&& csym
->native
->u
.syment
.n_sclass
== C_FILE
)
2543 name
= csym
->symbol
.name
;
2546 if (!strcmp (name
, _TEXT
))
2549 else if (!strcmp (name
, ".wtext"))
2552 else if (!strcmp (name
, _DATA
))
2554 else if (!strcmp (name
, _BSS
))
2558 /* Now i == bfd_get_symcount (abfd). */
2559 /* @@ For now, don't deal with .file symbol. */
2562 if (!need_text
&& !need_data
&& !need_bss
&& !need_file
)
2564 nsyms
+= need_text
+ need_data
+ need_bss
+ need_file
;
2565 sympp2
= (asymbol
**) bfd_alloc (abfd
, nsyms
* sizeof (asymbol
*));
2568 memcpy (sympp2
, sympp
, i
* sizeof (asymbol
*));
2571 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
2575 sympp2
[i
++] = coff_section_symbol (abfd
, _TEXT
);
2577 sympp2
[i
++] = coff_section_symbol (abfd
, _DATA
);
2579 sympp2
[i
++] = coff_section_symbol (abfd
, _BSS
);
2580 BFD_ASSERT (i
== nsyms
);
2581 bfd_set_symtab (abfd
, sympp2
, nsyms
);
2590 coff_write_object_contents (abfd
)
2594 boolean hasrelocs
= false;
2595 boolean haslinno
= false;
2597 file_ptr reloc_base
;
2598 file_ptr lineno_base
;
2600 unsigned long reloc_size
= 0;
2601 unsigned long lnno_size
= 0;
2602 boolean long_section_names
;
2603 asection
*text_sec
= NULL
;
2604 asection
*data_sec
= NULL
;
2605 asection
*bss_sec
= NULL
;
2606 struct internal_filehdr internal_f
;
2607 struct internal_aouthdr internal_a
;
2608 #ifdef COFF_LONG_SECTION_NAMES
2609 size_t string_size
= STRING_SIZE_SIZE
;
2612 bfd_set_error (bfd_error_system_call
);
2614 /* Make a pass through the symbol table to count line number entries and
2615 put them into the correct asections */
2617 lnno_size
= coff_count_linenumbers (abfd
) * LINESZ
;
2619 if (abfd
->output_has_begun
== false)
2621 if (! coff_compute_section_file_positions (abfd
))
2625 reloc_base
= obj_relocbase (abfd
);
2627 /* Work out the size of the reloc and linno areas */
2629 for (current
= abfd
->sections
; current
!= NULL
; current
=
2631 reloc_size
+= current
->reloc_count
* RELSZ
;
2633 lineno_base
= reloc_base
+ reloc_size
;
2634 sym_base
= lineno_base
+ lnno_size
;
2636 /* Indicate in each section->line_filepos its actual file address */
2637 for (current
= abfd
->sections
; current
!= NULL
; current
=
2640 if (current
->lineno_count
)
2642 current
->line_filepos
= lineno_base
;
2643 current
->moving_line_filepos
= lineno_base
;
2644 lineno_base
+= current
->lineno_count
* LINESZ
;
2648 current
->line_filepos
= 0;
2650 if (current
->reloc_count
)
2652 current
->rel_filepos
= reloc_base
;
2653 reloc_base
+= current
->reloc_count
* RELSZ
;
2657 current
->rel_filepos
= 0;
2661 /* Write section headers to the file. */
2662 internal_f
.f_nscns
= 0;
2664 if ((abfd
->flags
& EXEC_P
) != 0)
2665 scn_base
= FILHSZ
+ AOUTSZ
;
2670 if (xcoff_data (abfd
)->full_aouthdr
)
2673 scn_base
+= SMALL_AOUTSZ
;
2677 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
2680 long_section_names
= false;
2681 for (current
= abfd
->sections
;
2683 current
= current
->next
)
2685 struct internal_scnhdr section
;
2688 /* If we've got a .reloc section, remember. */
2690 #ifdef COFF_IMAGE_WITH_PE
2691 if (strcmp (current
->name
, ".reloc") == 0)
2693 pe_data (abfd
)->has_reloc_section
= 1;
2698 internal_f
.f_nscns
++;
2700 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
2702 #ifdef COFF_LONG_SECTION_NAMES
2703 /* Handle long section names as in PE. This must be compatible
2704 with the code in coff_write_symbols. */
2708 len
= strlen (current
->name
);
2711 memset (section
.s_name
, 0, SCNNMLEN
);
2712 sprintf (section
.s_name
, "/%lu", (unsigned long) string_size
);
2713 string_size
+= len
+ 1;
2714 long_section_names
= true;
2720 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
2721 Ian Taylor <ian@cygnus.com>. */
2722 if (strcmp (current
->name
, _LIB
) == 0)
2723 section
.s_vaddr
= 0;
2726 section
.s_vaddr
= current
->vma
;
2727 section
.s_paddr
= current
->lma
;
2728 section
.s_size
= current
->_raw_size
;
2731 section
.s_paddr
= 0;
2733 #ifdef COFF_IMAGE_WITH_PE
2734 /* Reminder: s_paddr holds the virtual size of the section. */
2735 if (coff_section_data (abfd
, current
) != NULL
2736 && pei_section_data (abfd
, current
) != NULL
)
2737 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
2739 section
.s_paddr
= 0;
2743 If this section has no size or is unloadable then the scnptr
2746 if (current
->_raw_size
== 0 ||
2747 (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2749 section
.s_scnptr
= 0;
2753 section
.s_scnptr
= current
->filepos
;
2755 section
.s_relptr
= current
->rel_filepos
;
2756 section
.s_lnnoptr
= current
->line_filepos
;
2757 section
.s_nreloc
= current
->reloc_count
;
2758 section
.s_nlnno
= current
->lineno_count
;
2759 if (current
->reloc_count
!= 0)
2761 if (current
->lineno_count
!= 0)
2765 /* Indicate the use of an XCOFF overflow section header. */
2766 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
2768 section
.s_nreloc
= 0xffff;
2769 section
.s_nlnno
= 0xffff;
2773 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
2775 if (!strcmp (current
->name
, _TEXT
))
2779 else if (!strcmp (current
->name
, _DATA
))
2783 else if (!strcmp (current
->name
, _BSS
))
2789 section
.s_align
= (current
->alignment_power
2790 ? 1 << current
->alignment_power
2794 section
.s_flags
|= (current
->alignment_power
& 0xF) << 8;
2798 #ifdef COFF_IMAGE_WITH_PE
2799 /* suppress output of the sections if they are null. ld includes
2800 the bss and data sections even if there is no size assigned
2801 to them. NT loader doesn't like it if these section headers are
2802 included if the sections themselves are not needed */
2803 if (section
.s_size
== 0)
2804 internal_f
.f_nscns
--;
2809 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
2810 || bfd_write ((PTR
) (&buff
), 1, SCNHSZ
, abfd
) != SCNHSZ
)
2815 /* PE stores COMDAT section information in the symbol table. If
2816 this section is supposed to have some COMDAT info, track down
2817 the symbol in the symbol table and modify it. */
2818 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
2820 unsigned int i
, count
;
2822 coff_symbol_type
*csym
= NULL
;
2826 count
= bfd_get_symcount (abfd
);
2827 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
2829 if ((*psym
)->section
!= current
)
2832 /* Remember the location of the first symbol in this
2834 if (psymsec
== NULL
)
2837 /* See if this is the section symbol. */
2838 if (strcmp ((*psym
)->name
, current
->name
) == 0)
2840 csym
= coff_symbol_from (abfd
, *psym
);
2842 || csym
->native
== NULL
2843 || csym
->native
->u
.syment
.n_numaux
< 1
2844 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
2845 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
2848 /* Here *PSYM is the section symbol for CURRENT. */
2855 Note that we might not if we're converting the file from
2856 some other object file format. */
2859 combined_entry_type
*aux
;
2861 /* We don't touch the x_checksum field. The
2862 x_associated field is not currently supported. */
2864 aux
= csym
->native
+ 1;
2865 switch (current
->flags
& SEC_LINK_DUPLICATES
)
2867 case SEC_LINK_DUPLICATES_DISCARD
:
2868 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
2871 case SEC_LINK_DUPLICATES_ONE_ONLY
:
2872 aux
->u
.auxent
.x_scn
.x_comdat
=
2873 IMAGE_COMDAT_SELECT_NODUPLICATES
;
2876 case SEC_LINK_DUPLICATES_SAME_SIZE
:
2877 aux
->u
.auxent
.x_scn
.x_comdat
=
2878 IMAGE_COMDAT_SELECT_SAME_SIZE
;
2881 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
2882 aux
->u
.auxent
.x_scn
.x_comdat
=
2883 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
2887 /* The COMDAT symbol must be the first symbol from this
2888 section in the symbol table. In order to make this
2889 work, we move the COMDAT symbol before the first
2890 symbol we found in the search above. It's OK to
2891 rearrange the symbol table at this point, because
2892 coff_renumber_symbols is going to rearrange it
2893 further and fix up all the aux entries. */
2894 if (psym
!= psymsec
)
2900 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
2901 pcopy
[0] = pcopy
[-1];
2906 #endif /* COFF_WITH_PE */
2910 /* XCOFF handles overflows in the reloc and line number count fields
2911 by creating a new section header to hold the correct values. */
2912 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2914 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
2916 struct internal_scnhdr scnhdr
;
2919 internal_f
.f_nscns
++;
2920 strncpy (&(scnhdr
.s_name
[0]), current
->name
, 8);
2921 scnhdr
.s_paddr
= current
->reloc_count
;
2922 scnhdr
.s_vaddr
= current
->lineno_count
;
2924 scnhdr
.s_scnptr
= 0;
2925 scnhdr
.s_relptr
= current
->rel_filepos
;
2926 scnhdr
.s_lnnoptr
= current
->line_filepos
;
2927 scnhdr
.s_nreloc
= current
->target_index
;
2928 scnhdr
.s_nlnno
= current
->target_index
;
2929 scnhdr
.s_flags
= STYP_OVRFLO
;
2930 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
2931 || bfd_write ((PTR
) &buff
, 1, SCNHSZ
, abfd
) != SCNHSZ
)
2937 /* OK, now set up the filehdr... */
2939 /* Don't include the internal abs section in the section count */
2942 We will NOT put a fucking timestamp in the header here. Every time you
2943 put it back, I will come in and take it out again. I'm sorry. This
2944 field does not belong here. We fill it with a 0 so it compares the
2945 same but is not a reasonable time. -- gnu@cygnus.com
2947 internal_f
.f_timdat
= 0;
2949 internal_f
.f_flags
= 0;
2951 if (abfd
->flags
& EXEC_P
)
2952 internal_f
.f_opthdr
= AOUTSZ
;
2955 internal_f
.f_opthdr
= 0;
2957 if (xcoff_data (abfd
)->full_aouthdr
)
2958 internal_f
.f_opthdr
= AOUTSZ
;
2960 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
2965 internal_f
.f_flags
|= F_RELFLG
;
2967 internal_f
.f_flags
|= F_LNNO
;
2968 if (abfd
->flags
& EXEC_P
)
2969 internal_f
.f_flags
|= F_EXEC
;
2971 /* FIXME: this is wrong for PPC_PE! */
2972 if (bfd_little_endian (abfd
))
2973 internal_f
.f_flags
|= F_AR32WR
;
2975 internal_f
.f_flags
|= F_AR32W
;
2977 #ifdef TIC80_TARGET_ID
2978 internal_f
.f_target_id
= TIC80_TARGET_ID
;
2982 FIXME, should do something about the other byte orders and
2987 if ((abfd
->flags
& DYNAMIC
) != 0)
2988 internal_f
.f_flags
|= F_SHROBJ
;
2989 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
2990 internal_f
.f_flags
|= F_DYNLOAD
;
2993 memset (&internal_a
, 0, sizeof internal_a
);
2995 /* Set up architecture-dependent stuff */
2998 unsigned int magic
= 0;
2999 unsigned short flags
= 0;
3000 coff_set_flags (abfd
, &magic
, &flags
);
3001 internal_f
.f_magic
= magic
;
3002 internal_f
.f_flags
|= flags
;
3003 /* ...and the "opt"hdr... */
3006 #ifdef ULTRA3 /* NYU's machine */
3007 /* FIXME: This is a bogus check. I really want to see if there
3008 * is a .shbss or a .shdata section, if so then set the magic
3009 * number to indicate a shared data executable.
3011 if (internal_f
.f_nscns
>= 7)
3012 internal_a
.magic
= SHMAGIC
; /* Shared magic */
3015 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
3016 #define __A_MAGIC_SET__
3019 internal_a
.magic
= TIC80_ARCH_MAGIC
;
3020 #define __A_MAGIC_SET__
3023 /* FIXME: What are the a.out magic numbers for the i860? */
3024 internal_a
.magic
= 0;
3025 #define __A_MAGIC_SET__
3028 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
3029 #define __A_MAGIC_SET__
3032 #define __A_MAGIC_SET__
3033 internal_a
.magic
= PAGEMAGICBCS
;
3037 #define __A_MAGIC_SET__
3038 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
3041 #if defined(M68) || defined(WE32K) || defined(M68K)
3042 #define __A_MAGIC_SET__
3044 internal_a
.magic
= LYNXCOFFMAGIC
;
3046 #if defined(TARG_AUX)
3047 internal_a
.magic
= (abfd
->flags
& D_PAGED
? PAGEMAGICPEXECPAGED
:
3048 abfd
->flags
& WP_TEXT
? PAGEMAGICPEXECSWAPPED
:
3049 PAGEMAGICEXECSWAPPED
);
3051 #if defined (PAGEMAGICPEXECPAGED)
3052 internal_a
.magic
= PAGEMAGICPEXECPAGED
;
3054 #endif /* TARG_AUX */
3056 #endif /* M68 || WE32K || M68K */
3059 #define __A_MAGIC_SET__
3060 internal_a
.magic
= ZMAGIC
;
3064 #define __A_MAGIC_SET__
3065 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3068 #if defined MCORE_PE
3069 #define __A_MAGIC_SET__
3070 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3074 #define __A_MAGIC_SET__
3076 internal_a
.magic
= LYNXCOFFMAGIC
;
3078 internal_a
.magic
= ZMAGIC
;
3083 #define __A_MAGIC_SET__
3085 internal_a
.magic
= LYNXCOFFMAGIC
;
3090 #define __A_MAGIC_SET__
3091 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
3092 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
3093 RS6K_AOUTHDR_OMAGIC
;
3096 #ifndef __A_MAGIC_SET__
3097 #include "Your aouthdr magic number is not being set!"
3099 #undef __A_MAGIC_SET__
3103 /* FIXME: Does anybody ever set this to another value? */
3104 internal_a
.vstamp
= 0;
3106 /* Now should write relocs, strings, syms */
3107 obj_sym_filepos (abfd
) = sym_base
;
3109 if (bfd_get_symcount (abfd
) != 0)
3113 if (!coff_add_missing_symbols (abfd
))
3116 if (!coff_renumber_symbols (abfd
, &firstundef
))
3118 coff_mangle_symbols (abfd
);
3119 if (! coff_write_symbols (abfd
))
3121 if (! coff_write_linenumbers (abfd
))
3123 if (! coff_write_relocs (abfd
, firstundef
))
3126 #ifdef COFF_LONG_SECTION_NAMES
3127 else if (long_section_names
)
3129 /* If we have long section names we have to write out the string
3130 table even if there are no symbols. */
3131 if (! coff_write_symbols (abfd
))
3135 #ifdef COFF_IMAGE_WITH_PE
3137 else if ((abfd
->flags
& EXEC_P
) != 0)
3141 /* PowerPC PE appears to require that all executable files be
3142 rounded up to the page size. */
3145 BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
3147 || bfd_write (&b
, 1, 1, abfd
) != 1)
3153 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3154 backend linker, and obj_raw_syment_count is not valid until after
3155 coff_write_symbols is called. */
3156 if (obj_raw_syment_count (abfd
) != 0)
3158 internal_f
.f_symptr
= sym_base
;
3160 /* AIX appears to require that F_RELFLG not be set if there are
3161 local symbols but no relocations. */
3162 internal_f
.f_flags
&=~ F_RELFLG
;
3167 if (long_section_names
)
3168 internal_f
.f_symptr
= sym_base
;
3170 internal_f
.f_symptr
= 0;
3171 internal_f
.f_flags
|= F_LSYMS
;
3176 internal_a
.tsize
= bfd_get_section_size_before_reloc (text_sec
);
3177 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
3181 internal_a
.dsize
= bfd_get_section_size_before_reloc (data_sec
);
3182 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
3186 internal_a
.bsize
= bfd_get_section_size_before_reloc (bss_sec
);
3187 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
3188 internal_a
.data_start
= bss_sec
->vma
;
3191 internal_a
.entry
= bfd_get_start_address (abfd
);
3192 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
3195 if (xcoff_data (abfd
)->full_aouthdr
)
3198 asection
*loader_sec
;
3200 internal_a
.vstamp
= 1;
3202 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
3203 if (internal_a
.o_snentry
== 0)
3204 internal_a
.entry
= (bfd_vma
) -1;
3206 if (text_sec
!= NULL
)
3208 internal_a
.o_sntext
= text_sec
->target_index
;
3209 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
3213 internal_a
.o_sntext
= 0;
3214 internal_a
.o_algntext
= 0;
3216 if (data_sec
!= NULL
)
3218 internal_a
.o_sndata
= data_sec
->target_index
;
3219 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
3223 internal_a
.o_sndata
= 0;
3224 internal_a
.o_algndata
= 0;
3226 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
3227 if (loader_sec
!= NULL
)
3228 internal_a
.o_snloader
= loader_sec
->target_index
;
3230 internal_a
.o_snloader
= 0;
3231 if (bss_sec
!= NULL
)
3232 internal_a
.o_snbss
= bss_sec
->target_index
;
3234 internal_a
.o_snbss
= 0;
3236 toc
= xcoff_data (abfd
)->toc
;
3237 internal_a
.o_toc
= toc
;
3238 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
3240 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
3241 if (xcoff_data (abfd
)->cputype
!= -1)
3242 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
3245 switch (bfd_get_arch (abfd
))
3247 case bfd_arch_rs6000
:
3248 internal_a
.o_cputype
= 4;
3250 case bfd_arch_powerpc
:
3251 if (bfd_get_mach (abfd
) == 0)
3252 internal_a
.o_cputype
= 3;
3254 internal_a
.o_cputype
= 1;
3260 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
3261 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
3265 /* now write them */
3266 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
3270 coff_swap_filehdr_out (abfd
, (PTR
) & internal_f
, (PTR
) buff
);
3271 if (bfd_write ((PTR
) buff
, 1, FILHSZ
, abfd
) != FILHSZ
)
3274 if (abfd
->flags
& EXEC_P
)
3276 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
3277 include/coff/pe.h sets AOUTSZ == sizeof(PEAOUTHDR)) */
3279 coff_swap_aouthdr_out (abfd
, (PTR
) & internal_a
, (PTR
) buff
);
3280 if (bfd_write ((PTR
) buff
, 1, AOUTSZ
, abfd
) != AOUTSZ
)
3289 /* XCOFF seems to always write at least a small a.out header. */
3290 coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, (PTR
) &buff
);
3291 if (xcoff_data (abfd
)->full_aouthdr
)
3294 size
= SMALL_AOUTSZ
;
3295 if (bfd_write ((PTR
) &buff
, 1, size
, abfd
) != size
)
3304 coff_set_section_contents (abfd
, section
, location
, offset
, count
)
3309 bfd_size_type count
;
3311 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
3313 if (! coff_compute_section_file_positions (abfd
))
3317 #if defined(_LIB) && !defined(TARG_AUX)
3319 /* The physical address field of a .lib section is used to hold the
3320 number of shared libraries in the section. This code counts the
3321 number of sections being written, and increments the lma field
3324 I have found no documentation on the contents of this section.
3325 Experimentation indicates that the section contains zero or more
3326 records, each of which has the following structure:
3328 - a (four byte) word holding the length of this record, in words,
3329 - a word that always seems to be set to "2",
3330 - the path to a shared library, null-terminated and then padded
3331 to a whole word boundary.
3333 bfd_assert calls have been added to alert if an attempt is made
3334 to write a section which doesn't follow these assumptions. The
3335 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
3336 <robertl@arnet.com> (Thanks!).
3338 Gvran Uddeborg <gvran@uddeborg.pp.se> */
3340 if (strcmp (section
->name
, _LIB
) == 0)
3342 bfd_byte
*rec
, *recend
;
3344 rec
= (bfd_byte
*) location
;
3345 recend
= rec
+ count
;
3346 while (rec
< recend
)
3349 rec
+= bfd_get_32 (abfd
, rec
) * 4;
3352 BFD_ASSERT (rec
== recend
);
3357 /* Don't write out bss sections - one way to do this is to
3358 see if the filepos has not been set. */
3359 if (section
->filepos
== 0)
3362 if (bfd_seek (abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
) != 0)
3367 return (bfd_write (location
, 1, count
, abfd
) == count
) ? true : false;
3373 coff_close_and_cleanup (abfd
)
3376 if (!bfd_read_p (abfd
))
3377 switch (abfd
->format
)
3380 if (!_bfd_write_archive_contents (abfd
))
3384 if (!coff_write_object_contents (abfd
))
3388 bfd_set_error (bfd_error_invalid_operation
);
3392 /* We depend on bfd_close to free all the memory on the objalloc. */
3399 buy_and_read (abfd
, where
, seek_direction
, size
)
3405 PTR area
= (PTR
) bfd_alloc (abfd
, size
);
3408 if (bfd_seek (abfd
, where
, seek_direction
) != 0
3409 || bfd_read (area
, 1, size
, abfd
) != size
)
3412 } /* buy_and_read() */
3418 Creating the linenumber table is done by reading in the entire
3419 coff linenumber table, and creating another table for internal use.
3421 A coff linenumber table is structured so that each function
3422 is marked as having a line number of 0. Each line within the
3423 function is an offset from the first line in the function. The
3424 base of the line number information for the table is stored in
3425 the symbol associated with the function.
3427 The information is copied from the external to the internal
3428 table, and each symbol which marks a function is marked by
3431 How does this work ?
3436 coff_slurp_line_table (abfd
, asect
)
3440 LINENO
*native_lineno
;
3441 alent
*lineno_cache
;
3443 BFD_ASSERT (asect
->lineno
== (alent
*) NULL
);
3445 native_lineno
= (LINENO
*) buy_and_read (abfd
,
3446 asect
->line_filepos
,
3449 asect
->lineno_count
));
3451 (alent
*) bfd_alloc (abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof (alent
)));
3452 if (lineno_cache
== NULL
)
3456 unsigned int counter
= 0;
3457 alent
*cache_ptr
= lineno_cache
;
3458 LINENO
*src
= native_lineno
;
3460 while (counter
< asect
->lineno_count
)
3462 struct internal_lineno dst
;
3463 coff_swap_lineno_in (abfd
, src
, &dst
);
3464 cache_ptr
->line_number
= dst
.l_lnno
;
3466 if (cache_ptr
->line_number
== 0)
3470 coff_symbol_type
*sym
;
3473 symndx
= dst
.l_addr
.l_symndx
;
3475 || (unsigned long) symndx
>= obj_raw_syment_count (abfd
))
3477 (*_bfd_error_handler
)
3478 (_("%s: warning: illegal symbol index %ld in line numbers"),
3479 bfd_get_filename (abfd
), dst
.l_addr
.l_symndx
);
3483 /* FIXME: We should not be casting between ints and
3484 pointers like this. */
3485 sym
= ((coff_symbol_type
*)
3486 ((symndx
+ obj_raw_syments (abfd
))
3487 ->u
.syment
._n
._n_n
._n_zeroes
));
3488 cache_ptr
->u
.sym
= (asymbol
*) sym
;
3489 if (sym
->lineno
!= NULL
&& ! warned
)
3491 (*_bfd_error_handler
)
3492 (_("%s: warning: duplicate line number information for `%s'"),
3493 bfd_get_filename (abfd
),
3494 bfd_asymbol_name (&sym
->symbol
));
3496 sym
->lineno
= cache_ptr
;
3500 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
3501 - bfd_section_vma (abfd
, asect
);
3502 } /* If no linenumber expect a symbol index */
3508 cache_ptr
->line_number
= 0;
3511 asect
->lineno
= lineno_cache
;
3512 /* FIXME, free native_lineno here, or use alloca or something. */
3517 coff_slurp_symbol_table (abfd
)
3520 combined_entry_type
*native_symbols
;
3521 coff_symbol_type
*cached_area
;
3522 unsigned int *table_ptr
;
3524 unsigned int number_of_symbols
= 0;
3526 if (obj_symbols (abfd
))
3529 /* Read in the symbol table */
3530 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
3535 /* Allocate enough room for all the symbols in cached form */
3536 cached_area
= ((coff_symbol_type
*)
3538 (obj_raw_syment_count (abfd
)
3539 * sizeof (coff_symbol_type
))));
3541 if (cached_area
== NULL
)
3543 table_ptr
= ((unsigned int *)
3545 (obj_raw_syment_count (abfd
)
3546 * sizeof (unsigned int))));
3548 if (table_ptr
== NULL
)
3552 coff_symbol_type
*dst
= cached_area
;
3553 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
3554 unsigned int this_index
= 0;
3555 while (this_index
< last_native_index
)
3557 combined_entry_type
*src
= native_symbols
+ this_index
;
3558 table_ptr
[this_index
] = number_of_symbols
;
3559 dst
->symbol
.the_bfd
= abfd
;
3561 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
3562 /* We use the native name field to point to the cached field. */
3563 src
->u
.syment
._n
._n_n
._n_zeroes
= (long) dst
;
3564 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
3565 src
->u
.syment
.n_scnum
);
3566 dst
->symbol
.flags
= 0;
3567 dst
->done_lineno
= false;
3569 switch (src
->u
.syment
.n_sclass
)
3574 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
3575 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
3576 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
3578 /* Fall through to next case */
3586 case C_THUMBEXTFUNC
:
3592 case C_SYSTEM
: /* System Wide variable */
3595 /* In PE, 0x68 (104) denotes a section symbol */
3597 /* In PE, 0x69 (105) denotes a weak external symbol. */
3600 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
3602 case COFF_SYMBOL_GLOBAL
:
3603 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
3604 #if defined COFF_WITH_PE
3605 /* PE sets the symbol to a value relative to the
3606 start of the section. */
3607 dst
->symbol
.value
= src
->u
.syment
.n_value
;
3609 dst
->symbol
.value
= (src
->u
.syment
.n_value
3610 - dst
->symbol
.section
->vma
);
3612 if (ISFCN ((src
->u
.syment
.n_type
)))
3614 /* A function ext does not go at the end of a
3616 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
3620 case COFF_SYMBOL_COMMON
:
3621 dst
->symbol
.section
= bfd_com_section_ptr
;
3622 dst
->symbol
.value
= src
->u
.syment
.n_value
;
3625 case COFF_SYMBOL_UNDEFINED
:
3626 dst
->symbol
.section
= bfd_und_section_ptr
;
3627 dst
->symbol
.value
= 0;
3630 case COFF_SYMBOL_PE_SECTION
:
3631 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
3632 dst
->symbol
.value
= 0;
3635 case COFF_SYMBOL_LOCAL
:
3636 dst
->symbol
.flags
= BSF_LOCAL
;
3637 #if defined COFF_WITH_PE
3638 /* PE sets the symbol to a value relative to the
3639 start of the section. */
3640 dst
->symbol
.value
= src
->u
.syment
.n_value
;
3642 dst
->symbol
.value
= (src
->u
.syment
.n_value
3643 - dst
->symbol
.section
->vma
);
3645 if (ISFCN ((src
->u
.syment
.n_type
)))
3646 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
3651 /* A symbol with a csect entry should not go at the end. */
3652 if (src
->u
.syment
.n_numaux
> 0)
3653 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
3657 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
3658 dst
->symbol
.flags
= BSF_WEAK
;
3659 if (src
->u
.syment
.n_sclass
== C_SECTION
3660 && src
->u
.syment
.n_scnum
> 0)
3662 dst
->symbol
.flags
= BSF_LOCAL
;
3666 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
)
3667 dst
->symbol
.flags
= BSF_WEAK
;
3671 case C_STAT
: /* static */
3673 case C_LEAFSTAT
: /* static leaf procedure */
3676 case C_THUMBSTAT
: /* Thumb static */
3677 case C_THUMBLABEL
: /* Thumb label */
3678 case C_THUMBSTATFUNC
:/* Thumb static function */
3680 case C_LABEL
: /* label */
3681 if (src
->u
.syment
.n_scnum
== -2)
3682 dst
->symbol
.flags
= BSF_DEBUGGING
;
3684 dst
->symbol
.flags
= BSF_LOCAL
;
3686 /* Base the value as an index from the base of the
3687 section, if there is one. */
3688 if (dst
->symbol
.section
)
3690 #if defined COFF_WITH_PE
3691 /* PE sets the symbol to a value relative to the
3692 start of the section. */
3693 dst
->symbol
.value
= src
->u
.syment
.n_value
;
3695 dst
->symbol
.value
= (src
->u
.syment
.n_value
3696 - dst
->symbol
.section
->vma
);
3700 dst
->symbol
.value
= src
->u
.syment
.n_value
;
3703 case C_MOS
: /* member of structure */
3704 case C_EOS
: /* end of structure */
3705 #ifdef NOTDEF /* C_AUTOARG has the same value */
3707 case C_GLBLREG
: /* A29k-specific storage class */
3710 case C_REGPARM
: /* register parameter */
3711 case C_REG
: /* register variable */
3714 case C_AUTOARG
: /* 960-specific storage class */
3717 case C_TPDEF
: /* type definition */
3719 case C_AUTO
: /* automatic variable */
3720 case C_FIELD
: /* bit field */
3721 case C_ENTAG
: /* enumeration tag */
3722 case C_MOE
: /* member of enumeration */
3723 case C_MOU
: /* member of union */
3724 case C_UNTAG
: /* union tag */
3725 dst
->symbol
.flags
= BSF_DEBUGGING
;
3726 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3729 case C_FILE
: /* file name */
3730 case C_STRTAG
: /* structure tag */
3745 dst
->symbol
.flags
= BSF_DEBUGGING
;
3746 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3750 case C_BINCL
: /* beginning of include file */
3751 case C_EINCL
: /* ending of include file */
3752 /* The value is actually a pointer into the line numbers
3753 of the file. We locate the line number entry, and
3754 set the section to the section which contains it, and
3755 the value to the index in that section. */
3759 dst
->symbol
.flags
= BSF_DEBUGGING
;
3760 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3761 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
3762 && ((file_ptr
) (sec
->line_filepos
3763 + sec
->lineno_count
* LINESZ
)
3764 > (file_ptr
) src
->u
.syment
.n_value
))
3767 dst
->symbol
.value
= 0;
3770 dst
->symbol
.section
= sec
;
3771 dst
->symbol
.value
= ((src
->u
.syment
.n_value
3772 - sec
->line_filepos
)
3780 dst
->symbol
.flags
= BSF_DEBUGGING
;
3782 /* The value is actually a symbol index. Save a pointer
3783 to the symbol instead of the index. FIXME: This
3784 should use a union. */
3785 src
->u
.syment
.n_value
=
3786 (long) (native_symbols
+ src
->u
.syment
.n_value
);
3787 dst
->symbol
.value
= src
->u
.syment
.n_value
;
3792 case C_BLOCK
: /* ".bb" or ".eb" */
3793 case C_FCN
: /* ".bf" or ".ef" */
3794 case C_EFCN
: /* physical end of function */
3795 dst
->symbol
.flags
= BSF_LOCAL
;
3796 #if defined COFF_WITH_PE
3797 /* PE sets the symbol to a value relative to the start
3799 dst
->symbol
.value
= src
->u
.syment
.n_value
;
3801 /* Base the value as an index from the base of the
3803 dst
->symbol
.value
= (src
->u
.syment
.n_value
3804 - dst
->symbol
.section
->vma
);
3809 case C_EXTDEF
: /* external definition */
3810 case C_ULABEL
: /* undefined label */
3811 case C_USTATIC
: /* undefined static */
3812 #ifndef COFF_WITH_PE
3813 /* C_LINE in regular coff is 0x68. NT has taken over this storage
3814 class to represent a section symbol */
3815 case C_LINE
: /* line # reformatted as symbol table entry */
3816 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
3817 case C_ALIAS
: /* duplicate tag */
3819 /* New storage classes for TIc80 */
3821 case C_UEXT
: /* Tentative external definition */
3823 case C_STATLAB
: /* Static load time label */
3824 case C_EXTLAB
: /* External load time label */
3825 case C_HIDDEN
: /* ext symbol in dmert public lib */
3827 (*_bfd_error_handler
)
3828 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
3829 bfd_get_filename (abfd
), src
->u
.syment
.n_sclass
,
3830 dst
->symbol
.section
->name
, dst
->symbol
.name
);
3831 dst
->symbol
.flags
= BSF_DEBUGGING
;
3832 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3836 /* BFD_ASSERT(dst->symbol.flags != 0);*/
3840 dst
->symbol
.udata
.i
= 0;
3841 dst
->lineno
= (alent
*) NULL
;
3842 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
3844 number_of_symbols
++;
3845 } /* walk the native symtab */
3846 } /* bfdize the native symtab */
3848 obj_symbols (abfd
) = cached_area
;
3849 obj_raw_syments (abfd
) = native_symbols
;
3851 bfd_get_symcount (abfd
) = number_of_symbols
;
3852 obj_convert (abfd
) = table_ptr
;
3853 /* Slurp the line tables for each section too */
3859 coff_slurp_line_table (abfd
, p
);
3864 } /* coff_slurp_symbol_table() */
3866 /* Classify a COFF symbol. A couple of targets have globally visible
3867 symbols which are not class C_EXT, and this handles those. It also
3868 recognizes some special PE cases. */
3870 static enum coff_symbol_classification
3871 coff_classify_symbol (abfd
, syment
)
3873 struct internal_syment
*syment
;
3875 /* FIXME: This partially duplicates the switch in
3876 coff_slurp_symbol_table. */
3877 switch (syment
->n_sclass
)
3886 case C_THUMBEXTFUNC
:
3894 if (syment
->n_scnum
== 0)
3896 if (syment
->n_value
== 0)
3897 return COFF_SYMBOL_UNDEFINED
;
3899 return COFF_SYMBOL_COMMON
;
3901 return COFF_SYMBOL_GLOBAL
;
3908 if (syment
->n_sclass
== C_STAT
)
3910 if (syment
->n_scnum
== 0)
3912 /* The Microsoft compiler sometimes generates these if a
3913 small static function is inlined every time it is used.
3914 The function is discarded, but the symbol table entry
3916 return COFF_SYMBOL_LOCAL
;
3920 /* This is correct for Microsoft generated objects, but it
3921 breaks gas generated objects. */
3923 if (syment
->n_value
== 0)
3926 char buf
[SYMNMLEN
+ 1];
3928 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
3930 && (strcmp (bfd_get_section_name (abfd
, sec
),
3931 _bfd_coff_internal_syment_name (abfd
, syment
, buf
))
3933 return COFF_SYMBOL_PE_SECTION
;
3937 return COFF_SYMBOL_LOCAL
;
3940 if (syment
->n_sclass
== C_SECTION
)
3942 /* In some cases in a DLL generated by the Microsoft linker, the
3943 n_value field will contain garbage. FIXME: This should
3944 probably be handled by the swapping function instead. */
3945 syment
->n_value
= 0;
3946 if (syment
->n_scnum
== 0)
3947 return COFF_SYMBOL_UNDEFINED
;
3948 return COFF_SYMBOL_PE_SECTION
;
3950 #endif /* COFF_WITH_PE */
3952 /* If it is not a global symbol, we presume it is a local symbol. */
3954 if (syment
->n_scnum
== 0)
3956 char buf
[SYMNMLEN
+ 1];
3958 (*_bfd_error_handler
)
3959 (_("warning: %s: local symbol `%s' has no section"),
3960 bfd_get_filename (abfd
),
3961 _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
3964 return COFF_SYMBOL_LOCAL
;
3971 Coff relocations are easily transformed into the internal BFD form
3974 Reading a coff relocation table is done in the following stages:
3976 o Read the entire coff relocation table into memory.
3978 o Process each relocation in turn; first swap it from the
3979 external to the internal form.
3981 o Turn the symbol referenced in the relocation's symbol index
3982 into a pointer into the canonical symbol table.
3983 This table is the same as the one returned by a call to
3984 @code{bfd_canonicalize_symtab}. The back end will call that
3985 routine and save the result if a canonicalization hasn't been done.
3987 o The reloc index is turned into a pointer to a howto
3988 structure, in a back end specific way. For instance, the 386
3989 and 960 use the @code{r_type} to directly produce an index
3990 into a howto table vector; the 88k subtracts a number from the
3991 @code{r_type} field and creates an addend field.
3997 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
3999 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
4000 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
4001 coffsym = (obj_symbols (abfd) \
4002 + (cache_ptr->sym_ptr_ptr - symbols)); \
4004 coffsym = coff_symbol_from (abfd, ptr); \
4005 if (coffsym != (coff_symbol_type *) NULL \
4006 && coffsym->native->u.syment.n_scnum == 0) \
4007 cache_ptr->addend = 0; \
4008 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
4009 && ptr->section != (asection *) NULL) \
4010 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
4012 cache_ptr->addend = 0; \
4017 coff_slurp_reloc_table (abfd
, asect
, symbols
)
4022 RELOC
*native_relocs
;
4023 arelent
*reloc_cache
;
4028 if (asect
->relocation
)
4030 if (asect
->reloc_count
== 0)
4032 if (asect
->flags
& SEC_CONSTRUCTOR
)
4034 if (!coff_slurp_symbol_table (abfd
))
4037 (RELOC
*) buy_and_read (abfd
,
4041 asect
->reloc_count
));
4042 reloc_cache
= (arelent
*)
4043 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
4045 if (reloc_cache
== NULL
)
4049 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
4051 struct internal_reloc dst
;
4052 struct external_reloc
*src
;
4053 #ifndef RELOC_PROCESSING
4057 cache_ptr
= reloc_cache
+ idx
;
4058 src
= native_relocs
+ idx
;
4060 coff_swap_reloc_in (abfd
, src
, &dst
);
4062 #ifdef RELOC_PROCESSING
4063 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
4065 cache_ptr
->address
= dst
.r_vaddr
;
4067 if (dst
.r_symndx
!= -1)
4069 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
4071 (*_bfd_error_handler
)
4072 (_("%s: warning: illegal symbol index %ld in relocs"),
4073 bfd_get_filename (abfd
), dst
.r_symndx
);
4074 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
4079 cache_ptr
->sym_ptr_ptr
= (symbols
4080 + obj_convert (abfd
)[dst
.r_symndx
]);
4081 ptr
= *(cache_ptr
->sym_ptr_ptr
);
4086 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
4090 /* The symbols definitions that we have read in have been
4091 relocated as if their sections started at 0. But the offsets
4092 refering to the symbols in the raw data have not been
4093 modified, so we have to have a negative addend to compensate.
4095 Note that symbols which used to be common must be left alone */
4097 /* Calculate any reloc addend by looking at the symbol */
4098 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
4100 cache_ptr
->address
-= asect
->vma
;
4101 /* !! cache_ptr->section = (asection *) NULL;*/
4103 /* Fill in the cache_ptr->howto field from dst.r_type */
4104 RTYPE2HOWTO (cache_ptr
, &dst
);
4105 #endif /* RELOC_PROCESSING */
4107 if (cache_ptr
->howto
== NULL
)
4109 (*_bfd_error_handler
)
4110 (_("%s: illegal relocation type %d at address 0x%lx"),
4111 bfd_get_filename (abfd
), dst
.r_type
, (long) dst
.r_vaddr
);
4112 bfd_set_error (bfd_error_bad_value
);
4117 asect
->relocation
= reloc_cache
;
4121 #ifndef coff_rtype_to_howto
4124 /* Get the howto structure for a reloc. This is only used if the file
4125 including this one defines coff_relocate_section to be
4126 _bfd_coff_generic_relocate_section, so it is OK if it does not
4127 always work. It is the responsibility of the including file to
4128 make sure it is reasonable if it is needed. */
4130 static reloc_howto_type
*coff_rtype_to_howto
4131 PARAMS ((bfd
*, asection
*, struct internal_reloc
*,
4132 struct coff_link_hash_entry
*, struct internal_syment
*,
4136 static reloc_howto_type
*
4137 coff_rtype_to_howto (abfd
, sec
, rel
, h
, sym
, addendp
)
4138 bfd
*abfd ATTRIBUTE_UNUSED
;
4139 asection
*sec ATTRIBUTE_UNUSED
;
4140 struct internal_reloc
*rel
;
4141 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
;
4142 struct internal_syment
*sym ATTRIBUTE_UNUSED
;
4143 bfd_vma
*addendp ATTRIBUTE_UNUSED
;
4147 RTYPE2HOWTO (&genrel
, rel
);
4148 return genrel
.howto
;
4151 #else /* ! defined (RTYPE2HOWTO) */
4153 #define coff_rtype_to_howto NULL
4155 #endif /* ! defined (RTYPE2HOWTO) */
4156 #endif /* ! defined (coff_rtype_to_howto) */
4158 /* This is stupid. This function should be a boolean predicate. */
4160 coff_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
4166 arelent
*tblptr
= section
->relocation
;
4167 unsigned int count
= 0;
4170 if (section
->flags
& SEC_CONSTRUCTOR
)
4172 /* this section has relocs made up by us, they are not in the
4173 file, so take them out of their chain and place them into
4174 the data area provided */
4175 arelent_chain
*chain
= section
->constructor_chain
;
4176 for (count
= 0; count
< section
->reloc_count
; count
++)
4178 *relptr
++ = &chain
->relent
;
4179 chain
= chain
->next
;
4185 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
4188 tblptr
= section
->relocation
;
4190 for (; count
++ < section
->reloc_count
;)
4191 *relptr
++ = tblptr
++;
4196 return section
->reloc_count
;
4201 coff_sym_filepos (abfd
)
4204 return obj_sym_filepos (abfd
);
4208 #ifndef coff_reloc16_estimate
4209 #define coff_reloc16_estimate dummy_reloc16_estimate
4211 static int dummy_reloc16_estimate
4212 PARAMS ((bfd
*, asection
*, arelent
*, unsigned int,
4213 struct bfd_link_info
*));
4216 dummy_reloc16_estimate (abfd
, input_section
, reloc
, shrink
, link_info
)
4217 bfd
*abfd ATTRIBUTE_UNUSED
;
4218 asection
*input_section ATTRIBUTE_UNUSED
;
4219 arelent
*reloc ATTRIBUTE_UNUSED
;
4220 unsigned int shrink ATTRIBUTE_UNUSED
;
4221 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
4228 #ifndef coff_reloc16_extra_cases
4230 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
4232 /* This works even if abort is not declared in any header file. */
4234 static void dummy_reloc16_extra_cases
4235 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*, arelent
*,
4236 bfd_byte
*, unsigned int *, unsigned int *));
4239 dummy_reloc16_extra_cases (abfd
, link_info
, link_order
, reloc
, data
, src_ptr
,
4241 bfd
*abfd ATTRIBUTE_UNUSED
;
4242 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
4243 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
;
4244 arelent
*reloc ATTRIBUTE_UNUSED
;
4245 bfd_byte
*data ATTRIBUTE_UNUSED
;
4246 unsigned int *src_ptr ATTRIBUTE_UNUSED
;
4247 unsigned int *dst_ptr ATTRIBUTE_UNUSED
;
4253 /* If coff_relocate_section is defined, we can use the optimized COFF
4254 backend linker. Otherwise we must continue to use the old linker. */
4255 #ifdef coff_relocate_section
4256 #ifndef coff_bfd_link_hash_table_create
4257 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
4259 #ifndef coff_bfd_link_add_symbols
4260 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
4262 #ifndef coff_bfd_final_link
4263 #define coff_bfd_final_link _bfd_coff_final_link
4265 #else /* ! defined (coff_relocate_section) */
4266 #define coff_relocate_section NULL
4267 #ifndef coff_bfd_link_hash_table_create
4268 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
4270 #ifndef coff_bfd_link_add_symbols
4271 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
4273 #define coff_bfd_final_link _bfd_generic_final_link
4274 #endif /* ! defined (coff_relocate_section) */
4276 #define coff_bfd_link_split_section _bfd_generic_link_split_section
4278 #ifndef coff_start_final_link
4279 #define coff_start_final_link NULL
4282 #ifndef coff_adjust_symndx
4283 #define coff_adjust_symndx NULL
4286 #ifndef coff_link_add_one_symbol
4287 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
4290 #ifndef coff_link_output_has_begun
4292 static boolean coff_link_output_has_begun
4293 PARAMS ((bfd
*, struct coff_final_link_info
*));
4296 coff_link_output_has_begun (abfd
, info
)
4298 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
;
4300 return abfd
->output_has_begun
;
4304 #ifndef coff_final_link_postscript
4306 static boolean coff_final_link_postscript
4307 PARAMS ((bfd
*, struct coff_final_link_info
*));
4310 coff_final_link_postscript (abfd
, pfinfo
)
4311 bfd
* abfd ATTRIBUTE_UNUSED
;
4312 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
;
4318 #ifndef coff_SWAP_aux_in
4319 #define coff_SWAP_aux_in coff_swap_aux_in
4321 #ifndef coff_SWAP_sym_in
4322 #define coff_SWAP_sym_in coff_swap_sym_in
4324 #ifndef coff_SWAP_lineno_in
4325 #define coff_SWAP_lineno_in coff_swap_lineno_in
4327 #ifndef coff_SWAP_aux_out
4328 #define coff_SWAP_aux_out coff_swap_aux_out
4330 #ifndef coff_SWAP_sym_out
4331 #define coff_SWAP_sym_out coff_swap_sym_out
4333 #ifndef coff_SWAP_lineno_out
4334 #define coff_SWAP_lineno_out coff_swap_lineno_out
4336 #ifndef coff_SWAP_reloc_out
4337 #define coff_SWAP_reloc_out coff_swap_reloc_out
4339 #ifndef coff_SWAP_filehdr_out
4340 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
4342 #ifndef coff_SWAP_aouthdr_out
4343 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
4345 #ifndef coff_SWAP_scnhdr_out
4346 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
4348 #ifndef coff_SWAP_reloc_in
4349 #define coff_SWAP_reloc_in coff_swap_reloc_in
4351 #ifndef coff_SWAP_filehdr_in
4352 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
4354 #ifndef coff_SWAP_aouthdr_in
4355 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
4357 #ifndef coff_SWAP_scnhdr_in
4358 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
4363 static CONST bfd_coff_backend_data bfd_coff_std_swap_table
=
4365 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
4366 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
4367 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
4368 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
4369 coff_SWAP_scnhdr_out
,
4370 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
,
4371 #ifdef COFF_LONG_FILENAMES
4376 #ifdef COFF_LONG_SECTION_NAMES
4381 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
4382 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
4383 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
4384 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
4385 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
4386 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
4387 coff_classify_symbol
, coff_compute_section_file_positions
,
4388 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
4389 coff_adjust_symndx
, coff_link_add_one_symbol
,
4390 coff_link_output_has_begun
, coff_final_link_postscript
4393 #ifndef coff_close_and_cleanup
4394 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
4397 #ifndef coff_bfd_free_cached_info
4398 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
4401 #ifndef coff_get_section_contents
4402 #define coff_get_section_contents _bfd_generic_get_section_contents
4405 #ifndef coff_bfd_copy_private_symbol_data
4406 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
4409 #ifndef coff_bfd_copy_private_section_data
4410 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
4413 #ifndef coff_bfd_copy_private_bfd_data
4414 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
4417 #ifndef coff_bfd_merge_private_bfd_data
4418 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
4421 #ifndef coff_bfd_set_private_flags
4422 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
4425 #ifndef coff_bfd_print_private_bfd_data
4426 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
4429 #ifndef coff_bfd_is_local_label_name
4430 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
4433 #ifndef coff_read_minisymbols
4434 #define coff_read_minisymbols _bfd_generic_read_minisymbols
4437 #ifndef coff_minisymbol_to_symbol
4438 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
4441 /* The reloc lookup routine must be supplied by each individual COFF
4443 #ifndef coff_bfd_reloc_type_lookup
4444 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4447 #ifndef coff_bfd_get_relocated_section_contents
4448 #define coff_bfd_get_relocated_section_contents \
4449 bfd_generic_get_relocated_section_contents
4452 #ifndef coff_bfd_relax_section
4453 #define coff_bfd_relax_section bfd_generic_relax_section
4456 #ifndef coff_bfd_gc_sections
4457 #define coff_bfd_gc_sections bfd_generic_gc_sections
4460 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
4461 const bfd_target VAR = \
4464 bfd_target_coff_flavour, \
4465 BFD_ENDIAN_BIG, /* data byte order is big */ \
4466 BFD_ENDIAN_BIG, /* header byte order is big */ \
4467 /* object flags */ \
4468 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
4469 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
4470 /* section flags */ \
4471 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS), \
4472 UNDER, /* leading symbol underscore */ \
4473 '/', /* ar_pad_char */ \
4474 15, /* ar_max_namelen */ \
4476 /* Data conversion functions. */ \
4477 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
4478 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
4479 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
4481 /* Header conversion functions. */ \
4482 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
4483 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
4484 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
4486 /* bfd_check_format */ \
4487 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, _bfd_dummy_target }, \
4488 /* bfd_set_format */ \
4489 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
4490 /* bfd_write_contents */ \
4491 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, bfd_false }, \
4493 BFD_JUMP_TABLE_GENERIC (coff), \
4494 BFD_JUMP_TABLE_COPY (coff), \
4495 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
4496 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
4497 BFD_JUMP_TABLE_SYMBOLS (coff), \
4498 BFD_JUMP_TABLE_RELOCS (coff), \
4499 BFD_JUMP_TABLE_WRITE (coff), \
4500 BFD_JUMP_TABLE_LINK (coff), \
4501 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
4508 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
4509 const bfd_target VAR = \
4512 bfd_target_coff_flavour, \
4513 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
4514 BFD_ENDIAN_LITTLE, /* header byte order is little */ \
4515 /* object flags */ \
4516 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
4517 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
4518 /* section flags */ \
4519 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS), \
4520 UNDER, /* leading symbol underscore */ \
4521 '/', /* ar_pad_char */ \
4522 15, /* ar_max_namelen */ \
4524 /* Data conversion functions. */ \
4525 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
4526 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
4527 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
4528 /* Header conversion functions. */ \
4529 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
4530 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
4531 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
4532 /* bfd_check_format */ \
4533 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, _bfd_dummy_target }, \
4534 /* bfd_set_format */ \
4535 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
4536 /* bfd_write_contents */ \
4537 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, bfd_false }, \
4539 BFD_JUMP_TABLE_GENERIC (coff), \
4540 BFD_JUMP_TABLE_COPY (coff), \
4541 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
4542 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
4543 BFD_JUMP_TABLE_SYMBOLS (coff), \
4544 BFD_JUMP_TABLE_RELOCS (coff), \
4545 BFD_JUMP_TABLE_WRITE (coff), \
4546 BFD_JUMP_TABLE_LINK (coff), \
4547 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \