1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright 1990, 91, 92, 93, 94, 1995 Free Software Foundation, Inc.
3 Written by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 Most of this hacked by Steve Chamberlain,
30 BFD supports a number of different flavours of coff format.
31 The major differences between formats are the sizes and
32 alignments of fields in structures on disk, and the occasional
35 Coff in all its varieties is implemented with a few common
36 files and a number of implementation specific files. For
37 example, The 88k bcs coff format is implemented in the file
38 @file{coff-m88k.c}. This file @code{#include}s
39 @file{coff/m88k.h} which defines the external structure of the
40 coff format for the 88k, and @file{coff/internal.h} which
41 defines the internal structure. @file{coff-m88k.c} also
42 defines the relocations used by the 88k format
45 The Intel i960 processor version of coff is implemented in
46 @file{coff-i960.c}. This file has the same structure as
47 @file{coff-m88k.c}, except that it includes @file{coff/i960.h}
48 rather than @file{coff-m88k.h}.
51 Porting to a new version of coff
53 The recommended method is to select from the existing
54 implementations the version of coff which is most like the one
55 you want to use. For example, we'll say that i386 coff is
56 the one you select, and that your coff flavour is called foo.
57 Copy @file{i386coff.c} to @file{foocoff.c}, copy
58 @file{../include/coff/i386.h} to @file{../include/coff/foo.h},
59 and add the lines to @file{targets.c} and @file{Makefile.in}
60 so that your new back end is used. Alter the shapes of the
61 structures in @file{../include/coff/foo.h} so that they match
62 what you need. You will probably also have to add
63 @code{#ifdef}s to the code in @file{coff/internal.h} and
64 @file{coffcode.h} if your version of coff is too wild.
66 You can verify that your new BFD backend works quite simply by
67 building @file{objdump} from the @file{binutils} directory,
68 and making sure that its version of what's going on and your
69 host system's idea (assuming it has the pretty standard coff
70 dump utility, usually called @code{att-dump} or just
71 @code{dump}) are the same. Then clean up your code, and send
72 what you've done to Cygnus. Then your stuff will be in the
73 next release, and you won't have to keep integrating it.
76 How the coff backend works
81 The Coff backend is split into generic routines that are
82 applicable to any Coff target and routines that are specific
83 to a particular target. The target-specific routines are
84 further split into ones which are basically the same for all
85 Coff targets except that they use the external symbol format
86 or use different values for certain constants.
88 The generic routines are in @file{coffgen.c}. These routines
89 work for any Coff target. They use some hooks into the target
90 specific code; the hooks are in a @code{bfd_coff_backend_data}
91 structure, one of which exists for each target.
93 The essentially similar target-specific routines are in
94 @file{coffcode.h}. This header file includes executable C code.
95 The various Coff targets first include the appropriate Coff
96 header file, make any special defines that are needed, and
97 then include @file{coffcode.h}.
99 Some of the Coff targets then also have additional routines in
100 the target source file itself.
102 For example, @file{coff-i960.c} includes
103 @file{coff/internal.h} and @file{coff/i960.h}. It then
104 defines a few constants, such as @code{I960}, and includes
105 @file{coffcode.h}. Since the i960 has complex relocation
106 types, @file{coff-i960.c} also includes some code to
107 manipulate the i960 relocs. This code is not in
108 @file{coffcode.h} because it would not be used by any other
114 Each flavour of coff supported in BFD has its own header file
115 describing the external layout of the structures. There is also
116 an internal description of the coff layout, in
117 @file{coff/internal.h}. A major function of the
118 coff backend is swapping the bytes and twiddling the bits to
119 translate the external form of the structures into the normal
120 internal form. This is all performed in the
121 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
122 elements are different sizes between different versions of
123 coff; it is the duty of the coff version specific include file
124 to override the definitions of various packing routines in
125 @file{coffcode.h}. E.g., the size of line number entry in coff is
126 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
127 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
128 correct one. No doubt, some day someone will find a version of
129 coff which has a varying field size not catered to at the
130 moment. To port BFD, that person will have to add more @code{#defines}.
131 Three of the bit twiddling routines are exported to
132 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
133 and @code{coff_swap_linno_in}. @code{GDB} reads the symbol
134 table on its own, but uses BFD to fix things up. More of the
135 bit twiddlers are exported for @code{gas};
136 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
137 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
138 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
139 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
140 of all the symbol table and reloc drudgery itself, thereby
141 saving the internal BFD overhead, but uses BFD to swap things
142 on the way out, making cross ports much safer. Doing so also
143 allows BFD (and thus the linker) to use the same header files
144 as @code{gas}, which makes one avenue to disaster disappear.
149 The simple canonical form for symbols used by BFD is not rich
150 enough to keep all the information available in a coff symbol
151 table. The back end gets around this problem by keeping the original
152 symbol table around, "behind the scenes".
154 When a symbol table is requested (through a call to
155 @code{bfd_canonicalize_symtab}), a request gets through to
156 @code{coff_get_normalized_symtab}. This reads the symbol table from
157 the coff file and swaps all the structures inside into the
158 internal form. It also fixes up all the pointers in the table
159 (represented in the file by offsets from the first symbol in
160 the table) into physical pointers to elements in the new
161 internal table. This involves some work since the meanings of
162 fields change depending upon context: a field that is a
163 pointer to another structure in the symbol table at one moment
164 may be the size in bytes of a structure at the next. Another
165 pass is made over the table. All symbols which mark file names
166 (<<C_FILE>> symbols) are modified so that the internal
167 string points to the value in the auxent (the real filename)
168 rather than the normal text associated with the symbol
171 At this time the symbol names are moved around. Coff stores
172 all symbols less than nine characters long physically
173 within the symbol table; longer strings are kept at the end of
174 the file in the string table. This pass moves all strings
175 into memory and replaces them with pointers to the strings.
178 The symbol table is massaged once again, this time to create
179 the canonical table used by the BFD application. Each symbol
180 is inspected in turn, and a decision made (using the
181 @code{sclass} field) about the various flags to set in the
182 @code{asymbol}. @xref{Symbols}. The generated canonical table
183 shares strings with the hidden internal symbol table.
185 Any linenumbers are read from the coff file too, and attached
186 to the symbols which own the functions the linenumbers belong to.
191 Writing a symbol to a coff file which didn't come from a coff
192 file will lose any debugging information. The @code{asymbol}
193 structure remembers the BFD from which the symbol was taken, and on
194 output the back end makes sure that the same destination target as
195 source target is present.
197 When the symbols have come from a coff file then all the
198 debugging information is preserved.
200 Symbol tables are provided for writing to the back end in a
201 vector of pointers to pointers. This allows applications like
202 the linker to accumulate and output large symbol tables
203 without having to do too much byte copying.
205 This function runs through the provided symbol table and
206 patches each symbol marked as a file place holder
207 (@code{C_FILE}) to point to the next file place holder in the
208 list. It also marks each @code{offset} field in the list with
209 the offset from the first symbol of the current symbol.
211 Another function of this procedure is to turn the canonical
212 value form of BFD into the form used by coff. Internally, BFD
213 expects symbol values to be offsets from a section base; so a
214 symbol physically at 0x120, but in a section starting at
215 0x100, would have the value 0x20. Coff expects symbols to
216 contain their final value, so symbols have their values
217 changed at this point to reflect their sum with their owning
218 section. This transformation uses the
219 <<output_section>> field of the @code{asymbol}'s
220 @code{asection} @xref{Sections}.
222 o <<coff_mangle_symbols>>
224 This routine runs though the provided symbol table and uses
225 the offsets generated by the previous pass and the pointers
226 generated when the symbol table was read in to create the
227 structured hierachy required by coff. It changes each pointer
228 to a symbol into the index into the symbol table of the asymbol.
230 o <<coff_write_symbols>>
232 This routine runs through the symbol table and patches up the
233 symbols from their internal form into the coff way, calls the
234 bit twiddlers, and writes out the table to the file.
243 The hidden information for an <<asymbol>> is described in a
244 <<combined_entry_type>>:
248 .typedef struct coff_ptr_struct
251 . {* Remembers the offset from the first symbol in the file for
252 . this symbol. Generated by coff_renumber_symbols. *}
253 .unsigned int offset;
255 . {* Should the value of this symbol be renumbered. Used for
256 . XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
257 .unsigned int fix_value : 1;
259 . {* Should the tag field of this symbol be renumbered.
260 . Created by coff_pointerize_aux. *}
261 .unsigned int fix_tag : 1;
263 . {* Should the endidx field of this symbol be renumbered.
264 . Created by coff_pointerize_aux. *}
265 .unsigned int fix_end : 1;
267 . {* Should the x_csect.x_scnlen field be renumbered.
268 . Created by coff_pointerize_aux. *}
269 .unsigned int fix_scnlen : 1;
271 . {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
272 . index into the line number entries. Set by
273 . coff_slurp_symbol_table. *}
274 .unsigned int fix_line : 1;
276 . {* The container for the symbol structure as read and translated
280 . union internal_auxent auxent;
281 . struct internal_syment syment;
283 .} combined_entry_type;
286 .{* Each canonical asymbol really looks like this: *}
288 .typedef struct coff_symbol_struct
290 . {* The actual symbol which the rest of BFD works with *}
293 . {* A pointer to the hidden information for this symbol *}
294 .combined_entry_type *native;
296 . {* A pointer to the linenumber information for this symbol *}
297 .struct lineno_cache_entry *lineno;
299 . {* Have the line numbers been relocated yet ? *}
300 .boolean done_lineno;
309 #include "coffswap.h"
313 /* void warning(); */
316 * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the
317 * incoming SEC_* flags. The inverse of this function is styp_to_sec_flags().
318 * NOTE: If you add to/change this routine, you should mirror the changes
319 * in styp_to_sec_flags().
322 sec_to_styp_flags (sec_name
, sec_flags
)
323 CONST
char *sec_name
;
328 if (!strcmp (sec_name
, _TEXT
))
330 styp_flags
= STYP_TEXT
;
332 else if (!strcmp (sec_name
, _DATA
))
334 styp_flags
= STYP_DATA
;
336 else if (!strcmp (sec_name
, _BSS
))
338 styp_flags
= STYP_BSS
;
341 else if (!strcmp (sec_name
, _COMMENT
))
343 styp_flags
= STYP_INFO
;
344 #endif /* _COMMENT */
347 else if (!strcmp (sec_name
, _LIB
))
349 styp_flags
= STYP_LIB
;
353 else if (!strcmp (sec_name
, _LIT
))
355 styp_flags
= STYP_LIT
;
358 else if (!strcmp (sec_name
, ".debug"))
361 styp_flags
= STYP_DEBUG
;
363 styp_flags
= STYP_INFO
;
366 else if (!strncmp (sec_name
, ".stab", 5))
368 styp_flags
= STYP_INFO
;
371 else if (!strcmp (sec_name
, ".edata"))
373 styp_flags
= STYP_DATA
;
377 else if (!strcmp (sec_name
, _PAD
))
379 styp_flags
= STYP_PAD
;
381 else if (!strcmp (sec_name
, _LOADER
))
383 styp_flags
= STYP_LOADER
;
386 /* Try and figure out what it should be */
387 else if (sec_flags
& SEC_CODE
)
389 styp_flags
= STYP_TEXT
;
391 else if (sec_flags
& SEC_DATA
)
393 styp_flags
= STYP_DATA
;
395 else if (sec_flags
& SEC_READONLY
)
397 #ifdef STYP_LIT /* 29k readonly text/data section */
398 styp_flags
= STYP_LIT
;
400 styp_flags
= STYP_TEXT
;
401 #endif /* STYP_LIT */
403 else if (sec_flags
& SEC_LOAD
)
405 styp_flags
= STYP_TEXT
;
407 else if (sec_flags
& SEC_ALLOC
)
409 styp_flags
= STYP_BSS
;
413 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
414 styp_flags
|= STYP_NOLOAD
;
420 * Return a word with SEC_* flags set to represent the incoming
421 * STYP_* flags (from scnhdr.s_flags). The inverse of this
422 * function is sec_to_styp_flags().
423 * NOTE: If you add to/change this routine, you should mirror the changes
424 * in sec_to_styp_flags().
427 styp_to_sec_flags (abfd
, hdr
, name
)
432 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
433 long styp_flags
= internal_s
->s_flags
;
434 flagword sec_flags
= 0;
437 if (styp_flags
& STYP_NOLOAD
)
439 sec_flags
|= SEC_NEVER_LOAD
;
441 #endif /* STYP_NOLOAD */
443 /* For 386 COFF, at least, an unloadable text or data section is
444 actually a shared library section. */
445 if (styp_flags
& STYP_TEXT
)
447 if (sec_flags
& SEC_NEVER_LOAD
)
448 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
450 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
452 else if (styp_flags
& STYP_DATA
)
454 if (sec_flags
& SEC_NEVER_LOAD
)
455 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
457 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
459 else if (styp_flags
& STYP_BSS
)
461 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
462 if (sec_flags
& SEC_NEVER_LOAD
)
463 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
466 sec_flags
|= SEC_ALLOC
;
468 else if (styp_flags
& STYP_INFO
)
470 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
471 defined. coff_compute_section_file_positions uses
472 COFF_PAGE_SIZE to ensure that the low order bits of the
473 section VMA and the file offset match. If we don't know
474 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
475 and demand page loading of the file will fail. */
476 #ifdef COFF_PAGE_SIZE
477 sec_flags
|= SEC_DEBUGGING
;
480 else if (styp_flags
& STYP_PAD
)
484 else if (strcmp (name
, _TEXT
) == 0)
486 if (sec_flags
& SEC_NEVER_LOAD
)
487 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
489 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
491 else if (strcmp (name
, _DATA
) == 0)
493 if (sec_flags
& SEC_NEVER_LOAD
)
494 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
496 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
498 else if (strcmp (name
, _BSS
) == 0)
500 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
501 if (sec_flags
& SEC_NEVER_LOAD
)
502 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
505 sec_flags
|= SEC_ALLOC
;
507 else if (strcmp (name
, ".debug") == 0
509 || strcmp (name
, _COMMENT
) == 0
511 || strncmp (name
, ".stab", 5) == 0)
513 #ifdef COFF_PAGE_SIZE
514 sec_flags
|= SEC_DEBUGGING
;
518 else if (strcmp (name
, _LIB
) == 0)
522 else if (strcmp (name
, _LIT
) == 0)
524 sec_flags
= SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
529 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
532 #ifdef STYP_LIT /* A29k readonly text/data section type */
533 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
535 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
537 #endif /* STYP_LIT */
538 #ifdef STYP_OTHER_LOAD /* Other loaded sections */
539 if (styp_flags
& STYP_OTHER_LOAD
)
541 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
543 #endif /* STYP_SDATA */
548 #define get_index(symbol) ((symbol)->udata.i)
552 bfd_coff_backend_data
556 Special entry points for gdb to swap in coff symbol table parts:
559 . void (*_bfd_coff_swap_aux_in) PARAMS ((
568 . void (*_bfd_coff_swap_sym_in) PARAMS ((
573 . void (*_bfd_coff_swap_lineno_in) PARAMS ((
579 Special entry points for gas to swap out coff parts:
581 . unsigned int (*_bfd_coff_swap_aux_out) PARAMS ((
590 . unsigned int (*_bfd_coff_swap_sym_out) PARAMS ((
595 . unsigned int (*_bfd_coff_swap_lineno_out) PARAMS ((
600 . unsigned int (*_bfd_coff_swap_reloc_out) PARAMS ((
605 . unsigned int (*_bfd_coff_swap_filehdr_out) PARAMS ((
610 . unsigned int (*_bfd_coff_swap_aouthdr_out) PARAMS ((
615 . unsigned int (*_bfd_coff_swap_scnhdr_out) PARAMS ((
621 Special entry points for generic COFF routines to call target
622 dependent COFF routines:
624 . unsigned int _bfd_filhsz;
625 . unsigned int _bfd_aoutsz;
626 . unsigned int _bfd_scnhsz;
627 . unsigned int _bfd_symesz;
628 . unsigned int _bfd_auxesz;
629 . unsigned int _bfd_relsz;
630 . unsigned int _bfd_linesz;
631 . boolean _bfd_coff_long_filenames;
632 . void (*_bfd_coff_swap_filehdr_in) PARAMS ((
636 . void (*_bfd_coff_swap_aouthdr_in) PARAMS ((
640 . void (*_bfd_coff_swap_scnhdr_in) PARAMS ((
644 . void (*_bfd_coff_swap_reloc_in) PARAMS ((
648 . boolean (*_bfd_coff_bad_format_hook) PARAMS ((
650 . PTR internal_filehdr));
651 . boolean (*_bfd_coff_set_arch_mach_hook) PARAMS ((
653 . PTR internal_filehdr));
654 . PTR (*_bfd_coff_mkobject_hook) PARAMS ((
656 . PTR internal_filehdr,
657 . PTR internal_aouthdr));
658 . flagword (*_bfd_styp_to_sec_flags_hook) PARAMS ((
660 . PTR internal_scnhdr,
661 . const char *name));
662 . void (*_bfd_set_alignment_hook) PARAMS ((
665 . PTR internal_scnhdr));
666 . boolean (*_bfd_coff_slurp_symbol_table) PARAMS ((
668 . boolean (*_bfd_coff_symname_in_debug) PARAMS ((
670 . struct internal_syment *sym));
671 . boolean (*_bfd_coff_pointerize_aux_hook) PARAMS ((
673 . combined_entry_type *table_base,
674 . combined_entry_type *symbol,
675 . unsigned int indaux,
676 . combined_entry_type *aux));
677 . boolean (*_bfd_coff_print_aux) PARAMS ((
680 . combined_entry_type *table_base,
681 . combined_entry_type *symbol,
682 . combined_entry_type *aux,
683 . unsigned int indaux));
684 . void (*_bfd_coff_reloc16_extra_cases) PARAMS ((
686 . struct bfd_link_info *link_info,
687 . struct bfd_link_order *link_order,
690 . unsigned int *src_ptr,
691 . unsigned int *dst_ptr));
692 . int (*_bfd_coff_reloc16_estimate) PARAMS ((
694 . asection *input_section,
696 . unsigned int shrink,
697 . struct bfd_link_info *link_info));
698 . boolean (*_bfd_coff_sym_is_global) PARAMS ((
700 . struct internal_syment *));
701 . void (*_bfd_coff_compute_section_file_positions) PARAMS ((
703 . boolean (*_bfd_coff_start_final_link) PARAMS ((
705 . struct bfd_link_info *info));
706 . boolean (*_bfd_coff_relocate_section) PARAMS ((
708 . struct bfd_link_info *info,
710 . asection *input_section,
711 . bfd_byte *contents,
712 . struct internal_reloc *relocs,
713 . struct internal_syment *syms,
714 . asection **sections));
715 . reloc_howto_type *(*_bfd_coff_rtype_to_howto) PARAMS ((
718 . struct internal_reloc *rel,
719 . struct coff_link_hash_entry *h,
720 . struct internal_syment *sym,
721 . bfd_vma *addendp));
722 . boolean (*_bfd_coff_adjust_symndx) PARAMS ((
724 . struct bfd_link_info *info,
727 . struct internal_reloc *reloc,
728 . boolean *adjustedp));
730 .} bfd_coff_backend_data;
732 .#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
734 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
735 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
737 .#define bfd_coff_swap_sym_in(a,e,i) \
738 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
740 .#define bfd_coff_swap_lineno_in(a,e,i) \
741 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
743 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
744 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
746 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
747 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
749 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
750 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
752 .#define bfd_coff_swap_sym_out(abfd, i,o) \
753 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
755 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
756 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
758 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
759 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
761 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
762 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
764 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
765 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
766 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
767 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
768 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
769 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
770 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
771 .#define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames)
772 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
773 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
775 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
776 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
778 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
779 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
781 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
782 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
784 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
785 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
787 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
788 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
789 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
790 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
792 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name)\
793 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook) (abfd, scnhdr, name))
795 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
796 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
798 .#define bfd_coff_slurp_symbol_table(abfd)\
799 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
801 .#define bfd_coff_symname_in_debug(abfd, sym)\
802 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
804 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
805 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
806 . (abfd, file, base, symbol, aux, indaux))
808 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
809 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
810 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
812 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
813 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
814 . (abfd, section, reloc, shrink, link_info))
816 .#define bfd_coff_sym_is_global(abfd, sym)\
817 . ((coff_backend_info (abfd)->_bfd_coff_sym_is_global)\
820 .#define bfd_coff_compute_section_file_positions(abfd)\
821 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
824 .#define bfd_coff_start_final_link(obfd, info)\
825 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
827 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
828 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
829 . (obfd, info, ibfd, o, con, rel, isyms, secs))
830 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
831 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
832 . (abfd, sec, rel, h, sym, addendp))
833 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
834 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
835 . (obfd, info, ibfd, sec, rel, adjustedp))
839 /* See whether the magic number matches. */
842 coff_bad_format_hook (abfd
, filehdr
)
846 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
848 if (BADMAG (*internal_f
))
851 /* if the optional header is NULL or not the correct size then
852 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
853 and Intel 960 readwrite headers (I960WRMAGIC) is that the
854 optional header is of a different size.
856 But the mips keeps extra stuff in it's opthdr, so dont check
860 #if defined(M88) || defined(I960)
861 if (internal_f
->f_opthdr
!= 0 && AOUTSZ
!= internal_f
->f_opthdr
)
869 initialize a section structure with information peculiar to this
870 particular implementation of coff
874 coff_new_section_hook (abfd
, section
)
878 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
881 if (xcoff_data (abfd
)->text_align_power
!= 0
882 && strcmp (bfd_get_section_name (abfd
, section
), ".text") == 0)
883 section
->alignment_power
= xcoff_data (abfd
)->text_align_power
;
884 if (xcoff_data (abfd
)->data_align_power
!= 0
885 && strcmp (bfd_get_section_name (abfd
, section
), ".data") == 0)
886 section
->alignment_power
= xcoff_data (abfd
)->data_align_power
;
889 /* Allocate aux records for section symbols, to store size and
892 @@ Shouldn't use constant multiplier here! */
893 coffsymbol (section
->symbol
)->native
=
894 (combined_entry_type
*) bfd_zalloc (abfd
,
895 sizeof (combined_entry_type
) * 10);
897 /* The .stab section must be aligned to 2**2 at most, because
898 otherwise there may be gaps in the section which gdb will not
899 know how to interpret. Examining the section name is a hack, but
900 that is also how gdb locates the section.
901 We need to handle the .ctors and .dtors sections similarly, to
902 avoid introducing null words in the tables. */
903 if (COFF_DEFAULT_SECTION_ALIGNMENT_POWER
> 2
904 && (strncmp (section
->name
, ".stab", 5) == 0
905 || strcmp (section
->name
, ".ctors") == 0
906 || strcmp (section
->name
, ".dtors") == 0))
907 section
->alignment_power
= 2;
914 /* Set the alignment of a BFD section. */
917 coff_set_alignment_hook (abfd
, section
, scnhdr
)
922 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
925 for (i
= 0; i
< 32; i
++)
926 if ((1 << i
) >= hdr
->s_align
)
928 section
->alignment_power
= i
;
933 #define coff_set_alignment_hook \
934 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
938 #ifndef coff_mkobject
943 coff_data_type
*coff
;
945 abfd
->tdata
.coff_obj_data
= (struct coff_tdata
*) bfd_zalloc (abfd
, sizeof (coff_data_type
));
946 if (abfd
->tdata
.coff_obj_data
== 0)
948 bfd_set_error (bfd_error_no_memory
);
951 coff
= coff_data (abfd
);
952 coff
->symbols
= (coff_symbol_type
*) NULL
;
953 coff
->conversion_table
= (unsigned int *) NULL
;
954 coff
->raw_syments
= (struct coff_ptr_struct
*) NULL
;
956 /* make_abs_section(abfd);*/
962 /* Create the COFF backend specific information. */
963 #ifndef coff_mkobject_hook
965 coff_mkobject_hook (abfd
, filehdr
, aouthdr
)
970 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
971 coff_data_type
*coff
;
973 if (coff_mkobject (abfd
) == false)
976 coff
= coff_data (abfd
);
978 coff
->sym_filepos
= internal_f
->f_symptr
;
980 /* These members communicate important constants about the symbol
981 table to GDB's symbol-reading code. These `constants'
982 unfortunately vary among coff implementations... */
983 coff
->local_n_btmask
= N_BTMASK
;
984 coff
->local_n_btshft
= N_BTSHFT
;
985 coff
->local_n_tmask
= N_TMASK
;
986 coff
->local_n_tshift
= N_TSHIFT
;
987 coff
->local_symesz
= SYMESZ
;
988 coff
->local_auxesz
= AUXESZ
;
989 coff
->local_linesz
= LINESZ
;
991 obj_raw_syment_count (abfd
) =
992 obj_conv_table_size (abfd
) =
996 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
997 abfd
->flags
|= DYNAMIC
;
998 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= AOUTSZ
)
1000 struct internal_aouthdr
*internal_a
=
1001 (struct internal_aouthdr
*) aouthdr
;
1002 struct xcoff_tdata
*xcoff
;
1004 xcoff
= xcoff_data (abfd
);
1005 xcoff
->full_aouthdr
= true;
1006 xcoff
->toc
= internal_a
->o_toc
;
1007 if (internal_a
->o_sntoc
== 0)
1008 xcoff
->toc_section
= NULL
;
1010 xcoff
->toc_section
=
1011 coff_section_from_bfd_index (abfd
, internal_a
->o_sntoc
);
1012 if (internal_a
->o_snentry
== 0)
1013 xcoff
->entry_section
= NULL
;
1015 xcoff
->entry_section
=
1016 coff_section_from_bfd_index (abfd
, internal_a
->o_snentry
);
1017 xcoff
->text_align_power
= internal_a
->o_algntext
;
1018 xcoff
->data_align_power
= internal_a
->o_algndata
;
1019 xcoff
->modtype
= internal_a
->o_modtype
;
1020 xcoff
->cputype
= internal_a
->o_cputype
;
1021 xcoff
->maxdata
= internal_a
->o_maxdata
;
1022 xcoff
->maxstack
= internal_a
->o_maxstack
;
1030 /* Determine the machine architecture and type. FIXME: This is target
1031 dependent because the magic numbers are defined in the target
1032 dependent header files. But there is no particular need for this.
1033 If the magic numbers were moved to a separate file, this function
1034 would be target independent and would also be much more successful
1035 at linking together COFF files for different architectures. */
1038 coff_set_arch_mach_hook (abfd
, filehdr
)
1043 enum bfd_architecture arch
;
1044 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1047 switch (internal_f
->f_magic
)
1051 arch
= bfd_arch_powerpc
;
1052 machine
= 0; /* what does this mean? (krk) */
1058 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler */
1059 case LYNXCOFFMAGIC
: /* shadows the m68k Lynx number below, sigh */
1060 arch
= bfd_arch_i386
;
1064 #ifdef A29K_MAGIC_BIG
1065 case A29K_MAGIC_BIG
:
1066 case A29K_MAGIC_LITTLE
:
1067 arch
= bfd_arch_a29k
;
1073 arch
= bfd_arch_arm
;
1080 #ifdef MC68KBCSMAGIC
1083 #ifdef APOLLOM68KMAGIC
1084 case APOLLOM68KMAGIC
:
1086 #ifdef LYNXCOFFMAGIC
1089 arch
= bfd_arch_m68k
;
1097 arch
= bfd_arch_m88k
;
1103 arch
= bfd_arch_z8k
;
1104 switch (internal_f
->f_flags
& F_MACHMASK
)
1107 machine
= bfd_mach_z8001
;
1110 machine
= bfd_mach_z8002
;
1121 arch
= bfd_arch_i960
;
1122 switch (F_I960TYPE
& internal_f
->f_flags
)
1126 machine
= bfd_mach_i960_core
;
1129 machine
= bfd_mach_i960_kb_sb
;
1132 machine
= bfd_mach_i960_mc
;
1135 machine
= bfd_mach_i960_xa
;
1138 machine
= bfd_mach_i960_ca
;
1141 machine
= bfd_mach_i960_ka_sa
;
1143 /* start-sanitize-i960xl */
1145 machine
= bfd_mach_i960_xl
;
1147 /* end-sanitize-i960xl */
1160 if (xcoff_data (abfd
)->cputype
!= -1)
1161 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
1164 /* We did not get a value from the a.out header. If the
1165 file has not been stripped, we may be able to get the
1166 architecture information from the first symbol, if it
1167 is a .file symbol. */
1168 if (obj_raw_syment_count (abfd
) == 0)
1172 bfd_byte buf
[SYMESZ
];
1173 struct internal_syment sym
;
1175 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1176 || bfd_read (buf
, 1, SYMESZ
, abfd
) != SYMESZ
)
1178 coff_swap_sym_in (abfd
, (PTR
) buf
, (PTR
) &sym
);
1179 if (sym
.n_sclass
== C_FILE
)
1180 cputype
= sym
.n_type
& 0xff;
1186 /* FIXME: We don't handle all cases here. */
1192 /* PowerPC Macs use the same magic numbers as RS/6000
1193 (because that's how they were bootstrapped originally),
1194 but they are always PowerPC architecture. */
1195 arch
= bfd_arch_powerpc
;
1198 arch
= bfd_arch_rs6000
;
1200 #endif /* POWERMAC */
1204 arch
= bfd_arch_powerpc
;
1207 case 2: /* 64 bit PowerPC */
1208 arch
= bfd_arch_powerpc
;
1212 arch
= bfd_arch_powerpc
;
1216 arch
= bfd_arch_rs6000
;
1226 arch
= bfd_arch_we32k
;
1233 arch
= bfd_arch_h8300
;
1234 machine
= bfd_mach_h8300
;
1235 /* !! FIXME this probably isn't the right place for this */
1236 abfd
->flags
|= BFD_IS_RELAXABLE
;
1242 arch
= bfd_arch_h8300
;
1243 machine
= bfd_mach_h8300h
;
1244 /* !! FIXME this probably isn't the right place for this */
1245 abfd
->flags
|= BFD_IS_RELAXABLE
;
1249 #ifdef SH_ARCH_MAGIC_BIG
1250 case SH_ARCH_MAGIC_BIG
:
1251 case SH_ARCH_MAGIC_LITTLE
:
1259 arch
= bfd_arch_h8500
;
1266 #ifdef LYNXCOFFMAGIC
1269 arch
= bfd_arch_sparc
;
1274 default: /* Unreadable input file type */
1275 arch
= bfd_arch_obscure
;
1279 bfd_default_set_arch_mach (abfd
, arch
, machine
);
1283 #ifdef SYMNAME_IN_DEBUG
1286 symname_in_debug_hook (abfd
, sym
)
1288 struct internal_syment
*sym
;
1290 return SYMNAME_IN_DEBUG (sym
) ? true : false;
1295 #define symname_in_debug_hook \
1296 (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
1302 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
1304 static boolean coff_pointerize_aux_hook
1305 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
1306 unsigned int, combined_entry_type
*));
1310 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
1312 combined_entry_type
*table_base
;
1313 combined_entry_type
*symbol
;
1314 unsigned int indaux
;
1315 combined_entry_type
*aux
;
1317 int class = symbol
->u
.syment
.n_sclass
;
1319 if ((class == C_EXT
|| class == C_HIDEXT
)
1320 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
1322 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
1324 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
1325 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
1326 aux
->fix_scnlen
= 1;
1329 /* Return true to indicate that the caller should not do any
1330 further work on this auxent. */
1334 /* Return false to indicate that this auxent should be handled by
1342 /* We don't want to pointerize bal entries. */
1344 static boolean coff_pointerize_aux_hook
1345 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
1346 unsigned int, combined_entry_type
*));
1350 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
1352 combined_entry_type
*table_base
;
1353 combined_entry_type
*symbol
;
1354 unsigned int indaux
;
1355 combined_entry_type
*aux
;
1357 /* Return true if we don't want to pointerize this aux entry, which
1358 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
1359 return indaux
== 1 && symbol
->u
.syment
.n_sclass
== C_LEAFPROC
;
1364 #define coff_pointerize_aux_hook 0
1367 #endif /* ! RS6000COFF_C */
1369 /* Print an aux entry. This returns true if it has printed it. */
1371 static boolean coff_print_aux
1372 PARAMS ((bfd
*, FILE *, combined_entry_type
*, combined_entry_type
*,
1373 combined_entry_type
*, unsigned int));
1376 coff_print_aux (abfd
, file
, table_base
, symbol
, aux
, indaux
)
1379 combined_entry_type
*table_base
;
1380 combined_entry_type
*symbol
;
1381 combined_entry_type
*aux
;
1382 unsigned int indaux
;
1385 if ((symbol
->u
.syment
.n_sclass
== C_EXT
1386 || symbol
->u
.syment
.n_sclass
== C_HIDEXT
)
1387 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
1389 /* This is a csect entry. */
1390 fprintf (file
, "AUX ");
1391 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
1393 BFD_ASSERT (! aux
->fix_scnlen
);
1394 fprintf (file
, "val %5ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
1398 fprintf (file
, "indx ");
1399 if (! aux
->fix_scnlen
)
1400 fprintf (file
, "%4ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
1402 fprintf (file
, "%4ld",
1403 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
1406 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
1407 aux
->u
.auxent
.x_csect
.x_parmhash
,
1408 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
1409 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
1410 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
1411 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
1412 aux
->u
.auxent
.x_csect
.x_stab
,
1413 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
1418 /* Return false to indicate that no special action was taken. */
1426 To write relocations, the back end steps though the
1427 canonical relocation table and create an
1428 @code{internal_reloc}. The symbol index to use is removed from
1429 the @code{offset} field in the symbol table supplied. The
1430 address comes directly from the sum of the section base
1431 address and the relocation offset; the type is dug directly
1432 from the howto field. Then the @code{internal_reloc} is
1433 swapped into the shape of an @code{external_reloc} and written
1439 coff_write_relocs (abfd
, first_undef
)
1444 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
1447 struct external_reloc dst
;
1449 arelent
**p
= s
->orelocation
;
1450 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
1452 for (i
= 0; i
< s
->reloc_count
; i
++)
1454 struct internal_reloc n
;
1456 memset ((PTR
) & n
, 0, sizeof (n
));
1458 /* Now we've renumbered the symbols we know where the
1459 undefined symbols live in the table. Check the reloc
1460 entries for symbols who's output bfd isn't the right one.
1461 This is because the symbol was undefined (which means
1462 that all the pointers are never made to point to the same
1463 place). This is a bad thing,'cause the symbols attached
1464 to the output bfd are indexed, so that the relocation
1465 entries know which symbol index they point to. So we
1466 have to look up the output symbol here. */
1468 if (q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
1471 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
1472 asymbol
**outsyms
= abfd
->outsymbols
;
1473 for (i
= first_undef
; outsyms
[i
]; i
++)
1475 const char *intable
= outsyms
[i
]->name
;
1476 if (strcmp (intable
, sname
) == 0) {
1477 /* got a hit, so repoint the reloc */
1478 q
->sym_ptr_ptr
= outsyms
+ i
;
1484 n
.r_vaddr
= q
->address
+ s
->vma
;
1487 /* The 29k const/consth reloc pair is a real kludge. The consth
1488 part doesn't have a symbol; it has an offset. So rebuilt
1490 if (q
->howto
->type
== R_IHCONST
)
1491 n
.r_symndx
= q
->addend
;
1496 if (q
->sym_ptr_ptr
== bfd_abs_section_ptr
->symbol_ptr_ptr
)
1497 /* This is a relocation relative to the absolute symbol. */
1501 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
1502 /* Take notice if the symbol reloc points to a symbol
1503 we don't have in our symbol table. What should we
1505 if (n
.r_symndx
> obj_conv_table_size (abfd
))
1510 #ifdef SWAP_OUT_RELOC_OFFSET
1511 n
.r_offset
= q
->addend
;
1515 /* Work out reloc type from what is required */
1516 SELECT_RELOC (n
, q
->howto
);
1518 n
.r_type
= q
->howto
->type
;
1520 coff_swap_reloc_out (abfd
, &n
, &dst
);
1521 if (bfd_write ((PTR
) & dst
, 1, RELSZ
, abfd
) != RELSZ
)
1529 /* Set flags and magic number of a coff file from architecture and machine
1530 type. Result is true if we can represent the arch&type, false if not. */
1533 coff_set_flags (abfd
, magicp
, flagsp
)
1536 unsigned short *flagsp
;
1538 switch (bfd_get_arch (abfd
))
1543 switch (bfd_get_mach (abfd
))
1545 case bfd_mach_z8001
:
1548 case bfd_mach_z8002
:
1562 *magicp
= I960ROMAGIC
;
1564 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1565 I960RWMAGIC); FIXME???
1567 switch (bfd_get_mach (abfd
))
1569 case bfd_mach_i960_core
:
1572 case bfd_mach_i960_kb_sb
:
1575 case bfd_mach_i960_mc
:
1578 case bfd_mach_i960_xa
:
1581 case bfd_mach_i960_ca
:
1584 case bfd_mach_i960_ka_sa
:
1587 /* start-sanitize-i960xl */
1588 case bfd_mach_i960_xl
:
1591 /* end-sanitize-i960xl */
1606 case bfd_arch_powerpc
:
1613 *magicp
= I386MAGIC
;
1615 /* Just overwrite the usual value if we're doing Lynx. */
1616 *magicp
= LYNXCOFFMAGIC
;
1623 #ifdef APOLLOM68KMAGIC
1624 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
1626 *magicp
= MC68MAGIC
;
1629 /* Just overwrite the usual value if we're doing Lynx. */
1630 *magicp
= LYNXCOFFMAGIC
;
1638 *magicp
= MC88OMAGIC
;
1643 case bfd_arch_h8300
:
1644 switch (bfd_get_mach (abfd
))
1646 case bfd_mach_h8300
:
1647 *magicp
= H8300MAGIC
;
1649 case bfd_mach_h8300h
:
1650 *magicp
= H8300HMAGIC
;
1656 #ifdef SH_ARCH_MAGIC_BIG
1658 if (abfd
->xvec
->byteorder_big_p
)
1659 *magicp
= SH_ARCH_MAGIC_BIG
;
1661 *magicp
= SH_ARCH_MAGIC_LITTLE
;
1667 case bfd_arch_sparc
:
1668 *magicp
= SPARCMAGIC
;
1670 /* Just overwrite the usual value if we're doing Lynx. */
1671 *magicp
= LYNXCOFFMAGIC
;
1678 case bfd_arch_h8500
:
1679 *magicp
= H8500MAGIC
;
1683 #ifdef A29K_MAGIC_BIG
1685 if (abfd
->xvec
->byteorder_big_p
)
1686 *magicp
= A29K_MAGIC_BIG
;
1688 *magicp
= A29K_MAGIC_LITTLE
;
1694 case bfd_arch_we32k
:
1695 *magicp
= WE32KMAGIC
;
1701 case bfd_arch_rs6000
:
1703 case bfd_arch_powerpc
:
1705 *magicp
= U802TOCMAGIC
;
1710 default: /* Unknown architecture */
1711 /* return false; -- fall through to "return false" below, to avoid
1712 "statement never reached" errors on the one below. */
1721 coff_set_arch_mach (abfd
, arch
, machine
)
1723 enum bfd_architecture arch
;
1724 unsigned long machine
;
1727 unsigned short dummy2
;
1729 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
1732 if (arch
!= bfd_arch_unknown
&&
1733 coff_set_flags (abfd
, &dummy1
, &dummy2
) != true)
1734 return false; /* We can't represent this type */
1736 return true; /* We're easy ... */
1740 /* Calculate the file position for each section. */
1743 coff_compute_section_file_positions (abfd
)
1747 asection
*previous
= (asection
*) NULL
;
1748 file_ptr sofar
= FILHSZ
;
1756 #ifdef COFF_IMAGE_WITH_PE
1758 if (coff_data (abfd
)->link_info
)
1760 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
1763 page_size
= PE_DEF_FILE_ALIGNMENT
;
1764 #elif defined (COFF_PAGE_SIZE)
1765 int page_size
= COFF_PAGE_SIZE
;
1768 if (bfd_get_start_address (abfd
))
1770 /* A start address may have been added to the original file. In this
1771 case it will need an optional header to record it. */
1772 abfd
->flags
|= EXEC_P
;
1775 if (abfd
->flags
& EXEC_P
)
1778 else if (xcoff_data (abfd
)->full_aouthdr
)
1781 sofar
+= SMALL_AOUTSZ
;
1784 sofar
+= abfd
->section_count
* SCNHSZ
;
1785 for (current
= abfd
->sections
, count
= 1;
1786 current
!= (asection
*) NULL
;
1787 current
= current
->next
, ++count
)
1789 current
->target_index
= count
;
1791 /* Only deal with sections which have contents */
1792 if (!(current
->flags
& SEC_HAS_CONTENTS
))
1796 /* Do not include the .junk section. This is where we collect section
1797 data which we don't need. This is mainly the MS .debug$ data which
1798 stores codeview debug data. */
1799 if (strcmp (current
->name
, ".junk") == 0)
1805 /* Align the sections in the file to the same boundary on
1806 which they are aligned in virtual memory. I960 doesn't
1807 do this (FIXME) so we can stay in sync with Intel. 960
1808 doesn't yet page from files... */
1811 /* make sure this section is aligned on the right boundary - by
1812 padding the previous section up if necessary */
1815 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
1816 if (previous
!= (asection
*) NULL
)
1818 previous
->_raw_size
+= sofar
- old_sofar
;
1824 /* In demand paged files the low order bits of the file offset
1825 must match the low order bits of the virtual address. */
1826 #ifdef COFF_PAGE_SIZE
1827 if ((abfd
->flags
& D_PAGED
) != 0
1828 && (current
->flags
& SEC_ALLOC
) != 0)
1829 sofar
+= (current
->vma
- sofar
) % page_size
;
1831 current
->filepos
= sofar
;
1833 #ifdef COFF_IMAGE_WITH_PE
1834 /* With PE we have to pad each section to be a multiple of its page size
1835 too, and remember both sizes. Cooked_size becomes very useful. */
1836 current
->_cooked_size
= current
->_raw_size
;
1837 current
->_raw_size
= (current
->_raw_size
+ page_size
-1) & -page_size
;
1840 sofar
+= current
->_raw_size
;
1843 /* make sure that this section is of the right size too */
1845 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
1846 current
->_raw_size
+= sofar
- old_sofar
;
1850 /* Force .lib sections to start at zero. The vma is then
1851 incremented in coff_set_section_contents. This is right for
1853 if (strcmp (current
->name
, _LIB
) == 0)
1854 bfd_set_section_vma (abfd
, current
, 0);
1860 obj_relocbase (abfd
) = sofar
;
1861 abfd
->output_has_begun
= true;
1865 #ifndef RS6000COFF_C
1867 /* If .file, .text, .data, .bss symbols are missing, add them. */
1868 /* @@ Should we only be adding missing symbols, or overriding the aux
1869 values for existing section symbols? */
1871 coff_add_missing_symbols (abfd
)
1874 unsigned int nsyms
= bfd_get_symcount (abfd
);
1875 asymbol
**sympp
= abfd
->outsymbols
;
1878 int need_text
= 1, need_data
= 1, need_bss
= 1, need_file
= 1;
1880 for (i
= 0; i
< nsyms
; i
++)
1882 coff_symbol_type
*csym
= coff_symbol_from (abfd
, sympp
[i
]);
1886 /* only do this if there is a coff representation of the input
1888 if (csym
->native
&& csym
->native
->u
.syment
.n_sclass
== C_FILE
)
1893 name
= csym
->symbol
.name
;
1896 if (!strcmp (name
, _TEXT
))
1899 else if (!strcmp (name
, ".wtext"))
1902 else if (!strcmp (name
, _DATA
))
1904 else if (!strcmp (name
, _BSS
))
1908 /* Now i == bfd_get_symcount (abfd). */
1909 /* @@ For now, don't deal with .file symbol. */
1912 if (!need_text
&& !need_data
&& !need_bss
&& !need_file
)
1914 nsyms
+= need_text
+ need_data
+ need_bss
+ need_file
;
1915 sympp2
= (asymbol
**) bfd_alloc_by_size_t (abfd
, nsyms
* sizeof (asymbol
*));
1918 bfd_set_error (bfd_error_no_memory
);
1921 memcpy (sympp2
, sympp
, i
* sizeof (asymbol
*));
1924 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
1928 sympp2
[i
++] = coff_section_symbol (abfd
, _TEXT
);
1930 sympp2
[i
++] = coff_section_symbol (abfd
, _DATA
);
1932 sympp2
[i
++] = coff_section_symbol (abfd
, _BSS
);
1933 BFD_ASSERT (i
== nsyms
);
1934 bfd_set_symtab (abfd
, sympp2
, nsyms
);
1938 #endif /* ! defined (RS6000COFF_C) */
1945 coff_write_object_contents (abfd
)
1949 boolean hasrelocs
= false;
1950 boolean haslinno
= false;
1952 file_ptr reloc_base
;
1953 file_ptr lineno_base
;
1955 unsigned long reloc_size
= 0;
1956 unsigned long lnno_size
= 0;
1957 asection
*text_sec
= NULL
;
1958 asection
*data_sec
= NULL
;
1959 asection
*bss_sec
= NULL
;
1961 struct internal_filehdr internal_f
;
1962 struct internal_aouthdr internal_a
;
1964 bfd_set_error (bfd_error_system_call
);
1966 if (abfd
->output_has_begun
== false)
1967 coff_compute_section_file_positions (abfd
);
1969 reloc_base
= obj_relocbase (abfd
);
1971 /* Make a pass through the symbol table to count line number entries and
1972 put them into the correct asections */
1974 lnno_size
= coff_count_linenumbers (abfd
) * LINESZ
;
1976 /* Work out the size of the reloc and linno areas */
1978 for (current
= abfd
->sections
; current
!= NULL
; current
=
1980 reloc_size
+= current
->reloc_count
* RELSZ
;
1982 lineno_base
= reloc_base
+ reloc_size
;
1983 sym_base
= lineno_base
+ lnno_size
;
1985 /* Indicate in each section->line_filepos its actual file address */
1986 for (current
= abfd
->sections
; current
!= NULL
; current
=
1989 if (current
->lineno_count
)
1991 current
->line_filepos
= lineno_base
;
1992 current
->moving_line_filepos
= lineno_base
;
1993 lineno_base
+= current
->lineno_count
* LINESZ
;
1997 current
->line_filepos
= 0;
1999 if (current
->reloc_count
)
2001 current
->rel_filepos
= reloc_base
;
2002 reloc_base
+= current
->reloc_count
* RELSZ
;
2006 current
->rel_filepos
= 0;
2010 /* Write section headers to the file. */
2011 internal_f
.f_nscns
= 0;
2013 if ((abfd
->flags
& EXEC_P
) != 0)
2014 scn_base
= FILHSZ
+ AOUTSZ
;
2019 if (xcoff_data (abfd
)->full_aouthdr
)
2022 scn_base
+= SMALL_AOUTSZ
;
2026 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
2029 for (current
= abfd
->sections
;
2031 current
= current
->next
)
2033 struct internal_scnhdr section
;
2036 /* Do not include the .junk section. This is where we collect section
2037 data which we don't need. This is mainly the MS .debug$ data which
2038 stores codeview debug data. */
2039 if (strcmp (current
->name
, ".junk") == 0)
2044 /* If we've got a .reloc section, remember. */
2046 #ifdef COFF_IMAGE_WITH_PE
2047 if (strcmp (current
->name
, ".reloc") == 0)
2049 pe_data (abfd
)->has_reloc_section
= 1;
2054 internal_f
.f_nscns
++;
2055 strncpy (&(section
.s_name
[0]), current
->name
, 8);
2057 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
2058 Ian Taylor <ian@cygnus.com>. */
2059 if (strcmp (current
->name
, _LIB
) == 0)
2060 section
.s_vaddr
= 0;
2063 section
.s_vaddr
= current
->lma
;
2064 section
.s_paddr
= current
->lma
;
2065 section
.s_size
= current
->_raw_size
;
2068 section
.s_paddr
= current
->_cooked_size
;
2072 If this section has no size or is unloadable then the scnptr
2075 if (current
->_raw_size
== 0 ||
2076 (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2078 section
.s_scnptr
= 0;
2082 section
.s_scnptr
= current
->filepos
;
2084 section
.s_relptr
= current
->rel_filepos
;
2085 section
.s_lnnoptr
= current
->line_filepos
;
2086 section
.s_nreloc
= current
->reloc_count
;
2087 section
.s_nlnno
= current
->lineno_count
;
2088 if (current
->reloc_count
!= 0)
2090 if (current
->lineno_count
!= 0)
2093 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
2095 if (!strcmp (current
->name
, _TEXT
))
2099 else if (!strcmp (current
->name
, _DATA
))
2103 else if (!strcmp (current
->name
, _BSS
))
2109 section
.s_align
= (current
->alignment_power
2110 ? 1 << current
->alignment_power
2115 #ifdef COFF_IMAGE_WITH_PE
2116 /* suppress output of the sections if they are null. ld includes
2117 the bss and data sections even if there is no size assigned
2118 to them. NT loader doesn't like it if these section headers are
2119 included if the sections themselves are not needed */
2120 if (section
.s_size
== 0)
2121 internal_f
.f_nscns
--;
2126 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
2127 || bfd_write ((PTR
) (&buff
), 1, SCNHSZ
, abfd
) != SCNHSZ
)
2134 /* OK, now set up the filehdr... */
2136 /* Don't include the internal abs section in the section count */
2139 We will NOT put a fucking timestamp in the header here. Every time you
2140 put it back, I will come in and take it out again. I'm sorry. This
2141 field does not belong here. We fill it with a 0 so it compares the
2142 same but is not a reasonable time. -- gnu@cygnus.com
2144 internal_f
.f_timdat
= 0;
2146 internal_f
.f_flags
= 0;
2148 if (abfd
->flags
& EXEC_P
)
2149 internal_f
.f_opthdr
= AOUTSZ
;
2152 internal_f
.f_opthdr
= 0;
2154 if (xcoff_data (abfd
)->full_aouthdr
)
2155 internal_f
.f_opthdr
= AOUTSZ
;
2157 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
2162 internal_f
.f_flags
|= F_RELFLG
;
2164 internal_f
.f_flags
|= F_LNNO
;
2165 if (abfd
->flags
& EXEC_P
)
2166 internal_f
.f_flags
|= F_EXEC
;
2168 if (!abfd
->xvec
->byteorder_big_p
)
2169 internal_f
.f_flags
|= F_AR32WR
;
2171 internal_f
.f_flags
|= F_AR32W
;
2174 FIXME, should do something about the other byte orders and
2179 if ((abfd
->flags
& DYNAMIC
) != 0)
2180 internal_f
.f_flags
|= F_SHROBJ
;
2181 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
2182 internal_f
.f_flags
|= F_DYNLOAD
;
2185 memset (&internal_a
, 0, sizeof internal_a
);
2187 /* Set up architecture-dependent stuff */
2190 unsigned int magic
= 0;
2191 unsigned short flags
= 0;
2192 coff_set_flags (abfd
, &magic
, &flags
);
2193 internal_f
.f_magic
= magic
;
2194 internal_f
.f_flags
|= flags
;
2195 /* ...and the "opt"hdr... */
2198 #ifdef ULTRA3 /* NYU's machine */
2199 /* FIXME: This is a bogus check. I really want to see if there
2200 * is a .shbss or a .shdata section, if so then set the magic
2201 * number to indicate a shared data executable.
2203 if (internal_f
.f_nscns
>= 7)
2204 internal_a
.magic
= SHMAGIC
; /* Shared magic */
2207 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
2208 #define __A_MAGIC_SET__
2211 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
2212 #define __A_MAGIC_SET__
2215 #define __A_MAGIC_SET__
2216 internal_a
.magic
= PAGEMAGICBCS
;
2220 #define __A_MAGIC_SET__
2221 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
2224 #if defined(M68) || defined(WE32K) || defined(M68K)
2225 #define __A_MAGIC_SET__
2227 internal_a
.magic
= LYNXCOFFMAGIC
;
2230 #if defined (PAGEMAGICPEXECPAGED)
2231 internal_a
.magic
= PAGEMAGICPEXECPAGED
;
2233 #endif /* M68 || WE32K || M68K */
2236 #define __A_MAGIC_SET__
2237 internal_a
.magic
= ZMAGIC
;
2240 #define __A_MAGIC_SET__
2241 internal_a
.magic
= PPCMAGIC
;
2244 #define __A_MAGIC_SET__
2246 internal_a
.magic
= LYNXCOFFMAGIC
;
2248 internal_a
.magic
= ZMAGIC
;
2253 #define __A_MAGIC_SET__
2255 internal_a
.magic
= LYNXCOFFMAGIC
;
2260 #define __A_MAGIC_SET__
2261 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
2262 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
2263 RS6K_AOUTHDR_OMAGIC
;
2266 #ifndef __A_MAGIC_SET__
2267 #include "Your aouthdr magic number is not being set!"
2269 #undef __A_MAGIC_SET__
2273 /* FIXME: Does anybody ever set this to another value? */
2274 internal_a
.vstamp
= 0;
2276 /* Now should write relocs, strings, syms */
2277 obj_sym_filepos (abfd
) = sym_base
;
2279 if (bfd_get_symcount (abfd
) != 0)
2282 #ifndef RS6000COFF_C
2283 if (!coff_add_missing_symbols (abfd
))
2286 if (!coff_renumber_symbols (abfd
, &firstundef
))
2288 coff_mangle_symbols (abfd
);
2289 if (! coff_write_symbols (abfd
))
2291 if (! coff_write_linenumbers (abfd
))
2293 if (! coff_write_relocs (abfd
, firstundef
))
2297 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
2298 backend linker, and obj_raw_syment_count is not valid until after
2299 coff_write_symbols is called. */
2300 if (obj_raw_syment_count (abfd
) != 0)
2302 internal_f
.f_symptr
= sym_base
;
2304 /* AIX appears to require that F_RELFLG not be set if there are
2305 local symbols but no relocations. */
2306 internal_f
.f_flags
&=~ F_RELFLG
;
2311 internal_f
.f_symptr
= 0;
2312 internal_f
.f_flags
|= F_LSYMS
;
2317 internal_a
.tsize
= bfd_get_section_size_before_reloc (text_sec
);
2318 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
2322 internal_a
.dsize
= bfd_get_section_size_before_reloc (data_sec
);
2323 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
2327 internal_a
.bsize
= bfd_get_section_size_before_reloc (bss_sec
);
2328 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
2329 internal_a
.data_start
= bss_sec
->vma
;
2332 internal_a
.entry
= bfd_get_start_address (abfd
);
2333 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
2336 if (xcoff_data (abfd
)->full_aouthdr
)
2339 asection
*loader_sec
;
2341 if (xcoff_data (abfd
)->entry_section
!= NULL
)
2342 internal_a
.o_snentry
= xcoff_data (abfd
)->entry_section
->target_index
;
2345 internal_a
.o_snentry
= 0;
2346 if (internal_a
.entry
== 0)
2347 internal_a
.entry
= (bfd_vma
) -1;
2350 if (text_sec
!= NULL
)
2352 internal_a
.o_sntext
= text_sec
->target_index
;
2353 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
2357 internal_a
.o_sntext
= 0;
2358 internal_a
.o_algntext
= 0;
2360 if (data_sec
!= NULL
)
2362 internal_a
.o_sndata
= data_sec
->target_index
;
2363 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
2367 internal_a
.o_sndata
= 0;
2368 internal_a
.o_algndata
= 0;
2370 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
2371 if (loader_sec
!= NULL
)
2372 internal_a
.o_snloader
= loader_sec
->target_index
;
2374 internal_a
.o_snloader
= 0;
2375 if (bss_sec
!= NULL
)
2376 internal_a
.o_snbss
= bss_sec
->target_index
;
2378 internal_a
.o_snbss
= 0;
2380 toc
= xcoff_data (abfd
)->toc
;
2381 internal_a
.o_toc
= toc
;
2382 if (xcoff_data (abfd
)->toc_section
== NULL
)
2383 internal_a
.o_sntoc
= 0;
2385 internal_a
.o_sntoc
= xcoff_data (abfd
)->toc_section
->target_index
;
2387 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
2388 if (xcoff_data (abfd
)->cputype
!= -1)
2389 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
2392 switch (bfd_get_arch (abfd
))
2394 case bfd_arch_rs6000
:
2395 internal_a
.o_cputype
= 4;
2397 case bfd_arch_powerpc
:
2398 if (bfd_get_mach (abfd
) == 0)
2399 internal_a
.o_cputype
= 3;
2401 internal_a
.o_cputype
= 1;
2407 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
2408 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
2412 /* now write them */
2413 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
2417 coff_swap_filehdr_out (abfd
, (PTR
) & internal_f
, (PTR
) & buff
);
2418 if (bfd_write ((PTR
) & buff
, 1, FILHSZ
, abfd
) != FILHSZ
)
2421 if (abfd
->flags
& EXEC_P
)
2424 coff_swap_aouthdr_out (abfd
, (PTR
) & internal_a
, (PTR
) & buff
);
2425 if (bfd_write ((PTR
) & buff
, 1, AOUTSZ
, abfd
) != AOUTSZ
)
2434 /* XCOFF seems to always write at least a small a.out header. */
2435 coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, (PTR
) &buff
);
2436 if (xcoff_data (abfd
)->full_aouthdr
)
2439 size
= SMALL_AOUTSZ
;
2440 if (bfd_write ((PTR
) &buff
, 1, size
, abfd
) != size
)
2449 coff_set_section_contents (abfd
, section
, location
, offset
, count
)
2454 bfd_size_type count
;
2456 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
2457 coff_compute_section_file_positions (abfd
);
2460 /* If this is a .lib section, bump the vma address so that it
2461 winds up being the number of .lib sections output. This is
2462 right for SVR3.2. Shared libraries should probably get more
2463 generic support. Ian Taylor <ian@cygnus.com>. */
2464 if (strcmp (section
->name
, _LIB
) == 0)
2468 /* Don't write out bss sections - one way to do this is to
2469 see if the filepos has not been set. */
2470 if (section
->filepos
== 0)
2473 if (bfd_seek (abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
) != 0)
2478 return (bfd_write (location
, 1, count
, abfd
) == count
) ? true : false;
2484 coff_close_and_cleanup (abfd
)
2487 if (!bfd_read_p (abfd
))
2488 switch (abfd
->format
)
2491 if (!_bfd_write_archive_contents (abfd
))
2495 if (!coff_write_object_contents (abfd
))
2499 bfd_set_error (bfd_error_invalid_operation
);
2503 /* We depend on bfd_close to free all the memory on the obstack. */
2504 /* FIXME if bfd_release is not using obstacks! */
2511 buy_and_read (abfd
, where
, seek_direction
, size
)
2517 PTR area
= (PTR
) bfd_alloc (abfd
, size
);
2520 bfd_set_error (bfd_error_no_memory
);
2523 if (bfd_seek (abfd
, where
, seek_direction
) != 0
2524 || bfd_read (area
, 1, size
, abfd
) != size
)
2527 } /* buy_and_read() */
2533 Creating the linenumber table is done by reading in the entire
2534 coff linenumber table, and creating another table for internal use.
2536 A coff linenumber table is structured so that each function
2537 is marked as having a line number of 0. Each line within the
2538 function is an offset from the first line in the function. The
2539 base of the line number information for the table is stored in
2540 the symbol associated with the function.
2542 The information is copied from the external to the internal
2543 table, and each symbol which marks a function is marked by
2546 How does this work ?
2551 coff_slurp_line_table (abfd
, asect
)
2555 LINENO
*native_lineno
;
2556 alent
*lineno_cache
;
2558 BFD_ASSERT (asect
->lineno
== (alent
*) NULL
);
2560 native_lineno
= (LINENO
*) buy_and_read (abfd
,
2561 asect
->line_filepos
,
2564 asect
->lineno_count
));
2566 (alent
*) bfd_alloc (abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof (alent
)));
2567 if (lineno_cache
== NULL
)
2569 bfd_set_error (bfd_error_no_memory
);
2574 unsigned int counter
= 0;
2575 alent
*cache_ptr
= lineno_cache
;
2576 LINENO
*src
= native_lineno
;
2578 while (counter
< asect
->lineno_count
)
2580 struct internal_lineno dst
;
2581 coff_swap_lineno_in (abfd
, src
, &dst
);
2582 cache_ptr
->line_number
= dst
.l_lnno
;
2584 if (cache_ptr
->line_number
== 0)
2586 coff_symbol_type
*sym
=
2587 (coff_symbol_type
*) (dst
.l_addr
.l_symndx
2588 + obj_raw_syments (abfd
))->u
.syment
._n
._n_n
._n_zeroes
;
2589 cache_ptr
->u
.sym
= (asymbol
*) sym
;
2590 if (sym
->lineno
!= NULL
)
2592 (*_bfd_error_handler
)
2593 ("%s: warning: duplicate line number information for `%s'",
2594 bfd_get_filename (abfd
),
2595 bfd_asymbol_name (&sym
->symbol
));
2597 sym
->lineno
= cache_ptr
;
2601 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
2602 - bfd_section_vma (abfd
, asect
);
2603 } /* If no linenumber expect a symbol index */
2609 cache_ptr
->line_number
= 0;
2612 asect
->lineno
= lineno_cache
;
2613 /* FIXME, free native_lineno here, or use alloca or something. */
2618 coff_slurp_symbol_table (abfd
)
2621 combined_entry_type
*native_symbols
;
2622 coff_symbol_type
*cached_area
;
2623 unsigned int *table_ptr
;
2625 unsigned int number_of_symbols
= 0;
2627 if (obj_symbols (abfd
))
2630 /* Read in the symbol table */
2631 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
2636 /* Allocate enough room for all the symbols in cached form */
2637 cached_area
= ((coff_symbol_type
*)
2639 (obj_raw_syment_count (abfd
)
2640 * sizeof (coff_symbol_type
))));
2642 if (cached_area
== NULL
)
2644 bfd_set_error (bfd_error_no_memory
);
2647 table_ptr
= ((unsigned int *)
2649 (obj_raw_syment_count (abfd
)
2650 * sizeof (unsigned int))));
2652 if (table_ptr
== NULL
)
2654 bfd_set_error (bfd_error_no_memory
);
2659 coff_symbol_type
*dst
= cached_area
;
2660 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
2661 unsigned int this_index
= 0;
2662 while (this_index
< last_native_index
)
2664 combined_entry_type
*src
= native_symbols
+ this_index
;
2665 table_ptr
[this_index
] = number_of_symbols
;
2666 dst
->symbol
.the_bfd
= abfd
;
2668 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
2669 /* We use the native name field to point to the cached field. */
2670 src
->u
.syment
._n
._n_n
._n_zeroes
= (long) dst
;
2671 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
2672 src
->u
.syment
.n_scnum
);
2673 dst
->symbol
.flags
= 0;
2674 dst
->done_lineno
= false;
2676 switch (src
->u
.syment
.n_sclass
)
2681 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
2682 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2683 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
2685 /* Fall through to next case */
2694 /* PE uses storage class 0x68 to denote a section symbol */
2697 if ((src
->u
.syment
.n_scnum
) == 0)
2699 if ((src
->u
.syment
.n_value
) == 0)
2701 dst
->symbol
.section
= bfd_und_section_ptr
;
2702 dst
->symbol
.value
= 0;
2706 dst
->symbol
.section
= bfd_com_section_ptr
;
2707 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2712 /* Base the value as an index from the base of the
2715 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2716 dst
->symbol
.value
= (src
->u
.syment
.n_value
2717 - dst
->symbol
.section
->vma
);
2719 if (ISFCN ((src
->u
.syment
.n_type
)))
2721 /* A function ext does not go at the end of a
2723 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
2728 /* A C_HIDEXT symbol is not global. */
2729 if (src
->u
.syment
.n_sclass
== C_HIDEXT
)
2730 dst
->symbol
.flags
= BSF_LOCAL
;
2731 /* A symbol with a csect entry should not go at the end. */
2732 if (src
->u
.syment
.n_numaux
> 0)
2733 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
2738 case C_STAT
: /* static */
2740 case C_LEAFSTAT
: /* static leaf procedure */
2742 case C_LABEL
: /* label */
2743 if (src
->u
.syment
.n_scnum
== -2)
2744 dst
->symbol
.flags
= BSF_DEBUGGING
;
2746 dst
->symbol
.flags
= BSF_LOCAL
;
2748 Base the value as an index from the base of the section, if
2751 if (dst
->symbol
.section
)
2752 dst
->symbol
.value
= (src
->u
.syment
.n_value
) -
2753 dst
->symbol
.section
->vma
;
2755 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2758 case C_MOS
: /* member of structure */
2759 case C_EOS
: /* end of structure */
2760 #ifdef NOTDEF /* C_AUTOARG has the same value */
2762 case C_GLBLREG
: /* A29k-specific storage class */
2765 case C_REGPARM
: /* register parameter */
2766 case C_REG
: /* register variable */
2768 case C_AUTOARG
: /* 960-specific storage class */
2770 case C_TPDEF
: /* type definition */
2772 case C_AUTO
: /* automatic variable */
2773 case C_FIELD
: /* bit field */
2774 case C_ENTAG
: /* enumeration tag */
2775 case C_MOE
: /* member of enumeration */
2776 case C_MOU
: /* member of union */
2777 case C_UNTAG
: /* union tag */
2778 dst
->symbol
.flags
= BSF_DEBUGGING
;
2779 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2782 case C_FILE
: /* file name */
2783 case C_STRTAG
: /* structure tag */
2798 dst
->symbol
.flags
= BSF_DEBUGGING
;
2799 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2803 case C_BINCL
: /* beginning of include file */
2804 case C_EINCL
: /* ending of include file */
2805 /* The value is actually a pointer into the line numbers
2806 of the file. We locate the line number entry, and
2807 set the section to the section which contains it, and
2808 the value to the index in that section. */
2812 dst
->symbol
.flags
= BSF_DEBUGGING
;
2813 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2814 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
2815 && ((file_ptr
) (sec
->line_filepos
2816 + sec
->lineno_count
* LINESZ
)
2817 > (file_ptr
) src
->u
.syment
.n_value
))
2820 dst
->symbol
.value
= 0;
2823 dst
->symbol
.section
= sec
;
2824 dst
->symbol
.value
= ((src
->u
.syment
.n_value
2825 - sec
->line_filepos
)
2833 dst
->symbol
.flags
= BSF_DEBUGGING
;
2835 /* The value is actually a symbol index. Save a pointer
2836 to the symbol instead of the index. FIXME: This
2837 should use a union. */
2838 src
->u
.syment
.n_value
=
2839 (long) (native_symbols
+ src
->u
.syment
.n_value
);
2840 dst
->symbol
.value
= src
->u
.syment
.n_value
;
2845 case C_BLOCK
: /* ".bb" or ".eb" */
2846 case C_FCN
: /* ".bf" or ".ef" */
2847 case C_EFCN
: /* physical end of function */
2848 dst
->symbol
.flags
= BSF_LOCAL
;
2850 Base the value as an index from the base of the section
2852 dst
->symbol
.value
= (src
->u
.syment
.n_value
) - dst
->symbol
.section
->vma
;
2856 case C_EXTDEF
: /* external definition */
2857 case C_ULABEL
: /* undefined label */
2858 case C_USTATIC
: /* undefined static */
2859 #ifndef COFF_WITH_PE
2860 /* C_LINE in regular coff is 0x68. NT has taken over this storage
2861 class to represent a section symbol */
2862 case C_LINE
: /* line # reformatted as symbol table entry */
2864 case C_ALIAS
: /* duplicate tag */
2865 case C_HIDDEN
: /* ext symbol in dmert public lib */
2867 (*_bfd_error_handler
)
2868 ("%s: Unrecognized storage class %d for %s symbol `%s'",
2869 bfd_get_filename (abfd
), src
->u
.syment
.n_sclass
,
2870 dst
->symbol
.section
->name
, dst
->symbol
.name
);
2871 dst
->symbol
.flags
= BSF_DEBUGGING
;
2872 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2876 /* BFD_ASSERT(dst->symbol.flags != 0);*/
2880 dst
->symbol
.udata
.i
= 0;
2881 dst
->lineno
= (alent
*) NULL
;
2882 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
2884 number_of_symbols
++;
2885 } /* walk the native symtab */
2886 } /* bfdize the native symtab */
2888 obj_symbols (abfd
) = cached_area
;
2889 obj_raw_syments (abfd
) = native_symbols
;
2891 bfd_get_symcount (abfd
) = number_of_symbols
;
2892 obj_convert (abfd
) = table_ptr
;
2893 /* Slurp the line tables for each section too */
2899 coff_slurp_line_table (abfd
, p
);
2904 } /* coff_slurp_symbol_table() */
2906 /* Check whether a symbol is globally visible. This is used by the
2907 COFF backend linker code in cofflink.c, since a couple of targets
2908 have globally visible symbols which are not class C_EXT. This
2909 function need not handle the case of n_class == C_EXT. */
2911 #undef OTHER_GLOBAL_CLASS
2914 #define OTHER_GLOBAL_CLASS C_LEAFEXT
2918 #define OTHER_GLOBAL_CLASS C_SECTION
2921 #ifdef OTHER_GLOBAL_CLASS
2924 coff_sym_is_global (abfd
, syment
)
2926 struct internal_syment
*syment
;
2928 if (syment
->n_sclass
== OTHER_GLOBAL_CLASS
)
2933 #undef OTHER_GLOBAL_CLASS
2935 #else /* ! defined (OTHER_GLOBAL_CLASS) */
2937 /* sym_is_global should not be defined if it has nothing to do. */
2939 #define coff_sym_is_global 0
2941 #endif /* ! defined (OTHER_GLOBAL_CLASS) */
2947 Coff relocations are easily transformed into the internal BFD form
2950 Reading a coff relocation table is done in the following stages:
2952 o Read the entire coff relocation table into memory.
2954 o Process each relocation in turn; first swap it from the
2955 external to the internal form.
2957 o Turn the symbol referenced in the relocation's symbol index
2958 into a pointer into the canonical symbol table.
2959 This table is the same as the one returned by a call to
2960 @code{bfd_canonicalize_symtab}. The back end will call that
2961 routine and save the result if a canonicalization hasn't been done.
2963 o The reloc index is turned into a pointer to a howto
2964 structure, in a back end specific way. For instance, the 386
2965 and 960 use the @code{r_type} to directly produce an index
2966 into a howto table vector; the 88k subtracts a number from the
2967 @code{r_type} field and creates an addend field.
2973 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
2975 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
2976 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
2977 coffsym = (obj_symbols (abfd) \
2978 + (cache_ptr->sym_ptr_ptr - symbols)); \
2980 coffsym = coff_symbol_from (abfd, ptr); \
2981 if (coffsym != (coff_symbol_type *) NULL \
2982 && coffsym->native->u.syment.n_scnum == 0) \
2983 cache_ptr->addend = 0; \
2984 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
2985 && ptr->section != (asection *) NULL) \
2986 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
2988 cache_ptr->addend = 0; \
2993 coff_slurp_reloc_table (abfd
, asect
, symbols
)
2998 RELOC
*native_relocs
;
2999 arelent
*reloc_cache
;
3004 if (asect
->relocation
)
3006 if (asect
->reloc_count
== 0)
3008 if (asect
->flags
& SEC_CONSTRUCTOR
)
3010 if (!coff_slurp_symbol_table (abfd
))
3013 (RELOC
*) buy_and_read (abfd
,
3017 asect
->reloc_count
));
3018 reloc_cache
= (arelent
*)
3019 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
3021 if (reloc_cache
== NULL
)
3023 bfd_set_error (bfd_error_no_memory
);
3028 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
3030 #ifdef RELOC_PROCESSING
3031 struct internal_reloc dst
;
3032 struct external_reloc
*src
;
3034 cache_ptr
= reloc_cache
+ idx
;
3035 src
= native_relocs
+ idx
;
3036 coff_swap_reloc_in (abfd
, src
, &dst
);
3038 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
3040 struct internal_reloc dst
;
3042 struct external_reloc
*src
;
3044 cache_ptr
= reloc_cache
+ idx
;
3045 src
= native_relocs
+ idx
;
3047 coff_swap_reloc_in (abfd
, src
, &dst
);
3050 cache_ptr
->address
= dst
.r_vaddr
;
3052 if (dst
.r_symndx
!= -1)
3054 /* @@ Should never be greater than count of symbols! */
3055 if (dst
.r_symndx
>= obj_conv_table_size (abfd
))
3057 cache_ptr
->sym_ptr_ptr
= symbols
+ obj_convert (abfd
)[dst
.r_symndx
];
3058 ptr
= *(cache_ptr
->sym_ptr_ptr
);
3062 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
3066 /* The symbols definitions that we have read in have been
3067 relocated as if their sections started at 0. But the offsets
3068 refering to the symbols in the raw data have not been
3069 modified, so we have to have a negative addend to compensate.
3071 Note that symbols which used to be common must be left alone */
3073 /* Calculate any reloc addend by looking at the symbol */
3074 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
3076 cache_ptr
->address
-= asect
->vma
;
3077 /* !! cache_ptr->section = (asection *) NULL;*/
3079 /* Fill in the cache_ptr->howto field from dst.r_type */
3080 RTYPE2HOWTO (cache_ptr
, &dst
);
3085 asect
->relocation
= reloc_cache
;
3089 #ifndef coff_rtype_to_howto
3092 /* Get the howto structure for a reloc. This is only used if the file
3093 including this one defines coff_relocate_section to be
3094 _bfd_coff_generic_relocate_section, so it is OK if it does not
3095 always work. It is the responsibility of the including file to
3096 make sure it is reasonable if it is needed. */
3098 static reloc_howto_type
*coff_rtype_to_howto
3099 PARAMS ((bfd
*, asection
*, struct internal_reloc
*,
3100 struct coff_link_hash_entry
*, struct internal_syment
*,
3104 static reloc_howto_type
*
3105 coff_rtype_to_howto (abfd
, sec
, rel
, h
, sym
, addendp
)
3108 struct internal_reloc
*rel
;
3109 struct coff_link_hash_entry
*h
;
3110 struct internal_syment
*sym
;
3115 RTYPE2HOWTO (&genrel
, rel
);
3116 return genrel
.howto
;
3119 #else /* ! defined (RTYPE2HOWTO) */
3121 #define coff_rtype_to_howto NULL
3123 #endif /* ! defined (RTYPE2HOWTO) */
3124 #endif /* ! defined (coff_rtype_to_howto) */
3126 /* This is stupid. This function should be a boolean predicate. */
3128 coff_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3134 arelent
*tblptr
= section
->relocation
;
3135 unsigned int count
= 0;
3138 if (section
->flags
& SEC_CONSTRUCTOR
)
3140 /* this section has relocs made up by us, they are not in the
3141 file, so take them out of their chain and place them into
3142 the data area provided */
3143 arelent_chain
*chain
= section
->constructor_chain
;
3144 for (count
= 0; count
< section
->reloc_count
; count
++)
3146 *relptr
++ = &chain
->relent
;
3147 chain
= chain
->next
;
3153 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
3156 tblptr
= section
->relocation
;
3158 for (; count
++ < section
->reloc_count
;)
3159 *relptr
++ = tblptr
++;
3164 return section
->reloc_count
;
3169 coff_sym_filepos (abfd
)
3172 return obj_sym_filepos (abfd
);
3176 #ifndef coff_reloc16_estimate
3177 #define coff_reloc16_estimate dummy_reloc16_estimate
3180 dummy_reloc16_estimate (abfd
, input_section
, reloc
, shrink
, link_info
)
3182 asection
*input_section
;
3184 unsigned int shrink
;
3185 struct bfd_link_info
*link_info
;
3192 #ifndef coff_reloc16_extra_cases
3193 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
3194 /* This works even if abort is not declared in any header file. */
3196 dummy_reloc16_extra_cases (abfd
, link_info
, link_order
, reloc
, data
, src_ptr
,
3199 struct bfd_link_info
*link_info
;
3200 struct bfd_link_order
*link_order
;
3203 unsigned int *src_ptr
;
3204 unsigned int *dst_ptr
;
3210 /* If coff_relocate_section is defined, we can use the optimized COFF
3211 backend linker. Otherwise we must continue to use the old linker. */
3212 #ifdef coff_relocate_section
3213 #ifndef coff_bfd_link_hash_table_create
3214 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
3216 #ifndef coff_bfd_link_add_symbols
3217 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
3219 #ifndef coff_bfd_final_link
3220 #define coff_bfd_final_link _bfd_coff_final_link
3222 #else /* ! defined (coff_relocate_section) */
3223 #define coff_relocate_section NULL
3224 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
3225 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
3226 #define coff_bfd_final_link _bfd_generic_final_link
3227 #endif /* ! defined (coff_relocate_section) */
3228 #define coff_bfd_link_split_section _bfd_generic_link_split_section
3230 #ifndef coff_start_final_link
3231 #define coff_start_final_link NULL
3234 #ifndef coff_adjust_symndx
3235 #define coff_adjust_symndx NULL
3238 static CONST bfd_coff_backend_data bfd_coff_std_swap_table
=
3240 coff_swap_aux_in
, coff_swap_sym_in
, coff_swap_lineno_in
,
3241 coff_swap_aux_out
, coff_swap_sym_out
,
3242 coff_swap_lineno_out
, coff_swap_reloc_out
,
3243 coff_swap_filehdr_out
, coff_swap_aouthdr_out
,
3244 coff_swap_scnhdr_out
,
3245 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
,
3246 #ifdef COFF_LONG_FILENAMES
3251 coff_swap_filehdr_in
, coff_swap_aouthdr_in
, coff_swap_scnhdr_in
,
3252 coff_swap_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
3253 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
3254 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
3255 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
3256 coff_sym_is_global
, coff_compute_section_file_positions
,
3257 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
3261 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
3262 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
3263 #define coff_get_section_contents _bfd_generic_get_section_contents
3265 #ifndef coff_bfd_copy_private_symbol_data
3266 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
3269 #ifndef coff_bfd_copy_private_section_data
3270 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
3273 #ifndef coff_bfd_copy_private_bfd_data
3274 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
3277 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
3278 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
3280 #ifndef coff_bfd_print_private_bfd_data
3281 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
3284 #ifndef coff_bfd_is_local_label
3285 #define coff_bfd_is_local_label bfd_generic_is_local_label
3287 #ifndef coff_read_minisymbols
3288 #define coff_read_minisymbols _bfd_generic_read_minisymbols
3290 #ifndef coff_minisymbol_to_symbol
3291 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
3294 /* The reloc lookup routine must be supplied by each individual COFF
3296 #ifndef coff_bfd_reloc_type_lookup
3297 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
3300 #ifndef coff_bfd_get_relocated_section_contents
3301 #define coff_bfd_get_relocated_section_contents \
3302 bfd_generic_get_relocated_section_contents
3304 #ifndef coff_bfd_relax_section
3305 #define coff_bfd_relax_section bfd_generic_relax_section