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
;
453 * Return a word with SEC_* flags set to represent the incoming
454 * STYP_* flags (from scnhdr.s_flags). The inverse of this
455 * function is sec_to_styp_flags().
456 * NOTE: If you add to/change this routine, you should mirror the changes
457 * in sec_to_styp_flags().
460 styp_to_sec_flags (abfd
, hdr
, name
)
461 bfd
*abfd ATTRIBUTE_UNUSED
;
465 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
466 long styp_flags
= internal_s
->s_flags
;
467 flagword sec_flags
= 0;
470 if (styp_flags
& STYP_NOLOAD
)
472 sec_flags
|= SEC_NEVER_LOAD
;
474 #endif /* STYP_NOLOAD */
476 /* For 386 COFF, at least, an unloadable text or data section is
477 actually a shared library section. */
478 if (styp_flags
& STYP_TEXT
)
480 if (sec_flags
& SEC_NEVER_LOAD
)
481 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
483 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
485 else if (styp_flags
& STYP_DATA
)
487 if (sec_flags
& SEC_NEVER_LOAD
)
488 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
490 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
492 else if (styp_flags
& STYP_BSS
)
494 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
495 if (sec_flags
& SEC_NEVER_LOAD
)
496 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
499 sec_flags
|= SEC_ALLOC
;
501 else if (styp_flags
& STYP_INFO
)
503 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
504 defined. coff_compute_section_file_positions uses
505 COFF_PAGE_SIZE to ensure that the low order bits of the
506 section VMA and the file offset match. If we don't know
507 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
508 and demand page loading of the file will fail. */
509 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
510 sec_flags
|= SEC_DEBUGGING
;
513 else if (styp_flags
& STYP_PAD
)
517 else if (strcmp (name
, _TEXT
) == 0)
519 if (sec_flags
& SEC_NEVER_LOAD
)
520 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
522 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
524 else if (strcmp (name
, _DATA
) == 0)
526 if (sec_flags
& SEC_NEVER_LOAD
)
527 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
529 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
531 else if (strcmp (name
, _BSS
) == 0)
533 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
534 if (sec_flags
& SEC_NEVER_LOAD
)
535 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
538 sec_flags
|= SEC_ALLOC
;
540 else if (strcmp (name
, ".debug") == 0
542 || strcmp (name
, _COMMENT
) == 0
544 || strncmp (name
, ".stab", 5) == 0)
546 #ifdef COFF_PAGE_SIZE
547 sec_flags
|= SEC_DEBUGGING
;
551 else if (strcmp (name
, _LIB
) == 0)
555 else if (strcmp (name
, _LIT
) == 0)
557 sec_flags
= SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
562 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
565 #ifdef STYP_LIT /* A29k readonly text/data section type */
566 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
568 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
570 #endif /* STYP_LIT */
571 #ifdef STYP_OTHER_LOAD /* Other loaded sections */
572 if (styp_flags
& STYP_OTHER_LOAD
)
574 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
576 #endif /* STYP_SDATA */
579 if (styp_flags
& IMAGE_SCN_LNK_REMOVE
)
580 sec_flags
|= SEC_EXCLUDE
;
582 if (styp_flags
& IMAGE_SCN_LNK_COMDAT
)
584 sec_flags
|= SEC_LINK_ONCE
;
586 /* Unfortunately, the PE format stores essential information in
587 the symbol table, of all places. We need to extract that
588 information now, so that objdump and the linker will know how
589 to handle the section without worrying about the symbols. We
590 can't call slurp_symtab, because the linker doesn't want the
593 /* COMDAT sections are special. The first symbol is the section
594 symbol, which tells what kind of COMDAT section it is. The
595 *second* symbol is the "comdat symbol" - the one with the
596 unique name. GNU uses the section symbol for the unique
597 name; MS uses ".text" for every comdat section. Sigh. - DJ */
599 if (_bfd_coff_get_external_symbols (abfd
))
601 bfd_byte
*esym
, *esymend
;
603 esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
604 esymend
= esym
+ obj_raw_syment_count (abfd
) * SYMESZ
;
606 while (esym
< esymend
)
608 struct internal_syment isym
;
610 bfd_coff_swap_sym_in (abfd
, (PTR
) esym
, (PTR
) &isym
);
612 if (sizeof (internal_s
->s_name
) > SYMNMLEN
)
614 /* This case implies that the matching symbol name
615 will be in the string table. */
619 if (isym
.n_sclass
== C_STAT
620 && isym
.n_type
== T_NULL
621 && isym
.n_numaux
== 1)
623 char buf
[SYMNMLEN
+ 1];
626 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
, buf
);
630 if (strcmp (name
, symname
) == 0)
632 union internal_auxent aux
;
634 /* This is the section symbol. */
636 bfd_coff_swap_aux_in (abfd
, (PTR
) (esym
+ SYMESZ
),
637 isym
.n_type
, isym
.n_sclass
,
638 0, isym
.n_numaux
, (PTR
) &aux
);
640 /* FIXME: Microsoft uses NODUPLICATES and
641 ASSOCIATIVE, but gnu uses ANY and SAME_SIZE.
642 Unfortunately, gnu doesn't do the comdat
643 symbols right. So, until we can fix it to do
644 the right thing, we are temporarily disabling
645 comdats for the MS types (they're used in
646 DLLs and C++, but we don't support *their*
647 C++ libraries anyway - DJ */
649 switch (aux
.x_scn
.x_comdat
)
651 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
653 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
655 sec_flags
&= ~SEC_LINK_ONCE
;
660 case IMAGE_COMDAT_SELECT_ANY
:
661 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
664 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
665 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
668 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
669 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
672 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
674 /* FIXME: This is not currently implemented. */
675 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
677 sec_flags
&= ~SEC_LINK_ONCE
;
686 esym
+= (isym
.n_numaux
+ 1) * SYMESZ
;
692 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
693 /* As a GNU extension, if the name begins with .gnu.linkonce, we
694 only link a single copy of the section. This is used to support
695 g++. g++ will emit each template expansion in its own section.
696 The symbols will be defined as weak, so that multiple definitions
697 are permitted. The GNU linker extension is to actually discard
698 all but one of the sections. */
699 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
700 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
706 #define get_index(symbol) ((symbol)->udata.i)
710 bfd_coff_backend_data
714 .{* COFF symbol classifications. *}
716 .enum coff_symbol_classification
718 . {* Global symbol. *}
719 . COFF_SYMBOL_GLOBAL,
720 . {* Common symbol. *}
721 . COFF_SYMBOL_COMMON,
722 . {* Undefined symbol. *}
723 . COFF_SYMBOL_UNDEFINED,
724 . {* Local symbol. *}
726 . {* PE section symbol. *}
727 . COFF_SYMBOL_PE_SECTION
730 Special entry points for gdb to swap in coff symbol table parts:
733 . void (*_bfd_coff_swap_aux_in) PARAMS ((
742 . void (*_bfd_coff_swap_sym_in) PARAMS ((
747 . void (*_bfd_coff_swap_lineno_in) PARAMS ((
753 Special entry points for gas to swap out coff parts:
755 . unsigned int (*_bfd_coff_swap_aux_out) PARAMS ((
764 . unsigned int (*_bfd_coff_swap_sym_out) PARAMS ((
769 . unsigned int (*_bfd_coff_swap_lineno_out) PARAMS ((
774 . unsigned int (*_bfd_coff_swap_reloc_out) PARAMS ((
779 . unsigned int (*_bfd_coff_swap_filehdr_out) PARAMS ((
784 . unsigned int (*_bfd_coff_swap_aouthdr_out) PARAMS ((
789 . unsigned int (*_bfd_coff_swap_scnhdr_out) PARAMS ((
795 Special entry points for generic COFF routines to call target
796 dependent COFF routines:
798 . unsigned int _bfd_filhsz;
799 . unsigned int _bfd_aoutsz;
800 . unsigned int _bfd_scnhsz;
801 . unsigned int _bfd_symesz;
802 . unsigned int _bfd_auxesz;
803 . unsigned int _bfd_relsz;
804 . unsigned int _bfd_linesz;
805 . boolean _bfd_coff_long_filenames;
806 . boolean _bfd_coff_long_section_names;
807 . unsigned int _bfd_coff_default_section_alignment_power;
808 . void (*_bfd_coff_swap_filehdr_in) PARAMS ((
812 . void (*_bfd_coff_swap_aouthdr_in) PARAMS ((
816 . void (*_bfd_coff_swap_scnhdr_in) PARAMS ((
820 . void (*_bfd_coff_swap_reloc_in) PARAMS ((
824 . boolean (*_bfd_coff_bad_format_hook) PARAMS ((
826 . PTR internal_filehdr));
827 . boolean (*_bfd_coff_set_arch_mach_hook) PARAMS ((
829 . PTR internal_filehdr));
830 . PTR (*_bfd_coff_mkobject_hook) PARAMS ((
832 . PTR internal_filehdr,
833 . PTR internal_aouthdr));
834 . flagword (*_bfd_styp_to_sec_flags_hook) PARAMS ((
836 . PTR internal_scnhdr,
837 . const char *name));
838 . void (*_bfd_set_alignment_hook) PARAMS ((
841 . PTR internal_scnhdr));
842 . boolean (*_bfd_coff_slurp_symbol_table) PARAMS ((
844 . boolean (*_bfd_coff_symname_in_debug) PARAMS ((
846 . struct internal_syment *sym));
847 . boolean (*_bfd_coff_pointerize_aux_hook) PARAMS ((
849 . combined_entry_type *table_base,
850 . combined_entry_type *symbol,
851 . unsigned int indaux,
852 . combined_entry_type *aux));
853 . boolean (*_bfd_coff_print_aux) PARAMS ((
856 . combined_entry_type *table_base,
857 . combined_entry_type *symbol,
858 . combined_entry_type *aux,
859 . unsigned int indaux));
860 . void (*_bfd_coff_reloc16_extra_cases) PARAMS ((
862 . struct bfd_link_info *link_info,
863 . struct bfd_link_order *link_order,
866 . unsigned int *src_ptr,
867 . unsigned int *dst_ptr));
868 . int (*_bfd_coff_reloc16_estimate) PARAMS ((
870 . asection *input_section,
872 . unsigned int shrink,
873 . struct bfd_link_info *link_info));
874 . enum coff_symbol_classification (*_bfd_coff_classify_symbol) PARAMS ((
876 . struct internal_syment *));
877 . boolean (*_bfd_coff_compute_section_file_positions) PARAMS ((
879 . boolean (*_bfd_coff_start_final_link) PARAMS ((
881 . struct bfd_link_info *info));
882 . boolean (*_bfd_coff_relocate_section) PARAMS ((
884 . struct bfd_link_info *info,
886 . asection *input_section,
887 . bfd_byte *contents,
888 . struct internal_reloc *relocs,
889 . struct internal_syment *syms,
890 . asection **sections));
891 . reloc_howto_type *(*_bfd_coff_rtype_to_howto) PARAMS ((
894 . struct internal_reloc *rel,
895 . struct coff_link_hash_entry *h,
896 . struct internal_syment *sym,
897 . bfd_vma *addendp));
898 . boolean (*_bfd_coff_adjust_symndx) PARAMS ((
900 . struct bfd_link_info *info,
903 . struct internal_reloc *reloc,
904 . boolean *adjustedp));
905 . boolean (*_bfd_coff_link_add_one_symbol) PARAMS ((
906 . struct bfd_link_info *info,
912 . const char *string,
915 . struct bfd_link_hash_entry **hashp));
917 . boolean (*_bfd_coff_link_output_has_begun) PARAMS ((
919 . struct coff_final_link_info * pfinfo));
920 . boolean (*_bfd_coff_final_link_postscript) PARAMS ((
922 . struct coff_final_link_info * pfinfo));
924 .} bfd_coff_backend_data;
926 .#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
928 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
929 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
931 .#define bfd_coff_swap_sym_in(a,e,i) \
932 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
934 .#define bfd_coff_swap_lineno_in(a,e,i) \
935 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
937 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
938 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
940 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
941 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
943 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
944 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
946 .#define bfd_coff_swap_sym_out(abfd, i,o) \
947 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
949 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
950 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
952 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
953 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
955 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
956 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
958 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
959 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
960 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
961 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
962 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
963 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
964 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
965 .#define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames)
966 .#define bfd_coff_long_section_names(abfd) \
967 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
968 .#define bfd_coff_default_section_alignment_power(abfd) \
969 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
970 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
971 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
973 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
974 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
976 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
977 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
979 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
980 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
982 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
983 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
985 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
986 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
987 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
988 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
990 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name)\
991 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook) (abfd, scnhdr, name))
993 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
994 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
996 .#define bfd_coff_slurp_symbol_table(abfd)\
997 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
999 .#define bfd_coff_symname_in_debug(abfd, sym)\
1000 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1002 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1003 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1004 . (abfd, file, base, symbol, aux, indaux))
1006 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
1007 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1008 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1010 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1011 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1012 . (abfd, section, reloc, shrink, link_info))
1014 .#define bfd_coff_classify_symbol(abfd, sym)\
1015 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1018 .#define bfd_coff_compute_section_file_positions(abfd)\
1019 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1022 .#define bfd_coff_start_final_link(obfd, info)\
1023 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1025 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1026 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1027 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1028 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1029 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1030 . (abfd, sec, rel, h, sym, addendp))
1031 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1032 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1033 . (obfd, info, ibfd, sec, rel, adjustedp))
1034 .#define bfd_coff_link_add_one_symbol(info,abfd,name,flags,section,value,string,cp,coll,hashp)\
1035 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1036 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1038 .#define bfd_coff_link_output_has_begun(a,p) \
1039 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p))
1040 .#define bfd_coff_final_link_postscript(a,p) \
1041 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
1045 /* See whether the magic number matches. */
1048 coff_bad_format_hook (abfd
, filehdr
)
1049 bfd
* abfd ATTRIBUTE_UNUSED
;
1052 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1054 if (BADMAG (*internal_f
))
1057 /* if the optional header is NULL or not the correct size then
1058 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1059 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1060 optional header is of a different size.
1062 But the mips keeps extra stuff in it's opthdr, so dont check
1066 #if defined(M88) || defined(I960)
1067 if (internal_f
->f_opthdr
!= 0 && AOUTSZ
!= internal_f
->f_opthdr
)
1075 initialize a section structure with information peculiar to this
1076 particular implementation of coff
1080 coff_new_section_hook (abfd
, section
)
1084 combined_entry_type
*native
;
1086 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1089 if (xcoff_data (abfd
)->text_align_power
!= 0
1090 && strcmp (bfd_get_section_name (abfd
, section
), ".text") == 0)
1091 section
->alignment_power
= xcoff_data (abfd
)->text_align_power
;
1092 if (xcoff_data (abfd
)->data_align_power
!= 0
1093 && strcmp (bfd_get_section_name (abfd
, section
), ".data") == 0)
1094 section
->alignment_power
= xcoff_data (abfd
)->data_align_power
;
1097 /* Allocate aux records for section symbols, to store size and
1100 @@ The 10 is a guess at a plausible maximum number of aux entries
1101 (but shouldn't be a constant). */
1102 native
= ((combined_entry_type
*)
1103 bfd_zalloc (abfd
, sizeof (combined_entry_type
) * 10));
1107 /* We don't need to set up n_name, n_value, or n_scnum in the native
1108 symbol information, since they'll be overriden by the BFD symbol
1109 anyhow. However, we do need to set the type and storage class,
1110 in case this symbol winds up getting written out. The value 0
1111 for n_numaux is already correct. */
1113 native
->u
.syment
.n_type
= T_NULL
;
1114 native
->u
.syment
.n_sclass
= C_STAT
;
1116 coffsymbol (section
->symbol
)->native
= native
;
1118 /* The .stab section must be aligned to 2**2 at most, because
1119 otherwise there may be gaps in the section which gdb will not
1120 know how to interpret. Examining the section name is a hack, but
1121 that is also how gdb locates the section.
1122 We need to handle the .ctors and .dtors sections similarly, to
1123 avoid introducing null words in the tables. */
1124 if (COFF_DEFAULT_SECTION_ALIGNMENT_POWER
> 2
1125 && (strncmp (section
->name
, ".stab", 5) == 0
1126 || strcmp (section
->name
, ".ctors") == 0
1127 || strcmp (section
->name
, ".dtors") == 0))
1128 section
->alignment_power
= 2;
1130 /* Similarly, the .stabstr section must be aligned to 2**0 at most. */
1131 if (COFF_DEFAULT_SECTION_ALIGNMENT_POWER
> 0
1132 && strncmp (section
->name
, ".stabstr", 8) == 0)
1133 section
->alignment_power
= 0;
1138 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1140 /* Set the alignment of a BFD section. */
1142 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1145 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1146 bfd
* abfd ATTRIBUTE_UNUSED
;
1150 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1154 /* Extract ALIGN from 2**ALIGN stored in section header */
1155 for (i
= 0; i
< 32; i
++)
1156 if ((1 << i
) >= hdr
->s_align
)
1160 /* TI tools hijack bits 8-11 for the alignment */
1161 i
= (hdr
->s_flags
>> 8) & 0xF ;
1163 section
->alignment_power
= i
;
1166 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1169 /* a couple of macros to help setting the alignment power field */
1170 #define ALIGN_SET(field,x,y) \
1171 if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1173 section->alignment_power = y;\
1176 #define ELIFALIGN_SET(field,x,y) \
1177 else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1179 section->alignment_power = y;\
1182 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1185 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1186 bfd
* abfd ATTRIBUTE_UNUSED
;
1190 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1192 ALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_64BYTES
, 6)
1193 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_32BYTES
, 5)
1194 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_16BYTES
, 4)
1195 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_8BYTES
, 3)
1196 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_4BYTES
, 2)
1197 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_2BYTES
, 1)
1198 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_1BYTES
, 0)
1200 #ifdef POWERPC_LE_PE
1201 if (strcmp (section
->name
, ".idata$2") == 0)
1203 section
->alignment_power
= 0;
1205 else if (strcmp (section
->name
, ".idata$3") == 0)
1207 section
->alignment_power
= 0;
1209 else if (strcmp (section
->name
, ".idata$4") == 0)
1211 section
->alignment_power
= 2;
1213 else if (strcmp (section
->name
, ".idata$5") == 0)
1215 section
->alignment_power
= 2;
1217 else if (strcmp (section
->name
, ".idata$6") == 0)
1219 section
->alignment_power
= 1;
1221 else if (strcmp (section
->name
, ".reloc") == 0)
1223 section
->alignment_power
= 1;
1225 else if (strncmp (section
->name
, ".stab", 5) == 0)
1227 section
->alignment_power
= 2;
1231 #ifdef COFF_IMAGE_WITH_PE
1232 /* In a PE image file, the s_paddr field holds the virtual size of a
1233 section, while the s_size field holds the raw size. */
1234 if (hdr
->s_paddr
!= 0)
1236 if (coff_section_data (abfd
, section
) == NULL
)
1238 section
->used_by_bfd
=
1239 (PTR
) bfd_zalloc (abfd
, sizeof (struct coff_section_tdata
));
1240 if (section
->used_by_bfd
== NULL
)
1242 /* FIXME: Return error. */
1246 if (pei_section_data (abfd
, section
) == NULL
)
1248 coff_section_data (abfd
, section
)->tdata
=
1249 (PTR
) bfd_zalloc (abfd
, sizeof (struct pei_section_tdata
));
1250 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1252 /* FIXME: Return error. */
1256 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1261 section
->lma
= hdr
->s_vaddr
;
1265 #undef ELIFALIGN_SET
1267 #else /* ! COFF_WITH_PE */
1270 /* We grossly abuse this function to handle XCOFF overflow headers.
1271 When we see one, we correct the reloc and line number counts in the
1272 real header, and remove the section we just created. */
1274 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1277 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1282 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1286 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1289 real_sec
= coff_section_from_bfd_index (abfd
, hdr
->s_nreloc
);
1290 if (real_sec
== NULL
)
1293 real_sec
->reloc_count
= hdr
->s_paddr
;
1294 real_sec
->lineno_count
= hdr
->s_vaddr
;
1296 for (ps
= &abfd
->sections
; *ps
!= NULL
; ps
= &(*ps
)->next
)
1301 --abfd
->section_count
;
1307 #else /* ! RS6000COFF_C */
1309 #define coff_set_alignment_hook \
1310 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1312 #endif /* ! RS6000COFF_C */
1313 #endif /* ! COFF_WITH_PE */
1314 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1316 #ifndef coff_mkobject
1318 static boolean coff_mkobject
PARAMS ((bfd
*));
1321 coff_mkobject (abfd
)
1324 coff_data_type
*coff
;
1326 abfd
->tdata
.coff_obj_data
= (struct coff_tdata
*) bfd_zalloc (abfd
, sizeof (coff_data_type
));
1327 if (abfd
->tdata
.coff_obj_data
== 0)
1329 coff
= coff_data (abfd
);
1330 coff
->symbols
= (coff_symbol_type
*) NULL
;
1331 coff
->conversion_table
= (unsigned int *) NULL
;
1332 coff
->raw_syments
= (struct coff_ptr_struct
*) NULL
;
1333 coff
->relocbase
= 0;
1334 coff
->local_toc_sym_map
= 0;
1336 /* make_abs_section(abfd);*/
1342 /* Create the COFF backend specific information. */
1343 #ifndef coff_mkobject_hook
1345 coff_mkobject_hook (abfd
, filehdr
, aouthdr
)
1348 PTR aouthdr ATTRIBUTE_UNUSED
;
1350 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1351 coff_data_type
*coff
;
1353 if (coff_mkobject (abfd
) == false)
1356 coff
= coff_data (abfd
);
1358 coff
->sym_filepos
= internal_f
->f_symptr
;
1360 /* These members communicate important constants about the symbol
1361 table to GDB's symbol-reading code. These `constants'
1362 unfortunately vary among coff implementations... */
1363 coff
->local_n_btmask
= N_BTMASK
;
1364 coff
->local_n_btshft
= N_BTSHFT
;
1365 coff
->local_n_tmask
= N_TMASK
;
1366 coff
->local_n_tshift
= N_TSHIFT
;
1367 coff
->local_symesz
= SYMESZ
;
1368 coff
->local_auxesz
= AUXESZ
;
1369 coff
->local_linesz
= LINESZ
;
1371 obj_raw_syment_count (abfd
) =
1372 obj_conv_table_size (abfd
) =
1373 internal_f
->f_nsyms
;
1376 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
1377 abfd
->flags
|= DYNAMIC
;
1378 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= AOUTSZ
)
1380 struct internal_aouthdr
*internal_a
=
1381 (struct internal_aouthdr
*) aouthdr
;
1382 struct xcoff_tdata
*xcoff
;
1384 xcoff
= xcoff_data (abfd
);
1385 xcoff
->full_aouthdr
= true;
1386 xcoff
->toc
= internal_a
->o_toc
;
1387 xcoff
->sntoc
= internal_a
->o_sntoc
;
1388 xcoff
->snentry
= internal_a
->o_snentry
;
1389 xcoff
->text_align_power
= internal_a
->o_algntext
;
1390 xcoff
->data_align_power
= internal_a
->o_algndata
;
1391 xcoff
->modtype
= internal_a
->o_modtype
;
1392 xcoff
->cputype
= internal_a
->o_cputype
;
1393 xcoff
->maxdata
= internal_a
->o_maxdata
;
1394 xcoff
->maxstack
= internal_a
->o_maxstack
;
1399 /* Set the flags field from the COFF header read in */
1400 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
1408 /* Determine the machine architecture and type. FIXME: This is target
1409 dependent because the magic numbers are defined in the target
1410 dependent header files. But there is no particular need for this.
1411 If the magic numbers were moved to a separate file, this function
1412 would be target independent and would also be much more successful
1413 at linking together COFF files for different architectures. */
1416 coff_set_arch_mach_hook (abfd
, filehdr
)
1421 enum bfd_architecture arch
;
1422 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1425 switch (internal_f
->f_magic
)
1429 arch
= bfd_arch_powerpc
;
1430 machine
= 0; /* what does this mean? (krk) */
1436 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler */
1437 case LYNXCOFFMAGIC
: /* shadows the m68k Lynx number below, sigh */
1438 arch
= bfd_arch_i386
;
1442 #ifdef A29K_MAGIC_BIG
1443 case A29K_MAGIC_BIG
:
1444 case A29K_MAGIC_LITTLE
:
1445 arch
= bfd_arch_a29k
;
1451 arch
= bfd_arch_arm
;
1452 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
1454 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
1455 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
1456 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
1458 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
1459 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
1460 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
1461 case F_ARM_5
: machine
= bfd_mach_arm_5
; break;
1468 #ifdef MC68KBCSMAGIC
1471 #ifdef APOLLOM68KMAGIC
1472 case APOLLOM68KMAGIC
:
1474 #ifdef LYNXCOFFMAGIC
1477 arch
= bfd_arch_m68k
;
1478 machine
= bfd_mach_m68020
;
1485 arch
= bfd_arch_m88k
;
1491 arch
= bfd_arch_z8k
;
1492 switch (internal_f
->f_flags
& F_MACHMASK
)
1495 machine
= bfd_mach_z8001
;
1498 machine
= bfd_mach_z8002
;
1507 arch
= bfd_arch_i860
;
1514 arch
= bfd_arch_i960
;
1515 switch (F_I960TYPE
& internal_f
->f_flags
)
1519 machine
= bfd_mach_i960_core
;
1522 machine
= bfd_mach_i960_kb_sb
;
1525 machine
= bfd_mach_i960_mc
;
1528 machine
= bfd_mach_i960_xa
;
1531 machine
= bfd_mach_i960_ca
;
1534 machine
= bfd_mach_i960_ka_sa
;
1537 machine
= bfd_mach_i960_jx
;
1540 machine
= bfd_mach_i960_hx
;
1554 if (xcoff_data (abfd
)->cputype
!= -1)
1555 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
1558 /* We did not get a value from the a.out header. If the
1559 file has not been stripped, we may be able to get the
1560 architecture information from the first symbol, if it
1561 is a .file symbol. */
1562 if (obj_raw_syment_count (abfd
) == 0)
1566 bfd_byte buf
[SYMESZ
];
1567 struct internal_syment sym
;
1569 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1570 || bfd_read (buf
, 1, SYMESZ
, abfd
) != SYMESZ
)
1572 coff_swap_sym_in (abfd
, (PTR
) buf
, (PTR
) &sym
);
1573 if (sym
.n_sclass
== C_FILE
)
1574 cputype
= sym
.n_type
& 0xff;
1580 /* FIXME: We don't handle all cases here. */
1586 /* PowerPC Macs use the same magic numbers as RS/6000
1587 (because that's how they were bootstrapped originally),
1588 but they are always PowerPC architecture. */
1589 arch
= bfd_arch_powerpc
;
1592 arch
= bfd_arch_rs6000
;
1594 #endif /* POWERMAC */
1598 arch
= bfd_arch_powerpc
;
1601 case 2: /* 64 bit PowerPC */
1602 arch
= bfd_arch_powerpc
;
1606 arch
= bfd_arch_powerpc
;
1610 arch
= bfd_arch_rs6000
;
1620 arch
= bfd_arch_we32k
;
1627 arch
= bfd_arch_h8300
;
1628 machine
= bfd_mach_h8300
;
1629 /* !! FIXME this probably isn't the right place for this */
1630 abfd
->flags
|= BFD_IS_RELAXABLE
;
1636 arch
= bfd_arch_h8300
;
1637 machine
= bfd_mach_h8300h
;
1638 /* !! FIXME this probably isn't the right place for this */
1639 abfd
->flags
|= BFD_IS_RELAXABLE
;
1645 arch
= bfd_arch_h8300
;
1646 machine
= bfd_mach_h8300s
;
1647 /* !! FIXME this probably isn't the right place for this */
1648 abfd
->flags
|= BFD_IS_RELAXABLE
;
1652 #ifdef SH_ARCH_MAGIC_BIG
1653 case SH_ARCH_MAGIC_BIG
:
1654 case SH_ARCH_MAGIC_LITTLE
:
1662 arch
= bfd_arch_h8500
;
1669 #ifdef LYNXCOFFMAGIC
1672 arch
= bfd_arch_sparc
;
1679 arch
= bfd_arch_tic30
;
1683 #ifdef TIC80_ARCH_MAGIC
1684 case TIC80_ARCH_MAGIC
:
1685 arch
= bfd_arch_tic80
;
1691 arch
= bfd_arch_mcore
;
1694 default: /* Unreadable input file type */
1695 arch
= bfd_arch_obscure
;
1699 bfd_default_set_arch_mach (abfd
, arch
, machine
);
1703 #ifdef SYMNAME_IN_DEBUG
1705 static boolean symname_in_debug_hook
1706 PARAMS ((bfd
*, struct internal_syment
*));
1709 symname_in_debug_hook (abfd
, sym
)
1710 bfd
* abfd ATTRIBUTE_UNUSED
;
1711 struct internal_syment
*sym
;
1713 return SYMNAME_IN_DEBUG (sym
) ? true : false;
1718 #define symname_in_debug_hook \
1719 (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
1725 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
1727 static boolean coff_pointerize_aux_hook
1728 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
1729 unsigned int, combined_entry_type
*));
1733 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
1734 bfd
*abfd ATTRIBUTE_UNUSED
;
1735 combined_entry_type
*table_base
;
1736 combined_entry_type
*symbol
;
1737 unsigned int indaux
;
1738 combined_entry_type
*aux
;
1740 int class = symbol
->u
.syment
.n_sclass
;
1742 if ((class == C_EXT
|| class == C_HIDEXT
)
1743 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
1745 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
1747 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
1748 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
1749 aux
->fix_scnlen
= 1;
1752 /* Return true to indicate that the caller should not do any
1753 further work on this auxent. */
1757 /* Return false to indicate that this auxent should be handled by
1765 /* We don't want to pointerize bal entries. */
1767 static boolean coff_pointerize_aux_hook
1768 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
1769 unsigned int, combined_entry_type
*));
1773 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
1774 bfd
*abfd ATTRIBUTE_UNUSED
;
1775 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
1776 combined_entry_type
*symbol
;
1777 unsigned int indaux
;
1778 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
1780 /* Return true if we don't want to pointerize this aux entry, which
1781 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
1783 && (symbol
->u
.syment
.n_sclass
== C_LEAFPROC
1784 || symbol
->u
.syment
.n_sclass
== C_LEAFSTAT
1785 || symbol
->u
.syment
.n_sclass
== C_LEAFEXT
));
1790 #define coff_pointerize_aux_hook 0
1793 #endif /* ! RS6000COFF_C */
1795 /* Print an aux entry. This returns true if it has printed it. */
1797 static boolean coff_print_aux
1798 PARAMS ((bfd
*, FILE *, combined_entry_type
*, combined_entry_type
*,
1799 combined_entry_type
*, unsigned int));
1802 coff_print_aux (abfd
, file
, table_base
, symbol
, aux
, indaux
)
1803 bfd
*abfd ATTRIBUTE_UNUSED
;
1804 FILE *file ATTRIBUTE_UNUSED
;
1805 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
1806 combined_entry_type
*symbol ATTRIBUTE_UNUSED
;
1807 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
1808 unsigned int indaux ATTRIBUTE_UNUSED
;
1811 if ((symbol
->u
.syment
.n_sclass
== C_EXT
1812 || symbol
->u
.syment
.n_sclass
== C_HIDEXT
)
1813 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
1815 /* This is a csect entry. */
1816 fprintf (file
, "AUX ");
1817 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
1819 BFD_ASSERT (! aux
->fix_scnlen
);
1820 fprintf (file
, "val %5ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
1824 fprintf (file
, "indx ");
1825 if (! aux
->fix_scnlen
)
1826 fprintf (file
, "%4ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
1828 fprintf (file
, "%4ld",
1829 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
1832 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
1833 aux
->u
.auxent
.x_csect
.x_parmhash
,
1834 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
1835 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
1836 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
1837 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
1838 aux
->u
.auxent
.x_csect
.x_stab
,
1839 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
1844 /* Return false to indicate that no special action was taken. */
1852 To write relocations, the back end steps though the
1853 canonical relocation table and create an
1854 @code{internal_reloc}. The symbol index to use is removed from
1855 the @code{offset} field in the symbol table supplied. The
1856 address comes directly from the sum of the section base
1857 address and the relocation offset; the type is dug directly
1858 from the howto field. Then the @code{internal_reloc} is
1859 swapped into the shape of an @code{external_reloc} and written
1866 static int compare_arelent_ptr
PARAMS ((const PTR
, const PTR
));
1868 /* AUX's ld wants relocations to be sorted */
1870 compare_arelent_ptr (x
, y
)
1874 const arelent
**a
= (const arelent
**) x
;
1875 const arelent
**b
= (const arelent
**) y
;
1876 bfd_size_type aadr
= (*a
)->address
;
1877 bfd_size_type badr
= (*b
)->address
;
1879 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
1882 #endif /* TARG_AUX */
1885 coff_write_relocs (abfd
, first_undef
)
1891 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
1894 struct external_reloc dst
;
1900 /* sort relocations before we write them out */
1901 p
= (arelent
**) bfd_malloc (s
->reloc_count
* sizeof (arelent
*));
1902 if (p
== NULL
&& s
->reloc_count
> 0)
1904 memcpy (p
, s
->orelocation
, s
->reloc_count
* sizeof (arelent
*));
1905 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
1908 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
1910 for (i
= 0; i
< s
->reloc_count
; i
++)
1912 struct internal_reloc n
;
1914 memset ((PTR
) & n
, 0, sizeof (n
));
1916 /* Now we've renumbered the symbols we know where the
1917 undefined symbols live in the table. Check the reloc
1918 entries for symbols who's output bfd isn't the right one.
1919 This is because the symbol was undefined (which means
1920 that all the pointers are never made to point to the same
1921 place). This is a bad thing,'cause the symbols attached
1922 to the output bfd are indexed, so that the relocation
1923 entries know which symbol index they point to. So we
1924 have to look up the output symbol here. */
1926 if (q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
1929 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
1930 asymbol
**outsyms
= abfd
->outsymbols
;
1931 for (i
= first_undef
; outsyms
[i
]; i
++)
1933 const char *intable
= outsyms
[i
]->name
;
1934 if (strcmp (intable
, sname
) == 0) {
1935 /* got a hit, so repoint the reloc */
1936 q
->sym_ptr_ptr
= outsyms
+ i
;
1942 n
.r_vaddr
= q
->address
+ s
->vma
;
1945 /* The 29k const/consth reloc pair is a real kludge. The consth
1946 part doesn't have a symbol; it has an offset. So rebuilt
1948 if (q
->howto
->type
== R_IHCONST
)
1949 n
.r_symndx
= q
->addend
;
1954 if (q
->sym_ptr_ptr
== bfd_abs_section_ptr
->symbol_ptr_ptr
)
1955 /* This is a relocation relative to the absolute symbol. */
1959 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
1960 /* Take notice if the symbol reloc points to a symbol
1961 we don't have in our symbol table. What should we
1963 if (n
.r_symndx
> obj_conv_table_size (abfd
))
1968 #ifdef SWAP_OUT_RELOC_OFFSET
1969 n
.r_offset
= q
->addend
;
1973 /* Work out reloc type from what is required */
1974 SELECT_RELOC (n
, q
->howto
);
1976 n
.r_type
= q
->howto
->type
;
1978 coff_swap_reloc_out (abfd
, &n
, &dst
);
1979 if (bfd_write ((PTR
) & dst
, 1, RELSZ
, abfd
) != RELSZ
)
1992 /* Set flags and magic number of a coff file from architecture and machine
1993 type. Result is true if we can represent the arch&type, false if not. */
1996 coff_set_flags (abfd
, magicp
, flagsp
)
1998 unsigned int *magicp ATTRIBUTE_UNUSED
;
1999 unsigned short *flagsp ATTRIBUTE_UNUSED
;
2001 switch (bfd_get_arch (abfd
))
2006 switch (bfd_get_mach (abfd
))
2008 case bfd_mach_z8001
:
2011 case bfd_mach_z8002
:
2025 *magicp
= I960ROMAGIC
;
2027 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2028 I960RWMAGIC); FIXME???
2030 switch (bfd_get_mach (abfd
))
2032 case bfd_mach_i960_core
:
2035 case bfd_mach_i960_kb_sb
:
2038 case bfd_mach_i960_mc
:
2041 case bfd_mach_i960_xa
:
2044 case bfd_mach_i960_ca
:
2047 case bfd_mach_i960_ka_sa
:
2050 case bfd_mach_i960_jx
:
2053 case bfd_mach_i960_hx
:
2066 case bfd_arch_tic30
:
2067 *magicp
= TIC30MAGIC
;
2070 #ifdef TIC80_ARCH_MAGIC
2071 case bfd_arch_tic80
:
2072 *magicp
= TIC80_ARCH_MAGIC
;
2077 * magicp
= ARMMAGIC
;
2079 if (APCS_SET (abfd
))
2081 if (APCS_26_FLAG (abfd
))
2082 * flagsp
|= F_APCS26
;
2084 if (APCS_FLOAT_FLAG (abfd
))
2085 * flagsp
|= F_APCS_FLOAT
;
2087 if (PIC_FLAG (abfd
))
2090 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2091 * flagsp
|= F_INTERWORK
;
2092 switch (bfd_get_mach (abfd
))
2094 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2095 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2096 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2097 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2098 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2099 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2100 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2101 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break; /* XXX - we do not have an F_ARM_5T */
2106 case bfd_arch_powerpc
:
2113 *magicp
= I386MAGIC
;
2115 /* Just overwrite the usual value if we're doing Lynx. */
2116 *magicp
= LYNXCOFFMAGIC
;
2123 *magicp
= I860MAGIC
;
2129 #ifdef APOLLOM68KMAGIC
2130 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
2132 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2133 #ifdef NAMES_HAVE_UNDERSCORE
2134 *magicp
= MC68KBCSMAGIC
;
2136 *magicp
= MC68MAGIC
;
2140 /* Just overwrite the usual value if we're doing Lynx. */
2141 *magicp
= LYNXCOFFMAGIC
;
2149 *magicp
= MC88OMAGIC
;
2154 case bfd_arch_h8300
:
2155 switch (bfd_get_mach (abfd
))
2157 case bfd_mach_h8300
:
2158 *magicp
= H8300MAGIC
;
2160 case bfd_mach_h8300h
:
2161 *magicp
= H8300HMAGIC
;
2163 case bfd_mach_h8300s
:
2164 *magicp
= H8300SMAGIC
;
2170 #ifdef SH_ARCH_MAGIC_BIG
2172 if (bfd_big_endian (abfd
))
2173 *magicp
= SH_ARCH_MAGIC_BIG
;
2175 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2181 case bfd_arch_sparc
:
2182 *magicp
= SPARCMAGIC
;
2184 /* Just overwrite the usual value if we're doing Lynx. */
2185 *magicp
= LYNXCOFFMAGIC
;
2192 case bfd_arch_h8500
:
2193 *magicp
= H8500MAGIC
;
2197 #ifdef A29K_MAGIC_BIG
2199 if (bfd_big_endian (abfd
))
2200 *magicp
= A29K_MAGIC_BIG
;
2202 *magicp
= A29K_MAGIC_LITTLE
;
2208 case bfd_arch_we32k
:
2209 *magicp
= WE32KMAGIC
;
2215 case bfd_arch_rs6000
:
2217 case bfd_arch_powerpc
:
2219 *magicp
= U802TOCMAGIC
;
2225 case bfd_arch_mcore
:
2226 * magicp
= MCOREMAGIC
;
2230 default: /* Unknown architecture */
2231 /* return false; -- fall through to "return false" below, to avoid
2232 "statement never reached" errors on the one below. */
2241 coff_set_arch_mach (abfd
, arch
, machine
)
2243 enum bfd_architecture arch
;
2244 unsigned long machine
;
2247 unsigned short dummy2
;
2249 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
2252 if (arch
!= bfd_arch_unknown
&&
2253 coff_set_flags (abfd
, &dummy1
, &dummy2
) != true)
2254 return false; /* We can't represent this type */
2256 return true; /* We're easy ... */
2260 /* Calculate the file position for each section. */
2263 #define ALIGN_SECTIONS_IN_FILE
2266 #undef ALIGN_SECTIONS_IN_FILE
2270 coff_compute_section_file_positions (abfd
)
2274 asection
*previous
= (asection
*) NULL
;
2275 file_ptr sofar
= FILHSZ
;
2276 boolean align_adjust
;
2278 #ifdef ALIGN_SECTIONS_IN_FILE
2283 /* On XCOFF, if we have symbols, set up the .debug section. */
2284 if (bfd_get_symcount (abfd
) > 0)
2287 bfd_size_type i
, symcount
;
2291 symcount
= bfd_get_symcount (abfd
);
2292 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
2294 coff_symbol_type
*cf
;
2296 cf
= coff_symbol_from (abfd
, *symp
);
2298 && cf
->native
!= NULL
2299 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
2303 len
= strlen (bfd_asymbol_name (*symp
));
2312 dsec
= bfd_make_section_old_way (abfd
, ".debug");
2315 dsec
->_raw_size
= sz
;
2316 dsec
->flags
|= SEC_HAS_CONTENTS
;
2321 #ifdef COFF_IMAGE_WITH_PE
2323 if (coff_data (abfd
)->link_info
)
2325 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
2328 page_size
= PE_DEF_FILE_ALIGNMENT
;
2330 #ifdef COFF_PAGE_SIZE
2331 int page_size
= COFF_PAGE_SIZE
;
2335 if (bfd_get_start_address (abfd
))
2337 /* A start address may have been added to the original file. In this
2338 case it will need an optional header to record it. */
2339 abfd
->flags
|= EXEC_P
;
2342 if (abfd
->flags
& EXEC_P
)
2345 else if (xcoff_data (abfd
)->full_aouthdr
)
2348 sofar
+= SMALL_AOUTSZ
;
2351 sofar
+= abfd
->section_count
* SCNHSZ
;
2354 /* XCOFF handles overflows in the reloc and line number count fields
2355 by allocating a new section header to hold the correct counts. */
2356 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2357 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
2361 align_adjust
= false;
2362 for (current
= abfd
->sections
, count
= 1;
2363 current
!= (asection
*) NULL
;
2364 current
= current
->next
, ++count
)
2366 #ifdef COFF_IMAGE_WITH_PE
2367 /* The NT loader does not want empty section headers, so we omit
2368 them. We don't actually remove the section from the BFD,
2369 although we probably should. This matches code in
2370 coff_write_object_contents. */
2371 if (current
->_raw_size
== 0)
2373 current
->target_index
= -1;
2379 current
->target_index
= count
;
2381 /* Only deal with sections which have contents */
2382 if (!(current
->flags
& SEC_HAS_CONTENTS
))
2385 /* Align the sections in the file to the same boundary on
2386 which they are aligned in virtual memory. I960 doesn't
2387 do this (FIXME) so we can stay in sync with Intel. 960
2388 doesn't yet page from files... */
2389 #ifdef ALIGN_SECTIONS_IN_FILE
2390 if ((abfd
->flags
& EXEC_P
) != 0)
2392 /* make sure this section is aligned on the right boundary - by
2393 padding the previous section up if necessary */
2396 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
2397 if (previous
!= (asection
*) NULL
)
2399 previous
->_raw_size
+= sofar
- old_sofar
;
2405 /* In demand paged files the low order bits of the file offset
2406 must match the low order bits of the virtual address. */
2407 #ifdef COFF_PAGE_SIZE
2408 if ((abfd
->flags
& D_PAGED
) != 0
2409 && (current
->flags
& SEC_ALLOC
) != 0)
2410 sofar
+= (current
->vma
- sofar
) % page_size
;
2412 current
->filepos
= sofar
;
2414 #ifdef COFF_IMAGE_WITH_PE
2415 /* With PE we have to pad each section to be a multiple of its
2416 page size too, and remember both sizes. */
2418 if (coff_section_data (abfd
, current
) == NULL
)
2420 current
->used_by_bfd
=
2421 (PTR
) bfd_zalloc (abfd
, sizeof (struct coff_section_tdata
));
2422 if (current
->used_by_bfd
== NULL
)
2425 if (pei_section_data (abfd
, current
) == NULL
)
2427 coff_section_data (abfd
, current
)->tdata
=
2428 (PTR
) bfd_zalloc (abfd
, sizeof (struct pei_section_tdata
));
2429 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
2432 if (pei_section_data (abfd
, current
)->virt_size
== 0)
2433 pei_section_data (abfd
, current
)->virt_size
= current
->_raw_size
;
2435 current
->_raw_size
= (current
->_raw_size
+ page_size
-1) & -page_size
;
2438 sofar
+= current
->_raw_size
;
2440 #ifdef ALIGN_SECTIONS_IN_FILE
2441 /* make sure that this section is of the right size too */
2442 if ((abfd
->flags
& EXEC_P
) == 0)
2444 bfd_size_type old_size
;
2446 old_size
= current
->_raw_size
;
2447 current
->_raw_size
= BFD_ALIGN (current
->_raw_size
,
2448 1 << current
->alignment_power
);
2449 align_adjust
= current
->_raw_size
!= old_size
;
2450 sofar
+= current
->_raw_size
- old_size
;
2455 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
2456 align_adjust
= sofar
!= old_sofar
;
2457 current
->_raw_size
+= sofar
- old_sofar
;
2461 #ifdef COFF_IMAGE_WITH_PE
2462 /* For PE we need to make sure we pad out to the aligned
2463 _raw_size, in case the caller only writes out data to the
2464 unaligned _raw_size. */
2465 if (pei_section_data (abfd
, current
)->virt_size
< current
->_raw_size
)
2466 align_adjust
= true;
2470 /* Force .lib sections to start at zero. The vma is then
2471 incremented in coff_set_section_contents. This is right for
2473 if (strcmp (current
->name
, _LIB
) == 0)
2474 bfd_set_section_vma (abfd
, current
, 0);
2480 /* It is now safe to write to the output file. If we needed an
2481 alignment adjustment for the last section, then make sure that
2482 there is a byte at offset sofar. If there are no symbols and no
2483 relocs, then nothing follows the last section. If we don't force
2484 the last byte out, then the file may appear to be truncated. */
2490 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
2491 || bfd_write (&b
, 1, 1, abfd
) != 1)
2495 /* Make sure the relocations are aligned. We don't need to make
2496 sure that this byte exists, because it will only matter if there
2497 really are relocs. */
2498 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
2500 obj_relocbase (abfd
) = sofar
;
2501 abfd
->output_has_begun
= true;
2508 /* This can never work, because it is called too late--after the
2509 section positions have been set. I can't figure out what it is
2510 for, so I am going to disable it--Ian Taylor 20 March 1996. */
2512 /* If .file, .text, .data, .bss symbols are missing, add them. */
2513 /* @@ Should we only be adding missing symbols, or overriding the aux
2514 values for existing section symbols? */
2516 coff_add_missing_symbols (abfd
)
2519 unsigned int nsyms
= bfd_get_symcount (abfd
);
2520 asymbol
**sympp
= abfd
->outsymbols
;
2523 int need_text
= 1, need_data
= 1, need_bss
= 1, need_file
= 1;
2525 for (i
= 0; i
< nsyms
; i
++)
2527 coff_symbol_type
*csym
= coff_symbol_from (abfd
, sympp
[i
]);
2531 /* only do this if there is a coff representation of the input
2533 if (csym
->native
&& csym
->native
->u
.syment
.n_sclass
== C_FILE
)
2538 name
= csym
->symbol
.name
;
2541 if (!strcmp (name
, _TEXT
))
2544 else if (!strcmp (name
, ".wtext"))
2547 else if (!strcmp (name
, _DATA
))
2549 else if (!strcmp (name
, _BSS
))
2553 /* Now i == bfd_get_symcount (abfd). */
2554 /* @@ For now, don't deal with .file symbol. */
2557 if (!need_text
&& !need_data
&& !need_bss
&& !need_file
)
2559 nsyms
+= need_text
+ need_data
+ need_bss
+ need_file
;
2560 sympp2
= (asymbol
**) bfd_alloc (abfd
, nsyms
* sizeof (asymbol
*));
2563 memcpy (sympp2
, sympp
, i
* sizeof (asymbol
*));
2566 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
2570 sympp2
[i
++] = coff_section_symbol (abfd
, _TEXT
);
2572 sympp2
[i
++] = coff_section_symbol (abfd
, _DATA
);
2574 sympp2
[i
++] = coff_section_symbol (abfd
, _BSS
);
2575 BFD_ASSERT (i
== nsyms
);
2576 bfd_set_symtab (abfd
, sympp2
, nsyms
);
2585 coff_write_object_contents (abfd
)
2589 boolean hasrelocs
= false;
2590 boolean haslinno
= false;
2592 file_ptr reloc_base
;
2593 file_ptr lineno_base
;
2595 unsigned long reloc_size
= 0;
2596 unsigned long lnno_size
= 0;
2597 boolean long_section_names
;
2598 asection
*text_sec
= NULL
;
2599 asection
*data_sec
= NULL
;
2600 asection
*bss_sec
= NULL
;
2601 struct internal_filehdr internal_f
;
2602 struct internal_aouthdr internal_a
;
2603 #ifdef COFF_LONG_SECTION_NAMES
2604 size_t string_size
= STRING_SIZE_SIZE
;
2607 bfd_set_error (bfd_error_system_call
);
2609 /* Make a pass through the symbol table to count line number entries and
2610 put them into the correct asections */
2612 lnno_size
= coff_count_linenumbers (abfd
) * LINESZ
;
2614 if (abfd
->output_has_begun
== false)
2616 if (! coff_compute_section_file_positions (abfd
))
2620 reloc_base
= obj_relocbase (abfd
);
2622 /* Work out the size of the reloc and linno areas */
2624 for (current
= abfd
->sections
; current
!= NULL
; current
=
2626 reloc_size
+= current
->reloc_count
* RELSZ
;
2628 lineno_base
= reloc_base
+ reloc_size
;
2629 sym_base
= lineno_base
+ lnno_size
;
2631 /* Indicate in each section->line_filepos its actual file address */
2632 for (current
= abfd
->sections
; current
!= NULL
; current
=
2635 if (current
->lineno_count
)
2637 current
->line_filepos
= lineno_base
;
2638 current
->moving_line_filepos
= lineno_base
;
2639 lineno_base
+= current
->lineno_count
* LINESZ
;
2643 current
->line_filepos
= 0;
2645 if (current
->reloc_count
)
2647 current
->rel_filepos
= reloc_base
;
2648 reloc_base
+= current
->reloc_count
* RELSZ
;
2652 current
->rel_filepos
= 0;
2656 /* Write section headers to the file. */
2657 internal_f
.f_nscns
= 0;
2659 if ((abfd
->flags
& EXEC_P
) != 0)
2660 scn_base
= FILHSZ
+ AOUTSZ
;
2665 if (xcoff_data (abfd
)->full_aouthdr
)
2668 scn_base
+= SMALL_AOUTSZ
;
2672 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
2675 long_section_names
= false;
2676 for (current
= abfd
->sections
;
2678 current
= current
->next
)
2680 struct internal_scnhdr section
;
2683 /* If we've got a .reloc section, remember. */
2685 #ifdef COFF_IMAGE_WITH_PE
2686 if (strcmp (current
->name
, ".reloc") == 0)
2688 pe_data (abfd
)->has_reloc_section
= 1;
2693 internal_f
.f_nscns
++;
2695 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
2697 #ifdef COFF_LONG_SECTION_NAMES
2698 /* Handle long section names as in PE. This must be compatible
2699 with the code in coff_write_symbols. */
2703 len
= strlen (current
->name
);
2706 memset (section
.s_name
, 0, SCNNMLEN
);
2707 sprintf (section
.s_name
, "/%lu", (unsigned long) string_size
);
2708 string_size
+= len
+ 1;
2709 long_section_names
= true;
2715 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
2716 Ian Taylor <ian@cygnus.com>. */
2717 if (strcmp (current
->name
, _LIB
) == 0)
2718 section
.s_vaddr
= 0;
2721 section
.s_vaddr
= current
->vma
;
2722 section
.s_paddr
= current
->lma
;
2723 section
.s_size
= current
->_raw_size
;
2726 section
.s_paddr
= 0;
2728 #ifdef COFF_IMAGE_WITH_PE
2729 /* Reminder: s_paddr holds the virtual size of the section. */
2730 if (coff_section_data (abfd
, current
) != NULL
2731 && pei_section_data (abfd
, current
) != NULL
)
2732 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
2734 section
.s_paddr
= 0;
2738 If this section has no size or is unloadable then the scnptr
2741 if (current
->_raw_size
== 0 ||
2742 (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2744 section
.s_scnptr
= 0;
2748 section
.s_scnptr
= current
->filepos
;
2750 section
.s_relptr
= current
->rel_filepos
;
2751 section
.s_lnnoptr
= current
->line_filepos
;
2752 section
.s_nreloc
= current
->reloc_count
;
2753 section
.s_nlnno
= current
->lineno_count
;
2754 if (current
->reloc_count
!= 0)
2756 if (current
->lineno_count
!= 0)
2760 /* Indicate the use of an XCOFF overflow section header. */
2761 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
2763 section
.s_nreloc
= 0xffff;
2764 section
.s_nlnno
= 0xffff;
2768 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
2770 if (!strcmp (current
->name
, _TEXT
))
2774 else if (!strcmp (current
->name
, _DATA
))
2778 else if (!strcmp (current
->name
, _BSS
))
2784 section
.s_align
= (current
->alignment_power
2785 ? 1 << current
->alignment_power
2789 section
.s_flags
|= (current
->alignment_power
& 0xF) << 8;
2793 #ifdef COFF_IMAGE_WITH_PE
2794 /* suppress output of the sections if they are null. ld includes
2795 the bss and data sections even if there is no size assigned
2796 to them. NT loader doesn't like it if these section headers are
2797 included if the sections themselves are not needed */
2798 if (section
.s_size
== 0)
2799 internal_f
.f_nscns
--;
2804 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
2805 || bfd_write ((PTR
) (&buff
), 1, SCNHSZ
, abfd
) != SCNHSZ
)
2810 /* PE stores COMDAT section information in the symbol table. If
2811 this section is supposed to have some COMDAT info, track down
2812 the symbol in the symbol table and modify it. */
2813 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
2815 unsigned int i
, count
;
2817 coff_symbol_type
*csym
= NULL
;
2821 count
= bfd_get_symcount (abfd
);
2822 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
2824 if ((*psym
)->section
!= current
)
2827 /* Remember the location of the first symbol in this
2829 if (psymsec
== NULL
)
2832 /* See if this is the section symbol. */
2833 if (strcmp ((*psym
)->name
, current
->name
) == 0)
2835 csym
= coff_symbol_from (abfd
, *psym
);
2837 || csym
->native
== NULL
2838 || csym
->native
->u
.syment
.n_numaux
< 1
2839 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
2840 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
2843 /* Here *PSYM is the section symbol for CURRENT. */
2850 Note that we might not if we're converting the file from
2851 some other object file format. */
2854 combined_entry_type
*aux
;
2856 /* We don't touch the x_checksum field. The
2857 x_associated field is not currently supported. */
2859 aux
= csym
->native
+ 1;
2860 switch (current
->flags
& SEC_LINK_DUPLICATES
)
2862 case SEC_LINK_DUPLICATES_DISCARD
:
2863 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
2866 case SEC_LINK_DUPLICATES_ONE_ONLY
:
2867 aux
->u
.auxent
.x_scn
.x_comdat
=
2868 IMAGE_COMDAT_SELECT_NODUPLICATES
;
2871 case SEC_LINK_DUPLICATES_SAME_SIZE
:
2872 aux
->u
.auxent
.x_scn
.x_comdat
=
2873 IMAGE_COMDAT_SELECT_SAME_SIZE
;
2876 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
2877 aux
->u
.auxent
.x_scn
.x_comdat
=
2878 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
2882 /* The COMDAT symbol must be the first symbol from this
2883 section in the symbol table. In order to make this
2884 work, we move the COMDAT symbol before the first
2885 symbol we found in the search above. It's OK to
2886 rearrange the symbol table at this point, because
2887 coff_renumber_symbols is going to rearrange it
2888 further and fix up all the aux entries. */
2889 if (psym
!= psymsec
)
2895 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
2896 pcopy
[0] = pcopy
[-1];
2901 #endif /* COFF_WITH_PE */
2905 /* XCOFF handles overflows in the reloc and line number count fields
2906 by creating a new section header to hold the correct values. */
2907 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2909 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
2911 struct internal_scnhdr scnhdr
;
2914 internal_f
.f_nscns
++;
2915 strncpy (&(scnhdr
.s_name
[0]), current
->name
, 8);
2916 scnhdr
.s_paddr
= current
->reloc_count
;
2917 scnhdr
.s_vaddr
= current
->lineno_count
;
2919 scnhdr
.s_scnptr
= 0;
2920 scnhdr
.s_relptr
= current
->rel_filepos
;
2921 scnhdr
.s_lnnoptr
= current
->line_filepos
;
2922 scnhdr
.s_nreloc
= current
->target_index
;
2923 scnhdr
.s_nlnno
= current
->target_index
;
2924 scnhdr
.s_flags
= STYP_OVRFLO
;
2925 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
2926 || bfd_write ((PTR
) &buff
, 1, SCNHSZ
, abfd
) != SCNHSZ
)
2932 /* OK, now set up the filehdr... */
2934 /* Don't include the internal abs section in the section count */
2937 We will NOT put a fucking timestamp in the header here. Every time you
2938 put it back, I will come in and take it out again. I'm sorry. This
2939 field does not belong here. We fill it with a 0 so it compares the
2940 same but is not a reasonable time. -- gnu@cygnus.com
2942 internal_f
.f_timdat
= 0;
2944 internal_f
.f_flags
= 0;
2946 if (abfd
->flags
& EXEC_P
)
2947 internal_f
.f_opthdr
= AOUTSZ
;
2950 internal_f
.f_opthdr
= 0;
2952 if (xcoff_data (abfd
)->full_aouthdr
)
2953 internal_f
.f_opthdr
= AOUTSZ
;
2955 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
2960 internal_f
.f_flags
|= F_RELFLG
;
2962 internal_f
.f_flags
|= F_LNNO
;
2963 if (abfd
->flags
& EXEC_P
)
2964 internal_f
.f_flags
|= F_EXEC
;
2966 /* FIXME: this is wrong for PPC_PE! */
2967 if (bfd_little_endian (abfd
))
2968 internal_f
.f_flags
|= F_AR32WR
;
2970 internal_f
.f_flags
|= F_AR32W
;
2972 #ifdef TIC80_TARGET_ID
2973 internal_f
.f_target_id
= TIC80_TARGET_ID
;
2977 FIXME, should do something about the other byte orders and
2982 if ((abfd
->flags
& DYNAMIC
) != 0)
2983 internal_f
.f_flags
|= F_SHROBJ
;
2984 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
2985 internal_f
.f_flags
|= F_DYNLOAD
;
2988 memset (&internal_a
, 0, sizeof internal_a
);
2990 /* Set up architecture-dependent stuff */
2993 unsigned int magic
= 0;
2994 unsigned short flags
= 0;
2995 coff_set_flags (abfd
, &magic
, &flags
);
2996 internal_f
.f_magic
= magic
;
2997 internal_f
.f_flags
|= flags
;
2998 /* ...and the "opt"hdr... */
3001 #ifdef ULTRA3 /* NYU's machine */
3002 /* FIXME: This is a bogus check. I really want to see if there
3003 * is a .shbss or a .shdata section, if so then set the magic
3004 * number to indicate a shared data executable.
3006 if (internal_f
.f_nscns
>= 7)
3007 internal_a
.magic
= SHMAGIC
; /* Shared magic */
3010 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
3011 #define __A_MAGIC_SET__
3014 internal_a
.magic
= TIC80_ARCH_MAGIC
;
3015 #define __A_MAGIC_SET__
3018 /* FIXME: What are the a.out magic numbers for the i860? */
3019 internal_a
.magic
= 0;
3020 #define __A_MAGIC_SET__
3023 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
3024 #define __A_MAGIC_SET__
3027 #define __A_MAGIC_SET__
3028 internal_a
.magic
= PAGEMAGICBCS
;
3032 #define __A_MAGIC_SET__
3033 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
3036 #if defined(M68) || defined(WE32K) || defined(M68K)
3037 #define __A_MAGIC_SET__
3039 internal_a
.magic
= LYNXCOFFMAGIC
;
3041 #if defined(TARG_AUX)
3042 internal_a
.magic
= (abfd
->flags
& D_PAGED
? PAGEMAGICPEXECPAGED
:
3043 abfd
->flags
& WP_TEXT
? PAGEMAGICPEXECSWAPPED
:
3044 PAGEMAGICEXECSWAPPED
);
3046 #if defined (PAGEMAGICPEXECPAGED)
3047 internal_a
.magic
= PAGEMAGICPEXECPAGED
;
3049 #endif /* TARG_AUX */
3051 #endif /* M68 || WE32K || M68K */
3054 #define __A_MAGIC_SET__
3055 internal_a
.magic
= ZMAGIC
;
3059 #define __A_MAGIC_SET__
3060 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3063 #if defined MCORE_PE
3064 #define __A_MAGIC_SET__
3065 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3069 #define __A_MAGIC_SET__
3071 internal_a
.magic
= LYNXCOFFMAGIC
;
3073 internal_a
.magic
= ZMAGIC
;
3078 #define __A_MAGIC_SET__
3080 internal_a
.magic
= LYNXCOFFMAGIC
;
3085 #define __A_MAGIC_SET__
3086 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
3087 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
3088 RS6K_AOUTHDR_OMAGIC
;
3091 #ifndef __A_MAGIC_SET__
3092 #include "Your aouthdr magic number is not being set!"
3094 #undef __A_MAGIC_SET__
3098 /* FIXME: Does anybody ever set this to another value? */
3099 internal_a
.vstamp
= 0;
3101 /* Now should write relocs, strings, syms */
3102 obj_sym_filepos (abfd
) = sym_base
;
3104 if (bfd_get_symcount (abfd
) != 0)
3108 if (!coff_add_missing_symbols (abfd
))
3111 if (!coff_renumber_symbols (abfd
, &firstundef
))
3113 coff_mangle_symbols (abfd
);
3114 if (! coff_write_symbols (abfd
))
3116 if (! coff_write_linenumbers (abfd
))
3118 if (! coff_write_relocs (abfd
, firstundef
))
3121 #ifdef COFF_LONG_SECTION_NAMES
3122 else if (long_section_names
)
3124 /* If we have long section names we have to write out the string
3125 table even if there are no symbols. */
3126 if (! coff_write_symbols (abfd
))
3130 #ifdef COFF_IMAGE_WITH_PE
3132 else if ((abfd
->flags
& EXEC_P
) != 0)
3136 /* PowerPC PE appears to require that all executable files be
3137 rounded up to the page size. */
3140 BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
3142 || bfd_write (&b
, 1, 1, abfd
) != 1)
3148 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3149 backend linker, and obj_raw_syment_count is not valid until after
3150 coff_write_symbols is called. */
3151 if (obj_raw_syment_count (abfd
) != 0)
3153 internal_f
.f_symptr
= sym_base
;
3155 /* AIX appears to require that F_RELFLG not be set if there are
3156 local symbols but no relocations. */
3157 internal_f
.f_flags
&=~ F_RELFLG
;
3162 if (long_section_names
)
3163 internal_f
.f_symptr
= sym_base
;
3165 internal_f
.f_symptr
= 0;
3166 internal_f
.f_flags
|= F_LSYMS
;
3171 internal_a
.tsize
= bfd_get_section_size_before_reloc (text_sec
);
3172 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
3176 internal_a
.dsize
= bfd_get_section_size_before_reloc (data_sec
);
3177 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
3181 internal_a
.bsize
= bfd_get_section_size_before_reloc (bss_sec
);
3182 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
3183 internal_a
.data_start
= bss_sec
->vma
;
3186 internal_a
.entry
= bfd_get_start_address (abfd
);
3187 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
3190 if (xcoff_data (abfd
)->full_aouthdr
)
3193 asection
*loader_sec
;
3195 internal_a
.vstamp
= 1;
3197 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
3198 if (internal_a
.o_snentry
== 0)
3199 internal_a
.entry
= (bfd_vma
) -1;
3201 if (text_sec
!= NULL
)
3203 internal_a
.o_sntext
= text_sec
->target_index
;
3204 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
3208 internal_a
.o_sntext
= 0;
3209 internal_a
.o_algntext
= 0;
3211 if (data_sec
!= NULL
)
3213 internal_a
.o_sndata
= data_sec
->target_index
;
3214 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
3218 internal_a
.o_sndata
= 0;
3219 internal_a
.o_algndata
= 0;
3221 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
3222 if (loader_sec
!= NULL
)
3223 internal_a
.o_snloader
= loader_sec
->target_index
;
3225 internal_a
.o_snloader
= 0;
3226 if (bss_sec
!= NULL
)
3227 internal_a
.o_snbss
= bss_sec
->target_index
;
3229 internal_a
.o_snbss
= 0;
3231 toc
= xcoff_data (abfd
)->toc
;
3232 internal_a
.o_toc
= toc
;
3233 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
3235 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
3236 if (xcoff_data (abfd
)->cputype
!= -1)
3237 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
3240 switch (bfd_get_arch (abfd
))
3242 case bfd_arch_rs6000
:
3243 internal_a
.o_cputype
= 4;
3245 case bfd_arch_powerpc
:
3246 if (bfd_get_mach (abfd
) == 0)
3247 internal_a
.o_cputype
= 3;
3249 internal_a
.o_cputype
= 1;
3255 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
3256 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
3260 /* now write them */
3261 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
3265 coff_swap_filehdr_out (abfd
, (PTR
) & internal_f
, (PTR
) buff
);
3266 if (bfd_write ((PTR
) buff
, 1, FILHSZ
, abfd
) != FILHSZ
)
3269 if (abfd
->flags
& EXEC_P
)
3271 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
3272 include/coff/pe.h sets AOUTSZ == sizeof(PEAOUTHDR)) */
3274 coff_swap_aouthdr_out (abfd
, (PTR
) & internal_a
, (PTR
) buff
);
3275 if (bfd_write ((PTR
) buff
, 1, AOUTSZ
, abfd
) != AOUTSZ
)
3284 /* XCOFF seems to always write at least a small a.out header. */
3285 coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, (PTR
) &buff
);
3286 if (xcoff_data (abfd
)->full_aouthdr
)
3289 size
= SMALL_AOUTSZ
;
3290 if (bfd_write ((PTR
) &buff
, 1, size
, abfd
) != size
)
3299 coff_set_section_contents (abfd
, section
, location
, offset
, count
)
3304 bfd_size_type count
;
3306 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
3308 if (! coff_compute_section_file_positions (abfd
))
3312 #if defined(_LIB) && !defined(TARG_AUX)
3314 /* The physical address field of a .lib section is used to hold the
3315 number of shared libraries in the section. This code counts the
3316 number of sections being written, and increments the lma field
3319 I have found no documentation on the contents of this section.
3320 Experimentation indicates that the section contains zero or more
3321 records, each of which has the following structure:
3323 - a (four byte) word holding the length of this record, in words,
3324 - a word that always seems to be set to "2",
3325 - the path to a shared library, null-terminated and then padded
3326 to a whole word boundary.
3328 bfd_assert calls have been added to alert if an attempt is made
3329 to write a section which doesn't follow these assumptions. The
3330 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
3331 <robertl@arnet.com> (Thanks!).
3333 Gvran Uddeborg <gvran@uddeborg.pp.se> */
3335 if (strcmp (section
->name
, _LIB
) == 0)
3337 bfd_byte
*rec
, *recend
;
3339 rec
= (bfd_byte
*) location
;
3340 recend
= rec
+ count
;
3341 while (rec
< recend
)
3344 rec
+= bfd_get_32 (abfd
, rec
) * 4;
3347 BFD_ASSERT (rec
== recend
);
3352 /* Don't write out bss sections - one way to do this is to
3353 see if the filepos has not been set. */
3354 if (section
->filepos
== 0)
3357 if (bfd_seek (abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
) != 0)
3362 return (bfd_write (location
, 1, count
, abfd
) == count
) ? true : false;
3368 coff_close_and_cleanup (abfd
)
3371 if (!bfd_read_p (abfd
))
3372 switch (abfd
->format
)
3375 if (!_bfd_write_archive_contents (abfd
))
3379 if (!coff_write_object_contents (abfd
))
3383 bfd_set_error (bfd_error_invalid_operation
);
3387 /* We depend on bfd_close to free all the memory on the objalloc. */
3394 buy_and_read (abfd
, where
, seek_direction
, size
)
3400 PTR area
= (PTR
) bfd_alloc (abfd
, size
);
3403 if (bfd_seek (abfd
, where
, seek_direction
) != 0
3404 || bfd_read (area
, 1, size
, abfd
) != size
)
3407 } /* buy_and_read() */
3413 Creating the linenumber table is done by reading in the entire
3414 coff linenumber table, and creating another table for internal use.
3416 A coff linenumber table is structured so that each function
3417 is marked as having a line number of 0. Each line within the
3418 function is an offset from the first line in the function. The
3419 base of the line number information for the table is stored in
3420 the symbol associated with the function.
3422 The information is copied from the external to the internal
3423 table, and each symbol which marks a function is marked by
3426 How does this work ?
3431 coff_slurp_line_table (abfd
, asect
)
3435 LINENO
*native_lineno
;
3436 alent
*lineno_cache
;
3438 BFD_ASSERT (asect
->lineno
== (alent
*) NULL
);
3440 native_lineno
= (LINENO
*) buy_and_read (abfd
,
3441 asect
->line_filepos
,
3444 asect
->lineno_count
));
3446 (alent
*) bfd_alloc (abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof (alent
)));
3447 if (lineno_cache
== NULL
)
3451 unsigned int counter
= 0;
3452 alent
*cache_ptr
= lineno_cache
;
3453 LINENO
*src
= native_lineno
;
3455 while (counter
< asect
->lineno_count
)
3457 struct internal_lineno dst
;
3458 coff_swap_lineno_in (abfd
, src
, &dst
);
3459 cache_ptr
->line_number
= dst
.l_lnno
;
3461 if (cache_ptr
->line_number
== 0)
3465 coff_symbol_type
*sym
;
3468 symndx
= dst
.l_addr
.l_symndx
;
3470 || (unsigned long) symndx
>= obj_raw_syment_count (abfd
))
3472 (*_bfd_error_handler
)
3473 (_("%s: warning: illegal symbol index %ld in line numbers"),
3474 bfd_get_filename (abfd
), dst
.l_addr
.l_symndx
);
3478 /* FIXME: We should not be casting between ints and
3479 pointers like this. */
3480 sym
= ((coff_symbol_type
*)
3481 ((symndx
+ obj_raw_syments (abfd
))
3482 ->u
.syment
._n
._n_n
._n_zeroes
));
3483 cache_ptr
->u
.sym
= (asymbol
*) sym
;
3484 if (sym
->lineno
!= NULL
&& ! warned
)
3486 (*_bfd_error_handler
)
3487 (_("%s: warning: duplicate line number information for `%s'"),
3488 bfd_get_filename (abfd
),
3489 bfd_asymbol_name (&sym
->symbol
));
3491 sym
->lineno
= cache_ptr
;
3495 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
3496 - bfd_section_vma (abfd
, asect
);
3497 } /* If no linenumber expect a symbol index */
3503 cache_ptr
->line_number
= 0;
3506 asect
->lineno
= lineno_cache
;
3507 /* FIXME, free native_lineno here, or use alloca or something. */
3512 coff_slurp_symbol_table (abfd
)
3515 combined_entry_type
*native_symbols
;
3516 coff_symbol_type
*cached_area
;
3517 unsigned int *table_ptr
;
3519 unsigned int number_of_symbols
= 0;
3521 if (obj_symbols (abfd
))
3524 /* Read in the symbol table */
3525 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
3530 /* Allocate enough room for all the symbols in cached form */
3531 cached_area
= ((coff_symbol_type
*)
3533 (obj_raw_syment_count (abfd
)
3534 * sizeof (coff_symbol_type
))));
3536 if (cached_area
== NULL
)
3538 table_ptr
= ((unsigned int *)
3540 (obj_raw_syment_count (abfd
)
3541 * sizeof (unsigned int))));
3543 if (table_ptr
== NULL
)
3547 coff_symbol_type
*dst
= cached_area
;
3548 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
3549 unsigned int this_index
= 0;
3550 while (this_index
< last_native_index
)
3552 combined_entry_type
*src
= native_symbols
+ this_index
;
3553 table_ptr
[this_index
] = number_of_symbols
;
3554 dst
->symbol
.the_bfd
= abfd
;
3556 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
3557 /* We use the native name field to point to the cached field. */
3558 src
->u
.syment
._n
._n_n
._n_zeroes
= (long) dst
;
3559 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
3560 src
->u
.syment
.n_scnum
);
3561 dst
->symbol
.flags
= 0;
3562 dst
->done_lineno
= false;
3564 switch (src
->u
.syment
.n_sclass
)
3569 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
3570 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
3571 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
3573 /* Fall through to next case */
3581 case C_THUMBEXTFUNC
:
3587 case C_SYSTEM
: /* System Wide variable */
3590 /* In PE, 0x68 (104) denotes a section symbol */
3592 /* In PE, 0x69 (105) denotes a weak external symbol. */
3595 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
3597 case COFF_SYMBOL_GLOBAL
:
3598 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
3599 #if defined COFF_WITH_PE
3600 /* PE sets the symbol to a value relative to the
3601 start of the section. */
3602 dst
->symbol
.value
= src
->u
.syment
.n_value
;
3604 dst
->symbol
.value
= (src
->u
.syment
.n_value
3605 - dst
->symbol
.section
->vma
);
3607 if (ISFCN ((src
->u
.syment
.n_type
)))
3609 /* A function ext does not go at the end of a
3611 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
3615 case COFF_SYMBOL_COMMON
:
3616 dst
->symbol
.section
= bfd_com_section_ptr
;
3617 dst
->symbol
.value
= src
->u
.syment
.n_value
;
3620 case COFF_SYMBOL_UNDEFINED
:
3621 dst
->symbol
.section
= bfd_und_section_ptr
;
3622 dst
->symbol
.value
= 0;
3625 case COFF_SYMBOL_PE_SECTION
:
3626 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
3627 dst
->symbol
.value
= 0;
3630 case COFF_SYMBOL_LOCAL
:
3631 dst
->symbol
.flags
= BSF_LOCAL
;
3632 #if defined COFF_WITH_PE
3633 /* PE sets the symbol to a value relative to the
3634 start of the section. */
3635 dst
->symbol
.value
= src
->u
.syment
.n_value
;
3637 dst
->symbol
.value
= (src
->u
.syment
.n_value
3638 - dst
->symbol
.section
->vma
);
3640 if (ISFCN ((src
->u
.syment
.n_type
)))
3641 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
3646 /* A symbol with a csect entry should not go at the end. */
3647 if (src
->u
.syment
.n_numaux
> 0)
3648 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
3652 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
3653 dst
->symbol
.flags
= BSF_WEAK
;
3654 if (src
->u
.syment
.n_sclass
== C_SECTION
3655 && src
->u
.syment
.n_scnum
> 0)
3657 dst
->symbol
.flags
= BSF_LOCAL
;
3661 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
)
3662 dst
->symbol
.flags
= BSF_WEAK
;
3666 case C_STAT
: /* static */
3668 case C_LEAFSTAT
: /* static leaf procedure */
3671 case C_THUMBSTAT
: /* Thumb static */
3672 case C_THUMBLABEL
: /* Thumb label */
3673 case C_THUMBSTATFUNC
:/* Thumb static function */
3675 case C_LABEL
: /* label */
3676 if (src
->u
.syment
.n_scnum
== -2)
3677 dst
->symbol
.flags
= BSF_DEBUGGING
;
3679 dst
->symbol
.flags
= BSF_LOCAL
;
3681 /* Base the value as an index from the base of the
3682 section, if there is one. */
3683 if (dst
->symbol
.section
)
3685 #if defined COFF_WITH_PE
3686 /* PE sets the symbol to a value relative to the
3687 start of the section. */
3688 dst
->symbol
.value
= src
->u
.syment
.n_value
;
3690 dst
->symbol
.value
= (src
->u
.syment
.n_value
3691 - dst
->symbol
.section
->vma
);
3695 dst
->symbol
.value
= src
->u
.syment
.n_value
;
3698 case C_MOS
: /* member of structure */
3699 case C_EOS
: /* end of structure */
3700 #ifdef NOTDEF /* C_AUTOARG has the same value */
3702 case C_GLBLREG
: /* A29k-specific storage class */
3705 case C_REGPARM
: /* register parameter */
3706 case C_REG
: /* register variable */
3709 case C_AUTOARG
: /* 960-specific storage class */
3712 case C_TPDEF
: /* type definition */
3714 case C_AUTO
: /* automatic variable */
3715 case C_FIELD
: /* bit field */
3716 case C_ENTAG
: /* enumeration tag */
3717 case C_MOE
: /* member of enumeration */
3718 case C_MOU
: /* member of union */
3719 case C_UNTAG
: /* union tag */
3720 dst
->symbol
.flags
= BSF_DEBUGGING
;
3721 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3724 case C_FILE
: /* file name */
3725 case C_STRTAG
: /* structure tag */
3740 dst
->symbol
.flags
= BSF_DEBUGGING
;
3741 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3745 case C_BINCL
: /* beginning of include file */
3746 case C_EINCL
: /* ending of include file */
3747 /* The value is actually a pointer into the line numbers
3748 of the file. We locate the line number entry, and
3749 set the section to the section which contains it, and
3750 the value to the index in that section. */
3754 dst
->symbol
.flags
= BSF_DEBUGGING
;
3755 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3756 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
3757 && ((file_ptr
) (sec
->line_filepos
3758 + sec
->lineno_count
* LINESZ
)
3759 > (file_ptr
) src
->u
.syment
.n_value
))
3762 dst
->symbol
.value
= 0;
3765 dst
->symbol
.section
= sec
;
3766 dst
->symbol
.value
= ((src
->u
.syment
.n_value
3767 - sec
->line_filepos
)
3775 dst
->symbol
.flags
= BSF_DEBUGGING
;
3777 /* The value is actually a symbol index. Save a pointer
3778 to the symbol instead of the index. FIXME: This
3779 should use a union. */
3780 src
->u
.syment
.n_value
=
3781 (long) (native_symbols
+ src
->u
.syment
.n_value
);
3782 dst
->symbol
.value
= src
->u
.syment
.n_value
;
3787 case C_BLOCK
: /* ".bb" or ".eb" */
3788 case C_FCN
: /* ".bf" or ".ef" */
3789 case C_EFCN
: /* physical end of function */
3790 dst
->symbol
.flags
= BSF_LOCAL
;
3791 #if defined COFF_WITH_PE
3792 /* PE sets the symbol to a value relative to the start
3794 dst
->symbol
.value
= src
->u
.syment
.n_value
;
3796 /* Base the value as an index from the base of the
3798 dst
->symbol
.value
= (src
->u
.syment
.n_value
3799 - dst
->symbol
.section
->vma
);
3804 case C_EXTDEF
: /* external definition */
3805 case C_ULABEL
: /* undefined label */
3806 case C_USTATIC
: /* undefined static */
3807 #ifndef COFF_WITH_PE
3808 /* C_LINE in regular coff is 0x68. NT has taken over this storage
3809 class to represent a section symbol */
3810 case C_LINE
: /* line # reformatted as symbol table entry */
3811 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
3812 case C_ALIAS
: /* duplicate tag */
3814 /* New storage classes for TIc80 */
3816 case C_UEXT
: /* Tentative external definition */
3818 case C_STATLAB
: /* Static load time label */
3819 case C_EXTLAB
: /* External load time label */
3820 case C_HIDDEN
: /* ext symbol in dmert public lib */
3822 (*_bfd_error_handler
)
3823 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
3824 bfd_get_filename (abfd
), src
->u
.syment
.n_sclass
,
3825 dst
->symbol
.section
->name
, dst
->symbol
.name
);
3826 dst
->symbol
.flags
= BSF_DEBUGGING
;
3827 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3831 /* BFD_ASSERT(dst->symbol.flags != 0);*/
3835 dst
->symbol
.udata
.i
= 0;
3836 dst
->lineno
= (alent
*) NULL
;
3837 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
3839 number_of_symbols
++;
3840 } /* walk the native symtab */
3841 } /* bfdize the native symtab */
3843 obj_symbols (abfd
) = cached_area
;
3844 obj_raw_syments (abfd
) = native_symbols
;
3846 bfd_get_symcount (abfd
) = number_of_symbols
;
3847 obj_convert (abfd
) = table_ptr
;
3848 /* Slurp the line tables for each section too */
3854 coff_slurp_line_table (abfd
, p
);
3859 } /* coff_slurp_symbol_table() */
3861 /* Classify a COFF symbol. A couple of targets have globally visible
3862 symbols which are not class C_EXT, and this handles those. It also
3863 recognizes some special PE cases. */
3865 static enum coff_symbol_classification
3866 coff_classify_symbol (abfd
, syment
)
3868 struct internal_syment
*syment
;
3870 /* FIXME: This partially duplicates the switch in
3871 coff_slurp_symbol_table. */
3872 switch (syment
->n_sclass
)
3881 case C_THUMBEXTFUNC
:
3889 if (syment
->n_scnum
== 0)
3891 if (syment
->n_value
== 0)
3892 return COFF_SYMBOL_UNDEFINED
;
3894 return COFF_SYMBOL_COMMON
;
3896 return COFF_SYMBOL_GLOBAL
;
3903 if (syment
->n_sclass
== C_STAT
)
3905 if (syment
->n_scnum
== 0)
3907 /* The Microsoft compiler sometimes generates these if a
3908 small static function is inlined every time it is used.
3909 The function is discarded, but the symbol table entry
3911 return COFF_SYMBOL_LOCAL
;
3914 if (syment
->n_value
== 0)
3917 char buf
[SYMNMLEN
+ 1];
3919 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
3921 && (strcmp (bfd_get_section_name (abfd
, sec
),
3922 _bfd_coff_internal_syment_name (abfd
, syment
, buf
))
3924 return COFF_SYMBOL_PE_SECTION
;
3927 return COFF_SYMBOL_LOCAL
;
3930 if (syment
->n_sclass
== C_SECTION
)
3932 /* In some cases in a DLL generated by the Microsoft linker, the
3933 n_value field will contain garbage. FIXME: This should
3934 probably be handled by the swapping function instead. */
3935 syment
->n_value
= 0;
3936 if (syment
->n_scnum
== 0)
3937 return COFF_SYMBOL_UNDEFINED
;
3938 return COFF_SYMBOL_PE_SECTION
;
3940 #endif /* COFF_WITH_PE */
3942 /* If it is not a global symbol, we presume it is a local symbol. */
3944 if (syment
->n_scnum
== 0)
3946 char buf
[SYMNMLEN
+ 1];
3948 (*_bfd_error_handler
)
3949 (_("warning: %s: local symbol `%s' has no section"),
3950 bfd_get_filename (abfd
),
3951 _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
3954 return COFF_SYMBOL_LOCAL
;
3961 Coff relocations are easily transformed into the internal BFD form
3964 Reading a coff relocation table is done in the following stages:
3966 o Read the entire coff relocation table into memory.
3968 o Process each relocation in turn; first swap it from the
3969 external to the internal form.
3971 o Turn the symbol referenced in the relocation's symbol index
3972 into a pointer into the canonical symbol table.
3973 This table is the same as the one returned by a call to
3974 @code{bfd_canonicalize_symtab}. The back end will call that
3975 routine and save the result if a canonicalization hasn't been done.
3977 o The reloc index is turned into a pointer to a howto
3978 structure, in a back end specific way. For instance, the 386
3979 and 960 use the @code{r_type} to directly produce an index
3980 into a howto table vector; the 88k subtracts a number from the
3981 @code{r_type} field and creates an addend field.
3987 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
3989 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
3990 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
3991 coffsym = (obj_symbols (abfd) \
3992 + (cache_ptr->sym_ptr_ptr - symbols)); \
3994 coffsym = coff_symbol_from (abfd, ptr); \
3995 if (coffsym != (coff_symbol_type *) NULL \
3996 && coffsym->native->u.syment.n_scnum == 0) \
3997 cache_ptr->addend = 0; \
3998 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
3999 && ptr->section != (asection *) NULL) \
4000 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
4002 cache_ptr->addend = 0; \
4007 coff_slurp_reloc_table (abfd
, asect
, symbols
)
4012 RELOC
*native_relocs
;
4013 arelent
*reloc_cache
;
4018 if (asect
->relocation
)
4020 if (asect
->reloc_count
== 0)
4022 if (asect
->flags
& SEC_CONSTRUCTOR
)
4024 if (!coff_slurp_symbol_table (abfd
))
4027 (RELOC
*) buy_and_read (abfd
,
4031 asect
->reloc_count
));
4032 reloc_cache
= (arelent
*)
4033 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
4035 if (reloc_cache
== NULL
)
4039 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
4041 struct internal_reloc dst
;
4042 struct external_reloc
*src
;
4043 #ifndef RELOC_PROCESSING
4047 cache_ptr
= reloc_cache
+ idx
;
4048 src
= native_relocs
+ idx
;
4050 coff_swap_reloc_in (abfd
, src
, &dst
);
4052 #ifdef RELOC_PROCESSING
4053 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
4055 cache_ptr
->address
= dst
.r_vaddr
;
4057 if (dst
.r_symndx
!= -1)
4059 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
4061 (*_bfd_error_handler
)
4062 (_("%s: warning: illegal symbol index %ld in relocs"),
4063 bfd_get_filename (abfd
), dst
.r_symndx
);
4064 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
4069 cache_ptr
->sym_ptr_ptr
= (symbols
4070 + obj_convert (abfd
)[dst
.r_symndx
]);
4071 ptr
= *(cache_ptr
->sym_ptr_ptr
);
4076 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
4080 /* The symbols definitions that we have read in have been
4081 relocated as if their sections started at 0. But the offsets
4082 refering to the symbols in the raw data have not been
4083 modified, so we have to have a negative addend to compensate.
4085 Note that symbols which used to be common must be left alone */
4087 /* Calculate any reloc addend by looking at the symbol */
4088 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
4090 cache_ptr
->address
-= asect
->vma
;
4091 /* !! cache_ptr->section = (asection *) NULL;*/
4093 /* Fill in the cache_ptr->howto field from dst.r_type */
4094 RTYPE2HOWTO (cache_ptr
, &dst
);
4095 #endif /* RELOC_PROCESSING */
4097 if (cache_ptr
->howto
== NULL
)
4099 (*_bfd_error_handler
)
4100 (_("%s: illegal relocation type %d at address 0x%lx"),
4101 bfd_get_filename (abfd
), dst
.r_type
, (long) dst
.r_vaddr
);
4102 bfd_set_error (bfd_error_bad_value
);
4107 asect
->relocation
= reloc_cache
;
4111 #ifndef coff_rtype_to_howto
4114 /* Get the howto structure for a reloc. This is only used if the file
4115 including this one defines coff_relocate_section to be
4116 _bfd_coff_generic_relocate_section, so it is OK if it does not
4117 always work. It is the responsibility of the including file to
4118 make sure it is reasonable if it is needed. */
4120 static reloc_howto_type
*coff_rtype_to_howto
4121 PARAMS ((bfd
*, asection
*, struct internal_reloc
*,
4122 struct coff_link_hash_entry
*, struct internal_syment
*,
4126 static reloc_howto_type
*
4127 coff_rtype_to_howto (abfd
, sec
, rel
, h
, sym
, addendp
)
4128 bfd
*abfd ATTRIBUTE_UNUSED
;
4129 asection
*sec ATTRIBUTE_UNUSED
;
4130 struct internal_reloc
*rel
;
4131 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
;
4132 struct internal_syment
*sym ATTRIBUTE_UNUSED
;
4133 bfd_vma
*addendp ATTRIBUTE_UNUSED
;
4137 RTYPE2HOWTO (&genrel
, rel
);
4138 return genrel
.howto
;
4141 #else /* ! defined (RTYPE2HOWTO) */
4143 #define coff_rtype_to_howto NULL
4145 #endif /* ! defined (RTYPE2HOWTO) */
4146 #endif /* ! defined (coff_rtype_to_howto) */
4148 /* This is stupid. This function should be a boolean predicate. */
4150 coff_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
4156 arelent
*tblptr
= section
->relocation
;
4157 unsigned int count
= 0;
4160 if (section
->flags
& SEC_CONSTRUCTOR
)
4162 /* this section has relocs made up by us, they are not in the
4163 file, so take them out of their chain and place them into
4164 the data area provided */
4165 arelent_chain
*chain
= section
->constructor_chain
;
4166 for (count
= 0; count
< section
->reloc_count
; count
++)
4168 *relptr
++ = &chain
->relent
;
4169 chain
= chain
->next
;
4175 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
4178 tblptr
= section
->relocation
;
4180 for (; count
++ < section
->reloc_count
;)
4181 *relptr
++ = tblptr
++;
4186 return section
->reloc_count
;
4191 coff_sym_filepos (abfd
)
4194 return obj_sym_filepos (abfd
);
4198 #ifndef coff_reloc16_estimate
4199 #define coff_reloc16_estimate dummy_reloc16_estimate
4201 static int dummy_reloc16_estimate
4202 PARAMS ((bfd
*, asection
*, arelent
*, unsigned int,
4203 struct bfd_link_info
*));
4206 dummy_reloc16_estimate (abfd
, input_section
, reloc
, shrink
, link_info
)
4207 bfd
*abfd ATTRIBUTE_UNUSED
;
4208 asection
*input_section ATTRIBUTE_UNUSED
;
4209 arelent
*reloc ATTRIBUTE_UNUSED
;
4210 unsigned int shrink ATTRIBUTE_UNUSED
;
4211 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
4218 #ifndef coff_reloc16_extra_cases
4220 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
4222 /* This works even if abort is not declared in any header file. */
4224 static void dummy_reloc16_extra_cases
4225 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*, arelent
*,
4226 bfd_byte
*, unsigned int *, unsigned int *));
4229 dummy_reloc16_extra_cases (abfd
, link_info
, link_order
, reloc
, data
, src_ptr
,
4231 bfd
*abfd ATTRIBUTE_UNUSED
;
4232 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
4233 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
;
4234 arelent
*reloc ATTRIBUTE_UNUSED
;
4235 bfd_byte
*data ATTRIBUTE_UNUSED
;
4236 unsigned int *src_ptr ATTRIBUTE_UNUSED
;
4237 unsigned int *dst_ptr ATTRIBUTE_UNUSED
;
4243 /* If coff_relocate_section is defined, we can use the optimized COFF
4244 backend linker. Otherwise we must continue to use the old linker. */
4245 #ifdef coff_relocate_section
4246 #ifndef coff_bfd_link_hash_table_create
4247 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
4249 #ifndef coff_bfd_link_add_symbols
4250 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
4252 #ifndef coff_bfd_final_link
4253 #define coff_bfd_final_link _bfd_coff_final_link
4255 #else /* ! defined (coff_relocate_section) */
4256 #define coff_relocate_section NULL
4257 #ifndef coff_bfd_link_hash_table_create
4258 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
4260 #ifndef coff_bfd_link_add_symbols
4261 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
4263 #define coff_bfd_final_link _bfd_generic_final_link
4264 #endif /* ! defined (coff_relocate_section) */
4266 #define coff_bfd_link_split_section _bfd_generic_link_split_section
4268 #ifndef coff_start_final_link
4269 #define coff_start_final_link NULL
4272 #ifndef coff_adjust_symndx
4273 #define coff_adjust_symndx NULL
4276 #ifndef coff_link_add_one_symbol
4277 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
4280 #ifndef coff_link_output_has_begun
4282 static boolean coff_link_output_has_begun
4283 PARAMS ((bfd
*, struct coff_final_link_info
*));
4286 coff_link_output_has_begun (abfd
, info
)
4288 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
;
4290 return abfd
->output_has_begun
;
4294 #ifndef coff_final_link_postscript
4296 static boolean coff_final_link_postscript
4297 PARAMS ((bfd
*, struct coff_final_link_info
*));
4300 coff_final_link_postscript (abfd
, pfinfo
)
4301 bfd
* abfd ATTRIBUTE_UNUSED
;
4302 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
;
4308 #ifndef coff_SWAP_aux_in
4309 #define coff_SWAP_aux_in coff_swap_aux_in
4311 #ifndef coff_SWAP_sym_in
4312 #define coff_SWAP_sym_in coff_swap_sym_in
4314 #ifndef coff_SWAP_lineno_in
4315 #define coff_SWAP_lineno_in coff_swap_lineno_in
4317 #ifndef coff_SWAP_aux_out
4318 #define coff_SWAP_aux_out coff_swap_aux_out
4320 #ifndef coff_SWAP_sym_out
4321 #define coff_SWAP_sym_out coff_swap_sym_out
4323 #ifndef coff_SWAP_lineno_out
4324 #define coff_SWAP_lineno_out coff_swap_lineno_out
4326 #ifndef coff_SWAP_reloc_out
4327 #define coff_SWAP_reloc_out coff_swap_reloc_out
4329 #ifndef coff_SWAP_filehdr_out
4330 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
4332 #ifndef coff_SWAP_aouthdr_out
4333 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
4335 #ifndef coff_SWAP_scnhdr_out
4336 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
4338 #ifndef coff_SWAP_reloc_in
4339 #define coff_SWAP_reloc_in coff_swap_reloc_in
4341 #ifndef coff_SWAP_filehdr_in
4342 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
4344 #ifndef coff_SWAP_aouthdr_in
4345 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
4347 #ifndef coff_SWAP_scnhdr_in
4348 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
4353 static CONST bfd_coff_backend_data bfd_coff_std_swap_table
=
4355 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
4356 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
4357 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
4358 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
4359 coff_SWAP_scnhdr_out
,
4360 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
,
4361 #ifdef COFF_LONG_FILENAMES
4366 #ifdef COFF_LONG_SECTION_NAMES
4371 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
4372 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
4373 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
4374 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
4375 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
4376 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
4377 coff_classify_symbol
, coff_compute_section_file_positions
,
4378 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
4379 coff_adjust_symndx
, coff_link_add_one_symbol
,
4380 coff_link_output_has_begun
, coff_final_link_postscript
4383 #ifndef coff_close_and_cleanup
4384 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
4387 #ifndef coff_bfd_free_cached_info
4388 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
4391 #ifndef coff_get_section_contents
4392 #define coff_get_section_contents _bfd_generic_get_section_contents
4395 #ifndef coff_bfd_copy_private_symbol_data
4396 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
4399 #ifndef coff_bfd_copy_private_section_data
4400 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
4403 #ifndef coff_bfd_copy_private_bfd_data
4404 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
4407 #ifndef coff_bfd_merge_private_bfd_data
4408 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
4411 #ifndef coff_bfd_set_private_flags
4412 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
4415 #ifndef coff_bfd_print_private_bfd_data
4416 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
4419 #ifndef coff_bfd_is_local_label_name
4420 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
4423 #ifndef coff_read_minisymbols
4424 #define coff_read_minisymbols _bfd_generic_read_minisymbols
4427 #ifndef coff_minisymbol_to_symbol
4428 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
4431 /* The reloc lookup routine must be supplied by each individual COFF
4433 #ifndef coff_bfd_reloc_type_lookup
4434 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4437 #ifndef coff_bfd_get_relocated_section_contents
4438 #define coff_bfd_get_relocated_section_contents \
4439 bfd_generic_get_relocated_section_contents
4442 #ifndef coff_bfd_relax_section
4443 #define coff_bfd_relax_section bfd_generic_relax_section
4446 #ifndef coff_bfd_gc_sections
4447 #define coff_bfd_gc_sections bfd_generic_gc_sections
4450 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
4451 const bfd_target VAR = \
4454 bfd_target_coff_flavour, \
4455 BFD_ENDIAN_BIG, /* data byte order is big */ \
4456 BFD_ENDIAN_BIG, /* header byte order is big */ \
4457 /* object flags */ \
4458 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
4459 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
4460 /* section flags */ \
4461 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS), \
4462 UNDER, /* leading symbol underscore */ \
4463 '/', /* ar_pad_char */ \
4464 15, /* ar_max_namelen */ \
4466 /* Data conversion functions. */ \
4467 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
4468 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
4469 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
4471 /* Header conversion functions. */ \
4472 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
4473 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
4474 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
4476 /* bfd_check_format */ \
4477 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, _bfd_dummy_target }, \
4478 /* bfd_set_format */ \
4479 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
4480 /* bfd_write_contents */ \
4481 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, bfd_false }, \
4483 BFD_JUMP_TABLE_GENERIC (coff), \
4484 BFD_JUMP_TABLE_COPY (coff), \
4485 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
4486 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
4487 BFD_JUMP_TABLE_SYMBOLS (coff), \
4488 BFD_JUMP_TABLE_RELOCS (coff), \
4489 BFD_JUMP_TABLE_WRITE (coff), \
4490 BFD_JUMP_TABLE_LINK (coff), \
4491 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
4498 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
4499 const bfd_target VAR = \
4502 bfd_target_coff_flavour, \
4503 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
4504 BFD_ENDIAN_LITTLE, /* header byte order is little */ \
4505 /* object flags */ \
4506 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
4507 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
4508 /* section flags */ \
4509 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS), \
4510 UNDER, /* leading symbol underscore */ \
4511 '/', /* ar_pad_char */ \
4512 15, /* ar_max_namelen */ \
4514 /* Data conversion functions. */ \
4515 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
4516 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
4517 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
4518 /* Header conversion functions. */ \
4519 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
4520 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
4521 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
4522 /* bfd_check_format */ \
4523 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, _bfd_dummy_target }, \
4524 /* bfd_set_format */ \
4525 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
4526 /* bfd_write_contents */ \
4527 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, bfd_false }, \
4529 BFD_JUMP_TABLE_GENERIC (coff), \
4530 BFD_JUMP_TABLE_COPY (coff), \
4531 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
4532 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
4533 BFD_JUMP_TABLE_SYMBOLS (coff), \
4534 BFD_JUMP_TABLE_RELOCS (coff), \
4535 BFD_JUMP_TABLE_WRITE (coff), \
4536 BFD_JUMP_TABLE_LINK (coff), \
4537 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \