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
->toc
= internal_a
->o_toc
;
1006 xcoff
->text_align_power
= internal_a
->o_algntext
;
1007 xcoff
->data_align_power
= internal_a
->o_algndata
;
1008 xcoff
->modtype
= internal_a
->o_modtype
;
1009 xcoff
->cputype
= internal_a
->o_cputype
;
1010 xcoff
->maxdata
= internal_a
->o_maxdata
;
1011 xcoff
->maxstack
= internal_a
->o_maxstack
;
1019 /* Determine the machine architecture and type. FIXME: This is target
1020 dependent because the magic numbers are defined in the target
1021 dependent header files. But there is no particular need for this.
1022 If the magic numbers were moved to a separate file, this function
1023 would be target independent and would also be much more successful
1024 at linking together COFF files for different architectures. */
1027 coff_set_arch_mach_hook (abfd
, filehdr
)
1032 enum bfd_architecture arch
;
1033 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1036 switch (internal_f
->f_magic
)
1040 arch
= bfd_arch_powerpc
;
1041 machine
= 0; /* what does this mean? (krk) */
1047 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler */
1048 case LYNXCOFFMAGIC
: /* shadows the m68k Lynx number below, sigh */
1049 arch
= bfd_arch_i386
;
1053 #ifdef A29K_MAGIC_BIG
1054 case A29K_MAGIC_BIG
:
1055 case A29K_MAGIC_LITTLE
:
1056 arch
= bfd_arch_a29k
;
1062 arch
= bfd_arch_arm
;
1069 #ifdef MC68KBCSMAGIC
1072 #ifdef APOLLOM68KMAGIC
1073 case APOLLOM68KMAGIC
:
1075 #ifdef LYNXCOFFMAGIC
1078 arch
= bfd_arch_m68k
;
1086 arch
= bfd_arch_m88k
;
1092 arch
= bfd_arch_z8k
;
1093 switch (internal_f
->f_flags
& F_MACHMASK
)
1096 machine
= bfd_mach_z8001
;
1099 machine
= bfd_mach_z8002
;
1110 arch
= bfd_arch_i960
;
1111 switch (F_I960TYPE
& internal_f
->f_flags
)
1115 machine
= bfd_mach_i960_core
;
1118 machine
= bfd_mach_i960_kb_sb
;
1121 machine
= bfd_mach_i960_mc
;
1124 machine
= bfd_mach_i960_xa
;
1127 machine
= bfd_mach_i960_ca
;
1130 machine
= bfd_mach_i960_ka_sa
;
1132 /* start-sanitize-i960xl */
1134 machine
= bfd_mach_i960_xl
;
1136 /* end-sanitize-i960xl */
1149 if (xcoff_data (abfd
)->cputype
!= -1)
1150 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
1153 /* We did not get a value from the a.out header. If the
1154 file has not been stripped, we may be able to get the
1155 architecture information from the first symbol, if it
1156 is a .file symbol. */
1157 if (obj_raw_syment_count (abfd
) == 0)
1161 bfd_byte buf
[SYMESZ
];
1162 struct internal_syment sym
;
1164 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1165 || bfd_read (buf
, 1, SYMESZ
, abfd
) != SYMESZ
)
1167 coff_swap_sym_in (abfd
, (PTR
) buf
, (PTR
) &sym
);
1168 if (sym
.n_sclass
== C_FILE
)
1169 cputype
= sym
.n_type
& 0xff;
1175 /* FIXME: We don't handle all cases here. */
1181 /* PowerPC Macs use the same magic numbers as RS/6000
1182 (because that's how they were bootstrapped originally),
1183 but they are always PowerPC architecture. */
1184 arch
= bfd_arch_powerpc
;
1187 arch
= bfd_arch_rs6000
;
1189 #endif /* POWERMAC */
1193 arch
= bfd_arch_powerpc
;
1196 case 2: /* 64 bit PowerPC */
1197 arch
= bfd_arch_powerpc
;
1201 arch
= bfd_arch_powerpc
;
1205 arch
= bfd_arch_rs6000
;
1215 arch
= bfd_arch_we32k
;
1222 arch
= bfd_arch_h8300
;
1223 machine
= bfd_mach_h8300
;
1224 /* !! FIXME this probably isn't the right place for this */
1225 abfd
->flags
|= BFD_IS_RELAXABLE
;
1231 arch
= bfd_arch_h8300
;
1232 machine
= bfd_mach_h8300h
;
1233 /* !! FIXME this probably isn't the right place for this */
1234 abfd
->flags
|= BFD_IS_RELAXABLE
;
1238 #ifdef SH_ARCH_MAGIC_BIG
1239 case SH_ARCH_MAGIC_BIG
:
1240 case SH_ARCH_MAGIC_LITTLE
:
1248 arch
= bfd_arch_h8500
;
1255 #ifdef LYNXCOFFMAGIC
1258 arch
= bfd_arch_sparc
;
1263 default: /* Unreadable input file type */
1264 arch
= bfd_arch_obscure
;
1268 bfd_default_set_arch_mach (abfd
, arch
, machine
);
1272 #ifdef SYMNAME_IN_DEBUG
1275 symname_in_debug_hook (abfd
, sym
)
1277 struct internal_syment
*sym
;
1279 return SYMNAME_IN_DEBUG (sym
) ? true : false;
1284 #define symname_in_debug_hook \
1285 (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
1291 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
1293 static boolean coff_pointerize_aux_hook
1294 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
1295 unsigned int, combined_entry_type
*));
1299 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
1301 combined_entry_type
*table_base
;
1302 combined_entry_type
*symbol
;
1303 unsigned int indaux
;
1304 combined_entry_type
*aux
;
1306 int class = symbol
->u
.syment
.n_sclass
;
1308 if ((class == C_EXT
|| class == C_HIDEXT
)
1309 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
1311 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
1313 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
1314 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
1315 aux
->fix_scnlen
= 1;
1318 /* Return true to indicate that the caller should not do any
1319 further work on this auxent. */
1323 /* Return false to indicate that this auxent should be handled by
1331 /* We don't want to pointerize bal entries. */
1333 static boolean coff_pointerize_aux_hook
1334 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
1335 unsigned int, combined_entry_type
*));
1339 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
1341 combined_entry_type
*table_base
;
1342 combined_entry_type
*symbol
;
1343 unsigned int indaux
;
1344 combined_entry_type
*aux
;
1346 /* Return true if we don't want to pointerize this aux entry, which
1347 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
1348 return indaux
== 1 && symbol
->u
.syment
.n_sclass
== C_LEAFPROC
;
1353 #define coff_pointerize_aux_hook 0
1356 #endif /* ! RS6000COFF_C */
1358 /* Print an aux entry. This returns true if it has printed it. */
1360 static boolean coff_print_aux
1361 PARAMS ((bfd
*, FILE *, combined_entry_type
*, combined_entry_type
*,
1362 combined_entry_type
*, unsigned int));
1365 coff_print_aux (abfd
, file
, table_base
, symbol
, aux
, indaux
)
1368 combined_entry_type
*table_base
;
1369 combined_entry_type
*symbol
;
1370 combined_entry_type
*aux
;
1371 unsigned int indaux
;
1374 if ((symbol
->u
.syment
.n_sclass
== C_EXT
1375 || symbol
->u
.syment
.n_sclass
== C_HIDEXT
)
1376 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
1378 /* This is a csect entry. */
1379 fprintf (file
, "AUX ");
1380 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
1382 BFD_ASSERT (! aux
->fix_scnlen
);
1383 fprintf (file
, "val %5ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
1387 fprintf (file
, "indx ");
1388 if (! aux
->fix_scnlen
)
1389 fprintf (file
, "%4ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
1391 fprintf (file
, "%4ld",
1392 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
1395 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
1396 aux
->u
.auxent
.x_csect
.x_parmhash
,
1397 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
1398 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
1399 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
1400 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
1401 aux
->u
.auxent
.x_csect
.x_stab
,
1402 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
1407 /* Return false to indicate that no special action was taken. */
1415 To write relocations, the back end steps though the
1416 canonical relocation table and create an
1417 @code{internal_reloc}. The symbol index to use is removed from
1418 the @code{offset} field in the symbol table supplied. The
1419 address comes directly from the sum of the section base
1420 address and the relocation offset; the type is dug directly
1421 from the howto field. Then the @code{internal_reloc} is
1422 swapped into the shape of an @code{external_reloc} and written
1428 coff_write_relocs (abfd
, first_undef
)
1433 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
1436 struct external_reloc dst
;
1438 arelent
**p
= s
->orelocation
;
1439 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
1441 for (i
= 0; i
< s
->reloc_count
; i
++)
1443 struct internal_reloc n
;
1445 memset ((PTR
) & n
, 0, sizeof (n
));
1447 /* Now we've renumbered the symbols we know where the
1448 undefined symbols live in the table. Check the reloc
1449 entries for symbols who's output bfd isn't the right one.
1450 This is because the symbol was undefined (which means
1451 that all the pointers are never made to point to the same
1452 place). This is a bad thing,'cause the symbols attached
1453 to the output bfd are indexed, so that the relocation
1454 entries know which symbol index they point to. So we
1455 have to look up the output symbol here. */
1457 if (q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
1460 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
1461 asymbol
**outsyms
= abfd
->outsymbols
;
1462 for (i
= first_undef
; outsyms
[i
]; i
++)
1464 const char *intable
= outsyms
[i
]->name
;
1465 if (strcmp (intable
, sname
) == 0) {
1466 /* got a hit, so repoint the reloc */
1467 q
->sym_ptr_ptr
= outsyms
+ i
;
1473 n
.r_vaddr
= q
->address
+ s
->vma
;
1476 /* The 29k const/consth reloc pair is a real kludge. The consth
1477 part doesn't have a symbol; it has an offset. So rebuilt
1479 if (q
->howto
->type
== R_IHCONST
)
1480 n
.r_symndx
= q
->addend
;
1485 if (q
->sym_ptr_ptr
== bfd_abs_section_ptr
->symbol_ptr_ptr
)
1486 /* This is a relocation relative to the absolute symbol. */
1490 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
1491 /* Take notice if the symbol reloc points to a symbol
1492 we don't have in our symbol table. What should we
1494 if (n
.r_symndx
> obj_conv_table_size (abfd
))
1499 #ifdef SWAP_OUT_RELOC_OFFSET
1500 n
.r_offset
= q
->addend
;
1504 /* Work out reloc type from what is required */
1505 SELECT_RELOC (n
, q
->howto
);
1507 n
.r_type
= q
->howto
->type
;
1509 coff_swap_reloc_out (abfd
, &n
, &dst
);
1510 if (bfd_write ((PTR
) & dst
, 1, RELSZ
, abfd
) != RELSZ
)
1518 /* Set flags and magic number of a coff file from architecture and machine
1519 type. Result is true if we can represent the arch&type, false if not. */
1522 coff_set_flags (abfd
, magicp
, flagsp
)
1525 unsigned short *flagsp
;
1527 switch (bfd_get_arch (abfd
))
1532 switch (bfd_get_mach (abfd
))
1534 case bfd_mach_z8001
:
1537 case bfd_mach_z8002
:
1551 *magicp
= I960ROMAGIC
;
1553 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1554 I960RWMAGIC); FIXME???
1556 switch (bfd_get_mach (abfd
))
1558 case bfd_mach_i960_core
:
1561 case bfd_mach_i960_kb_sb
:
1564 case bfd_mach_i960_mc
:
1567 case bfd_mach_i960_xa
:
1570 case bfd_mach_i960_ca
:
1573 case bfd_mach_i960_ka_sa
:
1576 /* start-sanitize-i960xl */
1577 case bfd_mach_i960_xl
:
1580 /* end-sanitize-i960xl */
1595 case bfd_arch_powerpc
:
1602 *magicp
= I386MAGIC
;
1604 /* Just overwrite the usual value if we're doing Lynx. */
1605 *magicp
= LYNXCOFFMAGIC
;
1612 #ifdef APOLLOM68KMAGIC
1613 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
1615 *magicp
= MC68MAGIC
;
1618 /* Just overwrite the usual value if we're doing Lynx. */
1619 *magicp
= LYNXCOFFMAGIC
;
1627 *magicp
= MC88OMAGIC
;
1632 case bfd_arch_h8300
:
1633 switch (bfd_get_mach (abfd
))
1635 case bfd_mach_h8300
:
1636 *magicp
= H8300MAGIC
;
1638 case bfd_mach_h8300h
:
1639 *magicp
= H8300HMAGIC
;
1645 #ifdef SH_ARCH_MAGIC_BIG
1647 if (abfd
->xvec
->byteorder_big_p
)
1648 *magicp
= SH_ARCH_MAGIC_BIG
;
1650 *magicp
= SH_ARCH_MAGIC_LITTLE
;
1656 case bfd_arch_sparc
:
1657 *magicp
= SPARCMAGIC
;
1659 /* Just overwrite the usual value if we're doing Lynx. */
1660 *magicp
= LYNXCOFFMAGIC
;
1667 case bfd_arch_h8500
:
1668 *magicp
= H8500MAGIC
;
1672 #ifdef A29K_MAGIC_BIG
1674 if (abfd
->xvec
->byteorder_big_p
)
1675 *magicp
= A29K_MAGIC_BIG
;
1677 *magicp
= A29K_MAGIC_LITTLE
;
1683 case bfd_arch_we32k
:
1684 *magicp
= WE32KMAGIC
;
1690 case bfd_arch_rs6000
:
1692 case bfd_arch_powerpc
:
1694 *magicp
= U802TOCMAGIC
;
1699 default: /* Unknown architecture */
1700 /* return false; -- fall through to "return false" below, to avoid
1701 "statement never reached" errors on the one below. */
1710 coff_set_arch_mach (abfd
, arch
, machine
)
1712 enum bfd_architecture arch
;
1713 unsigned long machine
;
1716 unsigned short dummy2
;
1718 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
1721 if (arch
!= bfd_arch_unknown
&&
1722 coff_set_flags (abfd
, &dummy1
, &dummy2
) != true)
1723 return false; /* We can't represent this type */
1725 return true; /* We're easy ... */
1729 /* Calculate the file position for each section. */
1732 coff_compute_section_file_positions (abfd
)
1736 asection
*previous
= (asection
*) NULL
;
1737 file_ptr sofar
= FILHSZ
;
1745 #ifdef COFF_IMAGE_WITH_PE
1747 if (coff_data (abfd
)->link_info
)
1749 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
1752 page_size
= PE_DEF_FILE_ALIGNMENT
;
1753 #elif defined (COFF_PAGE_SIZE)
1754 int page_size
= COFF_PAGE_SIZE
;
1757 if (bfd_get_start_address (abfd
))
1759 /* A start address may have been added to the original file. In this
1760 case it will need an optional header to record it. */
1761 abfd
->flags
|= EXEC_P
;
1764 if (abfd
->flags
& EXEC_P
)
1768 sofar
+= SMALL_AOUTSZ
;
1771 sofar
+= abfd
->section_count
* SCNHSZ
;
1772 for (current
= abfd
->sections
, count
= 1;
1773 current
!= (asection
*) NULL
;
1774 current
= current
->next
, ++count
)
1776 current
->target_index
= count
;
1778 /* Only deal with sections which have contents */
1779 if (!(current
->flags
& SEC_HAS_CONTENTS
))
1783 /* Do not include the .junk section. This is where we collect section
1784 data which we don't need. This is mainly the MS .debug$ data which
1785 stores codeview debug data. */
1786 if (strcmp (current
->name
, ".junk") == 0)
1792 /* Align the sections in the file to the same boundary on
1793 which they are aligned in virtual memory. I960 doesn't
1794 do this (FIXME) so we can stay in sync with Intel. 960
1795 doesn't yet page from files... */
1798 /* make sure this section is aligned on the right boundary - by
1799 padding the previous section up if necessary */
1802 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
1803 if (previous
!= (asection
*) NULL
)
1805 previous
->_raw_size
+= sofar
- old_sofar
;
1811 /* In demand paged files the low order bits of the file offset
1812 must match the low order bits of the virtual address. */
1813 #ifdef COFF_PAGE_SIZE
1814 if ((abfd
->flags
& D_PAGED
) != 0
1815 && (current
->flags
& SEC_ALLOC
) != 0)
1816 sofar
+= (current
->vma
- sofar
) % page_size
;
1818 current
->filepos
= sofar
;
1820 #ifdef COFF_IMAGE_WITH_PE
1821 /* With PE we have to pad each section to be a multiple of its page size
1822 too, and remember both sizes. Cooked_size becomes very useful. */
1823 current
->_cooked_size
= current
->_raw_size
;
1824 current
->_raw_size
= (current
->_raw_size
+ page_size
-1) & -page_size
;
1827 sofar
+= current
->_raw_size
;
1830 /* make sure that this section is of the right size too */
1832 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
1833 current
->_raw_size
+= sofar
- old_sofar
;
1837 /* Force .lib sections to start at zero. The vma is then
1838 incremented in coff_set_section_contents. This is right for
1840 if (strcmp (current
->name
, _LIB
) == 0)
1841 bfd_set_section_vma (abfd
, current
, 0);
1847 obj_relocbase (abfd
) = sofar
;
1848 abfd
->output_has_begun
= true;
1852 #ifndef RS6000COFF_C
1854 /* If .file, .text, .data, .bss symbols are missing, add them. */
1855 /* @@ Should we only be adding missing symbols, or overriding the aux
1856 values for existing section symbols? */
1858 coff_add_missing_symbols (abfd
)
1861 unsigned int nsyms
= bfd_get_symcount (abfd
);
1862 asymbol
**sympp
= abfd
->outsymbols
;
1865 int need_text
= 1, need_data
= 1, need_bss
= 1, need_file
= 1;
1867 for (i
= 0; i
< nsyms
; i
++)
1869 coff_symbol_type
*csym
= coff_symbol_from (abfd
, sympp
[i
]);
1873 /* only do this if there is a coff representation of the input
1875 if (csym
->native
&& csym
->native
->u
.syment
.n_sclass
== C_FILE
)
1880 name
= csym
->symbol
.name
;
1883 if (!strcmp (name
, _TEXT
))
1886 else if (!strcmp (name
, ".wtext"))
1889 else if (!strcmp (name
, _DATA
))
1891 else if (!strcmp (name
, _BSS
))
1895 /* Now i == bfd_get_symcount (abfd). */
1896 /* @@ For now, don't deal with .file symbol. */
1899 if (!need_text
&& !need_data
&& !need_bss
&& !need_file
)
1901 nsyms
+= need_text
+ need_data
+ need_bss
+ need_file
;
1902 sympp2
= (asymbol
**) bfd_alloc_by_size_t (abfd
, nsyms
* sizeof (asymbol
*));
1905 bfd_set_error (bfd_error_no_memory
);
1908 memcpy (sympp2
, sympp
, i
* sizeof (asymbol
*));
1911 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
1915 sympp2
[i
++] = coff_section_symbol (abfd
, _TEXT
);
1917 sympp2
[i
++] = coff_section_symbol (abfd
, _DATA
);
1919 sympp2
[i
++] = coff_section_symbol (abfd
, _BSS
);
1920 BFD_ASSERT (i
== nsyms
);
1921 bfd_set_symtab (abfd
, sympp2
, nsyms
);
1925 #endif /* ! defined (RS6000COFF_C) */
1932 coff_write_object_contents (abfd
)
1936 boolean hasrelocs
= false;
1937 boolean haslinno
= false;
1939 file_ptr reloc_base
;
1940 file_ptr lineno_base
;
1942 unsigned long reloc_size
= 0;
1943 unsigned long lnno_size
= 0;
1944 asection
*text_sec
= NULL
;
1945 asection
*data_sec
= NULL
;
1946 asection
*bss_sec
= NULL
;
1948 struct internal_filehdr internal_f
;
1949 struct internal_aouthdr internal_a
;
1951 bfd_set_error (bfd_error_system_call
);
1953 if (abfd
->output_has_begun
== false)
1954 coff_compute_section_file_positions (abfd
);
1956 reloc_base
= obj_relocbase (abfd
);
1958 /* Make a pass through the symbol table to count line number entries and
1959 put them into the correct asections */
1961 lnno_size
= coff_count_linenumbers (abfd
) * LINESZ
;
1963 /* Work out the size of the reloc and linno areas */
1965 for (current
= abfd
->sections
; current
!= NULL
; current
=
1967 reloc_size
+= current
->reloc_count
* RELSZ
;
1969 lineno_base
= reloc_base
+ reloc_size
;
1970 sym_base
= lineno_base
+ lnno_size
;
1972 /* Indicate in each section->line_filepos its actual file address */
1973 for (current
= abfd
->sections
; current
!= NULL
; current
=
1976 if (current
->lineno_count
)
1978 current
->line_filepos
= lineno_base
;
1979 current
->moving_line_filepos
= lineno_base
;
1980 lineno_base
+= current
->lineno_count
* LINESZ
;
1984 current
->line_filepos
= 0;
1986 if (current
->reloc_count
)
1988 current
->rel_filepos
= reloc_base
;
1989 reloc_base
+= current
->reloc_count
* RELSZ
;
1993 current
->rel_filepos
= 0;
1997 /* Write section headers to the file. */
1998 internal_f
.f_nscns
= 0;
2000 if ((abfd
->flags
& EXEC_P
) != 0)
2001 scn_base
= FILHSZ
+ AOUTSZ
;
2006 scn_base
+= SMALL_AOUTSZ
;
2010 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
2013 for (current
= abfd
->sections
;
2015 current
= current
->next
)
2017 struct internal_scnhdr section
;
2020 /* Do not include the .junk section. This is where we collect section
2021 data which we don't need. This is mainly the MS .debug$ data which
2022 stores codeview debug data. */
2023 if (strcmp (current
->name
, ".junk") == 0)
2028 /* If we've got a .reloc section, remember. */
2030 #ifdef COFF_IMAGE_WITH_PE
2031 if (strcmp (current
->name
, ".reloc") == 0)
2033 pe_data (abfd
)->has_reloc_section
= 1;
2038 internal_f
.f_nscns
++;
2039 strncpy (&(section
.s_name
[0]), current
->name
, 8);
2041 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
2042 Ian Taylor <ian@cygnus.com>. */
2043 if (strcmp (current
->name
, _LIB
) == 0)
2044 section
.s_vaddr
= 0;
2047 section
.s_vaddr
= current
->lma
;
2048 section
.s_paddr
= current
->lma
;
2049 section
.s_size
= current
->_raw_size
;
2052 section
.s_paddr
= current
->_cooked_size
;
2056 If this section has no size or is unloadable then the scnptr
2059 if (current
->_raw_size
== 0 ||
2060 (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2062 section
.s_scnptr
= 0;
2066 section
.s_scnptr
= current
->filepos
;
2068 section
.s_relptr
= current
->rel_filepos
;
2069 section
.s_lnnoptr
= current
->line_filepos
;
2070 section
.s_nreloc
= current
->reloc_count
;
2071 section
.s_nlnno
= current
->lineno_count
;
2072 if (current
->reloc_count
!= 0)
2074 if (current
->lineno_count
!= 0)
2077 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
2079 if (!strcmp (current
->name
, _TEXT
))
2083 else if (!strcmp (current
->name
, _DATA
))
2087 else if (!strcmp (current
->name
, _BSS
))
2093 section
.s_align
= (current
->alignment_power
2094 ? 1 << current
->alignment_power
2099 #ifdef COFF_IMAGE_WITH_PE
2100 /* suppress output of the sections if they are null. ld includes
2101 the bss and data sections even if there is no size assigned
2102 to them. NT loader doesn't like it if these section headers are
2103 included if the sections themselves are not needed */
2104 if (section
.s_size
== 0)
2105 internal_f
.f_nscns
--;
2110 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
2111 || bfd_write ((PTR
) (&buff
), 1, SCNHSZ
, abfd
) != SCNHSZ
)
2118 /* OK, now set up the filehdr... */
2120 /* Don't include the internal abs section in the section count */
2123 We will NOT put a fucking timestamp in the header here. Every time you
2124 put it back, I will come in and take it out again. I'm sorry. This
2125 field does not belong here. We fill it with a 0 so it compares the
2126 same but is not a reasonable time. -- gnu@cygnus.com
2128 internal_f
.f_timdat
= 0;
2130 internal_f
.f_flags
= 0;
2132 if (abfd
->flags
& EXEC_P
)
2133 internal_f
.f_opthdr
= AOUTSZ
;
2136 internal_f
.f_opthdr
= 0;
2138 /* XCOFF seems to always write at least a small a.out header. */
2139 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
2144 internal_f
.f_flags
|= F_RELFLG
;
2146 internal_f
.f_flags
|= F_LNNO
;
2147 if (abfd
->flags
& EXEC_P
)
2148 internal_f
.f_flags
|= F_EXEC
;
2150 if (!abfd
->xvec
->byteorder_big_p
)
2151 internal_f
.f_flags
|= F_AR32WR
;
2153 internal_f
.f_flags
|= F_AR32W
;
2156 FIXME, should do something about the other byte orders and
2161 if ((abfd
->flags
& DYNAMIC
) != 0)
2162 internal_f
.f_flags
|= F_SHROBJ
;
2163 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
2164 internal_f
.f_flags
|= F_DYNLOAD
;
2167 memset (&internal_a
, 0, sizeof internal_a
);
2169 /* Set up architecture-dependent stuff */
2172 unsigned int magic
= 0;
2173 unsigned short flags
= 0;
2174 coff_set_flags (abfd
, &magic
, &flags
);
2175 internal_f
.f_magic
= magic
;
2176 internal_f
.f_flags
|= flags
;
2177 /* ...and the "opt"hdr... */
2180 #ifdef ULTRA3 /* NYU's machine */
2181 /* FIXME: This is a bogus check. I really want to see if there
2182 * is a .shbss or a .shdata section, if so then set the magic
2183 * number to indicate a shared data executable.
2185 if (internal_f
.f_nscns
>= 7)
2186 internal_a
.magic
= SHMAGIC
; /* Shared magic */
2189 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
2190 #define __A_MAGIC_SET__
2193 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
2194 #define __A_MAGIC_SET__
2197 #define __A_MAGIC_SET__
2198 internal_a
.magic
= PAGEMAGICBCS
;
2202 #define __A_MAGIC_SET__
2203 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
2206 #if defined(M68) || defined(WE32K) || defined(M68K)
2207 #define __A_MAGIC_SET__
2209 internal_a
.magic
= LYNXCOFFMAGIC
;
2211 #endif /* M68 || WE32K || M68K */
2214 #define __A_MAGIC_SET__
2215 internal_a
.magic
= ZMAGIC
;
2218 #define __A_MAGIC_SET__
2219 internal_a
.magic
= PPCMAGIC
;
2222 #define __A_MAGIC_SET__
2224 internal_a
.magic
= LYNXCOFFMAGIC
;
2226 internal_a
.magic
= ZMAGIC
;
2231 #define __A_MAGIC_SET__
2233 internal_a
.magic
= LYNXCOFFMAGIC
;
2238 #define __A_MAGIC_SET__
2239 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
2240 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
2241 RS6K_AOUTHDR_OMAGIC
;
2244 #ifndef __A_MAGIC_SET__
2245 #include "Your aouthdr magic number is not being set!"
2247 #undef __A_MAGIC_SET__
2251 /* FIXME: Does anybody ever set this to another value? */
2252 internal_a
.vstamp
= 0;
2254 /* Now should write relocs, strings, syms */
2255 obj_sym_filepos (abfd
) = sym_base
;
2257 if (bfd_get_symcount (abfd
) != 0)
2260 #ifndef RS6000COFF_C
2261 if (!coff_add_missing_symbols (abfd
))
2264 if (!coff_renumber_symbols (abfd
, &firstundef
))
2266 coff_mangle_symbols (abfd
);
2267 if (! coff_write_symbols (abfd
))
2269 if (! coff_write_linenumbers (abfd
))
2271 if (! coff_write_relocs (abfd
, firstundef
))
2275 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
2276 backend linker, and obj_raw_syment_count is not valid until after
2277 coff_write_symbols is called. */
2278 if (obj_raw_syment_count (abfd
) != 0)
2280 internal_f
.f_symptr
= sym_base
;
2282 /* AIX appears to require that F_RELFLG not be set if there are
2283 local symbols but no relocations. */
2284 internal_f
.f_flags
&=~ F_RELFLG
;
2289 internal_f
.f_symptr
= 0;
2290 internal_f
.f_flags
|= F_LSYMS
;
2295 internal_a
.tsize
= bfd_get_section_size_before_reloc (text_sec
);
2296 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
2300 internal_a
.dsize
= bfd_get_section_size_before_reloc (data_sec
);
2301 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
2305 internal_a
.bsize
= bfd_get_section_size_before_reloc (bss_sec
);
2306 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
2307 internal_a
.data_start
= bss_sec
->vma
;
2310 internal_a
.entry
= bfd_get_start_address (abfd
);
2311 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
2314 if ((abfd
->flags
& EXEC_P
) != 0)
2317 asection
*loader_sec
;
2319 entry
= bfd_get_start_address (abfd
);
2320 if (text_sec
!= NULL
2321 && entry
>= text_sec
->vma
2322 && entry
< text_sec
->vma
+ bfd_section_size (abfd
, text_sec
))
2323 internal_a
.o_snentry
= text_sec
->target_index
;
2324 else if (data_sec
!= NULL
2325 && entry
>= data_sec
->vma
2326 && entry
< data_sec
->vma
+ bfd_section_size (abfd
, data_sec
))
2327 internal_a
.o_snentry
= data_sec
->target_index
;
2329 internal_a
.o_snentry
= 0;
2330 if (text_sec
!= NULL
)
2332 internal_a
.o_sntext
= text_sec
->target_index
;
2333 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
2337 internal_a
.o_sntext
= 0;
2338 internal_a
.o_algntext
= 0;
2340 if (data_sec
!= NULL
)
2342 internal_a
.o_sndata
= data_sec
->target_index
;
2343 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
2347 internal_a
.o_sndata
= 0;
2348 internal_a
.o_algndata
= 0;
2350 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
2351 if (loader_sec
!= NULL
)
2352 internal_a
.o_snloader
= loader_sec
->target_index
;
2354 internal_a
.o_snloader
= 0;
2355 if (bss_sec
!= NULL
)
2356 internal_a
.o_snbss
= bss_sec
->target_index
;
2358 internal_a
.o_snbss
= 0;
2360 toc
= xcoff_data (abfd
)->toc
;
2361 internal_a
.o_toc
= toc
;
2362 if (text_sec
!= NULL
2363 && toc
>= text_sec
->vma
2364 && toc
< text_sec
->vma
+ bfd_section_size (abfd
, text_sec
))
2365 internal_a
.o_sntoc
= text_sec
->target_index
;
2366 else if (data_sec
!= NULL
2367 && toc
>= data_sec
->vma
2368 && toc
< data_sec
->vma
+ bfd_section_size (abfd
, data_sec
))
2369 internal_a
.o_sntoc
= data_sec
->target_index
;
2371 internal_a
.o_sntoc
= 0;
2373 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
2374 if (xcoff_data (abfd
)->cputype
!= -1)
2375 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
2378 switch (bfd_get_arch (abfd
))
2380 case bfd_arch_rs6000
:
2381 internal_a
.o_cputype
= 4;
2383 case bfd_arch_powerpc
:
2384 if (bfd_get_mach (abfd
) == 0)
2385 internal_a
.o_cputype
= 3;
2387 internal_a
.o_cputype
= 1;
2393 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
2394 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
2398 /* now write them */
2399 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
2403 coff_swap_filehdr_out (abfd
, (PTR
) & internal_f
, (PTR
) & buff
);
2404 if (bfd_write ((PTR
) & buff
, 1, FILHSZ
, abfd
) != FILHSZ
)
2407 if (abfd
->flags
& EXEC_P
)
2410 coff_swap_aouthdr_out (abfd
, (PTR
) & internal_a
, (PTR
) & buff
);
2411 if (bfd_write ((PTR
) & buff
, 1, AOUTSZ
, abfd
) != AOUTSZ
)
2418 /* XCOFF seems to always write at least a small a.out header. */
2419 coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, (PTR
) &buff
);
2420 if (bfd_write ((PTR
) &buff
, 1, SMALL_AOUTSZ
, abfd
) != SMALL_AOUTSZ
)
2429 coff_set_section_contents (abfd
, section
, location
, offset
, count
)
2434 bfd_size_type count
;
2436 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
2437 coff_compute_section_file_positions (abfd
);
2440 /* If this is a .lib section, bump the vma address so that it
2441 winds up being the number of .lib sections output. This is
2442 right for SVR3.2. Shared libraries should probably get more
2443 generic support. Ian Taylor <ian@cygnus.com>. */
2444 if (strcmp (section
->name
, _LIB
) == 0)
2448 /* Don't write out bss sections - one way to do this is to
2449 see if the filepos has not been set. */
2450 if (section
->filepos
== 0)
2453 if (bfd_seek (abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
) != 0)
2458 return (bfd_write (location
, 1, count
, abfd
) == count
) ? true : false;
2464 coff_close_and_cleanup (abfd
)
2467 if (!bfd_read_p (abfd
))
2468 switch (abfd
->format
)
2471 if (!_bfd_write_archive_contents (abfd
))
2475 if (!coff_write_object_contents (abfd
))
2479 bfd_set_error (bfd_error_invalid_operation
);
2483 /* We depend on bfd_close to free all the memory on the obstack. */
2484 /* FIXME if bfd_release is not using obstacks! */
2491 buy_and_read (abfd
, where
, seek_direction
, size
)
2497 PTR area
= (PTR
) bfd_alloc (abfd
, size
);
2500 bfd_set_error (bfd_error_no_memory
);
2503 if (bfd_seek (abfd
, where
, seek_direction
) != 0
2504 || bfd_read (area
, 1, size
, abfd
) != size
)
2507 } /* buy_and_read() */
2513 Creating the linenumber table is done by reading in the entire
2514 coff linenumber table, and creating another table for internal use.
2516 A coff linenumber table is structured so that each function
2517 is marked as having a line number of 0. Each line within the
2518 function is an offset from the first line in the function. The
2519 base of the line number information for the table is stored in
2520 the symbol associated with the function.
2522 The information is copied from the external to the internal
2523 table, and each symbol which marks a function is marked by
2526 How does this work ?
2531 coff_slurp_line_table (abfd
, asect
)
2535 LINENO
*native_lineno
;
2536 alent
*lineno_cache
;
2538 BFD_ASSERT (asect
->lineno
== (alent
*) NULL
);
2540 native_lineno
= (LINENO
*) buy_and_read (abfd
,
2541 asect
->line_filepos
,
2544 asect
->lineno_count
));
2546 (alent
*) bfd_alloc (abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof (alent
)));
2547 if (lineno_cache
== NULL
)
2549 bfd_set_error (bfd_error_no_memory
);
2554 unsigned int counter
= 0;
2555 alent
*cache_ptr
= lineno_cache
;
2556 LINENO
*src
= native_lineno
;
2558 while (counter
< asect
->lineno_count
)
2560 struct internal_lineno dst
;
2561 coff_swap_lineno_in (abfd
, src
, &dst
);
2562 cache_ptr
->line_number
= dst
.l_lnno
;
2564 if (cache_ptr
->line_number
== 0)
2566 coff_symbol_type
*sym
=
2567 (coff_symbol_type
*) (dst
.l_addr
.l_symndx
2568 + obj_raw_syments (abfd
))->u
.syment
._n
._n_n
._n_zeroes
;
2569 cache_ptr
->u
.sym
= (asymbol
*) sym
;
2570 if (sym
->lineno
!= NULL
)
2572 (*_bfd_error_handler
)
2573 ("%s: warning: duplicate line number information for `%s'",
2574 bfd_get_filename (abfd
),
2575 bfd_asymbol_name (&sym
->symbol
));
2577 sym
->lineno
= cache_ptr
;
2581 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
2582 - bfd_section_vma (abfd
, asect
);
2583 } /* If no linenumber expect a symbol index */
2589 cache_ptr
->line_number
= 0;
2592 asect
->lineno
= lineno_cache
;
2593 /* FIXME, free native_lineno here, or use alloca or something. */
2598 coff_slurp_symbol_table (abfd
)
2601 combined_entry_type
*native_symbols
;
2602 coff_symbol_type
*cached_area
;
2603 unsigned int *table_ptr
;
2605 unsigned int number_of_symbols
= 0;
2607 if (obj_symbols (abfd
))
2610 /* Read in the symbol table */
2611 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
2616 /* Allocate enough room for all the symbols in cached form */
2617 cached_area
= ((coff_symbol_type
*)
2619 (obj_raw_syment_count (abfd
)
2620 * sizeof (coff_symbol_type
))));
2622 if (cached_area
== NULL
)
2624 bfd_set_error (bfd_error_no_memory
);
2627 table_ptr
= ((unsigned int *)
2629 (obj_raw_syment_count (abfd
)
2630 * sizeof (unsigned int))));
2632 if (table_ptr
== NULL
)
2634 bfd_set_error (bfd_error_no_memory
);
2639 coff_symbol_type
*dst
= cached_area
;
2640 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
2641 unsigned int this_index
= 0;
2642 while (this_index
< last_native_index
)
2644 combined_entry_type
*src
= native_symbols
+ this_index
;
2645 table_ptr
[this_index
] = number_of_symbols
;
2646 dst
->symbol
.the_bfd
= abfd
;
2648 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
2649 /* We use the native name field to point to the cached field. */
2650 src
->u
.syment
._n
._n_n
._n_zeroes
= (long) dst
;
2651 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
2652 src
->u
.syment
.n_scnum
);
2653 dst
->symbol
.flags
= 0;
2654 dst
->done_lineno
= false;
2656 switch (src
->u
.syment
.n_sclass
)
2661 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
2662 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2663 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
2665 /* Fall through to next case */
2674 /* PE uses storage class 0x68 to denote a section symbol */
2677 if ((src
->u
.syment
.n_scnum
) == 0)
2679 if ((src
->u
.syment
.n_value
) == 0)
2681 dst
->symbol
.section
= bfd_und_section_ptr
;
2682 dst
->symbol
.value
= 0;
2686 dst
->symbol
.section
= bfd_com_section_ptr
;
2687 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2692 /* Base the value as an index from the base of the
2695 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2696 dst
->symbol
.value
= (src
->u
.syment
.n_value
2697 - dst
->symbol
.section
->vma
);
2699 if (ISFCN ((src
->u
.syment
.n_type
)))
2701 /* A function ext does not go at the end of a
2703 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
2708 /* A C_HIDEXT symbol is not global. */
2709 if (src
->u
.syment
.n_sclass
== C_HIDEXT
)
2710 dst
->symbol
.flags
= BSF_LOCAL
;
2711 /* A symbol with a csect entry should not go at the end. */
2712 if (src
->u
.syment
.n_numaux
> 0)
2713 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
2718 case C_STAT
: /* static */
2720 case C_LEAFSTAT
: /* static leaf procedure */
2722 case C_LABEL
: /* label */
2723 if (src
->u
.syment
.n_scnum
== -2)
2724 dst
->symbol
.flags
= BSF_DEBUGGING
;
2726 dst
->symbol
.flags
= BSF_LOCAL
;
2728 Base the value as an index from the base of the section, if
2731 if (dst
->symbol
.section
)
2732 dst
->symbol
.value
= (src
->u
.syment
.n_value
) -
2733 dst
->symbol
.section
->vma
;
2735 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2738 case C_MOS
: /* member of structure */
2739 case C_EOS
: /* end of structure */
2740 #ifdef NOTDEF /* C_AUTOARG has the same value */
2742 case C_GLBLREG
: /* A29k-specific storage class */
2745 case C_REGPARM
: /* register parameter */
2746 case C_REG
: /* register variable */
2748 case C_AUTOARG
: /* 960-specific storage class */
2750 case C_TPDEF
: /* type definition */
2752 case C_AUTO
: /* automatic variable */
2753 case C_FIELD
: /* bit field */
2754 case C_ENTAG
: /* enumeration tag */
2755 case C_MOE
: /* member of enumeration */
2756 case C_MOU
: /* member of union */
2757 case C_UNTAG
: /* union tag */
2758 dst
->symbol
.flags
= BSF_DEBUGGING
;
2759 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2762 case C_FILE
: /* file name */
2763 case C_STRTAG
: /* structure tag */
2776 dst
->symbol
.flags
= BSF_DEBUGGING
;
2777 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2781 case C_BINCL
: /* beginning of include file */
2782 case C_EINCL
: /* ending of include file */
2783 /* The value is actually a pointer into the line numbers
2784 of the file. We locate the line number entry, and
2785 set the section to the section which contains it, and
2786 the value to the index in that section. */
2790 dst
->symbol
.flags
= BSF_DEBUGGING
;
2791 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2792 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
2793 && ((file_ptr
) (sec
->line_filepos
2794 + sec
->lineno_count
* LINESZ
)
2795 > (file_ptr
) src
->u
.syment
.n_value
))
2798 dst
->symbol
.value
= 0;
2801 dst
->symbol
.section
= sec
;
2802 dst
->symbol
.value
= ((src
->u
.syment
.n_value
2803 - sec
->line_filepos
)
2811 dst
->symbol
.flags
= BSF_DEBUGGING
;
2813 /* The value is actually a symbol index. Save a pointer
2814 to the symbol instead of the index. FIXME: This
2815 should use a union. */
2816 src
->u
.syment
.n_value
=
2817 (long) (native_symbols
+ src
->u
.syment
.n_value
);
2818 dst
->symbol
.value
= src
->u
.syment
.n_value
;
2823 case C_BLOCK
: /* ".bb" or ".eb" */
2824 case C_FCN
: /* ".bf" or ".ef" */
2825 case C_EFCN
: /* physical end of function */
2826 dst
->symbol
.flags
= BSF_LOCAL
;
2828 Base the value as an index from the base of the section
2830 dst
->symbol
.value
= (src
->u
.syment
.n_value
) - dst
->symbol
.section
->vma
;
2834 case C_EXTDEF
: /* external definition */
2835 case C_ULABEL
: /* undefined label */
2836 case C_USTATIC
: /* undefined static */
2837 #ifndef COFF_WITH_PE
2838 /* C_LINE in regular coff is 0x68. NT has taken over this storage
2839 class to represent a section symbol */
2840 case C_LINE
: /* line # reformatted as symbol table entry */
2842 case C_ALIAS
: /* duplicate tag */
2843 case C_HIDDEN
: /* ext symbol in dmert public lib */
2845 (*_bfd_error_handler
)
2846 ("%s: Unrecognized storage class %d for %s symbol `%s'",
2847 bfd_get_filename (abfd
), src
->u
.syment
.n_sclass
,
2848 dst
->symbol
.section
->name
, dst
->symbol
.name
);
2849 dst
->symbol
.flags
= BSF_DEBUGGING
;
2850 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2854 /* BFD_ASSERT(dst->symbol.flags != 0);*/
2858 dst
->symbol
.udata
.i
= 0;
2859 dst
->lineno
= (alent
*) NULL
;
2860 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
2862 number_of_symbols
++;
2863 } /* walk the native symtab */
2864 } /* bfdize the native symtab */
2866 obj_symbols (abfd
) = cached_area
;
2867 obj_raw_syments (abfd
) = native_symbols
;
2869 bfd_get_symcount (abfd
) = number_of_symbols
;
2870 obj_convert (abfd
) = table_ptr
;
2871 /* Slurp the line tables for each section too */
2877 coff_slurp_line_table (abfd
, p
);
2882 } /* coff_slurp_symbol_table() */
2884 /* Check whether a symbol is globally visible. This is used by the
2885 COFF backend linker code in cofflink.c, since a couple of targets
2886 have globally visible symbols which are not class C_EXT. This
2887 function need not handle the case of n_class == C_EXT. */
2889 #undef OTHER_GLOBAL_CLASS
2892 #define OTHER_GLOBAL_CLASS C_LEAFEXT
2896 #define OTHER_GLOBAL_CLASS C_SECTION
2899 #ifdef OTHER_GLOBAL_CLASS
2902 coff_sym_is_global (abfd
, syment
)
2904 struct internal_syment
*syment
;
2906 if (syment
->n_sclass
== OTHER_GLOBAL_CLASS
)
2911 #undef OTHER_GLOBAL_CLASS
2913 #else /* ! defined (OTHER_GLOBAL_CLASS) */
2915 /* sym_is_global should not be defined if it has nothing to do. */
2917 #define coff_sym_is_global 0
2919 #endif /* ! defined (OTHER_GLOBAL_CLASS) */
2925 Coff relocations are easily transformed into the internal BFD form
2928 Reading a coff relocation table is done in the following stages:
2930 o Read the entire coff relocation table into memory.
2932 o Process each relocation in turn; first swap it from the
2933 external to the internal form.
2935 o Turn the symbol referenced in the relocation's symbol index
2936 into a pointer into the canonical symbol table.
2937 This table is the same as the one returned by a call to
2938 @code{bfd_canonicalize_symtab}. The back end will call that
2939 routine and save the result if a canonicalization hasn't been done.
2941 o The reloc index is turned into a pointer to a howto
2942 structure, in a back end specific way. For instance, the 386
2943 and 960 use the @code{r_type} to directly produce an index
2944 into a howto table vector; the 88k subtracts a number from the
2945 @code{r_type} field and creates an addend field.
2951 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
2953 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
2954 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
2955 coffsym = (obj_symbols (abfd) \
2956 + (cache_ptr->sym_ptr_ptr - symbols)); \
2958 coffsym = coff_symbol_from (abfd, ptr); \
2959 if (coffsym != (coff_symbol_type *) NULL \
2960 && coffsym->native->u.syment.n_scnum == 0) \
2961 cache_ptr->addend = 0; \
2962 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
2963 && ptr->section != (asection *) NULL) \
2964 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
2966 cache_ptr->addend = 0; \
2971 coff_slurp_reloc_table (abfd
, asect
, symbols
)
2976 RELOC
*native_relocs
;
2977 arelent
*reloc_cache
;
2982 if (asect
->relocation
)
2984 if (asect
->reloc_count
== 0)
2986 if (asect
->flags
& SEC_CONSTRUCTOR
)
2988 if (!coff_slurp_symbol_table (abfd
))
2991 (RELOC
*) buy_and_read (abfd
,
2995 asect
->reloc_count
));
2996 reloc_cache
= (arelent
*)
2997 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
2999 if (reloc_cache
== NULL
)
3001 bfd_set_error (bfd_error_no_memory
);
3006 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
3008 #ifdef RELOC_PROCESSING
3009 struct internal_reloc dst
;
3010 struct external_reloc
*src
;
3012 cache_ptr
= reloc_cache
+ idx
;
3013 src
= native_relocs
+ idx
;
3014 coff_swap_reloc_in (abfd
, src
, &dst
);
3016 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
3018 struct internal_reloc dst
;
3020 struct external_reloc
*src
;
3022 cache_ptr
= reloc_cache
+ idx
;
3023 src
= native_relocs
+ idx
;
3025 coff_swap_reloc_in (abfd
, src
, &dst
);
3028 cache_ptr
->address
= dst
.r_vaddr
;
3030 if (dst
.r_symndx
!= -1)
3032 /* @@ Should never be greater than count of symbols! */
3033 if (dst
.r_symndx
>= obj_conv_table_size (abfd
))
3035 cache_ptr
->sym_ptr_ptr
= symbols
+ obj_convert (abfd
)[dst
.r_symndx
];
3036 ptr
= *(cache_ptr
->sym_ptr_ptr
);
3040 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
3044 /* The symbols definitions that we have read in have been
3045 relocated as if their sections started at 0. But the offsets
3046 refering to the symbols in the raw data have not been
3047 modified, so we have to have a negative addend to compensate.
3049 Note that symbols which used to be common must be left alone */
3051 /* Calculate any reloc addend by looking at the symbol */
3052 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
3054 cache_ptr
->address
-= asect
->vma
;
3055 /* !! cache_ptr->section = (asection *) NULL;*/
3057 /* Fill in the cache_ptr->howto field from dst.r_type */
3058 RTYPE2HOWTO (cache_ptr
, &dst
);
3063 asect
->relocation
= reloc_cache
;
3067 #ifndef coff_rtype_to_howto
3070 /* Get the howto structure for a reloc. This is only used if the file
3071 including this one defines coff_relocate_section to be
3072 _bfd_coff_generic_relocate_section, so it is OK if it does not
3073 always work. It is the responsibility of the including file to
3074 make sure it is reasonable if it is needed. */
3076 static reloc_howto_type
*coff_rtype_to_howto
3077 PARAMS ((bfd
*, asection
*, struct internal_reloc
*,
3078 struct coff_link_hash_entry
*, struct internal_syment
*,
3082 static reloc_howto_type
*
3083 coff_rtype_to_howto (abfd
, sec
, rel
, h
, sym
, addendp
)
3086 struct internal_reloc
*rel
;
3087 struct coff_link_hash_entry
*h
;
3088 struct internal_syment
*sym
;
3093 RTYPE2HOWTO (&genrel
, rel
);
3094 return genrel
.howto
;
3097 #else /* ! defined (RTYPE2HOWTO) */
3099 #define coff_rtype_to_howto NULL
3101 #endif /* ! defined (RTYPE2HOWTO) */
3102 #endif /* ! defined (coff_rtype_to_howto) */
3104 /* This is stupid. This function should be a boolean predicate. */
3106 coff_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3112 arelent
*tblptr
= section
->relocation
;
3113 unsigned int count
= 0;
3116 if (section
->flags
& SEC_CONSTRUCTOR
)
3118 /* this section has relocs made up by us, they are not in the
3119 file, so take them out of their chain and place them into
3120 the data area provided */
3121 arelent_chain
*chain
= section
->constructor_chain
;
3122 for (count
= 0; count
< section
->reloc_count
; count
++)
3124 *relptr
++ = &chain
->relent
;
3125 chain
= chain
->next
;
3131 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
3134 tblptr
= section
->relocation
;
3136 for (; count
++ < section
->reloc_count
;)
3137 *relptr
++ = tblptr
++;
3142 return section
->reloc_count
;
3147 coff_sym_filepos (abfd
)
3150 return obj_sym_filepos (abfd
);
3154 #ifndef coff_reloc16_estimate
3155 #define coff_reloc16_estimate dummy_reloc16_estimate
3158 dummy_reloc16_estimate (abfd
, input_section
, reloc
, shrink
, link_info
)
3160 asection
*input_section
;
3162 unsigned int shrink
;
3163 struct bfd_link_info
*link_info
;
3170 #ifndef coff_reloc16_extra_cases
3171 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
3172 /* This works even if abort is not declared in any header file. */
3174 dummy_reloc16_extra_cases (abfd
, link_info
, link_order
, reloc
, data
, src_ptr
,
3177 struct bfd_link_info
*link_info
;
3178 struct bfd_link_order
*link_order
;
3181 unsigned int *src_ptr
;
3182 unsigned int *dst_ptr
;
3188 /* If coff_relocate_section is defined, we can use the optimized COFF
3189 backend linker. Otherwise we must continue to use the old linker. */
3190 #ifdef coff_relocate_section
3191 #ifndef coff_bfd_link_hash_table_create
3192 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
3194 #ifndef coff_bfd_link_add_symbols
3195 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
3197 #ifndef coff_bfd_final_link
3198 #define coff_bfd_final_link _bfd_coff_final_link
3200 #else /* ! defined (coff_relocate_section) */
3201 #define coff_relocate_section NULL
3202 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
3203 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
3204 #define coff_bfd_final_link _bfd_generic_final_link
3205 #endif /* ! defined (coff_relocate_section) */
3206 #define coff_bfd_link_split_section _bfd_generic_link_split_section
3208 #ifndef coff_start_final_link
3209 #define coff_start_final_link NULL
3212 #ifndef coff_adjust_symndx
3213 #define coff_adjust_symndx NULL
3216 static CONST bfd_coff_backend_data bfd_coff_std_swap_table
=
3218 coff_swap_aux_in
, coff_swap_sym_in
, coff_swap_lineno_in
,
3219 coff_swap_aux_out
, coff_swap_sym_out
,
3220 coff_swap_lineno_out
, coff_swap_reloc_out
,
3221 coff_swap_filehdr_out
, coff_swap_aouthdr_out
,
3222 coff_swap_scnhdr_out
,
3223 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
,
3224 #ifdef COFF_LONG_FILENAMES
3229 coff_swap_filehdr_in
, coff_swap_aouthdr_in
, coff_swap_scnhdr_in
,
3230 coff_swap_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
3231 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
3232 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
3233 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
3234 coff_sym_is_global
, coff_compute_section_file_positions
,
3235 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
3239 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
3240 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
3241 #define coff_get_section_contents _bfd_generic_get_section_contents
3243 #ifndef coff_bfd_copy_private_symbol_data
3244 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
3247 #ifndef coff_bfd_copy_private_section_data
3248 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
3251 #ifndef coff_bfd_copy_private_bfd_data
3252 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
3255 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
3256 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
3258 #ifndef coff_bfd_print_private_bfd_data
3259 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
3262 #ifndef coff_bfd_is_local_label
3263 #define coff_bfd_is_local_label bfd_generic_is_local_label
3265 #ifndef coff_read_minisymbols
3266 #define coff_read_minisymbols _bfd_generic_read_minisymbols
3268 #ifndef coff_minisymbol_to_symbol
3269 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
3272 /* The reloc lookup routine must be supplied by each individual COFF
3274 #ifndef coff_bfd_reloc_type_lookup
3275 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
3278 #ifndef coff_bfd_get_relocated_section_contents
3279 #define coff_bfd_get_relocated_section_contents \
3280 bfd_generic_get_relocated_section_contents
3282 #ifndef coff_bfd_relax_section
3283 #define coff_bfd_relax_section bfd_generic_relax_section