1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 1998
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 boolean coff_slurp_reloc_table
PARAMS ((bfd
*, asection
*, asymbol
**));
333 static long coff_canonicalize_reloc
334 PARAMS ((bfd
*, asection
*, arelent
**, asymbol
**));
335 #ifndef coff_mkobject_hook
336 static PTR coff_mkobject_hook
PARAMS ((bfd
*, PTR
, PTR
));
339 /* void warning(); */
342 * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the
343 * incoming SEC_* flags. The inverse of this function is styp_to_sec_flags().
344 * NOTE: If you add to/change this routine, you should mirror the changes
345 * in styp_to_sec_flags().
348 sec_to_styp_flags (sec_name
, sec_flags
)
349 CONST
char *sec_name
;
354 if (!strcmp (sec_name
, _TEXT
))
356 styp_flags
= STYP_TEXT
;
358 else if (!strcmp (sec_name
, _DATA
))
360 styp_flags
= STYP_DATA
;
362 else if (!strcmp (sec_name
, _BSS
))
364 styp_flags
= STYP_BSS
;
367 else if (!strcmp (sec_name
, _COMMENT
))
369 styp_flags
= STYP_INFO
;
370 #endif /* _COMMENT */
373 else if (!strcmp (sec_name
, _LIB
))
375 styp_flags
= STYP_LIB
;
379 else if (!strcmp (sec_name
, _LIT
))
381 styp_flags
= STYP_LIT
;
384 else if (!strcmp (sec_name
, ".debug"))
387 styp_flags
= STYP_DEBUG
;
389 styp_flags
= STYP_INFO
;
392 else if (!strncmp (sec_name
, ".stab", 5))
394 styp_flags
= STYP_INFO
;
397 else if (!strcmp (sec_name
, ".edata"))
399 styp_flags
= STYP_DATA
;
403 else if (!strcmp (sec_name
, _PAD
))
405 styp_flags
= STYP_PAD
;
407 else if (!strcmp (sec_name
, _LOADER
))
409 styp_flags
= STYP_LOADER
;
412 /* Try and figure out what it should be */
413 else if (sec_flags
& SEC_CODE
)
415 styp_flags
= STYP_TEXT
;
417 else if (sec_flags
& SEC_DATA
)
419 styp_flags
= STYP_DATA
;
421 else if (sec_flags
& SEC_READONLY
)
423 #ifdef STYP_LIT /* 29k readonly text/data section */
424 styp_flags
= STYP_LIT
;
426 styp_flags
= STYP_TEXT
;
427 #endif /* STYP_LIT */
429 else if (sec_flags
& SEC_LOAD
)
431 styp_flags
= STYP_TEXT
;
433 else if (sec_flags
& SEC_ALLOC
)
435 styp_flags
= STYP_BSS
;
439 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
440 styp_flags
|= STYP_NOLOAD
;
444 if (sec_flags
& SEC_LINK_ONCE
)
445 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
451 * Return a word with SEC_* flags set to represent the incoming
452 * STYP_* flags (from scnhdr.s_flags). The inverse of this
453 * function is sec_to_styp_flags().
454 * NOTE: If you add to/change this routine, you should mirror the changes
455 * in sec_to_styp_flags().
458 styp_to_sec_flags (abfd
, hdr
, name
)
463 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
464 long styp_flags
= internal_s
->s_flags
;
465 flagword sec_flags
= 0;
468 if (styp_flags
& STYP_NOLOAD
)
470 sec_flags
|= SEC_NEVER_LOAD
;
472 #endif /* STYP_NOLOAD */
474 /* For 386 COFF, at least, an unloadable text or data section is
475 actually a shared library section. */
476 if (styp_flags
& STYP_TEXT
)
478 if (sec_flags
& SEC_NEVER_LOAD
)
479 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
481 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
483 else if (styp_flags
& STYP_DATA
)
485 if (sec_flags
& SEC_NEVER_LOAD
)
486 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
488 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
490 else if (styp_flags
& STYP_BSS
)
492 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
493 if (sec_flags
& SEC_NEVER_LOAD
)
494 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
497 sec_flags
|= SEC_ALLOC
;
499 else if (styp_flags
& STYP_INFO
)
501 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
502 defined. coff_compute_section_file_positions uses
503 COFF_PAGE_SIZE to ensure that the low order bits of the
504 section VMA and the file offset match. If we don't know
505 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
506 and demand page loading of the file will fail. */
507 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
508 sec_flags
|= SEC_DEBUGGING
;
511 else if (styp_flags
& STYP_PAD
)
515 else if (strcmp (name
, _TEXT
) == 0)
517 if (sec_flags
& SEC_NEVER_LOAD
)
518 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
520 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
522 else if (strcmp (name
, _DATA
) == 0)
524 if (sec_flags
& SEC_NEVER_LOAD
)
525 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
527 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
529 else if (strcmp (name
, _BSS
) == 0)
531 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
532 if (sec_flags
& SEC_NEVER_LOAD
)
533 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
536 sec_flags
|= SEC_ALLOC
;
538 else if (strcmp (name
, ".debug") == 0
540 || strcmp (name
, _COMMENT
) == 0
542 || strncmp (name
, ".stab", 5) == 0)
544 #ifdef COFF_PAGE_SIZE
545 sec_flags
|= SEC_DEBUGGING
;
549 else if (strcmp (name
, _LIB
) == 0)
553 else if (strcmp (name
, _LIT
) == 0)
555 sec_flags
= SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
560 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
563 #ifdef STYP_LIT /* A29k readonly text/data section type */
564 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
566 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
568 #endif /* STYP_LIT */
569 #ifdef STYP_OTHER_LOAD /* Other loaded sections */
570 if (styp_flags
& STYP_OTHER_LOAD
)
572 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
574 #endif /* STYP_SDATA */
577 if (styp_flags
& IMAGE_SCN_LNK_REMOVE
)
578 sec_flags
|= SEC_EXCLUDE
;
580 if (styp_flags
& IMAGE_SCN_LNK_COMDAT
)
582 sec_flags
|= SEC_LINK_ONCE
;
584 /* Unfortunately, the PE format stores essential information in
585 the symbol table, of all places. We need to extract that
586 information now, so that objdump and the linker will know how
587 to handle the section without worrying about the symbols. We
588 can't call slurp_symtab, because the linker doesn't want the
591 if (_bfd_coff_get_external_symbols (abfd
))
593 bfd_byte
*esym
, *esymend
;
595 esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
596 esymend
= esym
+ obj_raw_syment_count (abfd
) * SYMESZ
;
598 while (esym
< esymend
)
600 struct internal_syment isym
;
602 bfd_coff_swap_sym_in (abfd
, (PTR
) esym
, (PTR
) &isym
);
604 if (sizeof (internal_s
->s_name
) > SYMNMLEN
)
606 /* This case implies that the matching symbol name
607 will be in the string table. */
611 if (isym
.n_sclass
== C_STAT
612 && isym
.n_type
== T_NULL
613 && isym
.n_numaux
== 1)
615 char buf
[SYMNMLEN
+ 1];
618 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
, buf
);
622 if (strcmp (name
, symname
) == 0)
624 union internal_auxent aux
;
626 /* This is the section symbol. */
628 bfd_coff_swap_aux_in (abfd
, (PTR
) (esym
+ SYMESZ
),
629 isym
.n_type
, isym
.n_sclass
,
630 0, isym
.n_numaux
, (PTR
) &aux
);
632 switch (aux
.x_scn
.x_comdat
)
634 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
635 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
639 case IMAGE_COMDAT_SELECT_ANY
:
640 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
643 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
644 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
647 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
648 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
651 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
652 /* FIXME: This is not currently implemented. */
653 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
661 esym
+= (isym
.n_numaux
+ 1) * SYMESZ
;
670 #define get_index(symbol) ((symbol)->udata.i)
674 bfd_coff_backend_data
678 Special entry points for gdb to swap in coff symbol table parts:
681 . void (*_bfd_coff_swap_aux_in) PARAMS ((
690 . void (*_bfd_coff_swap_sym_in) PARAMS ((
695 . void (*_bfd_coff_swap_lineno_in) PARAMS ((
701 Special entry points for gas to swap out coff parts:
703 . unsigned int (*_bfd_coff_swap_aux_out) PARAMS ((
712 . unsigned int (*_bfd_coff_swap_sym_out) PARAMS ((
717 . unsigned int (*_bfd_coff_swap_lineno_out) PARAMS ((
722 . unsigned int (*_bfd_coff_swap_reloc_out) PARAMS ((
727 . unsigned int (*_bfd_coff_swap_filehdr_out) PARAMS ((
732 . unsigned int (*_bfd_coff_swap_aouthdr_out) PARAMS ((
737 . unsigned int (*_bfd_coff_swap_scnhdr_out) PARAMS ((
743 Special entry points for generic COFF routines to call target
744 dependent COFF routines:
746 . unsigned int _bfd_filhsz;
747 . unsigned int _bfd_aoutsz;
748 . unsigned int _bfd_scnhsz;
749 . unsigned int _bfd_symesz;
750 . unsigned int _bfd_auxesz;
751 . unsigned int _bfd_relsz;
752 . unsigned int _bfd_linesz;
753 . boolean _bfd_coff_long_filenames;
754 . boolean _bfd_coff_long_section_names;
755 . unsigned int _bfd_coff_default_section_alignment_power;
756 . void (*_bfd_coff_swap_filehdr_in) PARAMS ((
760 . void (*_bfd_coff_swap_aouthdr_in) PARAMS ((
764 . void (*_bfd_coff_swap_scnhdr_in) PARAMS ((
768 . void (*_bfd_coff_swap_reloc_in) PARAMS ((
772 . boolean (*_bfd_coff_bad_format_hook) PARAMS ((
774 . PTR internal_filehdr));
775 . boolean (*_bfd_coff_set_arch_mach_hook) PARAMS ((
777 . PTR internal_filehdr));
778 . PTR (*_bfd_coff_mkobject_hook) PARAMS ((
780 . PTR internal_filehdr,
781 . PTR internal_aouthdr));
782 . flagword (*_bfd_styp_to_sec_flags_hook) PARAMS ((
784 . PTR internal_scnhdr,
785 . const char *name));
786 . void (*_bfd_set_alignment_hook) PARAMS ((
789 . PTR internal_scnhdr));
790 . boolean (*_bfd_coff_slurp_symbol_table) PARAMS ((
792 . boolean (*_bfd_coff_symname_in_debug) PARAMS ((
794 . struct internal_syment *sym));
795 . boolean (*_bfd_coff_pointerize_aux_hook) PARAMS ((
797 . combined_entry_type *table_base,
798 . combined_entry_type *symbol,
799 . unsigned int indaux,
800 . combined_entry_type *aux));
801 . boolean (*_bfd_coff_print_aux) PARAMS ((
804 . combined_entry_type *table_base,
805 . combined_entry_type *symbol,
806 . combined_entry_type *aux,
807 . unsigned int indaux));
808 . void (*_bfd_coff_reloc16_extra_cases) PARAMS ((
810 . struct bfd_link_info *link_info,
811 . struct bfd_link_order *link_order,
814 . unsigned int *src_ptr,
815 . unsigned int *dst_ptr));
816 . int (*_bfd_coff_reloc16_estimate) PARAMS ((
818 . asection *input_section,
820 . unsigned int shrink,
821 . struct bfd_link_info *link_info));
822 . boolean (*_bfd_coff_sym_is_global) PARAMS ((
824 . struct internal_syment *));
825 . boolean (*_bfd_coff_compute_section_file_positions) PARAMS ((
827 . boolean (*_bfd_coff_start_final_link) PARAMS ((
829 . struct bfd_link_info *info));
830 . boolean (*_bfd_coff_relocate_section) PARAMS ((
832 . struct bfd_link_info *info,
834 . asection *input_section,
835 . bfd_byte *contents,
836 . struct internal_reloc *relocs,
837 . struct internal_syment *syms,
838 . asection **sections));
839 . reloc_howto_type *(*_bfd_coff_rtype_to_howto) PARAMS ((
842 . struct internal_reloc *rel,
843 . struct coff_link_hash_entry *h,
844 . struct internal_syment *sym,
845 . bfd_vma *addendp));
846 . boolean (*_bfd_coff_adjust_symndx) PARAMS ((
848 . struct bfd_link_info *info,
851 . struct internal_reloc *reloc,
852 . boolean *adjustedp));
853 . boolean (*_bfd_coff_link_add_one_symbol) PARAMS ((
854 . struct bfd_link_info *info,
860 . const char *string,
863 . struct bfd_link_hash_entry **hashp));
865 . boolean (*_bfd_coff_link_output_has_begun) PARAMS ((
867 . boolean (*_bfd_coff_final_link_postscript) PARAMS ((
869 . struct coff_final_link_info * pfinfo));
871 .} bfd_coff_backend_data;
873 .#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
875 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
876 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
878 .#define bfd_coff_swap_sym_in(a,e,i) \
879 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
881 .#define bfd_coff_swap_lineno_in(a,e,i) \
882 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
884 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
885 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
887 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
888 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
890 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
891 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
893 .#define bfd_coff_swap_sym_out(abfd, i,o) \
894 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
896 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
897 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
899 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
900 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
902 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
903 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
905 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
906 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
907 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
908 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
909 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
910 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
911 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
912 .#define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames)
913 .#define bfd_coff_long_section_names(abfd) \
914 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
915 .#define bfd_coff_default_section_alignment_power(abfd) \
916 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
917 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
918 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
920 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
921 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
923 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
924 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
926 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
927 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
929 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
930 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
932 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
933 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
934 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
935 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
937 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name)\
938 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook) (abfd, scnhdr, name))
940 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
941 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
943 .#define bfd_coff_slurp_symbol_table(abfd)\
944 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
946 .#define bfd_coff_symname_in_debug(abfd, sym)\
947 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
949 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
950 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
951 . (abfd, file, base, symbol, aux, indaux))
953 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
954 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
955 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
957 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
958 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
959 . (abfd, section, reloc, shrink, link_info))
961 .#define bfd_coff_sym_is_global(abfd, sym)\
962 . ((coff_backend_info (abfd)->_bfd_coff_sym_is_global)\
965 .#define bfd_coff_compute_section_file_positions(abfd)\
966 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
969 .#define bfd_coff_start_final_link(obfd, info)\
970 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
972 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
973 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
974 . (obfd, info, ibfd, o, con, rel, isyms, secs))
975 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
976 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
977 . (abfd, sec, rel, h, sym, addendp))
978 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
979 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
980 . (obfd, info, ibfd, sec, rel, adjustedp))
981 .#define bfd_coff_link_add_one_symbol(info,abfd,name,flags,section,value,string,cp,coll,hashp)\
982 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
983 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
985 .#define bfd_coff_link_output_has_begun(a) \
986 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a))
987 .#define bfd_coff_final_link_postscript(a,p) \
988 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
992 /* See whether the magic number matches. */
995 coff_bad_format_hook (abfd
, filehdr
)
999 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1001 if (BADMAG (*internal_f
))
1004 /* if the optional header is NULL or not the correct size then
1005 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1006 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1007 optional header is of a different size.
1009 But the mips keeps extra stuff in it's opthdr, so dont check
1013 #if defined(M88) || defined(I960)
1014 if (internal_f
->f_opthdr
!= 0 && AOUTSZ
!= internal_f
->f_opthdr
)
1022 initialize a section structure with information peculiar to this
1023 particular implementation of coff
1027 coff_new_section_hook (abfd
, section
)
1031 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1034 if (xcoff_data (abfd
)->text_align_power
!= 0
1035 && strcmp (bfd_get_section_name (abfd
, section
), ".text") == 0)
1036 section
->alignment_power
= xcoff_data (abfd
)->text_align_power
;
1037 if (xcoff_data (abfd
)->data_align_power
!= 0
1038 && strcmp (bfd_get_section_name (abfd
, section
), ".data") == 0)
1039 section
->alignment_power
= xcoff_data (abfd
)->data_align_power
;
1042 /* Allocate aux records for section symbols, to store size and
1045 @@ The 10 is a guess at a plausible maximum number of aux entries
1046 (but shouldn't be a constant). */
1047 coffsymbol (section
->symbol
)->native
=
1048 (combined_entry_type
*) bfd_zalloc (abfd
,
1049 sizeof (combined_entry_type
) * 10);
1051 /* The .stab section must be aligned to 2**2 at most, because
1052 otherwise there may be gaps in the section which gdb will not
1053 know how to interpret. Examining the section name is a hack, but
1054 that is also how gdb locates the section.
1055 We need to handle the .ctors and .dtors sections similarly, to
1056 avoid introducing null words in the tables. */
1057 if (COFF_DEFAULT_SECTION_ALIGNMENT_POWER
> 2
1058 && (strncmp (section
->name
, ".stab", 5) == 0
1059 || strcmp (section
->name
, ".ctors") == 0
1060 || strcmp (section
->name
, ".dtors") == 0))
1061 section
->alignment_power
= 2;
1063 /* Similarly, the .stabstr section must be aligned to 2**0 at most. */
1064 if (COFF_DEFAULT_SECTION_ALIGNMENT_POWER
> 0
1065 && strncmp (section
->name
, ".stabstr", 8) == 0)
1066 section
->alignment_power
= 0;
1071 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1073 /* Set the alignment of a BFD section. */
1075 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1078 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1083 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1087 /* Extract ALIGN from 2**ALIGN stored in section header */
1088 for (i
= 0; i
< 32; i
++)
1089 if ((1 << i
) >= hdr
->s_align
)
1092 /* start-sanitize-tic80 */
1094 /* TI tools hijack bits 8-11 for the alignment */
1095 i
= (hdr
->s_flags
>> 8) & 0xF ;
1097 /* end-sanitize-tic80 */
1098 section
->alignment_power
= i
;
1101 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1104 /* a couple of macros to help setting the alignment power field */
1105 #define ALIGN_SET(field,x,y) \
1106 if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1108 section->alignment_power = y;\
1111 #define ELIFALIGN_SET(field,x,y) \
1112 else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1114 section->alignment_power = y;\
1117 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1120 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1125 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1127 ALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_64BYTES
, 6)
1128 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_32BYTES
, 5)
1129 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_16BYTES
, 4)
1130 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_8BYTES
, 3)
1131 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_4BYTES
, 2)
1132 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_2BYTES
, 1)
1133 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_1BYTES
, 0)
1135 #ifdef POWERPC_LE_PE
1136 if (strcmp (section
->name
, ".idata$2") == 0)
1138 section
->alignment_power
= 0;
1140 else if (strcmp (section
->name
, ".idata$3") == 0)
1142 section
->alignment_power
= 0;
1144 else if (strcmp (section
->name
, ".idata$4") == 0)
1146 section
->alignment_power
= 2;
1148 else if (strcmp (section
->name
, ".idata$5") == 0)
1150 section
->alignment_power
= 2;
1152 else if (strcmp (section
->name
, ".idata$6") == 0)
1154 section
->alignment_power
= 1;
1156 else if (strcmp (section
->name
, ".reloc") == 0)
1158 section
->alignment_power
= 1;
1160 else if (strncmp (section
->name
, ".stab", 5) == 0)
1162 section
->alignment_power
= 2;
1166 #ifdef COFF_IMAGE_WITH_PE
1167 /* In a PE image file, the s_paddr field holds the virtual size of a
1168 section, while the s_size field holds the raw size. */
1169 if (hdr
->s_paddr
!= 0)
1171 if (coff_section_data (abfd
, section
) == NULL
)
1173 section
->used_by_bfd
=
1174 (PTR
) bfd_zalloc (abfd
, sizeof (struct coff_section_tdata
));
1175 if (section
->used_by_bfd
== NULL
)
1177 /* FIXME: Return error. */
1181 if (pei_section_data (abfd
, section
) == NULL
)
1183 coff_section_data (abfd
, section
)->tdata
=
1184 (PTR
) bfd_zalloc (abfd
, sizeof (struct pei_section_tdata
));
1185 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1187 /* FIXME: Return error. */
1191 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1197 #undef ELIFALIGN_SET
1199 #else /* ! COFF_WITH_PE */
1202 /* We grossly abuse this function to handle XCOFF overflow headers.
1203 When we see one, we correct the reloc and line number counts in the
1204 real header, and remove the section we just created. */
1206 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1209 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1214 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1218 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1221 real_sec
= coff_section_from_bfd_index (abfd
, hdr
->s_nreloc
);
1222 if (real_sec
== NULL
)
1225 real_sec
->reloc_count
= hdr
->s_paddr
;
1226 real_sec
->lineno_count
= hdr
->s_vaddr
;
1228 for (ps
= &abfd
->sections
; *ps
!= NULL
; ps
= &(*ps
)->next
)
1233 --abfd
->section_count
;
1239 #else /* ! RS6000COFF_C */
1241 #define coff_set_alignment_hook \
1242 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1244 #endif /* ! RS6000COFF_C */
1245 #endif /* ! COFF_WITH_PE */
1246 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1248 #ifndef coff_mkobject
1250 static boolean coff_mkobject
PARAMS ((bfd
*));
1253 coff_mkobject (abfd
)
1256 coff_data_type
*coff
;
1258 abfd
->tdata
.coff_obj_data
= (struct coff_tdata
*) bfd_zalloc (abfd
, sizeof (coff_data_type
));
1259 if (abfd
->tdata
.coff_obj_data
== 0)
1261 coff
= coff_data (abfd
);
1262 coff
->symbols
= (coff_symbol_type
*) NULL
;
1263 coff
->conversion_table
= (unsigned int *) NULL
;
1264 coff
->raw_syments
= (struct coff_ptr_struct
*) NULL
;
1265 coff
->relocbase
= 0;
1266 coff
->local_toc_sym_map
= 0;
1268 /* make_abs_section(abfd);*/
1274 /* Create the COFF backend specific information. */
1275 #ifndef coff_mkobject_hook
1277 coff_mkobject_hook (abfd
, filehdr
, aouthdr
)
1282 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1283 coff_data_type
*coff
;
1285 if (coff_mkobject (abfd
) == false)
1288 coff
= coff_data (abfd
);
1290 coff
->sym_filepos
= internal_f
->f_symptr
;
1292 /* These members communicate important constants about the symbol
1293 table to GDB's symbol-reading code. These `constants'
1294 unfortunately vary among coff implementations... */
1295 coff
->local_n_btmask
= N_BTMASK
;
1296 coff
->local_n_btshft
= N_BTSHFT
;
1297 coff
->local_n_tmask
= N_TMASK
;
1298 coff
->local_n_tshift
= N_TSHIFT
;
1299 coff
->local_symesz
= SYMESZ
;
1300 coff
->local_auxesz
= AUXESZ
;
1301 coff
->local_linesz
= LINESZ
;
1303 obj_raw_syment_count (abfd
) =
1304 obj_conv_table_size (abfd
) =
1305 internal_f
->f_nsyms
;
1308 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
1309 abfd
->flags
|= DYNAMIC
;
1310 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= AOUTSZ
)
1312 struct internal_aouthdr
*internal_a
=
1313 (struct internal_aouthdr
*) aouthdr
;
1314 struct xcoff_tdata
*xcoff
;
1316 xcoff
= xcoff_data (abfd
);
1317 xcoff
->full_aouthdr
= true;
1318 xcoff
->toc
= internal_a
->o_toc
;
1319 xcoff
->sntoc
= internal_a
->o_sntoc
;
1320 xcoff
->snentry
= internal_a
->o_snentry
;
1321 xcoff
->text_align_power
= internal_a
->o_algntext
;
1322 xcoff
->data_align_power
= internal_a
->o_algndata
;
1323 xcoff
->modtype
= internal_a
->o_modtype
;
1324 xcoff
->cputype
= internal_a
->o_cputype
;
1325 xcoff
->maxdata
= internal_a
->o_maxdata
;
1326 xcoff
->maxstack
= internal_a
->o_maxstack
;
1330 #if defined ARM && ! defined COFF_WITH_PE
1331 /* Set the flags field from the COFF header read in */
1332 if (! coff_arm_bfd_set_private_flags (abfd
, internal_f
->f_flags
))
1340 /* Determine the machine architecture and type. FIXME: This is target
1341 dependent because the magic numbers are defined in the target
1342 dependent header files. But there is no particular need for this.
1343 If the magic numbers were moved to a separate file, this function
1344 would be target independent and would also be much more successful
1345 at linking together COFF files for different architectures. */
1348 coff_set_arch_mach_hook (abfd
, filehdr
)
1353 enum bfd_architecture arch
;
1354 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1357 switch (internal_f
->f_magic
)
1361 arch
= bfd_arch_powerpc
;
1362 machine
= 0; /* what does this mean? (krk) */
1368 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler */
1369 case LYNXCOFFMAGIC
: /* shadows the m68k Lynx number below, sigh */
1370 arch
= bfd_arch_i386
;
1374 #ifdef A29K_MAGIC_BIG
1375 case A29K_MAGIC_BIG
:
1376 case A29K_MAGIC_LITTLE
:
1377 arch
= bfd_arch_a29k
;
1383 arch
= bfd_arch_arm
;
1384 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
1386 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
1387 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
1388 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
1390 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
1391 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
1392 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
1399 #ifdef MC68KBCSMAGIC
1402 #ifdef APOLLOM68KMAGIC
1403 case APOLLOM68KMAGIC
:
1405 #ifdef LYNXCOFFMAGIC
1408 arch
= bfd_arch_m68k
;
1409 machine
= bfd_mach_m68020
;
1416 arch
= bfd_arch_m88k
;
1422 arch
= bfd_arch_z8k
;
1423 switch (internal_f
->f_flags
& F_MACHMASK
)
1426 machine
= bfd_mach_z8001
;
1429 machine
= bfd_mach_z8002
;
1438 arch
= bfd_arch_i860
;
1445 arch
= bfd_arch_i960
;
1446 switch (F_I960TYPE
& internal_f
->f_flags
)
1450 machine
= bfd_mach_i960_core
;
1453 machine
= bfd_mach_i960_kb_sb
;
1456 machine
= bfd_mach_i960_mc
;
1459 machine
= bfd_mach_i960_xa
;
1462 machine
= bfd_mach_i960_ca
;
1465 machine
= bfd_mach_i960_ka_sa
;
1468 machine
= bfd_mach_i960_jx
;
1471 machine
= bfd_mach_i960_hx
;
1485 if (xcoff_data (abfd
)->cputype
!= -1)
1486 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
1489 /* We did not get a value from the a.out header. If the
1490 file has not been stripped, we may be able to get the
1491 architecture information from the first symbol, if it
1492 is a .file symbol. */
1493 if (obj_raw_syment_count (abfd
) == 0)
1497 bfd_byte buf
[SYMESZ
];
1498 struct internal_syment sym
;
1500 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1501 || bfd_read (buf
, 1, SYMESZ
, abfd
) != SYMESZ
)
1503 coff_swap_sym_in (abfd
, (PTR
) buf
, (PTR
) &sym
);
1504 if (sym
.n_sclass
== C_FILE
)
1505 cputype
= sym
.n_type
& 0xff;
1511 /* FIXME: We don't handle all cases here. */
1517 /* PowerPC Macs use the same magic numbers as RS/6000
1518 (because that's how they were bootstrapped originally),
1519 but they are always PowerPC architecture. */
1520 arch
= bfd_arch_powerpc
;
1523 arch
= bfd_arch_rs6000
;
1525 #endif /* POWERMAC */
1529 arch
= bfd_arch_powerpc
;
1532 case 2: /* 64 bit PowerPC */
1533 arch
= bfd_arch_powerpc
;
1537 arch
= bfd_arch_powerpc
;
1541 arch
= bfd_arch_rs6000
;
1551 arch
= bfd_arch_we32k
;
1558 arch
= bfd_arch_h8300
;
1559 machine
= bfd_mach_h8300
;
1560 /* !! FIXME this probably isn't the right place for this */
1561 abfd
->flags
|= BFD_IS_RELAXABLE
;
1567 arch
= bfd_arch_h8300
;
1568 machine
= bfd_mach_h8300h
;
1569 /* !! FIXME this probably isn't the right place for this */
1570 abfd
->flags
|= BFD_IS_RELAXABLE
;
1576 arch
= bfd_arch_h8300
;
1577 machine
= bfd_mach_h8300s
;
1578 /* !! FIXME this probably isn't the right place for this */
1579 abfd
->flags
|= BFD_IS_RELAXABLE
;
1583 #ifdef SH_ARCH_MAGIC_BIG
1584 case SH_ARCH_MAGIC_BIG
:
1585 case SH_ARCH_MAGIC_LITTLE
:
1593 arch
= bfd_arch_h8500
;
1600 #ifdef LYNXCOFFMAGIC
1603 arch
= bfd_arch_sparc
;
1610 arch
= bfd_arch_tic30
;
1614 /* start-sanitize-tic80 */
1615 #ifdef TIC80_ARCH_MAGIC
1616 case TIC80_ARCH_MAGIC
:
1617 arch
= bfd_arch_tic80
;
1620 /* end-sanitize-tic80 */
1622 default: /* Unreadable input file type */
1623 arch
= bfd_arch_obscure
;
1627 bfd_default_set_arch_mach (abfd
, arch
, machine
);
1631 #ifdef SYMNAME_IN_DEBUG
1633 static boolean symname_in_debug_hook
1634 PARAMS ((bfd
*, struct internal_syment
*));
1637 symname_in_debug_hook (abfd
, sym
)
1639 struct internal_syment
*sym
;
1641 return SYMNAME_IN_DEBUG (sym
) ? true : false;
1646 #define symname_in_debug_hook \
1647 (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
1653 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
1655 static boolean coff_pointerize_aux_hook
1656 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
1657 unsigned int, combined_entry_type
*));
1661 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
1663 combined_entry_type
*table_base
;
1664 combined_entry_type
*symbol
;
1665 unsigned int indaux
;
1666 combined_entry_type
*aux
;
1668 int class = symbol
->u
.syment
.n_sclass
;
1670 if ((class == C_EXT
|| class == C_HIDEXT
)
1671 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
1673 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
1675 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
1676 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
1677 aux
->fix_scnlen
= 1;
1680 /* Return true to indicate that the caller should not do any
1681 further work on this auxent. */
1685 /* Return false to indicate that this auxent should be handled by
1693 /* We don't want to pointerize bal entries. */
1695 static boolean coff_pointerize_aux_hook
1696 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
1697 unsigned int, combined_entry_type
*));
1701 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
1703 combined_entry_type
*table_base
;
1704 combined_entry_type
*symbol
;
1705 unsigned int indaux
;
1706 combined_entry_type
*aux
;
1708 /* Return true if we don't want to pointerize this aux entry, which
1709 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
1711 && (symbol
->u
.syment
.n_sclass
== C_LEAFPROC
1712 || symbol
->u
.syment
.n_sclass
== C_LEAFSTAT
1713 || symbol
->u
.syment
.n_sclass
== C_LEAFEXT
));
1718 #define coff_pointerize_aux_hook 0
1721 #endif /* ! RS6000COFF_C */
1723 /* Print an aux entry. This returns true if it has printed it. */
1725 static boolean coff_print_aux
1726 PARAMS ((bfd
*, FILE *, combined_entry_type
*, combined_entry_type
*,
1727 combined_entry_type
*, unsigned int));
1730 coff_print_aux (abfd
, file
, table_base
, symbol
, aux
, indaux
)
1733 combined_entry_type
*table_base
;
1734 combined_entry_type
*symbol
;
1735 combined_entry_type
*aux
;
1736 unsigned int indaux
;
1739 if ((symbol
->u
.syment
.n_sclass
== C_EXT
1740 || symbol
->u
.syment
.n_sclass
== C_HIDEXT
)
1741 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
1743 /* This is a csect entry. */
1744 fprintf (file
, "AUX ");
1745 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
1747 BFD_ASSERT (! aux
->fix_scnlen
);
1748 fprintf (file
, "val %5ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
1752 fprintf (file
, "indx ");
1753 if (! aux
->fix_scnlen
)
1754 fprintf (file
, "%4ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
1756 fprintf (file
, "%4ld",
1757 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
1760 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
1761 aux
->u
.auxent
.x_csect
.x_parmhash
,
1762 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
1763 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
1764 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
1765 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
1766 aux
->u
.auxent
.x_csect
.x_stab
,
1767 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
1772 /* Return false to indicate that no special action was taken. */
1780 To write relocations, the back end steps though the
1781 canonical relocation table and create an
1782 @code{internal_reloc}. The symbol index to use is removed from
1783 the @code{offset} field in the symbol table supplied. The
1784 address comes directly from the sum of the section base
1785 address and the relocation offset; the type is dug directly
1786 from the howto field. Then the @code{internal_reloc} is
1787 swapped into the shape of an @code{external_reloc} and written
1794 static int compare_arelent_ptr
PARAMS ((const PTR
, const PTR
));
1796 /* AUX's ld wants relocations to be sorted */
1798 compare_arelent_ptr (x
, y
)
1802 const arelent
**a
= (const arelent
**) x
;
1803 const arelent
**b
= (const arelent
**) y
;
1804 bfd_size_type aadr
= (*a
)->address
;
1805 bfd_size_type badr
= (*b
)->address
;
1807 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
1810 #endif /* TARG_AUX */
1813 coff_write_relocs (abfd
, first_undef
)
1819 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
1822 struct external_reloc dst
;
1828 /* sort relocations before we write them out */
1829 p
= (arelent
**) bfd_malloc (s
->reloc_count
* sizeof (arelent
*));
1830 if (p
== NULL
&& s
->reloc_count
> 0)
1832 memcpy (p
, s
->orelocation
, s
->reloc_count
* sizeof (arelent
*));
1833 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
1836 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
1838 for (i
= 0; i
< s
->reloc_count
; i
++)
1840 struct internal_reloc n
;
1842 memset ((PTR
) & n
, 0, sizeof (n
));
1844 /* Now we've renumbered the symbols we know where the
1845 undefined symbols live in the table. Check the reloc
1846 entries for symbols who's output bfd isn't the right one.
1847 This is because the symbol was undefined (which means
1848 that all the pointers are never made to point to the same
1849 place). This is a bad thing,'cause the symbols attached
1850 to the output bfd are indexed, so that the relocation
1851 entries know which symbol index they point to. So we
1852 have to look up the output symbol here. */
1854 if (q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
1857 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
1858 asymbol
**outsyms
= abfd
->outsymbols
;
1859 for (i
= first_undef
; outsyms
[i
]; i
++)
1861 const char *intable
= outsyms
[i
]->name
;
1862 if (strcmp (intable
, sname
) == 0) {
1863 /* got a hit, so repoint the reloc */
1864 q
->sym_ptr_ptr
= outsyms
+ i
;
1870 n
.r_vaddr
= q
->address
+ s
->vma
;
1873 /* The 29k const/consth reloc pair is a real kludge. The consth
1874 part doesn't have a symbol; it has an offset. So rebuilt
1876 if (q
->howto
->type
== R_IHCONST
)
1877 n
.r_symndx
= q
->addend
;
1882 if (q
->sym_ptr_ptr
== bfd_abs_section_ptr
->symbol_ptr_ptr
)
1883 /* This is a relocation relative to the absolute symbol. */
1887 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
1888 /* Take notice if the symbol reloc points to a symbol
1889 we don't have in our symbol table. What should we
1891 if (n
.r_symndx
> obj_conv_table_size (abfd
))
1896 #ifdef SWAP_OUT_RELOC_OFFSET
1897 n
.r_offset
= q
->addend
;
1901 /* Work out reloc type from what is required */
1902 SELECT_RELOC (n
, q
->howto
);
1904 n
.r_type
= q
->howto
->type
;
1906 coff_swap_reloc_out (abfd
, &n
, &dst
);
1907 if (bfd_write ((PTR
) & dst
, 1, RELSZ
, abfd
) != RELSZ
)
1920 /* Set flags and magic number of a coff file from architecture and machine
1921 type. Result is true if we can represent the arch&type, false if not. */
1924 coff_set_flags (abfd
, magicp
, flagsp
)
1926 unsigned int *magicp
;
1927 unsigned short *flagsp
;
1929 switch (bfd_get_arch (abfd
))
1934 switch (bfd_get_mach (abfd
))
1936 case bfd_mach_z8001
:
1939 case bfd_mach_z8002
:
1953 *magicp
= I960ROMAGIC
;
1955 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1956 I960RWMAGIC); FIXME???
1958 switch (bfd_get_mach (abfd
))
1960 case bfd_mach_i960_core
:
1963 case bfd_mach_i960_kb_sb
:
1966 case bfd_mach_i960_mc
:
1969 case bfd_mach_i960_xa
:
1972 case bfd_mach_i960_ca
:
1975 case bfd_mach_i960_ka_sa
:
1978 case bfd_mach_i960_jx
:
1981 case bfd_mach_i960_hx
:
1994 case bfd_arch_tic30
:
1995 *magicp
= TIC30MAGIC
;
1998 /* start-sanitize-tic80 */
1999 #ifdef TIC80_ARCH_MAGIC
2000 case bfd_arch_tic80
:
2001 *magicp
= TIC80_ARCH_MAGIC
;
2004 /* end-sanitize-tic80 */
2007 * magicp
= ARMMAGIC
;
2009 if (APCS_SET (abfd
))
2011 if (APCS_26_FLAG (abfd
))
2012 * flagsp
|= F_APCS26
;
2014 if (APCS_FLOAT_FLAG (abfd
))
2015 * flagsp
|= F_APCS_FLOAT
;
2017 if (PIC_FLAG (abfd
))
2020 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2021 * flagsp
|= F_INTERWORK
;
2022 switch (bfd_get_mach (abfd
))
2024 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2025 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2026 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2027 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2028 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2029 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2034 case bfd_arch_powerpc
:
2041 *magicp
= I386MAGIC
;
2043 /* Just overwrite the usual value if we're doing Lynx. */
2044 *magicp
= LYNXCOFFMAGIC
;
2051 *magicp
= I860MAGIC
;
2057 #ifdef APOLLOM68KMAGIC
2058 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
2060 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2061 #ifdef NAMES_HAVE_UNDERSCORE
2062 *magicp
= MC68KBCSMAGIC
;
2064 *magicp
= MC68MAGIC
;
2068 /* Just overwrite the usual value if we're doing Lynx. */
2069 *magicp
= LYNXCOFFMAGIC
;
2077 *magicp
= MC88OMAGIC
;
2082 case bfd_arch_h8300
:
2083 switch (bfd_get_mach (abfd
))
2085 case bfd_mach_h8300
:
2086 *magicp
= H8300MAGIC
;
2088 case bfd_mach_h8300h
:
2089 *magicp
= H8300HMAGIC
;
2091 case bfd_mach_h8300s
:
2092 *magicp
= H8300SMAGIC
;
2098 #ifdef SH_ARCH_MAGIC_BIG
2100 if (bfd_big_endian (abfd
))
2101 *magicp
= SH_ARCH_MAGIC_BIG
;
2103 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2109 case bfd_arch_sparc
:
2110 *magicp
= SPARCMAGIC
;
2112 /* Just overwrite the usual value if we're doing Lynx. */
2113 *magicp
= LYNXCOFFMAGIC
;
2120 case bfd_arch_h8500
:
2121 *magicp
= H8500MAGIC
;
2125 #ifdef A29K_MAGIC_BIG
2127 if (bfd_big_endian (abfd
))
2128 *magicp
= A29K_MAGIC_BIG
;
2130 *magicp
= A29K_MAGIC_LITTLE
;
2136 case bfd_arch_we32k
:
2137 *magicp
= WE32KMAGIC
;
2143 case bfd_arch_rs6000
:
2145 case bfd_arch_powerpc
:
2147 *magicp
= U802TOCMAGIC
;
2152 default: /* Unknown architecture */
2153 /* return false; -- fall through to "return false" below, to avoid
2154 "statement never reached" errors on the one below. */
2163 coff_set_arch_mach (abfd
, arch
, machine
)
2165 enum bfd_architecture arch
;
2166 unsigned long machine
;
2169 unsigned short dummy2
;
2171 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
2174 if (arch
!= bfd_arch_unknown
&&
2175 coff_set_flags (abfd
, &dummy1
, &dummy2
) != true)
2176 return false; /* We can't represent this type */
2178 return true; /* We're easy ... */
2182 /* Calculate the file position for each section. */
2185 #define ALIGN_SECTIONS_IN_FILE
2187 /* start-sanitize-tic80 */
2189 #undef ALIGN_SECTIONS_IN_FILE
2191 /* end-sanitize-tic80 */
2194 coff_compute_section_file_positions (abfd
)
2198 asection
*previous
= (asection
*) NULL
;
2199 file_ptr sofar
= FILHSZ
;
2200 boolean align_adjust
;
2208 /* On XCOFF, if we have symbols, set up the .debug section. */
2209 if (bfd_get_symcount (abfd
) > 0)
2212 bfd_size_type i
, symcount
;
2216 symcount
= bfd_get_symcount (abfd
);
2217 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
2219 coff_symbol_type
*cf
;
2221 cf
= coff_symbol_from (abfd
, *symp
);
2223 && cf
->native
!= NULL
2224 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
2228 len
= strlen (bfd_asymbol_name (*symp
));
2237 dsec
= bfd_make_section_old_way (abfd
, ".debug");
2240 dsec
->_raw_size
= sz
;
2241 dsec
->flags
|= SEC_HAS_CONTENTS
;
2246 #ifdef COFF_IMAGE_WITH_PE
2248 if (coff_data (abfd
)->link_info
)
2250 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
2253 page_size
= PE_DEF_FILE_ALIGNMENT
;
2255 #ifdef COFF_PAGE_SIZE
2256 int page_size
= COFF_PAGE_SIZE
;
2260 if (bfd_get_start_address (abfd
))
2262 /* A start address may have been added to the original file. In this
2263 case it will need an optional header to record it. */
2264 abfd
->flags
|= EXEC_P
;
2267 if (abfd
->flags
& EXEC_P
)
2270 else if (xcoff_data (abfd
)->full_aouthdr
)
2273 sofar
+= SMALL_AOUTSZ
;
2276 sofar
+= abfd
->section_count
* SCNHSZ
;
2279 /* XCOFF handles overflows in the reloc and line number count fields
2280 by allocating a new section header to hold the correct counts. */
2281 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2282 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
2286 align_adjust
= false;
2287 for (current
= abfd
->sections
, count
= 1;
2288 current
!= (asection
*) NULL
;
2289 current
= current
->next
, ++count
)
2291 #ifdef COFF_IMAGE_WITH_PE
2292 /* The NT loader does not want empty section headers, so we omit
2293 them. We don't actually remove the section from the BFD,
2294 although we probably should. This matches code in
2295 coff_write_object_contents. */
2296 if (current
->_raw_size
== 0)
2298 current
->target_index
= -1;
2304 current
->target_index
= count
;
2306 /* Only deal with sections which have contents */
2307 if (!(current
->flags
& SEC_HAS_CONTENTS
))
2310 /* Align the sections in the file to the same boundary on
2311 which they are aligned in virtual memory. I960 doesn't
2312 do this (FIXME) so we can stay in sync with Intel. 960
2313 doesn't yet page from files... */
2314 #ifdef ALIGN_SECTIONS_IN_FILE
2315 if ((abfd
->flags
& EXEC_P
) != 0)
2317 /* make sure this section is aligned on the right boundary - by
2318 padding the previous section up if necessary */
2321 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
2322 if (previous
!= (asection
*) NULL
)
2324 previous
->_raw_size
+= sofar
- old_sofar
;
2330 /* In demand paged files the low order bits of the file offset
2331 must match the low order bits of the virtual address. */
2332 #ifdef COFF_PAGE_SIZE
2333 if ((abfd
->flags
& D_PAGED
) != 0
2334 && (current
->flags
& SEC_ALLOC
) != 0)
2335 sofar
+= (current
->vma
- sofar
) % page_size
;
2337 current
->filepos
= sofar
;
2339 #ifdef COFF_IMAGE_WITH_PE
2340 /* With PE we have to pad each section to be a multiple of its
2341 page size too, and remember both sizes. */
2343 if (coff_section_data (abfd
, current
) == NULL
)
2345 current
->used_by_bfd
=
2346 (PTR
) bfd_zalloc (abfd
, sizeof (struct coff_section_tdata
));
2347 if (current
->used_by_bfd
== NULL
)
2350 if (pei_section_data (abfd
, current
) == NULL
)
2352 coff_section_data (abfd
, current
)->tdata
=
2353 (PTR
) bfd_zalloc (abfd
, sizeof (struct pei_section_tdata
));
2354 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
2357 if (pei_section_data (abfd
, current
)->virt_size
== 0)
2358 pei_section_data (abfd
, current
)->virt_size
= current
->_raw_size
;
2360 current
->_raw_size
= (current
->_raw_size
+ page_size
-1) & -page_size
;
2363 sofar
+= current
->_raw_size
;
2365 #ifdef ALIGN_SECTIONS_IN_FILE
2366 /* make sure that this section is of the right size too */
2367 if ((abfd
->flags
& EXEC_P
) == 0)
2369 bfd_size_type old_size
;
2371 old_size
= current
->_raw_size
;
2372 current
->_raw_size
= BFD_ALIGN (current
->_raw_size
,
2373 1 << current
->alignment_power
);
2374 align_adjust
= current
->_raw_size
!= old_size
;
2375 sofar
+= current
->_raw_size
- old_size
;
2380 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
2381 align_adjust
= sofar
!= old_sofar
;
2382 current
->_raw_size
+= sofar
- old_sofar
;
2386 #ifdef COFF_IMAGE_WITH_PE
2387 /* For PE we need to make sure we pad out to the aligned
2388 _raw_size, in case the caller only writes out data to the
2389 unaligned _raw_size. */
2390 if (pei_section_data (abfd
, current
)->virt_size
< current
->_raw_size
)
2391 align_adjust
= true;
2395 /* Force .lib sections to start at zero. The vma is then
2396 incremented in coff_set_section_contents. This is right for
2398 if (strcmp (current
->name
, _LIB
) == 0)
2399 bfd_set_section_vma (abfd
, current
, 0);
2405 /* It is now safe to write to the output file. If we needed an
2406 alignment adjustment for the last section, then make sure that
2407 there is a byte at offset sofar. If there are no symbols and no
2408 relocs, then nothing follows the last section. If we don't force
2409 the last byte out, then the file may appear to be truncated. */
2415 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
2416 || bfd_write (&b
, 1, 1, abfd
) != 1)
2420 /* Make sure the relocations are aligned. We don't need to make
2421 sure that this byte exists, because it will only matter if there
2422 really are relocs. */
2423 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
2425 obj_relocbase (abfd
) = sofar
;
2426 abfd
->output_has_begun
= true;
2433 /* This can never work, because it is called too late--after the
2434 section positions have been set. I can't figure out what it is
2435 for, so I am going to disable it--Ian Taylor 20 March 1996. */
2437 /* If .file, .text, .data, .bss symbols are missing, add them. */
2438 /* @@ Should we only be adding missing symbols, or overriding the aux
2439 values for existing section symbols? */
2441 coff_add_missing_symbols (abfd
)
2444 unsigned int nsyms
= bfd_get_symcount (abfd
);
2445 asymbol
**sympp
= abfd
->outsymbols
;
2448 int need_text
= 1, need_data
= 1, need_bss
= 1, need_file
= 1;
2450 for (i
= 0; i
< nsyms
; i
++)
2452 coff_symbol_type
*csym
= coff_symbol_from (abfd
, sympp
[i
]);
2456 /* only do this if there is a coff representation of the input
2458 if (csym
->native
&& csym
->native
->u
.syment
.n_sclass
== C_FILE
)
2463 name
= csym
->symbol
.name
;
2466 if (!strcmp (name
, _TEXT
))
2469 else if (!strcmp (name
, ".wtext"))
2472 else if (!strcmp (name
, _DATA
))
2474 else if (!strcmp (name
, _BSS
))
2478 /* Now i == bfd_get_symcount (abfd). */
2479 /* @@ For now, don't deal with .file symbol. */
2482 if (!need_text
&& !need_data
&& !need_bss
&& !need_file
)
2484 nsyms
+= need_text
+ need_data
+ need_bss
+ need_file
;
2485 sympp2
= (asymbol
**) bfd_alloc (abfd
, nsyms
* sizeof (asymbol
*));
2488 memcpy (sympp2
, sympp
, i
* sizeof (asymbol
*));
2491 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
2495 sympp2
[i
++] = coff_section_symbol (abfd
, _TEXT
);
2497 sympp2
[i
++] = coff_section_symbol (abfd
, _DATA
);
2499 sympp2
[i
++] = coff_section_symbol (abfd
, _BSS
);
2500 BFD_ASSERT (i
== nsyms
);
2501 bfd_set_symtab (abfd
, sympp2
, nsyms
);
2510 coff_write_object_contents (abfd
)
2514 boolean hasrelocs
= false;
2515 boolean haslinno
= false;
2517 file_ptr reloc_base
;
2518 file_ptr lineno_base
;
2520 unsigned long reloc_size
= 0;
2521 unsigned long lnno_size
= 0;
2522 boolean long_section_names
;
2523 asection
*text_sec
= NULL
;
2524 asection
*data_sec
= NULL
;
2525 asection
*bss_sec
= NULL
;
2526 struct internal_filehdr internal_f
;
2527 struct internal_aouthdr internal_a
;
2528 #ifdef COFF_LONG_SECTION_NAMES
2529 size_t string_size
= STRING_SIZE_SIZE
;
2532 bfd_set_error (bfd_error_system_call
);
2534 /* Make a pass through the symbol table to count line number entries and
2535 put them into the correct asections */
2537 lnno_size
= coff_count_linenumbers (abfd
) * LINESZ
;
2539 if (abfd
->output_has_begun
== false)
2541 if (! coff_compute_section_file_positions (abfd
))
2545 reloc_base
= obj_relocbase (abfd
);
2547 /* Work out the size of the reloc and linno areas */
2549 for (current
= abfd
->sections
; current
!= NULL
; current
=
2551 reloc_size
+= current
->reloc_count
* RELSZ
;
2553 lineno_base
= reloc_base
+ reloc_size
;
2554 sym_base
= lineno_base
+ lnno_size
;
2556 /* Indicate in each section->line_filepos its actual file address */
2557 for (current
= abfd
->sections
; current
!= NULL
; current
=
2560 if (current
->lineno_count
)
2562 current
->line_filepos
= lineno_base
;
2563 current
->moving_line_filepos
= lineno_base
;
2564 lineno_base
+= current
->lineno_count
* LINESZ
;
2568 current
->line_filepos
= 0;
2570 if (current
->reloc_count
)
2572 current
->rel_filepos
= reloc_base
;
2573 reloc_base
+= current
->reloc_count
* RELSZ
;
2577 current
->rel_filepos
= 0;
2581 /* Write section headers to the file. */
2582 internal_f
.f_nscns
= 0;
2584 if ((abfd
->flags
& EXEC_P
) != 0)
2585 scn_base
= FILHSZ
+ AOUTSZ
;
2590 if (xcoff_data (abfd
)->full_aouthdr
)
2593 scn_base
+= SMALL_AOUTSZ
;
2597 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
2600 long_section_names
= false;
2601 for (current
= abfd
->sections
;
2603 current
= current
->next
)
2605 struct internal_scnhdr section
;
2608 /* If we've got a .reloc section, remember. */
2610 #ifdef COFF_IMAGE_WITH_PE
2611 if (strcmp (current
->name
, ".reloc") == 0)
2613 pe_data (abfd
)->has_reloc_section
= 1;
2618 internal_f
.f_nscns
++;
2620 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
2622 #ifdef COFF_LONG_SECTION_NAMES
2623 /* Handle long section names as in PE. This must be compatible
2624 with the code in coff_write_symbols. */
2628 len
= strlen (current
->name
);
2631 memset (section
.s_name
, 0, SCNNMLEN
);
2632 sprintf (section
.s_name
, "/%lu", (unsigned long) string_size
);
2633 string_size
+= len
+ 1;
2634 long_section_names
= true;
2640 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
2641 Ian Taylor <ian@cygnus.com>. */
2642 if (strcmp (current
->name
, _LIB
) == 0)
2643 section
.s_vaddr
= 0;
2646 section
.s_vaddr
= current
->vma
;
2647 section
.s_paddr
= current
->lma
;
2648 section
.s_size
= current
->_raw_size
;
2651 section
.s_paddr
= 0;
2653 #ifdef COFF_IMAGE_WITH_PE
2654 /* Reminder: s_paddr holds the virtual size of the section. */
2655 if (coff_section_data (abfd
, current
) != NULL
2656 && pei_section_data (abfd
, current
) != NULL
)
2657 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
2659 section
.s_paddr
= 0;
2663 If this section has no size or is unloadable then the scnptr
2666 if (current
->_raw_size
== 0 ||
2667 (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2669 section
.s_scnptr
= 0;
2673 section
.s_scnptr
= current
->filepos
;
2675 section
.s_relptr
= current
->rel_filepos
;
2676 section
.s_lnnoptr
= current
->line_filepos
;
2677 section
.s_nreloc
= current
->reloc_count
;
2678 section
.s_nlnno
= current
->lineno_count
;
2679 if (current
->reloc_count
!= 0)
2681 if (current
->lineno_count
!= 0)
2685 /* Indicate the use of an XCOFF overflow section header. */
2686 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
2688 section
.s_nreloc
= 0xffff;
2689 section
.s_nlnno
= 0xffff;
2693 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
2695 if (!strcmp (current
->name
, _TEXT
))
2699 else if (!strcmp (current
->name
, _DATA
))
2703 else if (!strcmp (current
->name
, _BSS
))
2709 section
.s_align
= (current
->alignment_power
2710 ? 1 << current
->alignment_power
2712 /* start-sanitize-tic80 */
2715 section
.s_flags
|= (current
->alignment_power
& 0xF) << 8;
2717 /* end-sanitize-tic80 */
2720 #ifdef COFF_IMAGE_WITH_PE
2721 /* suppress output of the sections if they are null. ld includes
2722 the bss and data sections even if there is no size assigned
2723 to them. NT loader doesn't like it if these section headers are
2724 included if the sections themselves are not needed */
2725 if (section
.s_size
== 0)
2726 internal_f
.f_nscns
--;
2731 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
2732 || bfd_write ((PTR
) (&buff
), 1, SCNHSZ
, abfd
) != SCNHSZ
)
2737 /* PE stores COMDAT section information in the symbol table. If
2738 this section is supposed to have some COMDAT info, track down
2739 the symbol in the symbol table and modify it. */
2740 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
2742 unsigned int i
, count
;
2744 coff_symbol_type
*csym
;
2746 count
= bfd_get_symcount (abfd
);
2747 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
2749 /* Here *PSYM is the section symbol for CURRENT. */
2751 if (strcmp ((*psym
)->name
, current
->name
) == 0)
2753 csym
= coff_symbol_from (abfd
, *psym
);
2755 || csym
->native
== NULL
2756 || csym
->native
->u
.syment
.n_numaux
< 1
2757 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
2758 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
2765 Note that we might not if we're converting the file from
2766 some other object file format. */
2769 combined_entry_type
*aux
;
2771 /* We don't touch the x_checksum field. The
2772 x_associated field is not currently supported. */
2774 aux
= csym
->native
+ 1;
2775 switch (current
->flags
& SEC_LINK_DUPLICATES
)
2777 case SEC_LINK_DUPLICATES_DISCARD
:
2778 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
2781 case SEC_LINK_DUPLICATES_ONE_ONLY
:
2782 aux
->u
.auxent
.x_scn
.x_comdat
=
2783 IMAGE_COMDAT_SELECT_NODUPLICATES
;
2786 case SEC_LINK_DUPLICATES_SAME_SIZE
:
2787 aux
->u
.auxent
.x_scn
.x_comdat
=
2788 IMAGE_COMDAT_SELECT_SAME_SIZE
;
2791 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
2792 aux
->u
.auxent
.x_scn
.x_comdat
=
2793 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
2798 #endif /* COFF_WITH_PE */
2802 /* XCOFF handles overflows in the reloc and line number count fields
2803 by creating a new section header to hold the correct values. */
2804 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2806 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
2808 struct internal_scnhdr scnhdr
;
2811 internal_f
.f_nscns
++;
2812 strncpy (&(scnhdr
.s_name
[0]), current
->name
, 8);
2813 scnhdr
.s_paddr
= current
->reloc_count
;
2814 scnhdr
.s_vaddr
= current
->lineno_count
;
2816 scnhdr
.s_scnptr
= 0;
2817 scnhdr
.s_relptr
= current
->rel_filepos
;
2818 scnhdr
.s_lnnoptr
= current
->line_filepos
;
2819 scnhdr
.s_nreloc
= current
->target_index
;
2820 scnhdr
.s_nlnno
= current
->target_index
;
2821 scnhdr
.s_flags
= STYP_OVRFLO
;
2822 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
2823 || bfd_write ((PTR
) &buff
, 1, SCNHSZ
, abfd
) != SCNHSZ
)
2829 /* OK, now set up the filehdr... */
2831 /* Don't include the internal abs section in the section count */
2834 We will NOT put a fucking timestamp in the header here. Every time you
2835 put it back, I will come in and take it out again. I'm sorry. This
2836 field does not belong here. We fill it with a 0 so it compares the
2837 same but is not a reasonable time. -- gnu@cygnus.com
2839 internal_f
.f_timdat
= 0;
2841 internal_f
.f_flags
= 0;
2843 if (abfd
->flags
& EXEC_P
)
2844 internal_f
.f_opthdr
= AOUTSZ
;
2847 internal_f
.f_opthdr
= 0;
2849 if (xcoff_data (abfd
)->full_aouthdr
)
2850 internal_f
.f_opthdr
= AOUTSZ
;
2852 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
2857 internal_f
.f_flags
|= F_RELFLG
;
2859 internal_f
.f_flags
|= F_LNNO
;
2860 if (abfd
->flags
& EXEC_P
)
2861 internal_f
.f_flags
|= F_EXEC
;
2863 /* FIXME: this is wrong for PPC_PE! */
2864 if (bfd_little_endian (abfd
))
2865 internal_f
.f_flags
|= F_AR32WR
;
2867 internal_f
.f_flags
|= F_AR32W
;
2869 /* start-sanitize-tic80 */
2870 #ifdef TIC80_TARGET_ID
2871 internal_f
.f_target_id
= TIC80_TARGET_ID
;
2873 /* end-sanitize-tic80 */
2876 FIXME, should do something about the other byte orders and
2881 if ((abfd
->flags
& DYNAMIC
) != 0)
2882 internal_f
.f_flags
|= F_SHROBJ
;
2883 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
2884 internal_f
.f_flags
|= F_DYNLOAD
;
2887 memset (&internal_a
, 0, sizeof internal_a
);
2889 /* Set up architecture-dependent stuff */
2892 unsigned int magic
= 0;
2893 unsigned short flags
= 0;
2894 coff_set_flags (abfd
, &magic
, &flags
);
2895 internal_f
.f_magic
= magic
;
2896 internal_f
.f_flags
|= flags
;
2897 /* ...and the "opt"hdr... */
2900 #ifdef ULTRA3 /* NYU's machine */
2901 /* FIXME: This is a bogus check. I really want to see if there
2902 * is a .shbss or a .shdata section, if so then set the magic
2903 * number to indicate a shared data executable.
2905 if (internal_f
.f_nscns
>= 7)
2906 internal_a
.magic
= SHMAGIC
; /* Shared magic */
2909 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
2910 #define __A_MAGIC_SET__
2912 /* start-sanitize-tic80 */
2914 internal_a
.magic
= TIC80_ARCH_MAGIC
;
2915 #define __A_MAGIC_SET__
2917 /* end-sanitize-tic80 */
2919 /* FIXME: What are the a.out magic numbers for the i860? */
2920 internal_a
.magic
= 0;
2921 #define __A_MAGIC_SET__
2924 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
2925 #define __A_MAGIC_SET__
2928 #define __A_MAGIC_SET__
2929 internal_a
.magic
= PAGEMAGICBCS
;
2933 #define __A_MAGIC_SET__
2934 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
2937 #if defined(M68) || defined(WE32K) || defined(M68K)
2938 #define __A_MAGIC_SET__
2940 internal_a
.magic
= LYNXCOFFMAGIC
;
2942 #if defined(TARG_AUX)
2943 internal_a
.magic
= (abfd
->flags
& D_PAGED
? PAGEMAGICPEXECPAGED
:
2944 abfd
->flags
& WP_TEXT
? PAGEMAGICPEXECSWAPPED
:
2945 PAGEMAGICEXECSWAPPED
);
2947 #if defined (PAGEMAGICPEXECPAGED)
2948 internal_a
.magic
= PAGEMAGICPEXECPAGED
;
2950 #endif /* TARG_AUX */
2952 #endif /* M68 || WE32K || M68K */
2955 #define __A_MAGIC_SET__
2956 internal_a
.magic
= ZMAGIC
;
2960 #define __A_MAGIC_SET__
2961 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
2965 #define __A_MAGIC_SET__
2967 internal_a
.magic
= LYNXCOFFMAGIC
;
2969 internal_a
.magic
= ZMAGIC
;
2974 #define __A_MAGIC_SET__
2976 internal_a
.magic
= LYNXCOFFMAGIC
;
2981 #define __A_MAGIC_SET__
2982 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
2983 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
2984 RS6K_AOUTHDR_OMAGIC
;
2987 #ifndef __A_MAGIC_SET__
2988 #include "Your aouthdr magic number is not being set!"
2990 #undef __A_MAGIC_SET__
2994 /* FIXME: Does anybody ever set this to another value? */
2995 internal_a
.vstamp
= 0;
2997 /* Now should write relocs, strings, syms */
2998 obj_sym_filepos (abfd
) = sym_base
;
3000 if (bfd_get_symcount (abfd
) != 0)
3004 if (!coff_add_missing_symbols (abfd
))
3007 if (!coff_renumber_symbols (abfd
, &firstundef
))
3009 coff_mangle_symbols (abfd
);
3010 if (! coff_write_symbols (abfd
))
3012 if (! coff_write_linenumbers (abfd
))
3014 if (! coff_write_relocs (abfd
, firstundef
))
3017 #ifdef COFF_IMAGE_WITH_PE
3019 else if ((abfd
->flags
& EXEC_P
) != 0)
3023 /* PowerPC PE appears to require that all executable files be
3024 rounded up to the page size. */
3027 BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
3029 || bfd_write (&b
, 1, 1, abfd
) != 1)
3035 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3036 backend linker, and obj_raw_syment_count is not valid until after
3037 coff_write_symbols is called. */
3038 if (obj_raw_syment_count (abfd
) != 0)
3040 internal_f
.f_symptr
= sym_base
;
3042 /* AIX appears to require that F_RELFLG not be set if there are
3043 local symbols but no relocations. */
3044 internal_f
.f_flags
&=~ F_RELFLG
;
3049 if (long_section_names
)
3050 internal_f
.f_symptr
= sym_base
;
3052 internal_f
.f_symptr
= 0;
3053 internal_f
.f_flags
|= F_LSYMS
;
3058 internal_a
.tsize
= bfd_get_section_size_before_reloc (text_sec
);
3059 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
3063 internal_a
.dsize
= bfd_get_section_size_before_reloc (data_sec
);
3064 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
3068 internal_a
.bsize
= bfd_get_section_size_before_reloc (bss_sec
);
3069 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
3070 internal_a
.data_start
= bss_sec
->vma
;
3073 internal_a
.entry
= bfd_get_start_address (abfd
);
3074 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
3077 if (xcoff_data (abfd
)->full_aouthdr
)
3080 asection
*loader_sec
;
3082 internal_a
.vstamp
= 1;
3084 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
3085 if (internal_a
.o_snentry
== 0)
3086 internal_a
.entry
= (bfd_vma
) -1;
3088 if (text_sec
!= NULL
)
3090 internal_a
.o_sntext
= text_sec
->target_index
;
3091 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
3095 internal_a
.o_sntext
= 0;
3096 internal_a
.o_algntext
= 0;
3098 if (data_sec
!= NULL
)
3100 internal_a
.o_sndata
= data_sec
->target_index
;
3101 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
3105 internal_a
.o_sndata
= 0;
3106 internal_a
.o_algndata
= 0;
3108 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
3109 if (loader_sec
!= NULL
)
3110 internal_a
.o_snloader
= loader_sec
->target_index
;
3112 internal_a
.o_snloader
= 0;
3113 if (bss_sec
!= NULL
)
3114 internal_a
.o_snbss
= bss_sec
->target_index
;
3116 internal_a
.o_snbss
= 0;
3118 toc
= xcoff_data (abfd
)->toc
;
3119 internal_a
.o_toc
= toc
;
3120 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
3122 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
3123 if (xcoff_data (abfd
)->cputype
!= -1)
3124 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
3127 switch (bfd_get_arch (abfd
))
3129 case bfd_arch_rs6000
:
3130 internal_a
.o_cputype
= 4;
3132 case bfd_arch_powerpc
:
3133 if (bfd_get_mach (abfd
) == 0)
3134 internal_a
.o_cputype
= 3;
3136 internal_a
.o_cputype
= 1;
3142 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
3143 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
3147 /* now write them */
3148 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
3152 coff_swap_filehdr_out (abfd
, (PTR
) & internal_f
, (PTR
) buff
);
3153 if (bfd_write ((PTR
) buff
, 1, FILHSZ
, abfd
) != FILHSZ
)
3156 if (abfd
->flags
& EXEC_P
)
3158 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
3159 include/coff/pe.h sets AOUTSZ == sizeof(PEAOUTHDR)) */
3161 coff_swap_aouthdr_out (abfd
, (PTR
) & internal_a
, (PTR
) buff
);
3162 if (bfd_write ((PTR
) buff
, 1, AOUTSZ
, abfd
) != AOUTSZ
)
3171 /* XCOFF seems to always write at least a small a.out header. */
3172 coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, (PTR
) &buff
);
3173 if (xcoff_data (abfd
)->full_aouthdr
)
3176 size
= SMALL_AOUTSZ
;
3177 if (bfd_write ((PTR
) &buff
, 1, size
, abfd
) != size
)
3186 coff_set_section_contents (abfd
, section
, location
, offset
, count
)
3191 bfd_size_type count
;
3193 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
3195 if (! coff_compute_section_file_positions (abfd
))
3199 #if defined(_LIB) && !defined(TARG_AUX)
3201 /* The physical address field of a .lib section is used to hold the
3202 number of shared libraries in the section. This code counts the
3203 number of sections being written, and increments the lma field
3206 I have found no documentation on the contents of this section.
3207 Experimentation indicates that the section contains zero or more
3208 records, each of which has the following structure:
3210 - a (four byte) word holding the length of this record, in words,
3211 - a word that always seems to be set to "2",
3212 - the path to a shared library, null-terminated and then padded
3213 to a whole word boundary.
3215 bfd_assert calls have been added to alert if an attempt is made
3216 to write a section which doesn't follow these assumptions. The
3217 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
3218 <robertl@arnet.com> (Thanks!).
3220 Gvran Uddeborg <gvran@uddeborg.pp.se> */
3222 if (strcmp (section
->name
, _LIB
) == 0)
3224 bfd_byte
*rec
, *recend
;
3226 rec
= (bfd_byte
*) location
;
3227 recend
= rec
+ count
;
3228 while (rec
< recend
)
3231 rec
+= bfd_get_32 (abfd
, rec
) * 4;
3234 BFD_ASSERT (rec
== recend
);
3239 /* Don't write out bss sections - one way to do this is to
3240 see if the filepos has not been set. */
3241 if (section
->filepos
== 0)
3244 if (bfd_seek (abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
) != 0)
3249 return (bfd_write (location
, 1, count
, abfd
) == count
) ? true : false;
3255 coff_close_and_cleanup (abfd
)
3258 if (!bfd_read_p (abfd
))
3259 switch (abfd
->format
)
3262 if (!_bfd_write_archive_contents (abfd
))
3266 if (!coff_write_object_contents (abfd
))
3270 bfd_set_error (bfd_error_invalid_operation
);
3274 /* We depend on bfd_close to free all the memory on the objalloc. */
3281 buy_and_read (abfd
, where
, seek_direction
, size
)
3287 PTR area
= (PTR
) bfd_alloc (abfd
, size
);
3290 if (bfd_seek (abfd
, where
, seek_direction
) != 0
3291 || bfd_read (area
, 1, size
, abfd
) != size
)
3294 } /* buy_and_read() */
3300 Creating the linenumber table is done by reading in the entire
3301 coff linenumber table, and creating another table for internal use.
3303 A coff linenumber table is structured so that each function
3304 is marked as having a line number of 0. Each line within the
3305 function is an offset from the first line in the function. The
3306 base of the line number information for the table is stored in
3307 the symbol associated with the function.
3309 The information is copied from the external to the internal
3310 table, and each symbol which marks a function is marked by
3313 How does this work ?
3318 coff_slurp_line_table (abfd
, asect
)
3322 LINENO
*native_lineno
;
3323 alent
*lineno_cache
;
3325 BFD_ASSERT (asect
->lineno
== (alent
*) NULL
);
3327 native_lineno
= (LINENO
*) buy_and_read (abfd
,
3328 asect
->line_filepos
,
3331 asect
->lineno_count
));
3333 (alent
*) bfd_alloc (abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof (alent
)));
3334 if (lineno_cache
== NULL
)
3338 unsigned int counter
= 0;
3339 alent
*cache_ptr
= lineno_cache
;
3340 LINENO
*src
= native_lineno
;
3342 while (counter
< asect
->lineno_count
)
3344 struct internal_lineno dst
;
3345 coff_swap_lineno_in (abfd
, src
, &dst
);
3346 cache_ptr
->line_number
= dst
.l_lnno
;
3348 if (cache_ptr
->line_number
== 0)
3352 coff_symbol_type
*sym
;
3355 symndx
= dst
.l_addr
.l_symndx
;
3356 if (symndx
< 0 || symndx
>= obj_raw_syment_count (abfd
))
3358 (*_bfd_error_handler
)
3359 ("%s: warning: illegal symbol index %ld in line numbers",
3360 bfd_get_filename (abfd
), dst
.l_addr
.l_symndx
);
3364 /* FIXME: We should not be casting between ints and
3365 pointers like this. */
3366 sym
= ((coff_symbol_type
*)
3367 ((symndx
+ obj_raw_syments (abfd
))
3368 ->u
.syment
._n
._n_n
._n_zeroes
));
3369 cache_ptr
->u
.sym
= (asymbol
*) sym
;
3370 if (sym
->lineno
!= NULL
&& ! warned
)
3372 (*_bfd_error_handler
)
3373 ("%s: warning: duplicate line number information for `%s'",
3374 bfd_get_filename (abfd
),
3375 bfd_asymbol_name (&sym
->symbol
));
3377 sym
->lineno
= cache_ptr
;
3381 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
3382 - bfd_section_vma (abfd
, asect
);
3383 } /* If no linenumber expect a symbol index */
3389 cache_ptr
->line_number
= 0;
3392 asect
->lineno
= lineno_cache
;
3393 /* FIXME, free native_lineno here, or use alloca or something. */
3398 coff_slurp_symbol_table (abfd
)
3401 combined_entry_type
*native_symbols
;
3402 coff_symbol_type
*cached_area
;
3403 unsigned int *table_ptr
;
3405 unsigned int number_of_symbols
= 0;
3407 if (obj_symbols (abfd
))
3410 /* Read in the symbol table */
3411 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
3416 /* Allocate enough room for all the symbols in cached form */
3417 cached_area
= ((coff_symbol_type
*)
3419 (obj_raw_syment_count (abfd
)
3420 * sizeof (coff_symbol_type
))));
3422 if (cached_area
== NULL
)
3424 table_ptr
= ((unsigned int *)
3426 (obj_raw_syment_count (abfd
)
3427 * sizeof (unsigned int))));
3429 if (table_ptr
== NULL
)
3433 coff_symbol_type
*dst
= cached_area
;
3434 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
3435 unsigned int this_index
= 0;
3436 while (this_index
< last_native_index
)
3438 combined_entry_type
*src
= native_symbols
+ this_index
;
3439 table_ptr
[this_index
] = number_of_symbols
;
3440 dst
->symbol
.the_bfd
= abfd
;
3442 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
3443 /* We use the native name field to point to the cached field. */
3444 src
->u
.syment
._n
._n_n
._n_zeroes
= (long) dst
;
3445 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
3446 src
->u
.syment
.n_scnum
);
3447 dst
->symbol
.flags
= 0;
3448 dst
->done_lineno
= false;
3450 switch (src
->u
.syment
.n_sclass
)
3455 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
3456 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
3457 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
3459 /* Fall through to next case */
3464 #if defined ARM || defined COFF_WITH_PE
3466 case C_THUMBEXTFUNC
:
3472 case C_SYSTEM
: /* System Wide variable */
3475 /* PE uses storage class 0x68 to denote a section symbol */
3477 /* PE uses storage class 0x67 for a weak external symbol. */
3480 if ((src
->u
.syment
.n_scnum
) == 0)
3482 if ((src
->u
.syment
.n_value
) == 0)
3484 dst
->symbol
.section
= bfd_und_section_ptr
;
3485 dst
->symbol
.value
= 0;
3489 dst
->symbol
.section
= bfd_com_section_ptr
;
3490 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3495 /* Base the value as an index from the base of the
3498 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
3500 #if defined (COFF_WITH_PE) || defined (COFF_IMAGE_WITH_PE)
3501 /* PE sets the symbol to a value relative to the
3502 start of the section. */
3503 dst
->symbol
.value
= src
->u
.syment
.n_value
;
3505 dst
->symbol
.value
= (src
->u
.syment
.n_value
3506 - dst
->symbol
.section
->vma
);
3509 if (ISFCN ((src
->u
.syment
.n_type
)))
3511 /* A function ext does not go at the end of a
3513 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
3518 /* A C_HIDEXT symbol is not global. */
3519 if (src
->u
.syment
.n_sclass
== C_HIDEXT
)
3520 dst
->symbol
.flags
= BSF_LOCAL
;
3521 /* A symbol with a csect entry should not go at the end. */
3522 if (src
->u
.syment
.n_numaux
> 0)
3523 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
3527 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
3528 dst
->symbol
.flags
= BSF_WEAK
;
3533 case C_STAT
: /* static */
3535 case C_LEAFSTAT
: /* static leaf procedure */
3537 #if defined ARM || defined COFF_WITH_PE
3538 case C_THUMBSTAT
: /* Thumb static */
3539 case C_THUMBLABEL
: /* Thumb label */
3540 case C_THUMBSTATFUNC
:/* Thumb static function */
3542 case C_LABEL
: /* label */
3543 if (src
->u
.syment
.n_scnum
== -2)
3544 dst
->symbol
.flags
= BSF_DEBUGGING
;
3546 dst
->symbol
.flags
= BSF_LOCAL
;
3548 /* Base the value as an index from the base of the
3549 section, if there is one. */
3550 if (dst
->symbol
.section
)
3552 #if defined (COFF_WITH_PE) || defined (COFF_IMAGE_WITH_PE)
3553 /* PE sets the symbol to a value relative to the
3554 start of the section. */
3555 dst
->symbol
.value
= src
->u
.syment
.n_value
;
3557 dst
->symbol
.value
= (src
->u
.syment
.n_value
3558 - dst
->symbol
.section
->vma
);
3562 dst
->symbol
.value
= src
->u
.syment
.n_value
;
3565 case C_MOS
: /* member of structure */
3566 case C_EOS
: /* end of structure */
3567 #ifdef NOTDEF /* C_AUTOARG has the same value */
3569 case C_GLBLREG
: /* A29k-specific storage class */
3572 case C_REGPARM
: /* register parameter */
3573 case C_REG
: /* register variable */
3574 /* start-sanitize-tic80 */
3576 /* end-sanitize-tic80 */
3578 case C_AUTOARG
: /* 960-specific storage class */
3580 /* start-sanitize-tic80 */
3582 /* end-sanitize-tic80 */
3583 case C_TPDEF
: /* type definition */
3585 case C_AUTO
: /* automatic variable */
3586 case C_FIELD
: /* bit field */
3587 case C_ENTAG
: /* enumeration tag */
3588 case C_MOE
: /* member of enumeration */
3589 case C_MOU
: /* member of union */
3590 case C_UNTAG
: /* union tag */
3591 dst
->symbol
.flags
= BSF_DEBUGGING
;
3592 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3595 case C_FILE
: /* file name */
3596 case C_STRTAG
: /* structure tag */
3611 dst
->symbol
.flags
= BSF_DEBUGGING
;
3612 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3616 case C_BINCL
: /* beginning of include file */
3617 case C_EINCL
: /* ending of include file */
3618 /* The value is actually a pointer into the line numbers
3619 of the file. We locate the line number entry, and
3620 set the section to the section which contains it, and
3621 the value to the index in that section. */
3625 dst
->symbol
.flags
= BSF_DEBUGGING
;
3626 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3627 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
3628 && ((file_ptr
) (sec
->line_filepos
3629 + sec
->lineno_count
* LINESZ
)
3630 > (file_ptr
) src
->u
.syment
.n_value
))
3633 dst
->symbol
.value
= 0;
3636 dst
->symbol
.section
= sec
;
3637 dst
->symbol
.value
= ((src
->u
.syment
.n_value
3638 - sec
->line_filepos
)
3646 dst
->symbol
.flags
= BSF_DEBUGGING
;
3648 /* The value is actually a symbol index. Save a pointer
3649 to the symbol instead of the index. FIXME: This
3650 should use a union. */
3651 src
->u
.syment
.n_value
=
3652 (long) (native_symbols
+ src
->u
.syment
.n_value
);
3653 dst
->symbol
.value
= src
->u
.syment
.n_value
;
3658 case C_BLOCK
: /* ".bb" or ".eb" */
3659 case C_FCN
: /* ".bf" or ".ef" */
3660 case C_EFCN
: /* physical end of function */
3661 dst
->symbol
.flags
= BSF_LOCAL
;
3662 #if defined (COFF_WITH_PE) || defined (COFF_IMAGE_WITH_PE)
3663 /* PE sets the symbol to a value relative to the start
3665 dst
->symbol
.value
= src
->u
.syment
.n_value
;
3667 /* Base the value as an index from the base of the
3669 dst
->symbol
.value
= (src
->u
.syment
.n_value
3670 - dst
->symbol
.section
->vma
);
3675 case C_EXTDEF
: /* external definition */
3676 case C_ULABEL
: /* undefined label */
3677 case C_USTATIC
: /* undefined static */
3678 #ifndef COFF_WITH_PE
3679 /* C_LINE in regular coff is 0x68. NT has taken over this storage
3680 class to represent a section symbol */
3681 case C_LINE
: /* line # reformatted as symbol table entry */
3682 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
3683 case C_ALIAS
: /* duplicate tag */
3685 /* start-sanitize-tic80 */
3686 /* New storage classes for TIc80 */
3688 case C_UEXT
: /* Tentative external definition */
3690 case C_STATLAB
: /* Static load time label */
3691 case C_EXTLAB
: /* External load time label */
3692 /* end-sanitize-tic80 */
3693 case C_HIDDEN
: /* ext symbol in dmert public lib */
3695 (*_bfd_error_handler
)
3696 ("%s: Unrecognized storage class %d for %s symbol `%s'",
3697 bfd_get_filename (abfd
), src
->u
.syment
.n_sclass
,
3698 dst
->symbol
.section
->name
, dst
->symbol
.name
);
3699 dst
->symbol
.flags
= BSF_DEBUGGING
;
3700 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3704 /* BFD_ASSERT(dst->symbol.flags != 0);*/
3708 dst
->symbol
.udata
.i
= 0;
3709 dst
->lineno
= (alent
*) NULL
;
3710 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
3712 number_of_symbols
++;
3713 } /* walk the native symtab */
3714 } /* bfdize the native symtab */
3716 obj_symbols (abfd
) = cached_area
;
3717 obj_raw_syments (abfd
) = native_symbols
;
3719 bfd_get_symcount (abfd
) = number_of_symbols
;
3720 obj_convert (abfd
) = table_ptr
;
3721 /* Slurp the line tables for each section too */
3727 coff_slurp_line_table (abfd
, p
);
3732 } /* coff_slurp_symbol_table() */
3734 /* Check whether a symbol is globally visible. This is used by the
3735 COFF backend linker code in cofflink.c, since a couple of targets
3736 have globally visible symbols which are not class C_EXT. This
3737 function need not handle the case of n_class == C_EXT. */
3739 #undef OTHER_GLOBAL_CLASS
3742 #define OTHER_GLOBAL_CLASS C_LEAFEXT
3746 #define OTHER_GLOBAL_CLASS C_THUMBEXT || syment->n_sclass == C_THUMBEXTFUNC
3749 #define OTHER_GLOBAL_CLASS C_SECTION
3753 #ifdef OTHER_GLOBAL_CLASS
3755 static boolean coff_sym_is_global
PARAMS ((bfd
*, struct internal_syment
*));
3758 coff_sym_is_global (abfd
, syment
)
3760 struct internal_syment
* syment
;
3762 return (syment
->n_sclass
== OTHER_GLOBAL_CLASS
);
3765 #undef OTHER_GLOBAL_CLASS
3767 #else /* ! defined (OTHER_GLOBAL_CLASS) */
3769 /* sym_is_global should not be defined if it has nothing to do. */
3771 #define coff_sym_is_global 0
3773 #endif /* ! defined (OTHER_GLOBAL_CLASS) */
3779 Coff relocations are easily transformed into the internal BFD form
3782 Reading a coff relocation table is done in the following stages:
3784 o Read the entire coff relocation table into memory.
3786 o Process each relocation in turn; first swap it from the
3787 external to the internal form.
3789 o Turn the symbol referenced in the relocation's symbol index
3790 into a pointer into the canonical symbol table.
3791 This table is the same as the one returned by a call to
3792 @code{bfd_canonicalize_symtab}. The back end will call that
3793 routine and save the result if a canonicalization hasn't been done.
3795 o The reloc index is turned into a pointer to a howto
3796 structure, in a back end specific way. For instance, the 386
3797 and 960 use the @code{r_type} to directly produce an index
3798 into a howto table vector; the 88k subtracts a number from the
3799 @code{r_type} field and creates an addend field.
3805 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
3807 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
3808 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
3809 coffsym = (obj_symbols (abfd) \
3810 + (cache_ptr->sym_ptr_ptr - symbols)); \
3812 coffsym = coff_symbol_from (abfd, ptr); \
3813 if (coffsym != (coff_symbol_type *) NULL \
3814 && coffsym->native->u.syment.n_scnum == 0) \
3815 cache_ptr->addend = 0; \
3816 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
3817 && ptr->section != (asection *) NULL) \
3818 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
3820 cache_ptr->addend = 0; \
3825 coff_slurp_reloc_table (abfd
, asect
, symbols
)
3830 RELOC
*native_relocs
;
3831 arelent
*reloc_cache
;
3836 if (asect
->relocation
)
3838 if (asect
->reloc_count
== 0)
3840 if (asect
->flags
& SEC_CONSTRUCTOR
)
3842 if (!coff_slurp_symbol_table (abfd
))
3845 (RELOC
*) buy_and_read (abfd
,
3849 asect
->reloc_count
));
3850 reloc_cache
= (arelent
*)
3851 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
3853 if (reloc_cache
== NULL
)
3857 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
3859 struct internal_reloc dst
;
3860 struct external_reloc
*src
;
3861 #ifndef RELOC_PROCESSING
3865 cache_ptr
= reloc_cache
+ idx
;
3866 src
= native_relocs
+ idx
;
3868 coff_swap_reloc_in (abfd
, src
, &dst
);
3870 #ifdef RELOC_PROCESSING
3871 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
3873 cache_ptr
->address
= dst
.r_vaddr
;
3875 if (dst
.r_symndx
!= -1)
3877 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
3879 (*_bfd_error_handler
)
3880 ("%s: warning: illegal symbol index %ld in relocs",
3881 bfd_get_filename (abfd
), dst
.r_symndx
);
3882 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
3887 cache_ptr
->sym_ptr_ptr
= (symbols
3888 + obj_convert (abfd
)[dst
.r_symndx
]);
3889 ptr
= *(cache_ptr
->sym_ptr_ptr
);
3894 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
3898 /* The symbols definitions that we have read in have been
3899 relocated as if their sections started at 0. But the offsets
3900 refering to the symbols in the raw data have not been
3901 modified, so we have to have a negative addend to compensate.
3903 Note that symbols which used to be common must be left alone */
3905 /* Calculate any reloc addend by looking at the symbol */
3906 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
3908 cache_ptr
->address
-= asect
->vma
;
3909 /* !! cache_ptr->section = (asection *) NULL;*/
3911 /* Fill in the cache_ptr->howto field from dst.r_type */
3912 RTYPE2HOWTO (cache_ptr
, &dst
);
3913 #endif /* RELOC_PROCESSING */
3915 if (cache_ptr
->howto
== NULL
)
3917 (*_bfd_error_handler
)
3918 ("%s: illegal relocation type %d at address 0x%lx",
3919 bfd_get_filename (abfd
), dst
.r_type
, (long) dst
.r_vaddr
);
3920 bfd_set_error (bfd_error_bad_value
);
3925 asect
->relocation
= reloc_cache
;
3929 #ifndef coff_rtype_to_howto
3932 /* Get the howto structure for a reloc. This is only used if the file
3933 including this one defines coff_relocate_section to be
3934 _bfd_coff_generic_relocate_section, so it is OK if it does not
3935 always work. It is the responsibility of the including file to
3936 make sure it is reasonable if it is needed. */
3938 static reloc_howto_type
*coff_rtype_to_howto
3939 PARAMS ((bfd
*, asection
*, struct internal_reloc
*,
3940 struct coff_link_hash_entry
*, struct internal_syment
*,
3944 static reloc_howto_type
*
3945 coff_rtype_to_howto (abfd
, sec
, rel
, h
, sym
, addendp
)
3948 struct internal_reloc
*rel
;
3949 struct coff_link_hash_entry
*h
;
3950 struct internal_syment
*sym
;
3955 RTYPE2HOWTO (&genrel
, rel
);
3956 return genrel
.howto
;
3959 #else /* ! defined (RTYPE2HOWTO) */
3961 #define coff_rtype_to_howto NULL
3963 #endif /* ! defined (RTYPE2HOWTO) */
3964 #endif /* ! defined (coff_rtype_to_howto) */
3966 /* This is stupid. This function should be a boolean predicate. */
3968 coff_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3974 arelent
*tblptr
= section
->relocation
;
3975 unsigned int count
= 0;
3978 if (section
->flags
& SEC_CONSTRUCTOR
)
3980 /* this section has relocs made up by us, they are not in the
3981 file, so take them out of their chain and place them into
3982 the data area provided */
3983 arelent_chain
*chain
= section
->constructor_chain
;
3984 for (count
= 0; count
< section
->reloc_count
; count
++)
3986 *relptr
++ = &chain
->relent
;
3987 chain
= chain
->next
;
3993 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
3996 tblptr
= section
->relocation
;
3998 for (; count
++ < section
->reloc_count
;)
3999 *relptr
++ = tblptr
++;
4004 return section
->reloc_count
;
4009 coff_sym_filepos (abfd
)
4012 return obj_sym_filepos (abfd
);
4016 #ifndef coff_reloc16_estimate
4017 #define coff_reloc16_estimate dummy_reloc16_estimate
4019 static int dummy_reloc16_estimate
4020 PARAMS ((bfd
*, asection
*, arelent
*, unsigned int,
4021 struct bfd_link_info
*));
4024 dummy_reloc16_estimate (abfd
, input_section
, reloc
, shrink
, link_info
)
4026 asection
*input_section
;
4028 unsigned int shrink
;
4029 struct bfd_link_info
*link_info
;
4036 #ifndef coff_reloc16_extra_cases
4038 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
4040 /* This works even if abort is not declared in any header file. */
4042 static void dummy_reloc16_extra_cases
4043 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*, arelent
*,
4044 bfd_byte
*, unsigned int *, unsigned int *));
4047 dummy_reloc16_extra_cases (abfd
, link_info
, link_order
, reloc
, data
, src_ptr
,
4050 struct bfd_link_info
*link_info
;
4051 struct bfd_link_order
*link_order
;
4054 unsigned int *src_ptr
;
4055 unsigned int *dst_ptr
;
4061 /* If coff_relocate_section is defined, we can use the optimized COFF
4062 backend linker. Otherwise we must continue to use the old linker. */
4063 #ifdef coff_relocate_section
4064 #ifndef coff_bfd_link_hash_table_create
4065 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
4067 #ifndef coff_bfd_link_add_symbols
4068 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
4070 #ifndef coff_bfd_final_link
4071 #define coff_bfd_final_link _bfd_coff_final_link
4073 #else /* ! defined (coff_relocate_section) */
4074 #define coff_relocate_section NULL
4075 #ifndef coff_bfd_link_hash_table_create
4076 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
4078 #ifndef coff_bfd_link_add_symbols
4079 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
4081 #define coff_bfd_final_link _bfd_generic_final_link
4082 #endif /* ! defined (coff_relocate_section) */
4084 #define coff_bfd_link_split_section _bfd_generic_link_split_section
4086 #ifndef coff_start_final_link
4087 #define coff_start_final_link NULL
4090 #ifndef coff_adjust_symndx
4091 #define coff_adjust_symndx NULL
4094 #ifndef coff_link_add_one_symbol
4095 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
4098 #ifndef coff_link_output_has_begun
4099 #define coff_link_output_has_begun _coff_link_output_has_begun
4101 _coff_link_output_has_begun (abfd
)
4104 return abfd
->output_has_begun
;
4108 #ifndef coff_final_link_postscript
4109 #define coff_final_link_postscript _coff_final_link_postscript
4111 _coff_final_link_postscript (abfd
, pfinfo
)
4113 struct coff_final_link_info
* pfinfo
;
4119 #ifndef coff_SWAP_aux_in
4120 #define coff_SWAP_aux_in coff_swap_aux_in
4122 #ifndef coff_SWAP_sym_in
4123 #define coff_SWAP_sym_in coff_swap_sym_in
4125 #ifndef coff_SWAP_lineno_in
4126 #define coff_SWAP_lineno_in coff_swap_lineno_in
4128 #ifndef coff_SWAP_aux_out
4129 #define coff_SWAP_aux_out coff_swap_aux_out
4131 #ifndef coff_SWAP_sym_out
4132 #define coff_SWAP_sym_out coff_swap_sym_out
4134 #ifndef coff_SWAP_lineno_out
4135 #define coff_SWAP_lineno_out coff_swap_lineno_out
4137 #ifndef coff_SWAP_reloc_out
4138 #define coff_SWAP_reloc_out coff_swap_reloc_out
4140 #ifndef coff_SWAP_filehdr_out
4141 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
4143 #ifndef coff_SWAP_aouthdr_out
4144 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
4146 #ifndef coff_SWAP_scnhdr_out
4147 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
4149 #ifndef coff_SWAP_reloc_in
4150 #define coff_SWAP_reloc_in coff_swap_reloc_in
4152 #ifndef coff_SWAP_filehdr_in
4153 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
4155 #ifndef coff_SWAP_aouthdr_in
4156 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
4158 #ifndef coff_SWAP_scnhdr_in
4159 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
4164 static CONST bfd_coff_backend_data bfd_coff_std_swap_table
=
4166 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
4167 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
4168 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
4169 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
4170 coff_SWAP_scnhdr_out
,
4171 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
,
4172 #ifdef COFF_LONG_FILENAMES
4177 #ifdef COFF_LONG_SECTION_NAMES
4182 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
4183 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
4184 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
4185 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
4186 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
4187 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
4188 coff_sym_is_global
, coff_compute_section_file_positions
,
4189 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
4190 coff_adjust_symndx
, coff_link_add_one_symbol
,
4191 coff_link_output_has_begun
, coff_final_link_postscript
4194 #ifndef coff_close_and_cleanup
4195 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
4198 #ifndef coff_bfd_free_cached_info
4199 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
4202 #ifndef coff_get_section_contents
4203 #define coff_get_section_contents _bfd_generic_get_section_contents
4206 #ifndef coff_bfd_copy_private_symbol_data
4207 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
4210 #ifndef coff_bfd_copy_private_section_data
4211 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
4214 #ifndef coff_bfd_copy_private_bfd_data
4215 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
4218 #ifndef coff_bfd_merge_private_bfd_data
4219 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
4222 #ifndef coff_bfd_set_private_flags
4223 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
4226 #ifndef coff_bfd_print_private_bfd_data
4227 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
4230 #ifndef coff_bfd_is_local_label_name
4231 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
4234 #ifndef coff_read_minisymbols
4235 #define coff_read_minisymbols _bfd_generic_read_minisymbols
4238 #ifndef coff_minisymbol_to_symbol
4239 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
4242 /* The reloc lookup routine must be supplied by each individual COFF
4244 #ifndef coff_bfd_reloc_type_lookup
4245 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4248 #ifndef coff_bfd_get_relocated_section_contents
4249 #define coff_bfd_get_relocated_section_contents \
4250 bfd_generic_get_relocated_section_contents
4253 #ifndef coff_bfd_relax_section
4254 #define coff_bfd_relax_section bfd_generic_relax_section