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 . struct coff_final_link_info * pfinfo));
868 . boolean (*_bfd_coff_final_link_postscript) PARAMS ((
870 . struct coff_final_link_info * pfinfo));
872 .} bfd_coff_backend_data;
874 .#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
876 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
877 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
879 .#define bfd_coff_swap_sym_in(a,e,i) \
880 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
882 .#define bfd_coff_swap_lineno_in(a,e,i) \
883 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
885 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
886 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
888 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
889 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
891 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
892 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
894 .#define bfd_coff_swap_sym_out(abfd, i,o) \
895 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
897 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
898 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
900 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
901 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
903 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
904 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
906 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
907 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
908 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
909 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
910 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
911 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
912 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
913 .#define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames)
914 .#define bfd_coff_long_section_names(abfd) \
915 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
916 .#define bfd_coff_default_section_alignment_power(abfd) \
917 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
918 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
919 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
921 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
922 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
924 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
925 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
927 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
928 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
930 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
931 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
933 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
934 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
935 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
936 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
938 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name)\
939 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook) (abfd, scnhdr, name))
941 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
942 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
944 .#define bfd_coff_slurp_symbol_table(abfd)\
945 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
947 .#define bfd_coff_symname_in_debug(abfd, sym)\
948 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
950 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
951 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
952 . (abfd, file, base, symbol, aux, indaux))
954 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
955 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
956 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
958 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
959 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
960 . (abfd, section, reloc, shrink, link_info))
962 .#define bfd_coff_sym_is_global(abfd, sym)\
963 . ((coff_backend_info (abfd)->_bfd_coff_sym_is_global)\
966 .#define bfd_coff_compute_section_file_positions(abfd)\
967 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
970 .#define bfd_coff_start_final_link(obfd, info)\
971 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
973 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
974 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
975 . (obfd, info, ibfd, o, con, rel, isyms, secs))
976 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
977 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
978 . (abfd, sec, rel, h, sym, addendp))
979 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
980 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
981 . (obfd, info, ibfd, sec, rel, adjustedp))
982 .#define bfd_coff_link_add_one_symbol(info,abfd,name,flags,section,value,string,cp,coll,hashp)\
983 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
984 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
986 .#define bfd_coff_link_output_has_begun(a,p) \
987 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p))
988 .#define bfd_coff_final_link_postscript(a,p) \
989 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
993 /* See whether the magic number matches. */
996 coff_bad_format_hook (abfd
, filehdr
)
1000 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1002 if (BADMAG (*internal_f
))
1005 /* if the optional header is NULL or not the correct size then
1006 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1007 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1008 optional header is of a different size.
1010 But the mips keeps extra stuff in it's opthdr, so dont check
1014 #if defined(M88) || defined(I960)
1015 if (internal_f
->f_opthdr
!= 0 && AOUTSZ
!= internal_f
->f_opthdr
)
1023 initialize a section structure with information peculiar to this
1024 particular implementation of coff
1028 coff_new_section_hook (abfd
, section
)
1032 combined_entry_type
*native
;
1034 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1037 if (xcoff_data (abfd
)->text_align_power
!= 0
1038 && strcmp (bfd_get_section_name (abfd
, section
), ".text") == 0)
1039 section
->alignment_power
= xcoff_data (abfd
)->text_align_power
;
1040 if (xcoff_data (abfd
)->data_align_power
!= 0
1041 && strcmp (bfd_get_section_name (abfd
, section
), ".data") == 0)
1042 section
->alignment_power
= xcoff_data (abfd
)->data_align_power
;
1045 /* Allocate aux records for section symbols, to store size and
1048 @@ The 10 is a guess at a plausible maximum number of aux entries
1049 (but shouldn't be a constant). */
1050 native
= ((combined_entry_type
*)
1051 bfd_zalloc (abfd
, sizeof (combined_entry_type
) * 10));
1055 /* We don't need to set up n_name, n_value, or n_scnum in the native
1056 symbol information, since they'll be overriden by the BFD symbol
1057 anyhow. However, we do need to set the type and storage class,
1058 in case this symbol winds up getting written out. The value 0
1059 for n_numaux is already correct. */
1061 native
->u
.syment
.n_type
= T_NULL
;
1062 native
->u
.syment
.n_sclass
= C_STAT
;
1064 coffsymbol (section
->symbol
)->native
= native
;
1066 /* The .stab section must be aligned to 2**2 at most, because
1067 otherwise there may be gaps in the section which gdb will not
1068 know how to interpret. Examining the section name is a hack, but
1069 that is also how gdb locates the section.
1070 We need to handle the .ctors and .dtors sections similarly, to
1071 avoid introducing null words in the tables. */
1072 if (COFF_DEFAULT_SECTION_ALIGNMENT_POWER
> 2
1073 && (strncmp (section
->name
, ".stab", 5) == 0
1074 || strcmp (section
->name
, ".ctors") == 0
1075 || strcmp (section
->name
, ".dtors") == 0))
1076 section
->alignment_power
= 2;
1078 /* Similarly, the .stabstr section must be aligned to 2**0 at most. */
1079 if (COFF_DEFAULT_SECTION_ALIGNMENT_POWER
> 0
1080 && strncmp (section
->name
, ".stabstr", 8) == 0)
1081 section
->alignment_power
= 0;
1086 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1088 /* Set the alignment of a BFD section. */
1090 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1093 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1098 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1102 /* Extract ALIGN from 2**ALIGN stored in section header */
1103 for (i
= 0; i
< 32; i
++)
1104 if ((1 << i
) >= hdr
->s_align
)
1107 /* start-sanitize-tic80 */
1109 /* TI tools hijack bits 8-11 for the alignment */
1110 i
= (hdr
->s_flags
>> 8) & 0xF ;
1112 /* end-sanitize-tic80 */
1113 section
->alignment_power
= i
;
1116 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1119 /* a couple of macros to help setting the alignment power field */
1120 #define ALIGN_SET(field,x,y) \
1121 if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1123 section->alignment_power = y;\
1126 #define ELIFALIGN_SET(field,x,y) \
1127 else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1129 section->alignment_power = y;\
1132 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1135 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1140 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1142 ALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_64BYTES
, 6)
1143 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_32BYTES
, 5)
1144 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_16BYTES
, 4)
1145 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_8BYTES
, 3)
1146 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_4BYTES
, 2)
1147 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_2BYTES
, 1)
1148 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_1BYTES
, 0)
1150 #ifdef POWERPC_LE_PE
1151 if (strcmp (section
->name
, ".idata$2") == 0)
1153 section
->alignment_power
= 0;
1155 else if (strcmp (section
->name
, ".idata$3") == 0)
1157 section
->alignment_power
= 0;
1159 else if (strcmp (section
->name
, ".idata$4") == 0)
1161 section
->alignment_power
= 2;
1163 else if (strcmp (section
->name
, ".idata$5") == 0)
1165 section
->alignment_power
= 2;
1167 else if (strcmp (section
->name
, ".idata$6") == 0)
1169 section
->alignment_power
= 1;
1171 else if (strcmp (section
->name
, ".reloc") == 0)
1173 section
->alignment_power
= 1;
1175 else if (strncmp (section
->name
, ".stab", 5) == 0)
1177 section
->alignment_power
= 2;
1181 #ifdef COFF_IMAGE_WITH_PE
1182 /* In a PE image file, the s_paddr field holds the virtual size of a
1183 section, while the s_size field holds the raw size. */
1184 if (hdr
->s_paddr
!= 0)
1186 if (coff_section_data (abfd
, section
) == NULL
)
1188 section
->used_by_bfd
=
1189 (PTR
) bfd_zalloc (abfd
, sizeof (struct coff_section_tdata
));
1190 if (section
->used_by_bfd
== NULL
)
1192 /* FIXME: Return error. */
1196 if (pei_section_data (abfd
, section
) == NULL
)
1198 coff_section_data (abfd
, section
)->tdata
=
1199 (PTR
) bfd_zalloc (abfd
, sizeof (struct pei_section_tdata
));
1200 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1202 /* FIXME: Return error. */
1206 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1212 #undef ELIFALIGN_SET
1214 #else /* ! COFF_WITH_PE */
1217 /* We grossly abuse this function to handle XCOFF overflow headers.
1218 When we see one, we correct the reloc and line number counts in the
1219 real header, and remove the section we just created. */
1221 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1224 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1229 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1233 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1236 real_sec
= coff_section_from_bfd_index (abfd
, hdr
->s_nreloc
);
1237 if (real_sec
== NULL
)
1240 real_sec
->reloc_count
= hdr
->s_paddr
;
1241 real_sec
->lineno_count
= hdr
->s_vaddr
;
1243 for (ps
= &abfd
->sections
; *ps
!= NULL
; ps
= &(*ps
)->next
)
1248 --abfd
->section_count
;
1254 #else /* ! RS6000COFF_C */
1256 #define coff_set_alignment_hook \
1257 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1259 #endif /* ! RS6000COFF_C */
1260 #endif /* ! COFF_WITH_PE */
1261 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1263 #ifndef coff_mkobject
1265 static boolean coff_mkobject
PARAMS ((bfd
*));
1268 coff_mkobject (abfd
)
1271 coff_data_type
*coff
;
1273 abfd
->tdata
.coff_obj_data
= (struct coff_tdata
*) bfd_zalloc (abfd
, sizeof (coff_data_type
));
1274 if (abfd
->tdata
.coff_obj_data
== 0)
1276 coff
= coff_data (abfd
);
1277 coff
->symbols
= (coff_symbol_type
*) NULL
;
1278 coff
->conversion_table
= (unsigned int *) NULL
;
1279 coff
->raw_syments
= (struct coff_ptr_struct
*) NULL
;
1280 coff
->relocbase
= 0;
1281 coff
->local_toc_sym_map
= 0;
1283 /* make_abs_section(abfd);*/
1289 /* Create the COFF backend specific information. */
1290 #ifndef coff_mkobject_hook
1292 coff_mkobject_hook (abfd
, filehdr
, aouthdr
)
1297 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1298 coff_data_type
*coff
;
1300 if (coff_mkobject (abfd
) == false)
1303 coff
= coff_data (abfd
);
1305 coff
->sym_filepos
= internal_f
->f_symptr
;
1307 /* These members communicate important constants about the symbol
1308 table to GDB's symbol-reading code. These `constants'
1309 unfortunately vary among coff implementations... */
1310 coff
->local_n_btmask
= N_BTMASK
;
1311 coff
->local_n_btshft
= N_BTSHFT
;
1312 coff
->local_n_tmask
= N_TMASK
;
1313 coff
->local_n_tshift
= N_TSHIFT
;
1314 coff
->local_symesz
= SYMESZ
;
1315 coff
->local_auxesz
= AUXESZ
;
1316 coff
->local_linesz
= LINESZ
;
1318 obj_raw_syment_count (abfd
) =
1319 obj_conv_table_size (abfd
) =
1320 internal_f
->f_nsyms
;
1323 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
1324 abfd
->flags
|= DYNAMIC
;
1325 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= AOUTSZ
)
1327 struct internal_aouthdr
*internal_a
=
1328 (struct internal_aouthdr
*) aouthdr
;
1329 struct xcoff_tdata
*xcoff
;
1331 xcoff
= xcoff_data (abfd
);
1332 xcoff
->full_aouthdr
= true;
1333 xcoff
->toc
= internal_a
->o_toc
;
1334 xcoff
->sntoc
= internal_a
->o_sntoc
;
1335 xcoff
->snentry
= internal_a
->o_snentry
;
1336 xcoff
->text_align_power
= internal_a
->o_algntext
;
1337 xcoff
->data_align_power
= internal_a
->o_algndata
;
1338 xcoff
->modtype
= internal_a
->o_modtype
;
1339 xcoff
->cputype
= internal_a
->o_cputype
;
1340 xcoff
->maxdata
= internal_a
->o_maxdata
;
1341 xcoff
->maxstack
= internal_a
->o_maxstack
;
1346 /* Set the flags field from the COFF header read in */
1347 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
1355 /* Determine the machine architecture and type. FIXME: This is target
1356 dependent because the magic numbers are defined in the target
1357 dependent header files. But there is no particular need for this.
1358 If the magic numbers were moved to a separate file, this function
1359 would be target independent and would also be much more successful
1360 at linking together COFF files for different architectures. */
1363 coff_set_arch_mach_hook (abfd
, filehdr
)
1368 enum bfd_architecture arch
;
1369 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1372 switch (internal_f
->f_magic
)
1376 arch
= bfd_arch_powerpc
;
1377 machine
= 0; /* what does this mean? (krk) */
1383 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler */
1384 case LYNXCOFFMAGIC
: /* shadows the m68k Lynx number below, sigh */
1385 arch
= bfd_arch_i386
;
1389 #ifdef A29K_MAGIC_BIG
1390 case A29K_MAGIC_BIG
:
1391 case A29K_MAGIC_LITTLE
:
1392 arch
= bfd_arch_a29k
;
1398 arch
= bfd_arch_arm
;
1399 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
1401 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
1402 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
1403 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
1405 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
1406 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
1407 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
1414 #ifdef MC68KBCSMAGIC
1417 #ifdef APOLLOM68KMAGIC
1418 case APOLLOM68KMAGIC
:
1420 #ifdef LYNXCOFFMAGIC
1423 arch
= bfd_arch_m68k
;
1424 machine
= bfd_mach_m68020
;
1431 arch
= bfd_arch_m88k
;
1437 arch
= bfd_arch_z8k
;
1438 switch (internal_f
->f_flags
& F_MACHMASK
)
1441 machine
= bfd_mach_z8001
;
1444 machine
= bfd_mach_z8002
;
1453 arch
= bfd_arch_i860
;
1460 arch
= bfd_arch_i960
;
1461 switch (F_I960TYPE
& internal_f
->f_flags
)
1465 machine
= bfd_mach_i960_core
;
1468 machine
= bfd_mach_i960_kb_sb
;
1471 machine
= bfd_mach_i960_mc
;
1474 machine
= bfd_mach_i960_xa
;
1477 machine
= bfd_mach_i960_ca
;
1480 machine
= bfd_mach_i960_ka_sa
;
1483 machine
= bfd_mach_i960_jx
;
1486 machine
= bfd_mach_i960_hx
;
1500 if (xcoff_data (abfd
)->cputype
!= -1)
1501 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
1504 /* We did not get a value from the a.out header. If the
1505 file has not been stripped, we may be able to get the
1506 architecture information from the first symbol, if it
1507 is a .file symbol. */
1508 if (obj_raw_syment_count (abfd
) == 0)
1512 bfd_byte buf
[SYMESZ
];
1513 struct internal_syment sym
;
1515 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1516 || bfd_read (buf
, 1, SYMESZ
, abfd
) != SYMESZ
)
1518 coff_swap_sym_in (abfd
, (PTR
) buf
, (PTR
) &sym
);
1519 if (sym
.n_sclass
== C_FILE
)
1520 cputype
= sym
.n_type
& 0xff;
1526 /* FIXME: We don't handle all cases here. */
1532 /* PowerPC Macs use the same magic numbers as RS/6000
1533 (because that's how they were bootstrapped originally),
1534 but they are always PowerPC architecture. */
1535 arch
= bfd_arch_powerpc
;
1538 arch
= bfd_arch_rs6000
;
1540 #endif /* POWERMAC */
1544 arch
= bfd_arch_powerpc
;
1547 case 2: /* 64 bit PowerPC */
1548 arch
= bfd_arch_powerpc
;
1552 arch
= bfd_arch_powerpc
;
1556 arch
= bfd_arch_rs6000
;
1566 arch
= bfd_arch_we32k
;
1573 arch
= bfd_arch_h8300
;
1574 machine
= bfd_mach_h8300
;
1575 /* !! FIXME this probably isn't the right place for this */
1576 abfd
->flags
|= BFD_IS_RELAXABLE
;
1582 arch
= bfd_arch_h8300
;
1583 machine
= bfd_mach_h8300h
;
1584 /* !! FIXME this probably isn't the right place for this */
1585 abfd
->flags
|= BFD_IS_RELAXABLE
;
1591 arch
= bfd_arch_h8300
;
1592 machine
= bfd_mach_h8300s
;
1593 /* !! FIXME this probably isn't the right place for this */
1594 abfd
->flags
|= BFD_IS_RELAXABLE
;
1598 #ifdef SH_ARCH_MAGIC_BIG
1599 case SH_ARCH_MAGIC_BIG
:
1600 case SH_ARCH_MAGIC_LITTLE
:
1608 arch
= bfd_arch_h8500
;
1615 #ifdef LYNXCOFFMAGIC
1618 arch
= bfd_arch_sparc
;
1625 arch
= bfd_arch_tic30
;
1629 /* start-sanitize-tic80 */
1630 #ifdef TIC80_ARCH_MAGIC
1631 case TIC80_ARCH_MAGIC
:
1632 arch
= bfd_arch_tic80
;
1635 /* end-sanitize-tic80 */
1637 default: /* Unreadable input file type */
1638 arch
= bfd_arch_obscure
;
1642 bfd_default_set_arch_mach (abfd
, arch
, machine
);
1646 #ifdef SYMNAME_IN_DEBUG
1648 static boolean symname_in_debug_hook
1649 PARAMS ((bfd
*, struct internal_syment
*));
1652 symname_in_debug_hook (abfd
, sym
)
1654 struct internal_syment
*sym
;
1656 return SYMNAME_IN_DEBUG (sym
) ? true : false;
1661 #define symname_in_debug_hook \
1662 (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
1668 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
1670 static boolean coff_pointerize_aux_hook
1671 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
1672 unsigned int, combined_entry_type
*));
1676 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
1678 combined_entry_type
*table_base
;
1679 combined_entry_type
*symbol
;
1680 unsigned int indaux
;
1681 combined_entry_type
*aux
;
1683 int class = symbol
->u
.syment
.n_sclass
;
1685 if ((class == C_EXT
|| class == C_HIDEXT
)
1686 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
1688 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
1690 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
1691 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
1692 aux
->fix_scnlen
= 1;
1695 /* Return true to indicate that the caller should not do any
1696 further work on this auxent. */
1700 /* Return false to indicate that this auxent should be handled by
1708 /* We don't want to pointerize bal entries. */
1710 static boolean coff_pointerize_aux_hook
1711 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
1712 unsigned int, combined_entry_type
*));
1716 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
1718 combined_entry_type
*table_base
;
1719 combined_entry_type
*symbol
;
1720 unsigned int indaux
;
1721 combined_entry_type
*aux
;
1723 /* Return true if we don't want to pointerize this aux entry, which
1724 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
1726 && (symbol
->u
.syment
.n_sclass
== C_LEAFPROC
1727 || symbol
->u
.syment
.n_sclass
== C_LEAFSTAT
1728 || symbol
->u
.syment
.n_sclass
== C_LEAFEXT
));
1733 #define coff_pointerize_aux_hook 0
1736 #endif /* ! RS6000COFF_C */
1738 /* Print an aux entry. This returns true if it has printed it. */
1740 static boolean coff_print_aux
1741 PARAMS ((bfd
*, FILE *, combined_entry_type
*, combined_entry_type
*,
1742 combined_entry_type
*, unsigned int));
1745 coff_print_aux (abfd
, file
, table_base
, symbol
, aux
, indaux
)
1748 combined_entry_type
*table_base
;
1749 combined_entry_type
*symbol
;
1750 combined_entry_type
*aux
;
1751 unsigned int indaux
;
1754 if ((symbol
->u
.syment
.n_sclass
== C_EXT
1755 || symbol
->u
.syment
.n_sclass
== C_HIDEXT
)
1756 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
1758 /* This is a csect entry. */
1759 fprintf (file
, "AUX ");
1760 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
1762 BFD_ASSERT (! aux
->fix_scnlen
);
1763 fprintf (file
, "val %5ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
1767 fprintf (file
, "indx ");
1768 if (! aux
->fix_scnlen
)
1769 fprintf (file
, "%4ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
1771 fprintf (file
, "%4ld",
1772 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
1775 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
1776 aux
->u
.auxent
.x_csect
.x_parmhash
,
1777 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
1778 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
1779 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
1780 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
1781 aux
->u
.auxent
.x_csect
.x_stab
,
1782 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
1787 /* Return false to indicate that no special action was taken. */
1795 To write relocations, the back end steps though the
1796 canonical relocation table and create an
1797 @code{internal_reloc}. The symbol index to use is removed from
1798 the @code{offset} field in the symbol table supplied. The
1799 address comes directly from the sum of the section base
1800 address and the relocation offset; the type is dug directly
1801 from the howto field. Then the @code{internal_reloc} is
1802 swapped into the shape of an @code{external_reloc} and written
1809 static int compare_arelent_ptr
PARAMS ((const PTR
, const PTR
));
1811 /* AUX's ld wants relocations to be sorted */
1813 compare_arelent_ptr (x
, y
)
1817 const arelent
**a
= (const arelent
**) x
;
1818 const arelent
**b
= (const arelent
**) y
;
1819 bfd_size_type aadr
= (*a
)->address
;
1820 bfd_size_type badr
= (*b
)->address
;
1822 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
1825 #endif /* TARG_AUX */
1828 coff_write_relocs (abfd
, first_undef
)
1834 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
1837 struct external_reloc dst
;
1843 /* sort relocations before we write them out */
1844 p
= (arelent
**) bfd_malloc (s
->reloc_count
* sizeof (arelent
*));
1845 if (p
== NULL
&& s
->reloc_count
> 0)
1847 memcpy (p
, s
->orelocation
, s
->reloc_count
* sizeof (arelent
*));
1848 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
1851 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
1853 for (i
= 0; i
< s
->reloc_count
; i
++)
1855 struct internal_reloc n
;
1857 memset ((PTR
) & n
, 0, sizeof (n
));
1859 /* Now we've renumbered the symbols we know where the
1860 undefined symbols live in the table. Check the reloc
1861 entries for symbols who's output bfd isn't the right one.
1862 This is because the symbol was undefined (which means
1863 that all the pointers are never made to point to the same
1864 place). This is a bad thing,'cause the symbols attached
1865 to the output bfd are indexed, so that the relocation
1866 entries know which symbol index they point to. So we
1867 have to look up the output symbol here. */
1869 if (q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
1872 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
1873 asymbol
**outsyms
= abfd
->outsymbols
;
1874 for (i
= first_undef
; outsyms
[i
]; i
++)
1876 const char *intable
= outsyms
[i
]->name
;
1877 if (strcmp (intable
, sname
) == 0) {
1878 /* got a hit, so repoint the reloc */
1879 q
->sym_ptr_ptr
= outsyms
+ i
;
1885 n
.r_vaddr
= q
->address
+ s
->vma
;
1888 /* The 29k const/consth reloc pair is a real kludge. The consth
1889 part doesn't have a symbol; it has an offset. So rebuilt
1891 if (q
->howto
->type
== R_IHCONST
)
1892 n
.r_symndx
= q
->addend
;
1897 if (q
->sym_ptr_ptr
== bfd_abs_section_ptr
->symbol_ptr_ptr
)
1898 /* This is a relocation relative to the absolute symbol. */
1902 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
1903 /* Take notice if the symbol reloc points to a symbol
1904 we don't have in our symbol table. What should we
1906 if (n
.r_symndx
> obj_conv_table_size (abfd
))
1911 #ifdef SWAP_OUT_RELOC_OFFSET
1912 n
.r_offset
= q
->addend
;
1916 /* Work out reloc type from what is required */
1917 SELECT_RELOC (n
, q
->howto
);
1919 n
.r_type
= q
->howto
->type
;
1921 coff_swap_reloc_out (abfd
, &n
, &dst
);
1922 if (bfd_write ((PTR
) & dst
, 1, RELSZ
, abfd
) != RELSZ
)
1935 /* Set flags and magic number of a coff file from architecture and machine
1936 type. Result is true if we can represent the arch&type, false if not. */
1939 coff_set_flags (abfd
, magicp
, flagsp
)
1941 unsigned int *magicp
;
1942 unsigned short *flagsp
;
1944 switch (bfd_get_arch (abfd
))
1949 switch (bfd_get_mach (abfd
))
1951 case bfd_mach_z8001
:
1954 case bfd_mach_z8002
:
1968 *magicp
= I960ROMAGIC
;
1970 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1971 I960RWMAGIC); FIXME???
1973 switch (bfd_get_mach (abfd
))
1975 case bfd_mach_i960_core
:
1978 case bfd_mach_i960_kb_sb
:
1981 case bfd_mach_i960_mc
:
1984 case bfd_mach_i960_xa
:
1987 case bfd_mach_i960_ca
:
1990 case bfd_mach_i960_ka_sa
:
1993 case bfd_mach_i960_jx
:
1996 case bfd_mach_i960_hx
:
2009 case bfd_arch_tic30
:
2010 *magicp
= TIC30MAGIC
;
2013 /* start-sanitize-tic80 */
2014 #ifdef TIC80_ARCH_MAGIC
2015 case bfd_arch_tic80
:
2016 *magicp
= TIC80_ARCH_MAGIC
;
2019 /* end-sanitize-tic80 */
2022 * magicp
= ARMMAGIC
;
2024 if (APCS_SET (abfd
))
2026 if (APCS_26_FLAG (abfd
))
2027 * flagsp
|= F_APCS26
;
2029 if (APCS_FLOAT_FLAG (abfd
))
2030 * flagsp
|= F_APCS_FLOAT
;
2032 if (PIC_FLAG (abfd
))
2035 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2036 * flagsp
|= F_INTERWORK
;
2037 switch (bfd_get_mach (abfd
))
2039 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2040 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2041 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2042 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2043 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2044 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2049 case bfd_arch_powerpc
:
2056 *magicp
= I386MAGIC
;
2058 /* Just overwrite the usual value if we're doing Lynx. */
2059 *magicp
= LYNXCOFFMAGIC
;
2066 *magicp
= I860MAGIC
;
2072 #ifdef APOLLOM68KMAGIC
2073 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
2075 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2076 #ifdef NAMES_HAVE_UNDERSCORE
2077 *magicp
= MC68KBCSMAGIC
;
2079 *magicp
= MC68MAGIC
;
2083 /* Just overwrite the usual value if we're doing Lynx. */
2084 *magicp
= LYNXCOFFMAGIC
;
2092 *magicp
= MC88OMAGIC
;
2097 case bfd_arch_h8300
:
2098 switch (bfd_get_mach (abfd
))
2100 case bfd_mach_h8300
:
2101 *magicp
= H8300MAGIC
;
2103 case bfd_mach_h8300h
:
2104 *magicp
= H8300HMAGIC
;
2106 case bfd_mach_h8300s
:
2107 *magicp
= H8300SMAGIC
;
2113 #ifdef SH_ARCH_MAGIC_BIG
2115 if (bfd_big_endian (abfd
))
2116 *magicp
= SH_ARCH_MAGIC_BIG
;
2118 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2124 case bfd_arch_sparc
:
2125 *magicp
= SPARCMAGIC
;
2127 /* Just overwrite the usual value if we're doing Lynx. */
2128 *magicp
= LYNXCOFFMAGIC
;
2135 case bfd_arch_h8500
:
2136 *magicp
= H8500MAGIC
;
2140 #ifdef A29K_MAGIC_BIG
2142 if (bfd_big_endian (abfd
))
2143 *magicp
= A29K_MAGIC_BIG
;
2145 *magicp
= A29K_MAGIC_LITTLE
;
2151 case bfd_arch_we32k
:
2152 *magicp
= WE32KMAGIC
;
2158 case bfd_arch_rs6000
:
2160 case bfd_arch_powerpc
:
2162 *magicp
= U802TOCMAGIC
;
2167 default: /* Unknown architecture */
2168 /* return false; -- fall through to "return false" below, to avoid
2169 "statement never reached" errors on the one below. */
2178 coff_set_arch_mach (abfd
, arch
, machine
)
2180 enum bfd_architecture arch
;
2181 unsigned long machine
;
2184 unsigned short dummy2
;
2186 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
2189 if (arch
!= bfd_arch_unknown
&&
2190 coff_set_flags (abfd
, &dummy1
, &dummy2
) != true)
2191 return false; /* We can't represent this type */
2193 return true; /* We're easy ... */
2197 /* Calculate the file position for each section. */
2200 #define ALIGN_SECTIONS_IN_FILE
2202 /* start-sanitize-tic80 */
2204 #undef ALIGN_SECTIONS_IN_FILE
2206 /* end-sanitize-tic80 */
2209 coff_compute_section_file_positions (abfd
)
2213 asection
*previous
= (asection
*) NULL
;
2214 file_ptr sofar
= FILHSZ
;
2215 boolean align_adjust
;
2217 #ifdef ALIGN_SECTIONS_IN_FILE
2222 /* On XCOFF, if we have symbols, set up the .debug section. */
2223 if (bfd_get_symcount (abfd
) > 0)
2226 bfd_size_type i
, symcount
;
2230 symcount
= bfd_get_symcount (abfd
);
2231 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
2233 coff_symbol_type
*cf
;
2235 cf
= coff_symbol_from (abfd
, *symp
);
2237 && cf
->native
!= NULL
2238 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
2242 len
= strlen (bfd_asymbol_name (*symp
));
2251 dsec
= bfd_make_section_old_way (abfd
, ".debug");
2254 dsec
->_raw_size
= sz
;
2255 dsec
->flags
|= SEC_HAS_CONTENTS
;
2260 #ifdef COFF_IMAGE_WITH_PE
2262 if (coff_data (abfd
)->link_info
)
2264 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
2267 page_size
= PE_DEF_FILE_ALIGNMENT
;
2269 #ifdef COFF_PAGE_SIZE
2270 int page_size
= COFF_PAGE_SIZE
;
2274 if (bfd_get_start_address (abfd
))
2276 /* A start address may have been added to the original file. In this
2277 case it will need an optional header to record it. */
2278 abfd
->flags
|= EXEC_P
;
2281 if (abfd
->flags
& EXEC_P
)
2284 else if (xcoff_data (abfd
)->full_aouthdr
)
2287 sofar
+= SMALL_AOUTSZ
;
2290 sofar
+= abfd
->section_count
* SCNHSZ
;
2293 /* XCOFF handles overflows in the reloc and line number count fields
2294 by allocating a new section header to hold the correct counts. */
2295 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2296 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
2300 align_adjust
= false;
2301 for (current
= abfd
->sections
, count
= 1;
2302 current
!= (asection
*) NULL
;
2303 current
= current
->next
, ++count
)
2305 #ifdef COFF_IMAGE_WITH_PE
2306 /* The NT loader does not want empty section headers, so we omit
2307 them. We don't actually remove the section from the BFD,
2308 although we probably should. This matches code in
2309 coff_write_object_contents. */
2310 if (current
->_raw_size
== 0)
2312 current
->target_index
= -1;
2318 current
->target_index
= count
;
2320 /* Only deal with sections which have contents */
2321 if (!(current
->flags
& SEC_HAS_CONTENTS
))
2324 /* Align the sections in the file to the same boundary on
2325 which they are aligned in virtual memory. I960 doesn't
2326 do this (FIXME) so we can stay in sync with Intel. 960
2327 doesn't yet page from files... */
2328 #ifdef ALIGN_SECTIONS_IN_FILE
2329 if ((abfd
->flags
& EXEC_P
) != 0)
2331 /* make sure this section is aligned on the right boundary - by
2332 padding the previous section up if necessary */
2335 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
2336 if (previous
!= (asection
*) NULL
)
2338 previous
->_raw_size
+= sofar
- old_sofar
;
2344 /* In demand paged files the low order bits of the file offset
2345 must match the low order bits of the virtual address. */
2346 #ifdef COFF_PAGE_SIZE
2347 if ((abfd
->flags
& D_PAGED
) != 0
2348 && (current
->flags
& SEC_ALLOC
) != 0)
2349 sofar
+= (current
->vma
- sofar
) % page_size
;
2351 current
->filepos
= sofar
;
2353 #ifdef COFF_IMAGE_WITH_PE
2354 /* With PE we have to pad each section to be a multiple of its
2355 page size too, and remember both sizes. */
2357 if (coff_section_data (abfd
, current
) == NULL
)
2359 current
->used_by_bfd
=
2360 (PTR
) bfd_zalloc (abfd
, sizeof (struct coff_section_tdata
));
2361 if (current
->used_by_bfd
== NULL
)
2364 if (pei_section_data (abfd
, current
) == NULL
)
2366 coff_section_data (abfd
, current
)->tdata
=
2367 (PTR
) bfd_zalloc (abfd
, sizeof (struct pei_section_tdata
));
2368 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
2371 if (pei_section_data (abfd
, current
)->virt_size
== 0)
2372 pei_section_data (abfd
, current
)->virt_size
= current
->_raw_size
;
2374 current
->_raw_size
= (current
->_raw_size
+ page_size
-1) & -page_size
;
2377 sofar
+= current
->_raw_size
;
2379 #ifdef ALIGN_SECTIONS_IN_FILE
2380 /* make sure that this section is of the right size too */
2381 if ((abfd
->flags
& EXEC_P
) == 0)
2383 bfd_size_type old_size
;
2385 old_size
= current
->_raw_size
;
2386 current
->_raw_size
= BFD_ALIGN (current
->_raw_size
,
2387 1 << current
->alignment_power
);
2388 align_adjust
= current
->_raw_size
!= old_size
;
2389 sofar
+= current
->_raw_size
- old_size
;
2394 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
2395 align_adjust
= sofar
!= old_sofar
;
2396 current
->_raw_size
+= sofar
- old_sofar
;
2400 #ifdef COFF_IMAGE_WITH_PE
2401 /* For PE we need to make sure we pad out to the aligned
2402 _raw_size, in case the caller only writes out data to the
2403 unaligned _raw_size. */
2404 if (pei_section_data (abfd
, current
)->virt_size
< current
->_raw_size
)
2405 align_adjust
= true;
2409 /* Force .lib sections to start at zero. The vma is then
2410 incremented in coff_set_section_contents. This is right for
2412 if (strcmp (current
->name
, _LIB
) == 0)
2413 bfd_set_section_vma (abfd
, current
, 0);
2419 /* It is now safe to write to the output file. If we needed an
2420 alignment adjustment for the last section, then make sure that
2421 there is a byte at offset sofar. If there are no symbols and no
2422 relocs, then nothing follows the last section. If we don't force
2423 the last byte out, then the file may appear to be truncated. */
2429 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
2430 || bfd_write (&b
, 1, 1, abfd
) != 1)
2434 /* Make sure the relocations are aligned. We don't need to make
2435 sure that this byte exists, because it will only matter if there
2436 really are relocs. */
2437 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
2439 obj_relocbase (abfd
) = sofar
;
2440 abfd
->output_has_begun
= true;
2447 /* This can never work, because it is called too late--after the
2448 section positions have been set. I can't figure out what it is
2449 for, so I am going to disable it--Ian Taylor 20 March 1996. */
2451 /* If .file, .text, .data, .bss symbols are missing, add them. */
2452 /* @@ Should we only be adding missing symbols, or overriding the aux
2453 values for existing section symbols? */
2455 coff_add_missing_symbols (abfd
)
2458 unsigned int nsyms
= bfd_get_symcount (abfd
);
2459 asymbol
**sympp
= abfd
->outsymbols
;
2462 int need_text
= 1, need_data
= 1, need_bss
= 1, need_file
= 1;
2464 for (i
= 0; i
< nsyms
; i
++)
2466 coff_symbol_type
*csym
= coff_symbol_from (abfd
, sympp
[i
]);
2470 /* only do this if there is a coff representation of the input
2472 if (csym
->native
&& csym
->native
->u
.syment
.n_sclass
== C_FILE
)
2477 name
= csym
->symbol
.name
;
2480 if (!strcmp (name
, _TEXT
))
2483 else if (!strcmp (name
, ".wtext"))
2486 else if (!strcmp (name
, _DATA
))
2488 else if (!strcmp (name
, _BSS
))
2492 /* Now i == bfd_get_symcount (abfd). */
2493 /* @@ For now, don't deal with .file symbol. */
2496 if (!need_text
&& !need_data
&& !need_bss
&& !need_file
)
2498 nsyms
+= need_text
+ need_data
+ need_bss
+ need_file
;
2499 sympp2
= (asymbol
**) bfd_alloc (abfd
, nsyms
* sizeof (asymbol
*));
2502 memcpy (sympp2
, sympp
, i
* sizeof (asymbol
*));
2505 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
2509 sympp2
[i
++] = coff_section_symbol (abfd
, _TEXT
);
2511 sympp2
[i
++] = coff_section_symbol (abfd
, _DATA
);
2513 sympp2
[i
++] = coff_section_symbol (abfd
, _BSS
);
2514 BFD_ASSERT (i
== nsyms
);
2515 bfd_set_symtab (abfd
, sympp2
, nsyms
);
2524 coff_write_object_contents (abfd
)
2528 boolean hasrelocs
= false;
2529 boolean haslinno
= false;
2531 file_ptr reloc_base
;
2532 file_ptr lineno_base
;
2534 unsigned long reloc_size
= 0;
2535 unsigned long lnno_size
= 0;
2536 boolean long_section_names
;
2537 asection
*text_sec
= NULL
;
2538 asection
*data_sec
= NULL
;
2539 asection
*bss_sec
= NULL
;
2540 struct internal_filehdr internal_f
;
2541 struct internal_aouthdr internal_a
;
2542 #ifdef COFF_LONG_SECTION_NAMES
2543 size_t string_size
= STRING_SIZE_SIZE
;
2546 bfd_set_error (bfd_error_system_call
);
2548 /* Make a pass through the symbol table to count line number entries and
2549 put them into the correct asections */
2551 lnno_size
= coff_count_linenumbers (abfd
) * LINESZ
;
2553 if (abfd
->output_has_begun
== false)
2555 if (! coff_compute_section_file_positions (abfd
))
2559 reloc_base
= obj_relocbase (abfd
);
2561 /* Work out the size of the reloc and linno areas */
2563 for (current
= abfd
->sections
; current
!= NULL
; current
=
2565 reloc_size
+= current
->reloc_count
* RELSZ
;
2567 lineno_base
= reloc_base
+ reloc_size
;
2568 sym_base
= lineno_base
+ lnno_size
;
2570 /* Indicate in each section->line_filepos its actual file address */
2571 for (current
= abfd
->sections
; current
!= NULL
; current
=
2574 if (current
->lineno_count
)
2576 current
->line_filepos
= lineno_base
;
2577 current
->moving_line_filepos
= lineno_base
;
2578 lineno_base
+= current
->lineno_count
* LINESZ
;
2582 current
->line_filepos
= 0;
2584 if (current
->reloc_count
)
2586 current
->rel_filepos
= reloc_base
;
2587 reloc_base
+= current
->reloc_count
* RELSZ
;
2591 current
->rel_filepos
= 0;
2595 /* Write section headers to the file. */
2596 internal_f
.f_nscns
= 0;
2598 if ((abfd
->flags
& EXEC_P
) != 0)
2599 scn_base
= FILHSZ
+ AOUTSZ
;
2604 if (xcoff_data (abfd
)->full_aouthdr
)
2607 scn_base
+= SMALL_AOUTSZ
;
2611 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
2614 long_section_names
= false;
2615 for (current
= abfd
->sections
;
2617 current
= current
->next
)
2619 struct internal_scnhdr section
;
2622 /* If we've got a .reloc section, remember. */
2624 #ifdef COFF_IMAGE_WITH_PE
2625 if (strcmp (current
->name
, ".reloc") == 0)
2627 pe_data (abfd
)->has_reloc_section
= 1;
2632 internal_f
.f_nscns
++;
2634 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
2636 #ifdef COFF_LONG_SECTION_NAMES
2637 /* Handle long section names as in PE. This must be compatible
2638 with the code in coff_write_symbols. */
2642 len
= strlen (current
->name
);
2645 memset (section
.s_name
, 0, SCNNMLEN
);
2646 sprintf (section
.s_name
, "/%lu", (unsigned long) string_size
);
2647 string_size
+= len
+ 1;
2648 long_section_names
= true;
2654 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
2655 Ian Taylor <ian@cygnus.com>. */
2656 if (strcmp (current
->name
, _LIB
) == 0)
2657 section
.s_vaddr
= 0;
2660 section
.s_vaddr
= current
->vma
;
2661 section
.s_paddr
= current
->lma
;
2662 section
.s_size
= current
->_raw_size
;
2665 section
.s_paddr
= 0;
2667 #ifdef COFF_IMAGE_WITH_PE
2668 /* Reminder: s_paddr holds the virtual size of the section. */
2669 if (coff_section_data (abfd
, current
) != NULL
2670 && pei_section_data (abfd
, current
) != NULL
)
2671 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
2673 section
.s_paddr
= 0;
2677 If this section has no size or is unloadable then the scnptr
2680 if (current
->_raw_size
== 0 ||
2681 (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2683 section
.s_scnptr
= 0;
2687 section
.s_scnptr
= current
->filepos
;
2689 section
.s_relptr
= current
->rel_filepos
;
2690 section
.s_lnnoptr
= current
->line_filepos
;
2691 section
.s_nreloc
= current
->reloc_count
;
2692 section
.s_nlnno
= current
->lineno_count
;
2693 if (current
->reloc_count
!= 0)
2695 if (current
->lineno_count
!= 0)
2699 /* Indicate the use of an XCOFF overflow section header. */
2700 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
2702 section
.s_nreloc
= 0xffff;
2703 section
.s_nlnno
= 0xffff;
2707 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
2709 if (!strcmp (current
->name
, _TEXT
))
2713 else if (!strcmp (current
->name
, _DATA
))
2717 else if (!strcmp (current
->name
, _BSS
))
2723 section
.s_align
= (current
->alignment_power
2724 ? 1 << current
->alignment_power
2726 /* start-sanitize-tic80 */
2729 section
.s_flags
|= (current
->alignment_power
& 0xF) << 8;
2731 /* end-sanitize-tic80 */
2734 #ifdef COFF_IMAGE_WITH_PE
2735 /* suppress output of the sections if they are null. ld includes
2736 the bss and data sections even if there is no size assigned
2737 to them. NT loader doesn't like it if these section headers are
2738 included if the sections themselves are not needed */
2739 if (section
.s_size
== 0)
2740 internal_f
.f_nscns
--;
2745 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
2746 || bfd_write ((PTR
) (&buff
), 1, SCNHSZ
, abfd
) != SCNHSZ
)
2751 /* PE stores COMDAT section information in the symbol table. If
2752 this section is supposed to have some COMDAT info, track down
2753 the symbol in the symbol table and modify it. */
2754 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
2756 unsigned int i
, count
;
2758 coff_symbol_type
*csym
= NULL
;
2762 count
= bfd_get_symcount (abfd
);
2763 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
2765 if ((*psym
)->section
!= current
)
2768 /* Remember the location of the first symbol in this
2770 if (psymsec
== NULL
)
2773 /* See if this is the section symbol. */
2774 if (strcmp ((*psym
)->name
, current
->name
) == 0)
2776 csym
= coff_symbol_from (abfd
, *psym
);
2778 || csym
->native
== NULL
2779 || csym
->native
->u
.syment
.n_numaux
< 1
2780 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
2781 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
2784 /* Here *PSYM is the section symbol for CURRENT. */
2791 Note that we might not if we're converting the file from
2792 some other object file format. */
2795 combined_entry_type
*aux
;
2797 /* We don't touch the x_checksum field. The
2798 x_associated field is not currently supported. */
2800 aux
= csym
->native
+ 1;
2801 switch (current
->flags
& SEC_LINK_DUPLICATES
)
2803 case SEC_LINK_DUPLICATES_DISCARD
:
2804 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
2807 case SEC_LINK_DUPLICATES_ONE_ONLY
:
2808 aux
->u
.auxent
.x_scn
.x_comdat
=
2809 IMAGE_COMDAT_SELECT_NODUPLICATES
;
2812 case SEC_LINK_DUPLICATES_SAME_SIZE
:
2813 aux
->u
.auxent
.x_scn
.x_comdat
=
2814 IMAGE_COMDAT_SELECT_SAME_SIZE
;
2817 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
2818 aux
->u
.auxent
.x_scn
.x_comdat
=
2819 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
2823 /* The COMDAT symbol must be the first symbol from this
2824 section in the symbol table. In order to make this
2825 work, we move the COMDAT symbol before the first
2826 symbol we found in the search above. It's OK to
2827 rearrange the symbol table at this point, because
2828 coff_renumber_symbols is going to rearrange it
2829 further and fix up all the aux entries. */
2830 if (psym
!= psymsec
)
2836 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
2837 pcopy
[0] = pcopy
[-1];
2842 #endif /* COFF_WITH_PE */
2846 /* XCOFF handles overflows in the reloc and line number count fields
2847 by creating a new section header to hold the correct values. */
2848 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2850 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
2852 struct internal_scnhdr scnhdr
;
2855 internal_f
.f_nscns
++;
2856 strncpy (&(scnhdr
.s_name
[0]), current
->name
, 8);
2857 scnhdr
.s_paddr
= current
->reloc_count
;
2858 scnhdr
.s_vaddr
= current
->lineno_count
;
2860 scnhdr
.s_scnptr
= 0;
2861 scnhdr
.s_relptr
= current
->rel_filepos
;
2862 scnhdr
.s_lnnoptr
= current
->line_filepos
;
2863 scnhdr
.s_nreloc
= current
->target_index
;
2864 scnhdr
.s_nlnno
= current
->target_index
;
2865 scnhdr
.s_flags
= STYP_OVRFLO
;
2866 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
2867 || bfd_write ((PTR
) &buff
, 1, SCNHSZ
, abfd
) != SCNHSZ
)
2873 /* OK, now set up the filehdr... */
2875 /* Don't include the internal abs section in the section count */
2878 We will NOT put a fucking timestamp in the header here. Every time you
2879 put it back, I will come in and take it out again. I'm sorry. This
2880 field does not belong here. We fill it with a 0 so it compares the
2881 same but is not a reasonable time. -- gnu@cygnus.com
2883 internal_f
.f_timdat
= 0;
2885 internal_f
.f_flags
= 0;
2887 if (abfd
->flags
& EXEC_P
)
2888 internal_f
.f_opthdr
= AOUTSZ
;
2891 internal_f
.f_opthdr
= 0;
2893 if (xcoff_data (abfd
)->full_aouthdr
)
2894 internal_f
.f_opthdr
= AOUTSZ
;
2896 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
2901 internal_f
.f_flags
|= F_RELFLG
;
2903 internal_f
.f_flags
|= F_LNNO
;
2904 if (abfd
->flags
& EXEC_P
)
2905 internal_f
.f_flags
|= F_EXEC
;
2907 /* FIXME: this is wrong for PPC_PE! */
2908 if (bfd_little_endian (abfd
))
2909 internal_f
.f_flags
|= F_AR32WR
;
2911 internal_f
.f_flags
|= F_AR32W
;
2913 /* start-sanitize-tic80 */
2914 #ifdef TIC80_TARGET_ID
2915 internal_f
.f_target_id
= TIC80_TARGET_ID
;
2917 /* end-sanitize-tic80 */
2920 FIXME, should do something about the other byte orders and
2925 if ((abfd
->flags
& DYNAMIC
) != 0)
2926 internal_f
.f_flags
|= F_SHROBJ
;
2927 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
2928 internal_f
.f_flags
|= F_DYNLOAD
;
2931 memset (&internal_a
, 0, sizeof internal_a
);
2933 /* Set up architecture-dependent stuff */
2936 unsigned int magic
= 0;
2937 unsigned short flags
= 0;
2938 coff_set_flags (abfd
, &magic
, &flags
);
2939 internal_f
.f_magic
= magic
;
2940 internal_f
.f_flags
|= flags
;
2941 /* ...and the "opt"hdr... */
2944 #ifdef ULTRA3 /* NYU's machine */
2945 /* FIXME: This is a bogus check. I really want to see if there
2946 * is a .shbss or a .shdata section, if so then set the magic
2947 * number to indicate a shared data executable.
2949 if (internal_f
.f_nscns
>= 7)
2950 internal_a
.magic
= SHMAGIC
; /* Shared magic */
2953 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
2954 #define __A_MAGIC_SET__
2956 /* start-sanitize-tic80 */
2958 internal_a
.magic
= TIC80_ARCH_MAGIC
;
2959 #define __A_MAGIC_SET__
2961 /* end-sanitize-tic80 */
2963 /* FIXME: What are the a.out magic numbers for the i860? */
2964 internal_a
.magic
= 0;
2965 #define __A_MAGIC_SET__
2968 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
2969 #define __A_MAGIC_SET__
2972 #define __A_MAGIC_SET__
2973 internal_a
.magic
= PAGEMAGICBCS
;
2977 #define __A_MAGIC_SET__
2978 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
2981 #if defined(M68) || defined(WE32K) || defined(M68K)
2982 #define __A_MAGIC_SET__
2984 internal_a
.magic
= LYNXCOFFMAGIC
;
2986 #if defined(TARG_AUX)
2987 internal_a
.magic
= (abfd
->flags
& D_PAGED
? PAGEMAGICPEXECPAGED
:
2988 abfd
->flags
& WP_TEXT
? PAGEMAGICPEXECSWAPPED
:
2989 PAGEMAGICEXECSWAPPED
);
2991 #if defined (PAGEMAGICPEXECPAGED)
2992 internal_a
.magic
= PAGEMAGICPEXECPAGED
;
2994 #endif /* TARG_AUX */
2996 #endif /* M68 || WE32K || M68K */
2999 #define __A_MAGIC_SET__
3000 internal_a
.magic
= ZMAGIC
;
3004 #define __A_MAGIC_SET__
3005 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3009 #define __A_MAGIC_SET__
3011 internal_a
.magic
= LYNXCOFFMAGIC
;
3013 internal_a
.magic
= ZMAGIC
;
3018 #define __A_MAGIC_SET__
3020 internal_a
.magic
= LYNXCOFFMAGIC
;
3025 #define __A_MAGIC_SET__
3026 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
3027 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
3028 RS6K_AOUTHDR_OMAGIC
;
3031 #ifndef __A_MAGIC_SET__
3032 #include "Your aouthdr magic number is not being set!"
3034 #undef __A_MAGIC_SET__
3038 /* FIXME: Does anybody ever set this to another value? */
3039 internal_a
.vstamp
= 0;
3041 /* Now should write relocs, strings, syms */
3042 obj_sym_filepos (abfd
) = sym_base
;
3044 if (bfd_get_symcount (abfd
) != 0)
3048 if (!coff_add_missing_symbols (abfd
))
3051 if (!coff_renumber_symbols (abfd
, &firstundef
))
3053 coff_mangle_symbols (abfd
);
3054 if (! coff_write_symbols (abfd
))
3056 if (! coff_write_linenumbers (abfd
))
3058 if (! coff_write_relocs (abfd
, firstundef
))
3061 #ifdef COFF_IMAGE_WITH_PE
3063 else if ((abfd
->flags
& EXEC_P
) != 0)
3067 /* PowerPC PE appears to require that all executable files be
3068 rounded up to the page size. */
3071 BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
3073 || bfd_write (&b
, 1, 1, abfd
) != 1)
3079 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3080 backend linker, and obj_raw_syment_count is not valid until after
3081 coff_write_symbols is called. */
3082 if (obj_raw_syment_count (abfd
) != 0)
3084 internal_f
.f_symptr
= sym_base
;
3086 /* AIX appears to require that F_RELFLG not be set if there are
3087 local symbols but no relocations. */
3088 internal_f
.f_flags
&=~ F_RELFLG
;
3093 if (long_section_names
)
3094 internal_f
.f_symptr
= sym_base
;
3096 internal_f
.f_symptr
= 0;
3097 internal_f
.f_flags
|= F_LSYMS
;
3102 internal_a
.tsize
= bfd_get_section_size_before_reloc (text_sec
);
3103 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
3107 internal_a
.dsize
= bfd_get_section_size_before_reloc (data_sec
);
3108 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
3112 internal_a
.bsize
= bfd_get_section_size_before_reloc (bss_sec
);
3113 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
3114 internal_a
.data_start
= bss_sec
->vma
;
3117 internal_a
.entry
= bfd_get_start_address (abfd
);
3118 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
3121 if (xcoff_data (abfd
)->full_aouthdr
)
3124 asection
*loader_sec
;
3126 internal_a
.vstamp
= 1;
3128 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
3129 if (internal_a
.o_snentry
== 0)
3130 internal_a
.entry
= (bfd_vma
) -1;
3132 if (text_sec
!= NULL
)
3134 internal_a
.o_sntext
= text_sec
->target_index
;
3135 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
3139 internal_a
.o_sntext
= 0;
3140 internal_a
.o_algntext
= 0;
3142 if (data_sec
!= NULL
)
3144 internal_a
.o_sndata
= data_sec
->target_index
;
3145 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
3149 internal_a
.o_sndata
= 0;
3150 internal_a
.o_algndata
= 0;
3152 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
3153 if (loader_sec
!= NULL
)
3154 internal_a
.o_snloader
= loader_sec
->target_index
;
3156 internal_a
.o_snloader
= 0;
3157 if (bss_sec
!= NULL
)
3158 internal_a
.o_snbss
= bss_sec
->target_index
;
3160 internal_a
.o_snbss
= 0;
3162 toc
= xcoff_data (abfd
)->toc
;
3163 internal_a
.o_toc
= toc
;
3164 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
3166 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
3167 if (xcoff_data (abfd
)->cputype
!= -1)
3168 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
3171 switch (bfd_get_arch (abfd
))
3173 case bfd_arch_rs6000
:
3174 internal_a
.o_cputype
= 4;
3176 case bfd_arch_powerpc
:
3177 if (bfd_get_mach (abfd
) == 0)
3178 internal_a
.o_cputype
= 3;
3180 internal_a
.o_cputype
= 1;
3186 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
3187 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
3191 /* now write them */
3192 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
3196 coff_swap_filehdr_out (abfd
, (PTR
) & internal_f
, (PTR
) buff
);
3197 if (bfd_write ((PTR
) buff
, 1, FILHSZ
, abfd
) != FILHSZ
)
3200 if (abfd
->flags
& EXEC_P
)
3202 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
3203 include/coff/pe.h sets AOUTSZ == sizeof(PEAOUTHDR)) */
3205 coff_swap_aouthdr_out (abfd
, (PTR
) & internal_a
, (PTR
) buff
);
3206 if (bfd_write ((PTR
) buff
, 1, AOUTSZ
, abfd
) != AOUTSZ
)
3215 /* XCOFF seems to always write at least a small a.out header. */
3216 coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, (PTR
) &buff
);
3217 if (xcoff_data (abfd
)->full_aouthdr
)
3220 size
= SMALL_AOUTSZ
;
3221 if (bfd_write ((PTR
) &buff
, 1, size
, abfd
) != size
)
3230 coff_set_section_contents (abfd
, section
, location
, offset
, count
)
3235 bfd_size_type count
;
3237 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
3239 if (! coff_compute_section_file_positions (abfd
))
3243 #if defined(_LIB) && !defined(TARG_AUX)
3245 /* The physical address field of a .lib section is used to hold the
3246 number of shared libraries in the section. This code counts the
3247 number of sections being written, and increments the lma field
3250 I have found no documentation on the contents of this section.
3251 Experimentation indicates that the section contains zero or more
3252 records, each of which has the following structure:
3254 - a (four byte) word holding the length of this record, in words,
3255 - a word that always seems to be set to "2",
3256 - the path to a shared library, null-terminated and then padded
3257 to a whole word boundary.
3259 bfd_assert calls have been added to alert if an attempt is made
3260 to write a section which doesn't follow these assumptions. The
3261 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
3262 <robertl@arnet.com> (Thanks!).
3264 Gvran Uddeborg <gvran@uddeborg.pp.se> */
3266 if (strcmp (section
->name
, _LIB
) == 0)
3268 bfd_byte
*rec
, *recend
;
3270 rec
= (bfd_byte
*) location
;
3271 recend
= rec
+ count
;
3272 while (rec
< recend
)
3275 rec
+= bfd_get_32 (abfd
, rec
) * 4;
3278 BFD_ASSERT (rec
== recend
);
3283 /* Don't write out bss sections - one way to do this is to
3284 see if the filepos has not been set. */
3285 if (section
->filepos
== 0)
3288 if (bfd_seek (abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
) != 0)
3293 return (bfd_write (location
, 1, count
, abfd
) == count
) ? true : false;
3299 coff_close_and_cleanup (abfd
)
3302 if (!bfd_read_p (abfd
))
3303 switch (abfd
->format
)
3306 if (!_bfd_write_archive_contents (abfd
))
3310 if (!coff_write_object_contents (abfd
))
3314 bfd_set_error (bfd_error_invalid_operation
);
3318 /* We depend on bfd_close to free all the memory on the objalloc. */
3325 buy_and_read (abfd
, where
, seek_direction
, size
)
3331 PTR area
= (PTR
) bfd_alloc (abfd
, size
);
3334 if (bfd_seek (abfd
, where
, seek_direction
) != 0
3335 || bfd_read (area
, 1, size
, abfd
) != size
)
3338 } /* buy_and_read() */
3344 Creating the linenumber table is done by reading in the entire
3345 coff linenumber table, and creating another table for internal use.
3347 A coff linenumber table is structured so that each function
3348 is marked as having a line number of 0. Each line within the
3349 function is an offset from the first line in the function. The
3350 base of the line number information for the table is stored in
3351 the symbol associated with the function.
3353 The information is copied from the external to the internal
3354 table, and each symbol which marks a function is marked by
3357 How does this work ?
3362 coff_slurp_line_table (abfd
, asect
)
3366 LINENO
*native_lineno
;
3367 alent
*lineno_cache
;
3369 BFD_ASSERT (asect
->lineno
== (alent
*) NULL
);
3371 native_lineno
= (LINENO
*) buy_and_read (abfd
,
3372 asect
->line_filepos
,
3375 asect
->lineno_count
));
3377 (alent
*) bfd_alloc (abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof (alent
)));
3378 if (lineno_cache
== NULL
)
3382 unsigned int counter
= 0;
3383 alent
*cache_ptr
= lineno_cache
;
3384 LINENO
*src
= native_lineno
;
3386 while (counter
< asect
->lineno_count
)
3388 struct internal_lineno dst
;
3389 coff_swap_lineno_in (abfd
, src
, &dst
);
3390 cache_ptr
->line_number
= dst
.l_lnno
;
3392 if (cache_ptr
->line_number
== 0)
3396 coff_symbol_type
*sym
;
3399 symndx
= dst
.l_addr
.l_symndx
;
3401 || (unsigned long) symndx
>= obj_raw_syment_count (abfd
))
3403 (*_bfd_error_handler
)
3404 (_("%s: warning: illegal symbol index %ld in line numbers"),
3405 bfd_get_filename (abfd
), dst
.l_addr
.l_symndx
);
3409 /* FIXME: We should not be casting between ints and
3410 pointers like this. */
3411 sym
= ((coff_symbol_type
*)
3412 ((symndx
+ obj_raw_syments (abfd
))
3413 ->u
.syment
._n
._n_n
._n_zeroes
));
3414 cache_ptr
->u
.sym
= (asymbol
*) sym
;
3415 if (sym
->lineno
!= NULL
&& ! warned
)
3417 (*_bfd_error_handler
)
3418 (_("%s: warning: duplicate line number information for `%s'"),
3419 bfd_get_filename (abfd
),
3420 bfd_asymbol_name (&sym
->symbol
));
3422 sym
->lineno
= cache_ptr
;
3426 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
3427 - bfd_section_vma (abfd
, asect
);
3428 } /* If no linenumber expect a symbol index */
3434 cache_ptr
->line_number
= 0;
3437 asect
->lineno
= lineno_cache
;
3438 /* FIXME, free native_lineno here, or use alloca or something. */
3443 coff_slurp_symbol_table (abfd
)
3446 combined_entry_type
*native_symbols
;
3447 coff_symbol_type
*cached_area
;
3448 unsigned int *table_ptr
;
3450 unsigned int number_of_symbols
= 0;
3452 if (obj_symbols (abfd
))
3455 /* Read in the symbol table */
3456 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
3461 /* Allocate enough room for all the symbols in cached form */
3462 cached_area
= ((coff_symbol_type
*)
3464 (obj_raw_syment_count (abfd
)
3465 * sizeof (coff_symbol_type
))));
3467 if (cached_area
== NULL
)
3469 table_ptr
= ((unsigned int *)
3471 (obj_raw_syment_count (abfd
)
3472 * sizeof (unsigned int))));
3474 if (table_ptr
== NULL
)
3478 coff_symbol_type
*dst
= cached_area
;
3479 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
3480 unsigned int this_index
= 0;
3481 while (this_index
< last_native_index
)
3483 combined_entry_type
*src
= native_symbols
+ this_index
;
3484 table_ptr
[this_index
] = number_of_symbols
;
3485 dst
->symbol
.the_bfd
= abfd
;
3487 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
3488 /* We use the native name field to point to the cached field. */
3489 src
->u
.syment
._n
._n_n
._n_zeroes
= (long) dst
;
3490 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
3491 src
->u
.syment
.n_scnum
);
3492 dst
->symbol
.flags
= 0;
3493 dst
->done_lineno
= false;
3495 switch (src
->u
.syment
.n_sclass
)
3500 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
3501 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
3502 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
3504 /* Fall through to next case */
3511 case C_THUMBEXTFUNC
:
3517 case C_SYSTEM
: /* System Wide variable */
3520 /* PE uses storage class 0x68 to denote a section symbol */
3522 /* PE uses storage class 0x69 for a weak external symbol. */
3525 if ((src
->u
.syment
.n_scnum
) == 0)
3527 if ((src
->u
.syment
.n_value
) == 0)
3529 dst
->symbol
.section
= bfd_und_section_ptr
;
3530 dst
->symbol
.value
= 0;
3534 dst
->symbol
.section
= bfd_com_section_ptr
;
3535 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3540 /* Base the value as an index from the base of the
3543 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
3545 #if defined COFF_WITH_PE
3546 /* PE sets the symbol to a value relative to the
3547 start of the section. */
3548 dst
->symbol
.value
= src
->u
.syment
.n_value
;
3550 dst
->symbol
.value
= (src
->u
.syment
.n_value
3551 - dst
->symbol
.section
->vma
);
3554 if (ISFCN ((src
->u
.syment
.n_type
)))
3556 /* A function ext does not go at the end of a
3558 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
3563 /* A C_HIDEXT symbol is not global. */
3564 if (src
->u
.syment
.n_sclass
== C_HIDEXT
)
3565 dst
->symbol
.flags
= BSF_LOCAL
;
3566 /* A symbol with a csect entry should not go at the end. */
3567 if (src
->u
.syment
.n_numaux
> 0)
3568 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
3572 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
3573 dst
->symbol
.flags
= BSF_WEAK
;
3578 case C_STAT
: /* static */
3580 case C_LEAFSTAT
: /* static leaf procedure */
3583 case C_THUMBSTAT
: /* Thumb static */
3584 case C_THUMBLABEL
: /* Thumb label */
3585 case C_THUMBSTATFUNC
:/* Thumb static function */
3587 case C_LABEL
: /* label */
3588 if (src
->u
.syment
.n_scnum
== -2)
3589 dst
->symbol
.flags
= BSF_DEBUGGING
;
3591 dst
->symbol
.flags
= BSF_LOCAL
;
3593 /* Base the value as an index from the base of the
3594 section, if there is one. */
3595 if (dst
->symbol
.section
)
3597 #if defined COFF_WITH_PE
3598 /* PE sets the symbol to a value relative to the
3599 start of the section. */
3600 dst
->symbol
.value
= src
->u
.syment
.n_value
;
3602 dst
->symbol
.value
= (src
->u
.syment
.n_value
3603 - dst
->symbol
.section
->vma
);
3607 dst
->symbol
.value
= src
->u
.syment
.n_value
;
3610 case C_MOS
: /* member of structure */
3611 case C_EOS
: /* end of structure */
3612 #ifdef NOTDEF /* C_AUTOARG has the same value */
3614 case C_GLBLREG
: /* A29k-specific storage class */
3617 case C_REGPARM
: /* register parameter */
3618 case C_REG
: /* register variable */
3619 /* start-sanitize-tic80 */
3621 /* end-sanitize-tic80 */
3623 case C_AUTOARG
: /* 960-specific storage class */
3625 /* start-sanitize-tic80 */
3627 /* end-sanitize-tic80 */
3628 case C_TPDEF
: /* type definition */
3630 case C_AUTO
: /* automatic variable */
3631 case C_FIELD
: /* bit field */
3632 case C_ENTAG
: /* enumeration tag */
3633 case C_MOE
: /* member of enumeration */
3634 case C_MOU
: /* member of union */
3635 case C_UNTAG
: /* union tag */
3636 dst
->symbol
.flags
= BSF_DEBUGGING
;
3637 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3640 case C_FILE
: /* file name */
3641 case C_STRTAG
: /* structure tag */
3656 dst
->symbol
.flags
= BSF_DEBUGGING
;
3657 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3661 case C_BINCL
: /* beginning of include file */
3662 case C_EINCL
: /* ending of include file */
3663 /* The value is actually a pointer into the line numbers
3664 of the file. We locate the line number entry, and
3665 set the section to the section which contains it, and
3666 the value to the index in that section. */
3670 dst
->symbol
.flags
= BSF_DEBUGGING
;
3671 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3672 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
3673 && ((file_ptr
) (sec
->line_filepos
3674 + sec
->lineno_count
* LINESZ
)
3675 > (file_ptr
) src
->u
.syment
.n_value
))
3678 dst
->symbol
.value
= 0;
3681 dst
->symbol
.section
= sec
;
3682 dst
->symbol
.value
= ((src
->u
.syment
.n_value
3683 - sec
->line_filepos
)
3691 dst
->symbol
.flags
= BSF_DEBUGGING
;
3693 /* The value is actually a symbol index. Save a pointer
3694 to the symbol instead of the index. FIXME: This
3695 should use a union. */
3696 src
->u
.syment
.n_value
=
3697 (long) (native_symbols
+ src
->u
.syment
.n_value
);
3698 dst
->symbol
.value
= src
->u
.syment
.n_value
;
3703 case C_BLOCK
: /* ".bb" or ".eb" */
3704 case C_FCN
: /* ".bf" or ".ef" */
3705 case C_EFCN
: /* physical end of function */
3706 dst
->symbol
.flags
= BSF_LOCAL
;
3707 #if defined COFF_WITH_PE
3708 /* PE sets the symbol to a value relative to the start
3710 dst
->symbol
.value
= src
->u
.syment
.n_value
;
3712 /* Base the value as an index from the base of the
3714 dst
->symbol
.value
= (src
->u
.syment
.n_value
3715 - dst
->symbol
.section
->vma
);
3720 case C_EXTDEF
: /* external definition */
3721 case C_ULABEL
: /* undefined label */
3722 case C_USTATIC
: /* undefined static */
3723 #ifndef COFF_WITH_PE
3724 /* C_LINE in regular coff is 0x68. NT has taken over this storage
3725 class to represent a section symbol */
3726 case C_LINE
: /* line # reformatted as symbol table entry */
3727 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
3728 case C_ALIAS
: /* duplicate tag */
3730 /* start-sanitize-tic80 */
3731 /* New storage classes for TIc80 */
3733 case C_UEXT
: /* Tentative external definition */
3735 case C_STATLAB
: /* Static load time label */
3736 case C_EXTLAB
: /* External load time label */
3737 /* end-sanitize-tic80 */
3738 case C_HIDDEN
: /* ext symbol in dmert public lib */
3740 (*_bfd_error_handler
)
3741 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
3742 bfd_get_filename (abfd
), src
->u
.syment
.n_sclass
,
3743 dst
->symbol
.section
->name
, dst
->symbol
.name
);
3744 dst
->symbol
.flags
= BSF_DEBUGGING
;
3745 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3749 /* BFD_ASSERT(dst->symbol.flags != 0);*/
3753 dst
->symbol
.udata
.i
= 0;
3754 dst
->lineno
= (alent
*) NULL
;
3755 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
3757 number_of_symbols
++;
3758 } /* walk the native symtab */
3759 } /* bfdize the native symtab */
3761 obj_symbols (abfd
) = cached_area
;
3762 obj_raw_syments (abfd
) = native_symbols
;
3764 bfd_get_symcount (abfd
) = number_of_symbols
;
3765 obj_convert (abfd
) = table_ptr
;
3766 /* Slurp the line tables for each section too */
3772 coff_slurp_line_table (abfd
, p
);
3777 } /* coff_slurp_symbol_table() */
3779 /* Check whether a symbol is globally visible. This is used by the
3780 COFF backend linker code in cofflink.c, since a couple of targets
3781 have globally visible symbols which are not class C_EXT. This
3782 function need not handle the case of n_class == C_EXT. */
3784 #undef OTHER_GLOBAL_CLASS
3787 #define OTHER_GLOBAL_CLASS C_LEAFEXT
3791 #define OTHER_GLOBAL_CLASS C_THUMBEXT || syment->n_sclass == C_THUMBEXTFUNC
3794 #define OTHER_GLOBAL_CLASS C_SECTION
3798 #ifdef OTHER_GLOBAL_CLASS
3800 static boolean coff_sym_is_global
PARAMS ((bfd
*, struct internal_syment
*));
3803 coff_sym_is_global (abfd
, syment
)
3805 struct internal_syment
* syment
;
3807 return (syment
->n_sclass
== OTHER_GLOBAL_CLASS
);
3810 #undef OTHER_GLOBAL_CLASS
3812 #else /* ! defined (OTHER_GLOBAL_CLASS) */
3814 /* sym_is_global should not be defined if it has nothing to do. */
3816 #define coff_sym_is_global 0
3818 #endif /* ! defined (OTHER_GLOBAL_CLASS) */
3824 Coff relocations are easily transformed into the internal BFD form
3827 Reading a coff relocation table is done in the following stages:
3829 o Read the entire coff relocation table into memory.
3831 o Process each relocation in turn; first swap it from the
3832 external to the internal form.
3834 o Turn the symbol referenced in the relocation's symbol index
3835 into a pointer into the canonical symbol table.
3836 This table is the same as the one returned by a call to
3837 @code{bfd_canonicalize_symtab}. The back end will call that
3838 routine and save the result if a canonicalization hasn't been done.
3840 o The reloc index is turned into a pointer to a howto
3841 structure, in a back end specific way. For instance, the 386
3842 and 960 use the @code{r_type} to directly produce an index
3843 into a howto table vector; the 88k subtracts a number from the
3844 @code{r_type} field and creates an addend field.
3850 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
3852 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
3853 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
3854 coffsym = (obj_symbols (abfd) \
3855 + (cache_ptr->sym_ptr_ptr - symbols)); \
3857 coffsym = coff_symbol_from (abfd, ptr); \
3858 if (coffsym != (coff_symbol_type *) NULL \
3859 && coffsym->native->u.syment.n_scnum == 0) \
3860 cache_ptr->addend = 0; \
3861 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
3862 && ptr->section != (asection *) NULL) \
3863 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
3865 cache_ptr->addend = 0; \
3870 coff_slurp_reloc_table (abfd
, asect
, symbols
)
3875 RELOC
*native_relocs
;
3876 arelent
*reloc_cache
;
3881 if (asect
->relocation
)
3883 if (asect
->reloc_count
== 0)
3885 if (asect
->flags
& SEC_CONSTRUCTOR
)
3887 if (!coff_slurp_symbol_table (abfd
))
3890 (RELOC
*) buy_and_read (abfd
,
3894 asect
->reloc_count
));
3895 reloc_cache
= (arelent
*)
3896 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
3898 if (reloc_cache
== NULL
)
3902 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
3904 struct internal_reloc dst
;
3905 struct external_reloc
*src
;
3906 #ifndef RELOC_PROCESSING
3910 cache_ptr
= reloc_cache
+ idx
;
3911 src
= native_relocs
+ idx
;
3913 coff_swap_reloc_in (abfd
, src
, &dst
);
3915 #ifdef RELOC_PROCESSING
3916 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
3918 cache_ptr
->address
= dst
.r_vaddr
;
3920 if (dst
.r_symndx
!= -1)
3922 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
3924 (*_bfd_error_handler
)
3925 (_("%s: warning: illegal symbol index %ld in relocs"),
3926 bfd_get_filename (abfd
), dst
.r_symndx
);
3927 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
3932 cache_ptr
->sym_ptr_ptr
= (symbols
3933 + obj_convert (abfd
)[dst
.r_symndx
]);
3934 ptr
= *(cache_ptr
->sym_ptr_ptr
);
3939 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
3943 /* The symbols definitions that we have read in have been
3944 relocated as if their sections started at 0. But the offsets
3945 refering to the symbols in the raw data have not been
3946 modified, so we have to have a negative addend to compensate.
3948 Note that symbols which used to be common must be left alone */
3950 /* Calculate any reloc addend by looking at the symbol */
3951 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
3953 cache_ptr
->address
-= asect
->vma
;
3954 /* !! cache_ptr->section = (asection *) NULL;*/
3956 /* Fill in the cache_ptr->howto field from dst.r_type */
3957 RTYPE2HOWTO (cache_ptr
, &dst
);
3958 #endif /* RELOC_PROCESSING */
3960 if (cache_ptr
->howto
== NULL
)
3962 (*_bfd_error_handler
)
3963 (_("%s: illegal relocation type %d at address 0x%lx"),
3964 bfd_get_filename (abfd
), dst
.r_type
, (long) dst
.r_vaddr
);
3965 bfd_set_error (bfd_error_bad_value
);
3970 asect
->relocation
= reloc_cache
;
3974 #ifndef coff_rtype_to_howto
3977 /* Get the howto structure for a reloc. This is only used if the file
3978 including this one defines coff_relocate_section to be
3979 _bfd_coff_generic_relocate_section, so it is OK if it does not
3980 always work. It is the responsibility of the including file to
3981 make sure it is reasonable if it is needed. */
3983 static reloc_howto_type
*coff_rtype_to_howto
3984 PARAMS ((bfd
*, asection
*, struct internal_reloc
*,
3985 struct coff_link_hash_entry
*, struct internal_syment
*,
3989 static reloc_howto_type
*
3990 coff_rtype_to_howto (abfd
, sec
, rel
, h
, sym
, addendp
)
3993 struct internal_reloc
*rel
;
3994 struct coff_link_hash_entry
*h
;
3995 struct internal_syment
*sym
;
4000 RTYPE2HOWTO (&genrel
, rel
);
4001 return genrel
.howto
;
4004 #else /* ! defined (RTYPE2HOWTO) */
4006 #define coff_rtype_to_howto NULL
4008 #endif /* ! defined (RTYPE2HOWTO) */
4009 #endif /* ! defined (coff_rtype_to_howto) */
4011 /* This is stupid. This function should be a boolean predicate. */
4013 coff_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
4019 arelent
*tblptr
= section
->relocation
;
4020 unsigned int count
= 0;
4023 if (section
->flags
& SEC_CONSTRUCTOR
)
4025 /* this section has relocs made up by us, they are not in the
4026 file, so take them out of their chain and place them into
4027 the data area provided */
4028 arelent_chain
*chain
= section
->constructor_chain
;
4029 for (count
= 0; count
< section
->reloc_count
; count
++)
4031 *relptr
++ = &chain
->relent
;
4032 chain
= chain
->next
;
4038 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
4041 tblptr
= section
->relocation
;
4043 for (; count
++ < section
->reloc_count
;)
4044 *relptr
++ = tblptr
++;
4049 return section
->reloc_count
;
4054 coff_sym_filepos (abfd
)
4057 return obj_sym_filepos (abfd
);
4061 #ifndef coff_reloc16_estimate
4062 #define coff_reloc16_estimate dummy_reloc16_estimate
4064 static int dummy_reloc16_estimate
4065 PARAMS ((bfd
*, asection
*, arelent
*, unsigned int,
4066 struct bfd_link_info
*));
4069 dummy_reloc16_estimate (abfd
, input_section
, reloc
, shrink
, link_info
)
4071 asection
*input_section
;
4073 unsigned int shrink
;
4074 struct bfd_link_info
*link_info
;
4081 #ifndef coff_reloc16_extra_cases
4083 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
4085 /* This works even if abort is not declared in any header file. */
4087 static void dummy_reloc16_extra_cases
4088 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*, arelent
*,
4089 bfd_byte
*, unsigned int *, unsigned int *));
4092 dummy_reloc16_extra_cases (abfd
, link_info
, link_order
, reloc
, data
, src_ptr
,
4095 struct bfd_link_info
*link_info
;
4096 struct bfd_link_order
*link_order
;
4099 unsigned int *src_ptr
;
4100 unsigned int *dst_ptr
;
4106 /* If coff_relocate_section is defined, we can use the optimized COFF
4107 backend linker. Otherwise we must continue to use the old linker. */
4108 #ifdef coff_relocate_section
4109 #ifndef coff_bfd_link_hash_table_create
4110 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
4112 #ifndef coff_bfd_link_add_symbols
4113 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
4115 #ifndef coff_bfd_final_link
4116 #define coff_bfd_final_link _bfd_coff_final_link
4118 #else /* ! defined (coff_relocate_section) */
4119 #define coff_relocate_section NULL
4120 #ifndef coff_bfd_link_hash_table_create
4121 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
4123 #ifndef coff_bfd_link_add_symbols
4124 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
4126 #define coff_bfd_final_link _bfd_generic_final_link
4127 #endif /* ! defined (coff_relocate_section) */
4129 #define coff_bfd_link_split_section _bfd_generic_link_split_section
4131 #ifndef coff_start_final_link
4132 #define coff_start_final_link NULL
4135 #ifndef coff_adjust_symndx
4136 #define coff_adjust_symndx NULL
4139 #ifndef coff_link_add_one_symbol
4140 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
4143 #ifndef coff_link_output_has_begun
4144 #define coff_link_output_has_begun _coff_link_output_has_begun
4146 _coff_link_output_has_begun (abfd
, info
)
4148 struct bfd_link_info
* info
;
4150 return abfd
->output_has_begun
;
4154 #ifndef coff_final_link_postscript
4155 #define coff_final_link_postscript _coff_final_link_postscript
4157 _coff_final_link_postscript (abfd
, pfinfo
)
4159 struct coff_final_link_info
* pfinfo
;
4165 #ifndef coff_SWAP_aux_in
4166 #define coff_SWAP_aux_in coff_swap_aux_in
4168 #ifndef coff_SWAP_sym_in
4169 #define coff_SWAP_sym_in coff_swap_sym_in
4171 #ifndef coff_SWAP_lineno_in
4172 #define coff_SWAP_lineno_in coff_swap_lineno_in
4174 #ifndef coff_SWAP_aux_out
4175 #define coff_SWAP_aux_out coff_swap_aux_out
4177 #ifndef coff_SWAP_sym_out
4178 #define coff_SWAP_sym_out coff_swap_sym_out
4180 #ifndef coff_SWAP_lineno_out
4181 #define coff_SWAP_lineno_out coff_swap_lineno_out
4183 #ifndef coff_SWAP_reloc_out
4184 #define coff_SWAP_reloc_out coff_swap_reloc_out
4186 #ifndef coff_SWAP_filehdr_out
4187 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
4189 #ifndef coff_SWAP_aouthdr_out
4190 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
4192 #ifndef coff_SWAP_scnhdr_out
4193 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
4195 #ifndef coff_SWAP_reloc_in
4196 #define coff_SWAP_reloc_in coff_swap_reloc_in
4198 #ifndef coff_SWAP_filehdr_in
4199 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
4201 #ifndef coff_SWAP_aouthdr_in
4202 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
4204 #ifndef coff_SWAP_scnhdr_in
4205 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
4210 static CONST bfd_coff_backend_data bfd_coff_std_swap_table
=
4212 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
4213 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
4214 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
4215 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
4216 coff_SWAP_scnhdr_out
,
4217 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
,
4218 #ifdef COFF_LONG_FILENAMES
4223 #ifdef COFF_LONG_SECTION_NAMES
4228 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
4229 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
4230 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
4231 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
4232 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
4233 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
4234 coff_sym_is_global
, coff_compute_section_file_positions
,
4235 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
4236 coff_adjust_symndx
, coff_link_add_one_symbol
,
4237 coff_link_output_has_begun
, coff_final_link_postscript
4240 #ifndef coff_close_and_cleanup
4241 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
4244 #ifndef coff_bfd_free_cached_info
4245 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
4248 #ifndef coff_get_section_contents
4249 #define coff_get_section_contents _bfd_generic_get_section_contents
4252 #ifndef coff_bfd_copy_private_symbol_data
4253 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
4256 #ifndef coff_bfd_copy_private_section_data
4257 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
4260 #ifndef coff_bfd_copy_private_bfd_data
4261 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
4264 #ifndef coff_bfd_merge_private_bfd_data
4265 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
4268 #ifndef coff_bfd_set_private_flags
4269 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
4272 #ifndef coff_bfd_print_private_bfd_data
4273 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
4276 #ifndef coff_bfd_is_local_label_name
4277 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
4280 #ifndef coff_read_minisymbols
4281 #define coff_read_minisymbols _bfd_generic_read_minisymbols
4284 #ifndef coff_minisymbol_to_symbol
4285 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
4288 /* The reloc lookup routine must be supplied by each individual COFF
4290 #ifndef coff_bfd_reloc_type_lookup
4291 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4294 #ifndef coff_bfd_get_relocated_section_contents
4295 #define coff_bfd_get_relocated_section_contents \
4296 bfd_generic_get_relocated_section_contents
4299 #ifndef coff_bfd_relax_section
4300 #define coff_bfd_relax_section bfd_generic_relax_section
4303 #ifndef coff_bfd_gc_sections
4304 #define coff_bfd_gc_sections bfd_generic_gc_sections