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 . {* The container for the symbol structure as read and translated
275 . union internal_auxent auxent;
276 . struct internal_syment syment;
278 .} combined_entry_type;
281 .{* Each canonical asymbol really looks like this: *}
283 .typedef struct coff_symbol_struct
285 . {* The actual symbol which the rest of BFD works with *}
288 . {* A pointer to the hidden information for this symbol *}
289 .combined_entry_type *native;
291 . {* A pointer to the linenumber information for this symbol *}
292 .struct lineno_cache_entry *lineno;
294 . {* Have the line numbers been relocated yet ? *}
295 .boolean done_lineno;
301 #if defined(COFF_IMAGE_WITH_PE) || (defined(COFF_OBJ_WITH_PE) && defined(PPC))
304 #include "coffswap.h"
308 /* void warning(); */
311 * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the
312 * incoming SEC_* flags. The inverse of this function is styp_to_sec_flags().
313 * NOTE: If you add to/change this routine, you should mirror the changes
314 * in styp_to_sec_flags().
317 sec_to_styp_flags (sec_name
, sec_flags
)
318 CONST
char *sec_name
;
323 if (!strcmp (sec_name
, _TEXT
))
325 styp_flags
= STYP_TEXT
;
327 else if (!strcmp (sec_name
, _DATA
))
329 styp_flags
= STYP_DATA
;
331 else if (!strcmp (sec_name
, _BSS
))
333 styp_flags
= STYP_BSS
;
336 else if (!strcmp (sec_name
, _COMMENT
))
338 styp_flags
= STYP_INFO
;
339 #endif /* _COMMENT */
342 else if (!strcmp (sec_name
, _LIB
))
344 styp_flags
= STYP_LIB
;
348 else if (!strcmp (sec_name
, _LIT
))
350 styp_flags
= STYP_LIT
;
353 else if (!strcmp (sec_name
, ".debug"))
356 styp_flags
= STYP_DEBUG
;
358 styp_flags
= STYP_INFO
;
361 else if (!strncmp (sec_name
, ".stab", 5))
363 styp_flags
= STYP_INFO
;
366 else if (!strcmp (sec_name
, ".edata"))
368 styp_flags
= STYP_DATA
;
372 else if (!strcmp (sec_name
, _PAD
))
374 styp_flags
= STYP_PAD
;
376 else if (!strcmp (sec_name
, _LOADER
))
378 styp_flags
= STYP_LOADER
;
381 /* Try and figure out what it should be */
382 else if (sec_flags
& SEC_CODE
)
384 styp_flags
= STYP_TEXT
;
386 else if (sec_flags
& SEC_DATA
)
388 styp_flags
= STYP_DATA
;
390 else if (sec_flags
& SEC_READONLY
)
392 #ifdef STYP_LIT /* 29k readonly text/data section */
393 styp_flags
= STYP_LIT
;
395 styp_flags
= STYP_TEXT
;
396 #endif /* STYP_LIT */
398 else if (sec_flags
& SEC_LOAD
)
400 styp_flags
= STYP_TEXT
;
402 else if (sec_flags
& SEC_ALLOC
)
404 styp_flags
= STYP_BSS
;
408 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
409 styp_flags
|= STYP_NOLOAD
;
415 * Return a word with SEC_* flags set to represent the incoming
416 * STYP_* flags (from scnhdr.s_flags). The inverse of this
417 * function is sec_to_styp_flags().
418 * NOTE: If you add to/change this routine, you should mirror the changes
419 * in sec_to_styp_flags().
422 styp_to_sec_flags (abfd
, hdr
, name
)
427 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
428 long styp_flags
= internal_s
->s_flags
;
429 flagword sec_flags
= 0;
432 if (styp_flags
& STYP_NOLOAD
)
434 sec_flags
|= SEC_NEVER_LOAD
;
436 #endif /* STYP_NOLOAD */
438 /* For 386 COFF, at least, an unloadable text or data section is
439 actually a shared library section. */
440 if (styp_flags
& STYP_TEXT
)
442 if (sec_flags
& SEC_NEVER_LOAD
)
443 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
445 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
447 else if (styp_flags
& STYP_DATA
)
449 if (sec_flags
& SEC_NEVER_LOAD
)
450 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
452 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
454 else if (styp_flags
& STYP_BSS
)
456 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
457 if (sec_flags
& SEC_NEVER_LOAD
)
458 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
461 sec_flags
|= SEC_ALLOC
;
463 else if (styp_flags
& STYP_INFO
)
465 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
466 defined. coff_compute_section_file_positions uses
467 COFF_PAGE_SIZE to ensure that the low order bits of the
468 section VMA and the file offset match. If we don't know
469 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
470 and demand page loading of the file will fail. */
471 #ifdef COFF_PAGE_SIZE
472 sec_flags
|= SEC_DEBUGGING
;
475 else if (strcmp (name
, _TEXT
) == 0)
477 if (sec_flags
& SEC_NEVER_LOAD
)
478 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
480 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
482 else if (strcmp (name
, _DATA
) == 0)
484 if (sec_flags
& SEC_NEVER_LOAD
)
485 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
487 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
489 else if (strcmp (name
, _BSS
) == 0)
491 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
492 if (sec_flags
& SEC_NEVER_LOAD
)
493 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
496 sec_flags
|= SEC_ALLOC
;
498 else if (strcmp (name
, ".debug") == 0
500 || strcmp (name
, _COMMENT
) == 0
502 || strncmp (name
, ".stab", 5) == 0)
504 #ifdef COFF_PAGE_SIZE
505 sec_flags
|= SEC_DEBUGGING
;
509 else if (strcmp (name
, _LIB
) == 0)
513 else if (strcmp (name
, _LIT
) == 0)
515 sec_flags
= SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
520 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
523 #ifdef STYP_LIT /* A29k readonly text/data section type */
524 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
526 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
528 #endif /* STYP_LIT */
529 #ifdef STYP_OTHER_LOAD /* Other loaded sections */
530 if (styp_flags
& STYP_OTHER_LOAD
)
532 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
534 #endif /* STYP_SDATA */
539 #define get_index(symbol) ((symbol)->udata.i)
543 bfd_coff_backend_data
547 Special entry points for gdb to swap in coff symbol table parts:
550 . void (*_bfd_coff_swap_aux_in) PARAMS ((
559 . void (*_bfd_coff_swap_sym_in) PARAMS ((
564 . void (*_bfd_coff_swap_lineno_in) PARAMS ((
570 Special entry points for gas to swap out coff parts:
572 . unsigned int (*_bfd_coff_swap_aux_out) PARAMS ((
581 . unsigned int (*_bfd_coff_swap_sym_out) PARAMS ((
586 . unsigned int (*_bfd_coff_swap_lineno_out) PARAMS ((
591 . unsigned int (*_bfd_coff_swap_reloc_out) PARAMS ((
596 . unsigned int (*_bfd_coff_swap_filehdr_out) PARAMS ((
601 . unsigned int (*_bfd_coff_swap_aouthdr_out) PARAMS ((
606 . unsigned int (*_bfd_coff_swap_scnhdr_out) PARAMS ((
612 Special entry points for generic COFF routines to call target
613 dependent COFF routines:
615 . unsigned int _bfd_filhsz;
616 . unsigned int _bfd_aoutsz;
617 . unsigned int _bfd_scnhsz;
618 . unsigned int _bfd_symesz;
619 . unsigned int _bfd_auxesz;
620 . unsigned int _bfd_relsz;
621 . unsigned int _bfd_linesz;
622 . boolean _bfd_coff_long_filenames;
623 . void (*_bfd_coff_swap_filehdr_in) PARAMS ((
627 . void (*_bfd_coff_swap_aouthdr_in) PARAMS ((
631 . void (*_bfd_coff_swap_scnhdr_in) PARAMS ((
635 . void (*_bfd_coff_swap_reloc_in) PARAMS ((
639 . boolean (*_bfd_coff_bad_format_hook) PARAMS ((
641 . PTR internal_filehdr));
642 . boolean (*_bfd_coff_set_arch_mach_hook) PARAMS ((
644 . PTR internal_filehdr));
645 . PTR (*_bfd_coff_mkobject_hook) PARAMS ((
647 . PTR internal_filehdr,
648 . PTR internal_aouthdr));
649 . flagword (*_bfd_styp_to_sec_flags_hook) PARAMS ((
651 . PTR internal_scnhdr,
652 . const char *name));
653 . void (*_bfd_set_alignment_hook) PARAMS ((
656 . PTR internal_scnhdr));
657 . boolean (*_bfd_coff_slurp_symbol_table) PARAMS ((
659 . boolean (*_bfd_coff_symname_in_debug) PARAMS ((
661 . struct internal_syment *sym));
662 . boolean (*_bfd_coff_pointerize_aux_hook) PARAMS ((
664 . combined_entry_type *table_base,
665 . combined_entry_type *symbol,
666 . unsigned int indaux,
667 . combined_entry_type *aux));
668 . boolean (*_bfd_coff_print_aux) PARAMS ((
671 . combined_entry_type *table_base,
672 . combined_entry_type *symbol,
673 . combined_entry_type *aux,
674 . unsigned int indaux));
675 . void (*_bfd_coff_reloc16_extra_cases) PARAMS ((
677 . struct bfd_link_info *link_info,
678 . struct bfd_link_order *link_order,
681 . unsigned int *src_ptr,
682 . unsigned int *dst_ptr));
683 . int (*_bfd_coff_reloc16_estimate) PARAMS ((
685 . asection *input_section,
687 . unsigned int shrink,
688 . struct bfd_link_info *link_info));
689 . boolean (*_bfd_coff_sym_is_global) PARAMS ((
691 . struct internal_syment *));
692 . void (*_bfd_coff_compute_section_file_positions) PARAMS ((
694 . boolean (*_bfd_coff_start_final_link) PARAMS ((
696 . struct bfd_link_info *info));
697 . boolean (*_bfd_coff_relocate_section) PARAMS ((
699 . struct bfd_link_info *info,
701 . asection *input_section,
702 . bfd_byte *contents,
703 . struct internal_reloc *relocs,
704 . struct internal_syment *syms,
705 . asection **sections));
706 . reloc_howto_type *(*_bfd_coff_rtype_to_howto) PARAMS ((
709 . struct internal_reloc *rel,
710 . struct coff_link_hash_entry *h,
711 . struct internal_syment *sym,
712 . bfd_vma *addendp));
713 . boolean (*_bfd_coff_adjust_symndx) PARAMS ((
715 . struct bfd_link_info *info,
718 . struct internal_reloc *reloc,
719 . boolean *adjustedp));
721 .} bfd_coff_backend_data;
723 .#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
725 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
726 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
728 .#define bfd_coff_swap_sym_in(a,e,i) \
729 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
731 .#define bfd_coff_swap_lineno_in(a,e,i) \
732 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
734 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
735 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
737 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
738 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
740 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
741 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
743 .#define bfd_coff_swap_sym_out(abfd, i,o) \
744 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
746 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
747 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
749 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
750 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
752 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
753 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
755 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
756 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
757 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
758 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
759 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
760 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
761 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
762 .#define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames)
763 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
764 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
766 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
767 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
769 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
770 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
772 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
773 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
775 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
776 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
778 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
779 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
780 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
781 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
783 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name)\
784 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook) (abfd, scnhdr, name))
786 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
787 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
789 .#define bfd_coff_slurp_symbol_table(abfd)\
790 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
792 .#define bfd_coff_symname_in_debug(abfd, sym)\
793 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
795 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
796 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
797 . (abfd, file, base, symbol, aux, indaux))
799 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
800 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
801 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
803 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
804 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
805 . (abfd, section, reloc, shrink, link_info))
807 .#define bfd_coff_sym_is_global(abfd, sym)\
808 . ((coff_backend_info (abfd)->_bfd_coff_sym_is_global)\
811 .#define bfd_coff_compute_section_file_positions(abfd)\
812 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
815 .#define bfd_coff_start_final_link(obfd, info)\
816 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
818 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
819 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
820 . (obfd, info, ibfd, o, con, rel, isyms, secs))
821 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
822 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
823 . (abfd, sec, rel, h, sym, addendp))
824 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
825 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
826 . (obfd, info, ibfd, sec, rel, adjustedp))
830 /* See whether the magic number matches. */
833 coff_bad_format_hook (abfd
, filehdr
)
837 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
839 if (BADMAG (*internal_f
))
842 /* if the optional header is NULL or not the correct size then
843 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
844 and Intel 960 readwrite headers (I960WRMAGIC) is that the
845 optional header is of a different size.
847 But the mips keeps extra stuff in it's opthdr, so dont check
851 #if defined(M88) || defined(I960)
852 if (internal_f
->f_opthdr
!= 0 && AOUTSZ
!= internal_f
->f_opthdr
)
860 initialize a section structure with information peculiar to this
861 particular implementation of coff
865 coff_new_section_hook (abfd
, section
)
869 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
872 if (xcoff_data (abfd
)->text_align_power
!= 0
873 && strcmp (bfd_get_section_name (abfd
, section
), ".text") == 0)
874 section
->alignment_power
= xcoff_data (abfd
)->text_align_power
;
875 if (xcoff_data (abfd
)->data_align_power
!= 0
876 && strcmp (bfd_get_section_name (abfd
, section
), ".data") == 0)
877 section
->alignment_power
= xcoff_data (abfd
)->data_align_power
;
880 /* Allocate aux records for section symbols, to store size and
883 @@ Shouldn't use constant multiplier here! */
884 coffsymbol (section
->symbol
)->native
=
885 (combined_entry_type
*) bfd_zalloc (abfd
,
886 sizeof (combined_entry_type
) * 10);
888 /* The .stab section must be aligned to 2**2 at most, because
889 otherwise there may be gaps in the section which gdb will not
890 know how to interpret. Examining the section name is a hack, but
891 that is also how gdb locates the section.
892 We need to handle the .ctors and .dtors sections similarly, to
893 avoid introducing null words in the tables. */
894 if (COFF_DEFAULT_SECTION_ALIGNMENT_POWER
> 2
895 && (strncmp (section
->name
, ".stab", 5) == 0
896 || strcmp (section
->name
, ".ctors") == 0
897 || strcmp (section
->name
, ".dtors") == 0))
898 section
->alignment_power
= 2;
905 /* Set the alignment of a BFD section. */
908 coff_set_alignment_hook (abfd
, section
, scnhdr
)
913 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
916 for (i
= 0; i
< 32; i
++)
917 if ((1 << i
) >= hdr
->s_align
)
919 section
->alignment_power
= i
;
924 #define coff_set_alignment_hook \
925 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
929 #ifndef coff_mkobject
934 coff_data_type
*coff
;
936 abfd
->tdata
.coff_obj_data
= (struct coff_tdata
*) bfd_zalloc (abfd
, sizeof (coff_data_type
));
937 if (abfd
->tdata
.coff_obj_data
== 0)
939 bfd_set_error (bfd_error_no_memory
);
942 coff
= coff_data (abfd
);
943 coff
->symbols
= (coff_symbol_type
*) NULL
;
944 coff
->conversion_table
= (unsigned int *) NULL
;
945 coff
->raw_syments
= (struct coff_ptr_struct
*) NULL
;
947 /* make_abs_section(abfd);*/
953 /* Create the COFF backend specific information. */
954 #ifndef coff_mkobject_hook
956 coff_mkobject_hook (abfd
, filehdr
, aouthdr
)
961 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
962 coff_data_type
*coff
;
964 if (coff_mkobject (abfd
) == false)
967 coff
= coff_data (abfd
);
969 coff
->sym_filepos
= internal_f
->f_symptr
;
971 /* These members communicate important constants about the symbol
972 table to GDB's symbol-reading code. These `constants'
973 unfortunately vary among coff implementations... */
974 coff
->local_n_btmask
= N_BTMASK
;
975 coff
->local_n_btshft
= N_BTSHFT
;
976 coff
->local_n_tmask
= N_TMASK
;
977 coff
->local_n_tshift
= N_TSHIFT
;
978 coff
->local_symesz
= SYMESZ
;
979 coff
->local_auxesz
= AUXESZ
;
980 coff
->local_linesz
= LINESZ
;
982 obj_raw_syment_count (abfd
) =
983 obj_conv_table_size (abfd
) =
987 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
988 abfd
->flags
|= DYNAMIC
;
989 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= AOUTSZ
)
991 struct internal_aouthdr
*internal_a
=
992 (struct internal_aouthdr
*) aouthdr
;
993 struct xcoff_tdata
*xcoff
;
995 xcoff
= xcoff_data (abfd
);
996 xcoff
->toc
= internal_a
->o_toc
;
997 xcoff
->text_align_power
= internal_a
->o_algntext
;
998 xcoff
->data_align_power
= internal_a
->o_algndata
;
999 xcoff
->modtype
= internal_a
->o_modtype
;
1000 xcoff
->maxdata
= internal_a
->o_maxdata
;
1001 xcoff
->maxstack
= internal_a
->o_maxstack
;
1009 /* Determine the machine architecture and type. FIXME: This is target
1010 dependent because the magic numbers are defined in the target
1011 dependent header files. But there is no particular need for this.
1012 If the magic numbers were moved to a separate file, this function
1013 would be target independent and would also be much more successful
1014 at linking together COFF files for different architectures. */
1017 coff_set_arch_mach_hook (abfd
, filehdr
)
1022 enum bfd_architecture arch
;
1023 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1026 switch (internal_f
->f_magic
)
1030 arch
= bfd_arch_powerpc
;
1031 machine
= 0; /* what does this mean? (krk) */
1037 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler */
1038 case LYNXCOFFMAGIC
: /* shadows the m68k Lynx number below, sigh */
1039 arch
= bfd_arch_i386
;
1043 #ifdef A29K_MAGIC_BIG
1044 case A29K_MAGIC_BIG
:
1045 case A29K_MAGIC_LITTLE
:
1046 arch
= bfd_arch_a29k
;
1052 arch
= bfd_arch_arm
;
1059 #ifdef MC68KBCSMAGIC
1062 #ifdef APOLLOM68KMAGIC
1063 case APOLLOM68KMAGIC
:
1065 #ifdef LYNXCOFFMAGIC
1068 arch
= bfd_arch_m68k
;
1076 arch
= bfd_arch_m88k
;
1082 arch
= bfd_arch_z8k
;
1083 switch (internal_f
->f_flags
& F_MACHMASK
)
1086 machine
= bfd_mach_z8001
;
1089 machine
= bfd_mach_z8002
;
1100 arch
= bfd_arch_i960
;
1101 switch (F_I960TYPE
& internal_f
->f_flags
)
1105 machine
= bfd_mach_i960_core
;
1108 machine
= bfd_mach_i960_kb_sb
;
1111 machine
= bfd_mach_i960_mc
;
1114 machine
= bfd_mach_i960_xa
;
1117 machine
= bfd_mach_i960_ca
;
1120 machine
= bfd_mach_i960_ka_sa
;
1122 /* start-sanitize-i960xl */
1124 machine
= bfd_mach_i960_xl
;
1126 /* end-sanitize-i960xl */
1137 /* PowerPC Macs use the same magic numbers as RS/6000 (because
1138 that's how they were bootstrapped originally), but they are
1139 always PowerPC architecture. */
1140 arch
= bfd_arch_powerpc
;
1143 /* FIXME The architecture and machine can now (as of AIX 4.1) be
1144 identified by looking at fields in the a.out header. */
1145 arch
= bfd_arch_rs6000
;
1147 #endif /* POWERMAC */
1153 arch
= bfd_arch_we32k
;
1160 arch
= bfd_arch_h8300
;
1161 machine
= bfd_mach_h8300
;
1162 /* !! FIXME this probably isn't the right place for this */
1163 abfd
->flags
|= BFD_IS_RELAXABLE
;
1169 arch
= bfd_arch_h8300
;
1170 machine
= bfd_mach_h8300h
;
1171 /* !! FIXME this probably isn't the right place for this */
1172 abfd
->flags
|= BFD_IS_RELAXABLE
;
1176 #ifdef SH_ARCH_MAGIC_BIG
1177 case SH_ARCH_MAGIC_BIG
:
1178 case SH_ARCH_MAGIC_LITTLE
:
1186 arch
= bfd_arch_h8500
;
1193 #ifdef LYNXCOFFMAGIC
1196 arch
= bfd_arch_sparc
;
1201 default: /* Unreadable input file type */
1202 arch
= bfd_arch_obscure
;
1206 bfd_default_set_arch_mach (abfd
, arch
, machine
);
1210 #ifdef SYMNAME_IN_DEBUG
1213 symname_in_debug_hook (abfd
, sym
)
1215 struct internal_syment
*sym
;
1217 return SYMNAME_IN_DEBUG (sym
) ? true : false;
1222 #define symname_in_debug_hook \
1223 (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
1229 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
1231 static boolean coff_pointerize_aux_hook
1232 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
1233 unsigned int, combined_entry_type
*));
1237 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
1239 combined_entry_type
*table_base
;
1240 combined_entry_type
*symbol
;
1241 unsigned int indaux
;
1242 combined_entry_type
*aux
;
1244 int class = symbol
->u
.syment
.n_sclass
;
1246 if ((class == C_EXT
|| class == C_HIDEXT
)
1247 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
1249 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
1251 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
1252 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
1253 aux
->fix_scnlen
= 1;
1256 /* Return true to indicate that the caller should not do any
1257 further work on this auxent. */
1261 /* Return false to indicate that this auxent should be handled by
1269 /* We don't want to pointerize bal entries. */
1271 static boolean coff_pointerize_aux_hook
1272 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
1273 unsigned int, combined_entry_type
*));
1277 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
1279 combined_entry_type
*table_base
;
1280 combined_entry_type
*symbol
;
1281 unsigned int indaux
;
1282 combined_entry_type
*aux
;
1284 /* Return true if we don't want to pointerize this aux entry, which
1285 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
1286 return indaux
== 1 && symbol
->u
.syment
.n_sclass
== C_LEAFPROC
;
1291 #define coff_pointerize_aux_hook 0
1294 #endif /* ! RS6000COFF_C */
1296 /* Print an aux entry. This returns true if it has printed it. */
1298 static boolean coff_print_aux
1299 PARAMS ((bfd
*, FILE *, combined_entry_type
*, combined_entry_type
*,
1300 combined_entry_type
*, unsigned int));
1303 coff_print_aux (abfd
, file
, table_base
, symbol
, aux
, indaux
)
1306 combined_entry_type
*table_base
;
1307 combined_entry_type
*symbol
;
1308 combined_entry_type
*aux
;
1309 unsigned int indaux
;
1312 if ((symbol
->u
.syment
.n_sclass
== C_EXT
1313 || symbol
->u
.syment
.n_sclass
== C_HIDEXT
)
1314 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
1316 /* This is a csect entry. */
1317 fprintf (file
, "AUX ");
1318 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
1320 BFD_ASSERT (! aux
->fix_scnlen
);
1321 fprintf (file
, "val %5ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
1325 fprintf (file
, "indx ");
1326 if (! aux
->fix_scnlen
)
1327 fprintf (file
, "%4ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
1329 fprintf (file
, "%4ld",
1330 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
1333 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
1334 aux
->u
.auxent
.x_csect
.x_parmhash
,
1335 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
1336 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
1337 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
1338 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
1339 aux
->u
.auxent
.x_csect
.x_stab
,
1340 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
1345 /* Return false to indicate that no special action was taken. */
1353 To write relocations, the back end steps though the
1354 canonical relocation table and create an
1355 @code{internal_reloc}. The symbol index to use is removed from
1356 the @code{offset} field in the symbol table supplied. The
1357 address comes directly from the sum of the section base
1358 address and the relocation offset; the type is dug directly
1359 from the howto field. Then the @code{internal_reloc} is
1360 swapped into the shape of an @code{external_reloc} and written
1366 coff_write_relocs (abfd
, first_undef
)
1371 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
1374 struct external_reloc dst
;
1376 arelent
**p
= s
->orelocation
;
1377 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
1379 for (i
= 0; i
< s
->reloc_count
; i
++)
1381 struct internal_reloc n
;
1383 memset ((PTR
) & n
, 0, sizeof (n
));
1385 /* Now we've renumbered the symbols we know where the
1386 undefined symbols live in the table. Check the reloc
1387 entries for symbols who's output bfd isn't the right one.
1388 This is because the symbol was undefined (which means
1389 that all the pointers are never made to point to the same
1390 place). This is a bad thing,'cause the symbols attached
1391 to the output bfd are indexed, so that the relocation
1392 entries know which symbol index they point to. So we
1393 have to look up the output symbol here. */
1395 if (q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
1398 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
1399 asymbol
**outsyms
= abfd
->outsymbols
;
1400 for (i
= first_undef
; outsyms
[i
]; i
++)
1402 const char *intable
= outsyms
[i
]->name
;
1403 if (strcmp (intable
, sname
) == 0) {
1404 /* got a hit, so repoint the reloc */
1405 q
->sym_ptr_ptr
= outsyms
+ i
;
1411 n
.r_vaddr
= q
->address
+ s
->vma
;
1414 /* The 29k const/consth reloc pair is a real kludge. The consth
1415 part doesn't have a symbol; it has an offset. So rebuilt
1417 if (q
->howto
->type
== R_IHCONST
)
1418 n
.r_symndx
= q
->addend
;
1423 if (q
->sym_ptr_ptr
== bfd_abs_section_ptr
->symbol_ptr_ptr
)
1424 /* This is a relocation relative to the absolute symbol. */
1428 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
1429 /* Take notice if the symbol reloc points to a symbol
1430 we don't have in our symbol table. What should we
1432 if (n
.r_symndx
> obj_conv_table_size (abfd
))
1437 #ifdef SWAP_OUT_RELOC_OFFSET
1438 n
.r_offset
= q
->addend
;
1442 /* Work out reloc type from what is required */
1443 SELECT_RELOC (n
, q
->howto
);
1445 n
.r_type
= q
->howto
->type
;
1447 coff_swap_reloc_out (abfd
, &n
, &dst
);
1448 if (bfd_write ((PTR
) & dst
, 1, RELSZ
, abfd
) != RELSZ
)
1456 /* Set flags and magic number of a coff file from architecture and machine
1457 type. Result is true if we can represent the arch&type, false if not. */
1460 coff_set_flags (abfd
, magicp
, flagsp
)
1463 unsigned short *flagsp
;
1465 switch (bfd_get_arch (abfd
))
1470 switch (bfd_get_mach (abfd
))
1472 case bfd_mach_z8001
:
1475 case bfd_mach_z8002
:
1489 *magicp
= I960ROMAGIC
;
1491 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1492 I960RWMAGIC); FIXME???
1494 switch (bfd_get_mach (abfd
))
1496 case bfd_mach_i960_core
:
1499 case bfd_mach_i960_kb_sb
:
1502 case bfd_mach_i960_mc
:
1505 case bfd_mach_i960_xa
:
1508 case bfd_mach_i960_ca
:
1511 case bfd_mach_i960_ka_sa
:
1514 /* start-sanitize-i960xl */
1515 case bfd_mach_i960_xl
:
1518 /* end-sanitize-i960xl */
1533 case bfd_arch_powerpc
:
1540 *magicp
= I386MAGIC
;
1542 /* Just overwrite the usual value if we're doing Lynx. */
1543 *magicp
= LYNXCOFFMAGIC
;
1550 #ifdef APOLLOM68KMAGIC
1551 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
1553 *magicp
= MC68MAGIC
;
1556 /* Just overwrite the usual value if we're doing Lynx. */
1557 *magicp
= LYNXCOFFMAGIC
;
1565 *magicp
= MC88OMAGIC
;
1570 case bfd_arch_h8300
:
1571 switch (bfd_get_mach (abfd
))
1573 case bfd_mach_h8300
:
1574 *magicp
= H8300MAGIC
;
1576 case bfd_mach_h8300h
:
1577 *magicp
= H8300HMAGIC
;
1583 #ifdef SH_ARCH_MAGIC_BIG
1585 if (abfd
->xvec
->byteorder_big_p
)
1586 *magicp
= SH_ARCH_MAGIC_BIG
;
1588 *magicp
= SH_ARCH_MAGIC_LITTLE
;
1594 case bfd_arch_sparc
:
1595 *magicp
= SPARCMAGIC
;
1597 /* Just overwrite the usual value if we're doing Lynx. */
1598 *magicp
= LYNXCOFFMAGIC
;
1605 case bfd_arch_h8500
:
1606 *magicp
= H8500MAGIC
;
1610 #ifdef A29K_MAGIC_BIG
1612 if (abfd
->xvec
->byteorder_big_p
)
1613 *magicp
= A29K_MAGIC_BIG
;
1615 *magicp
= A29K_MAGIC_LITTLE
;
1621 case bfd_arch_we32k
:
1622 *magicp
= WE32KMAGIC
;
1628 case bfd_arch_rs6000
:
1630 case bfd_arch_powerpc
:
1632 *magicp
= U802TOCMAGIC
;
1637 default: /* Unknown architecture */
1638 /* return false; -- fall through to "return false" below, to avoid
1639 "statement never reached" errors on the one below. */
1648 coff_set_arch_mach (abfd
, arch
, machine
)
1650 enum bfd_architecture arch
;
1651 unsigned long machine
;
1654 unsigned short dummy2
;
1656 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
1659 if (arch
!= bfd_arch_unknown
&&
1660 coff_set_flags (abfd
, &dummy1
, &dummy2
) != true)
1661 return false; /* We can't represent this type */
1663 return true; /* We're easy ... */
1667 /* Calculate the file position for each section. */
1670 coff_compute_section_file_positions (abfd
)
1674 asection
*previous
= (asection
*) NULL
;
1675 file_ptr sofar
= FILHSZ
;
1683 #ifdef COFF_IMAGE_WITH_PE
1685 if (coff_data (abfd
)->link_info
)
1687 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
1690 page_size
= PE_DEF_FILE_ALIGNMENT
;
1691 #elif defined (COFF_PAGE_SIZE)
1692 int page_size
= COFF_PAGE_SIZE
;
1695 if (bfd_get_start_address (abfd
))
1697 /* A start address may have been added to the original file. In this
1698 case it will need an optional header to record it. */
1699 abfd
->flags
|= EXEC_P
;
1702 if (abfd
->flags
& EXEC_P
)
1705 sofar
+= abfd
->section_count
* SCNHSZ
;
1706 for (current
= abfd
->sections
, count
= 1;
1707 current
!= (asection
*) NULL
;
1708 current
= current
->next
, ++count
)
1710 current
->target_index
= count
;
1712 /* Only deal with sections which have contents */
1713 if (!(current
->flags
& SEC_HAS_CONTENTS
))
1717 /* Do not include the .junk section. This is where we collect section
1718 data which we don't need. This is mainly the MS .debug$ data which
1719 stores codeview debug data. */
1720 if (strcmp (current
->name
, ".junk") == 0)
1726 /* Align the sections in the file to the same boundary on
1727 which they are aligned in virtual memory. I960 doesn't
1728 do this (FIXME) so we can stay in sync with Intel. 960
1729 doesn't yet page from files... */
1732 /* make sure this section is aligned on the right boundary - by
1733 padding the previous section up if necessary */
1736 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
1737 if (previous
!= (asection
*) NULL
)
1739 previous
->_raw_size
+= sofar
- old_sofar
;
1745 /* In demand paged files the low order bits of the file offset
1746 must match the low order bits of the virtual address. */
1747 #ifdef COFF_PAGE_SIZE
1748 if ((abfd
->flags
& D_PAGED
) != 0
1749 && (current
->flags
& SEC_ALLOC
) != 0)
1750 sofar
+= (current
->vma
- sofar
) % page_size
;
1752 current
->filepos
= sofar
;
1754 #ifdef COFF_IMAGE_WITH_PE
1755 /* With PE we have to pad each section to be a multiple of its page size
1756 too, and remember both sizes. Cooked_size becomes very useful. */
1757 current
->_cooked_size
= current
->_raw_size
;
1758 current
->_raw_size
= (current
->_raw_size
+ page_size
-1) & -page_size
;
1761 sofar
+= current
->_raw_size
;
1764 /* make sure that this section is of the right size too */
1766 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
1767 current
->_raw_size
+= sofar
- old_sofar
;
1771 /* Force .lib sections to start at zero. The vma is then
1772 incremented in coff_set_section_contents. This is right for
1774 if (strcmp (current
->name
, _LIB
) == 0)
1775 bfd_set_section_vma (abfd
, current
, 0);
1781 obj_relocbase (abfd
) = sofar
;
1782 abfd
->output_has_begun
= true;
1786 #ifndef RS6000COFF_C
1788 /* If .file, .text, .data, .bss symbols are missing, add them. */
1789 /* @@ Should we only be adding missing symbols, or overriding the aux
1790 values for existing section symbols? */
1792 coff_add_missing_symbols (abfd
)
1795 unsigned int nsyms
= bfd_get_symcount (abfd
);
1796 asymbol
**sympp
= abfd
->outsymbols
;
1799 int need_text
= 1, need_data
= 1, need_bss
= 1, need_file
= 1;
1801 for (i
= 0; i
< nsyms
; i
++)
1803 coff_symbol_type
*csym
= coff_symbol_from (abfd
, sympp
[i
]);
1807 /* only do this if there is a coff representation of the input
1809 if (csym
->native
&& csym
->native
->u
.syment
.n_sclass
== C_FILE
)
1814 name
= csym
->symbol
.name
;
1817 if (!strcmp (name
, _TEXT
))
1820 else if (!strcmp (name
, ".wtext"))
1823 else if (!strcmp (name
, _DATA
))
1825 else if (!strcmp (name
, _BSS
))
1829 /* Now i == bfd_get_symcount (abfd). */
1830 /* @@ For now, don't deal with .file symbol. */
1833 if (!need_text
&& !need_data
&& !need_bss
&& !need_file
)
1835 nsyms
+= need_text
+ need_data
+ need_bss
+ need_file
;
1836 sympp2
= (asymbol
**) bfd_alloc_by_size_t (abfd
, nsyms
* sizeof (asymbol
*));
1839 bfd_set_error (bfd_error_no_memory
);
1842 memcpy (sympp2
, sympp
, i
* sizeof (asymbol
*));
1845 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
1849 sympp2
[i
++] = coff_section_symbol (abfd
, _TEXT
);
1851 sympp2
[i
++] = coff_section_symbol (abfd
, _DATA
);
1853 sympp2
[i
++] = coff_section_symbol (abfd
, _BSS
);
1854 BFD_ASSERT (i
== nsyms
);
1855 bfd_set_symtab (abfd
, sympp2
, nsyms
);
1859 #endif /* ! defined (RS6000COFF_C) */
1866 coff_write_object_contents (abfd
)
1870 boolean hasrelocs
= false;
1871 boolean haslinno
= false;
1872 file_ptr reloc_base
;
1873 file_ptr lineno_base
;
1875 unsigned long reloc_size
= 0;
1876 unsigned long lnno_size
= 0;
1877 asection
*text_sec
= NULL
;
1878 asection
*data_sec
= NULL
;
1879 asection
*bss_sec
= NULL
;
1881 struct internal_filehdr internal_f
;
1882 struct internal_aouthdr internal_a
;
1884 bfd_set_error (bfd_error_system_call
);
1886 if (abfd
->output_has_begun
== false)
1887 coff_compute_section_file_positions (abfd
);
1889 reloc_base
= obj_relocbase (abfd
);
1891 /* Make a pass through the symbol table to count line number entries and
1892 put them into the correct asections */
1894 lnno_size
= coff_count_linenumbers (abfd
) * LINESZ
;
1896 /* Work out the size of the reloc and linno areas */
1898 for (current
= abfd
->sections
; current
!= NULL
; current
=
1900 reloc_size
+= current
->reloc_count
* RELSZ
;
1902 lineno_base
= reloc_base
+ reloc_size
;
1903 sym_base
= lineno_base
+ lnno_size
;
1905 /* Indicate in each section->line_filepos its actual file address */
1906 for (current
= abfd
->sections
; current
!= NULL
; current
=
1909 if (current
->lineno_count
)
1911 current
->line_filepos
= lineno_base
;
1912 current
->moving_line_filepos
= lineno_base
;
1913 lineno_base
+= current
->lineno_count
* LINESZ
;
1917 current
->line_filepos
= 0;
1919 if (current
->reloc_count
)
1921 current
->rel_filepos
= reloc_base
;
1922 reloc_base
+= current
->reloc_count
* RELSZ
;
1926 current
->rel_filepos
= 0;
1930 /* Write section headers to the file. */
1931 internal_f
.f_nscns
= 0;
1934 (file_ptr
) ((abfd
->flags
& EXEC_P
) ?
1935 (FILHSZ
+ AOUTSZ
) : FILHSZ
),
1939 for (current
= abfd
->sections
;
1941 current
= current
->next
)
1943 struct internal_scnhdr section
;
1946 /* Do not include the .junk section. This is where we collect section
1947 data which we don't need. This is mainly the MS .debug$ data which
1948 stores codeview debug data. */
1949 if (strcmp (current
->name
, ".junk") == 0)
1954 /* If we've got a .reloc section, remember. */
1956 if (strcmp (current
->name
, ".reloc") == 0)
1958 pe_data (abfd
)->has_reloc_section
= 1;
1961 internal_f
.f_nscns
++;
1962 strncpy (&(section
.s_name
[0]), current
->name
, 8);
1964 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
1965 Ian Taylor <ian@cygnus.com>. */
1966 if (strcmp (current
->name
, _LIB
) == 0)
1967 section
.s_vaddr
= 0;
1970 section
.s_vaddr
= current
->lma
;
1971 section
.s_paddr
= current
->lma
;
1972 section
.s_size
= current
->_raw_size
;
1975 section
.s_paddr
= current
->_cooked_size
;
1979 If this section has no size or is unloadable then the scnptr
1982 if (current
->_raw_size
== 0 ||
1983 (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
1985 section
.s_scnptr
= 0;
1989 section
.s_scnptr
= current
->filepos
;
1991 section
.s_relptr
= current
->rel_filepos
;
1992 section
.s_lnnoptr
= current
->line_filepos
;
1993 section
.s_nreloc
= current
->reloc_count
;
1994 section
.s_nlnno
= current
->lineno_count
;
1995 if (current
->reloc_count
!= 0)
1997 if (current
->lineno_count
!= 0)
2000 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
2002 if (!strcmp (current
->name
, _TEXT
))
2006 else if (!strcmp (current
->name
, _DATA
))
2010 else if (!strcmp (current
->name
, _BSS
))
2016 section
.s_align
= (current
->alignment_power
2017 ? 1 << current
->alignment_power
2022 #ifdef COFF_IMAGE_WITH_PE
2023 /* suppress output of the sections if they are null. ld includes
2024 the bss and data sections even if there is no size assigned
2025 to them. NT loader doesn't like it if these section headers are
2026 included if the sections themselves are not needed */
2027 if (section
.s_size
== 0)
2028 internal_f
.f_nscns
--;
2033 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
2034 || bfd_write ((PTR
) (&buff
), 1, SCNHSZ
, abfd
) != SCNHSZ
)
2041 /* OK, now set up the filehdr... */
2043 /* Don't include the internal abs section in the section count */
2046 We will NOT put a fucking timestamp in the header here. Every time you
2047 put it back, I will come in and take it out again. I'm sorry. This
2048 field does not belong here. We fill it with a 0 so it compares the
2049 same but is not a reasonable time. -- gnu@cygnus.com
2051 internal_f
.f_timdat
= 0;
2053 internal_f
.f_flags
= 0;
2055 if (abfd
->flags
& EXEC_P
)
2056 internal_f
.f_opthdr
= AOUTSZ
;
2058 internal_f
.f_opthdr
= 0;
2061 internal_f
.f_flags
|= F_RELFLG
;
2063 internal_f
.f_flags
|= F_LNNO
;
2064 if (abfd
->flags
& EXEC_P
)
2065 internal_f
.f_flags
|= F_EXEC
;
2067 if (!abfd
->xvec
->byteorder_big_p
)
2068 internal_f
.f_flags
|= F_AR32WR
;
2070 internal_f
.f_flags
|= F_AR32W
;
2073 FIXME, should do something about the other byte orders and
2078 if ((abfd
->flags
& DYNAMIC
) != 0)
2079 internal_f
.f_flags
|= F_SHROBJ
;
2080 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
2081 internal_f
.f_flags
|= F_DYNLOAD
;
2084 memset (&internal_a
, 0, sizeof internal_a
);
2086 /* Set up architecture-dependent stuff */
2089 unsigned int magic
= 0;
2090 unsigned short flags
= 0;
2091 coff_set_flags (abfd
, &magic
, &flags
);
2092 internal_f
.f_magic
= magic
;
2093 internal_f
.f_flags
|= flags
;
2094 /* ...and the "opt"hdr... */
2097 #ifdef ULTRA3 /* NYU's machine */
2098 /* FIXME: This is a bogus check. I really want to see if there
2099 * is a .shbss or a .shdata section, if so then set the magic
2100 * number to indicate a shared data executable.
2102 if (internal_f
.f_nscns
>= 7)
2103 internal_a
.magic
= SHMAGIC
; /* Shared magic */
2106 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
2107 #define __A_MAGIC_SET__
2110 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
2111 #define __A_MAGIC_SET__
2114 #define __A_MAGIC_SET__
2115 internal_a
.magic
= PAGEMAGICBCS
;
2119 #define __A_MAGIC_SET__
2120 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
2123 #if defined(M68) || defined(WE32K) || defined(M68K)
2124 #define __A_MAGIC_SET__
2126 internal_a
.magic
= LYNXCOFFMAGIC
;
2128 #endif /* M68 || WE32K || M68K */
2131 #define __A_MAGIC_SET__
2132 internal_a
.magic
= ZMAGIC
;
2135 #define __A_MAGIC_SET__
2136 internal_a
.magic
= PPCMAGIC
;
2139 #define __A_MAGIC_SET__
2141 internal_a
.magic
= LYNXCOFFMAGIC
;
2143 internal_a
.magic
= ZMAGIC
;
2148 #define __A_MAGIC_SET__
2150 internal_a
.magic
= LYNXCOFFMAGIC
;
2155 #define __A_MAGIC_SET__
2156 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
2157 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
2158 RS6K_AOUTHDR_OMAGIC
;
2161 #ifndef __A_MAGIC_SET__
2162 #include "Your aouthdr magic number is not being set!"
2164 #undef __A_MAGIC_SET__
2168 /* FIXME: Does anybody ever set this to another value? */
2169 internal_a
.vstamp
= 0;
2171 /* Now should write relocs, strings, syms */
2172 obj_sym_filepos (abfd
) = sym_base
;
2174 if (bfd_get_symcount (abfd
) != 0)
2177 #ifndef RS6000COFF_C
2178 if (!coff_add_missing_symbols (abfd
))
2181 if (!coff_renumber_symbols (abfd
, &firstundef
))
2183 coff_mangle_symbols (abfd
);
2184 if (! coff_write_symbols (abfd
))
2186 if (! coff_write_linenumbers (abfd
))
2188 if (! coff_write_relocs (abfd
, firstundef
))
2192 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
2193 backend linker, and obj_raw_syment_count is not valid until after
2194 coff_write_symbols is called. */
2195 if (obj_raw_syment_count (abfd
) != 0)
2197 internal_f
.f_symptr
= sym_base
;
2199 /* AIX appears to require that F_RELFLG not be set if there are
2200 local symbols but no relocations. */
2201 internal_f
.f_flags
&=~ F_RELFLG
;
2206 internal_f
.f_symptr
= 0;
2207 internal_f
.f_flags
|= F_LSYMS
;
2212 internal_a
.tsize
= bfd_get_section_size_before_reloc (text_sec
);
2213 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
2217 internal_a
.dsize
= bfd_get_section_size_before_reloc (data_sec
);
2218 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
2222 internal_a
.bsize
= bfd_get_section_size_before_reloc (bss_sec
);
2225 internal_a
.entry
= bfd_get_start_address (abfd
);
2226 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
2229 if ((abfd
->flags
& EXEC_P
) != 0)
2232 asection
*loader_sec
;
2234 entry
= bfd_get_start_address (abfd
);
2235 if (text_sec
!= NULL
2236 && entry
>= text_sec
->vma
2237 && entry
< text_sec
->vma
+ bfd_section_size (abfd
, text_sec
))
2238 internal_a
.o_snentry
= text_sec
->target_index
;
2239 else if (data_sec
!= NULL
2240 && entry
>= data_sec
->vma
2241 && entry
< data_sec
->vma
+ bfd_section_size (abfd
, data_sec
))
2242 internal_a
.o_snentry
= data_sec
->target_index
;
2244 internal_a
.o_snentry
= 0;
2245 if (text_sec
!= NULL
)
2247 internal_a
.o_sntext
= text_sec
->target_index
;
2248 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
2252 internal_a
.o_sntext
= 0;
2253 internal_a
.o_algntext
= 0;
2255 if (data_sec
!= NULL
)
2257 internal_a
.o_sndata
= data_sec
->target_index
;
2258 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
2262 internal_a
.o_sndata
= 0;
2263 internal_a
.o_algndata
= 0;
2265 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
2266 if (loader_sec
!= NULL
)
2267 internal_a
.o_snloader
= loader_sec
->target_index
;
2269 internal_a
.o_snloader
= 0;
2270 if (bss_sec
!= NULL
)
2271 internal_a
.o_snbss
= bss_sec
->target_index
;
2273 internal_a
.o_snbss
= 0;
2275 toc
= xcoff_data (abfd
)->toc
;
2276 internal_a
.o_toc
= toc
;
2277 if (text_sec
!= NULL
2278 && toc
>= text_sec
->vma
2279 && toc
< text_sec
->vma
+ bfd_section_size (abfd
, text_sec
))
2280 internal_a
.o_sntoc
= text_sec
->target_index
;
2281 else if (data_sec
!= NULL
2282 && toc
>= data_sec
->vma
2283 && toc
< data_sec
->vma
+ bfd_section_size (abfd
, data_sec
))
2284 internal_a
.o_sntoc
= data_sec
->target_index
;
2286 internal_a
.o_sntoc
= 0;
2288 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
2289 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
2290 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
2294 /* now write them */
2295 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
2299 coff_swap_filehdr_out (abfd
, (PTR
) & internal_f
, (PTR
) & buff
);
2300 if (bfd_write ((PTR
) & buff
, 1, FILHSZ
, abfd
) != FILHSZ
)
2303 if (abfd
->flags
& EXEC_P
)
2306 coff_swap_aouthdr_out (abfd
, (PTR
) & internal_a
, (PTR
) & buff
);
2307 if (bfd_write ((PTR
) & buff
, 1, AOUTSZ
, abfd
) != AOUTSZ
)
2315 coff_set_section_contents (abfd
, section
, location
, offset
, count
)
2320 bfd_size_type count
;
2322 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
2323 coff_compute_section_file_positions (abfd
);
2326 /* If this is a .lib section, bump the vma address so that it
2327 winds up being the number of .lib sections output. This is
2328 right for SVR3.2. Shared libraries should probably get more
2329 generic support. Ian Taylor <ian@cygnus.com>. */
2330 if (strcmp (section
->name
, _LIB
) == 0)
2334 /* Don't write out bss sections - one way to do this is to
2335 see if the filepos has not been set. */
2336 if (section
->filepos
== 0)
2339 if (bfd_seek (abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
) != 0)
2344 return (bfd_write (location
, 1, count
, abfd
) == count
) ? true : false;
2350 coff_close_and_cleanup (abfd
)
2353 if (!bfd_read_p (abfd
))
2354 switch (abfd
->format
)
2357 if (!_bfd_write_archive_contents (abfd
))
2361 if (!coff_write_object_contents (abfd
))
2365 bfd_set_error (bfd_error_invalid_operation
);
2369 /* We depend on bfd_close to free all the memory on the obstack. */
2370 /* FIXME if bfd_release is not using obstacks! */
2377 buy_and_read (abfd
, where
, seek_direction
, size
)
2383 PTR area
= (PTR
) bfd_alloc (abfd
, size
);
2386 bfd_set_error (bfd_error_no_memory
);
2389 if (bfd_seek (abfd
, where
, seek_direction
) != 0
2390 || bfd_read (area
, 1, size
, abfd
) != size
)
2393 } /* buy_and_read() */
2399 Creating the linenumber table is done by reading in the entire
2400 coff linenumber table, and creating another table for internal use.
2402 A coff linenumber table is structured so that each function
2403 is marked as having a line number of 0. Each line within the
2404 function is an offset from the first line in the function. The
2405 base of the line number information for the table is stored in
2406 the symbol associated with the function.
2408 The information is copied from the external to the internal
2409 table, and each symbol which marks a function is marked by
2412 How does this work ?
2417 coff_slurp_line_table (abfd
, asect
)
2421 LINENO
*native_lineno
;
2422 alent
*lineno_cache
;
2424 BFD_ASSERT (asect
->lineno
== (alent
*) NULL
);
2426 native_lineno
= (LINENO
*) buy_and_read (abfd
,
2427 asect
->line_filepos
,
2430 asect
->lineno_count
));
2432 (alent
*) bfd_alloc (abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof (alent
)));
2433 if (lineno_cache
== NULL
)
2435 bfd_set_error (bfd_error_no_memory
);
2440 unsigned int counter
= 0;
2441 alent
*cache_ptr
= lineno_cache
;
2442 LINENO
*src
= native_lineno
;
2444 while (counter
< asect
->lineno_count
)
2446 struct internal_lineno dst
;
2447 coff_swap_lineno_in (abfd
, src
, &dst
);
2448 cache_ptr
->line_number
= dst
.l_lnno
;
2450 if (cache_ptr
->line_number
== 0)
2452 coff_symbol_type
*sym
=
2453 (coff_symbol_type
*) (dst
.l_addr
.l_symndx
2454 + obj_raw_syments (abfd
))->u
.syment
._n
._n_n
._n_zeroes
;
2455 cache_ptr
->u
.sym
= (asymbol
*) sym
;
2456 sym
->lineno
= cache_ptr
;
2460 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
2461 - bfd_section_vma (abfd
, asect
);
2462 } /* If no linenumber expect a symbol index */
2468 cache_ptr
->line_number
= 0;
2471 asect
->lineno
= lineno_cache
;
2472 /* FIXME, free native_lineno here, or use alloca or something. */
2477 coff_slurp_symbol_table (abfd
)
2480 combined_entry_type
*native_symbols
;
2481 coff_symbol_type
*cached_area
;
2482 unsigned int *table_ptr
;
2484 unsigned int number_of_symbols
= 0;
2486 if (obj_symbols (abfd
))
2489 /* Read in the symbol table */
2490 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
2495 /* Allocate enough room for all the symbols in cached form */
2496 cached_area
= ((coff_symbol_type
*)
2498 (obj_raw_syment_count (abfd
)
2499 * sizeof (coff_symbol_type
))));
2501 if (cached_area
== NULL
)
2503 bfd_set_error (bfd_error_no_memory
);
2506 table_ptr
= ((unsigned int *)
2508 (obj_raw_syment_count (abfd
)
2509 * sizeof (unsigned int))));
2511 if (table_ptr
== NULL
)
2513 bfd_set_error (bfd_error_no_memory
);
2518 coff_symbol_type
*dst
= cached_area
;
2519 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
2520 unsigned int this_index
= 0;
2521 while (this_index
< last_native_index
)
2523 combined_entry_type
*src
= native_symbols
+ this_index
;
2524 table_ptr
[this_index
] = number_of_symbols
;
2525 dst
->symbol
.the_bfd
= abfd
;
2527 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
2528 /* We use the native name field to point to the cached field. */
2529 src
->u
.syment
._n
._n_n
._n_zeroes
= (long) dst
;
2530 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
2531 src
->u
.syment
.n_scnum
);
2532 dst
->symbol
.flags
= 0;
2533 dst
->done_lineno
= false;
2535 switch (src
->u
.syment
.n_sclass
)
2540 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
2541 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2542 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
2544 /* Fall through to next case */
2553 /* PE uses storage class 0x68 to denote a section symbol */
2556 if ((src
->u
.syment
.n_scnum
) == 0)
2558 if ((src
->u
.syment
.n_value
) == 0)
2560 dst
->symbol
.section
= bfd_und_section_ptr
;
2561 dst
->symbol
.value
= 0;
2565 dst
->symbol
.section
= bfd_com_section_ptr
;
2566 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2571 /* Base the value as an index from the base of the
2574 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2575 dst
->symbol
.value
= (src
->u
.syment
.n_value
2576 - dst
->symbol
.section
->vma
);
2578 if (ISFCN ((src
->u
.syment
.n_type
)))
2580 /* A function ext does not go at the end of a
2582 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
2587 /* A C_HIDEXT symbol is not global. */
2588 if (src
->u
.syment
.n_sclass
== C_HIDEXT
)
2589 dst
->symbol
.flags
= BSF_LOCAL
;
2590 /* A symbol with a csect entry should not go at the end. */
2591 if (src
->u
.syment
.n_numaux
> 0)
2592 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
2597 case C_STAT
: /* static */
2599 case C_LEAFSTAT
: /* static leaf procedure */
2601 case C_LABEL
: /* label */
2602 if (src
->u
.syment
.n_scnum
== -2)
2603 dst
->symbol
.flags
= BSF_DEBUGGING
;
2605 dst
->symbol
.flags
= BSF_LOCAL
;
2607 Base the value as an index from the base of the section, if
2610 if (dst
->symbol
.section
)
2611 dst
->symbol
.value
= (src
->u
.syment
.n_value
) -
2612 dst
->symbol
.section
->vma
;
2614 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2617 case C_MOS
: /* member of structure */
2618 case C_EOS
: /* end of structure */
2619 #ifdef NOTDEF /* C_AUTOARG has the same value */
2621 case C_GLBLREG
: /* A29k-specific storage class */
2624 case C_REGPARM
: /* register parameter */
2625 case C_REG
: /* register variable */
2627 case C_AUTOARG
: /* 960-specific storage class */
2629 case C_TPDEF
: /* type definition */
2631 case C_AUTO
: /* automatic variable */
2632 case C_FIELD
: /* bit field */
2633 case C_ENTAG
: /* enumeration tag */
2634 case C_MOE
: /* member of enumeration */
2635 case C_MOU
: /* member of union */
2636 case C_UNTAG
: /* union tag */
2637 dst
->symbol
.flags
= BSF_DEBUGGING
;
2638 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2641 case C_FILE
: /* file name */
2642 case C_STRTAG
: /* structure tag */
2644 case C_BINCL
: /* beginning of include file */
2645 case C_EINCL
: /* ending of include file */
2657 dst
->symbol
.flags
= BSF_DEBUGGING
;
2658 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2663 dst
->symbol
.flags
= BSF_DEBUGGING
;
2664 dst
->symbol
.value
= src
->u
.syment
.n_value
;
2666 /* The value is actually a symbol index. Save a pointer
2667 to the symbol instead of the index. FIXME: This
2668 should use a union. */
2669 src
->u
.syment
.n_value
=
2670 (long) (native_symbols
+ src
->u
.syment
.n_value
);
2675 case C_BLOCK
: /* ".bb" or ".eb" */
2676 case C_FCN
: /* ".bf" or ".ef" */
2677 case C_EFCN
: /* physical end of function */
2678 dst
->symbol
.flags
= BSF_LOCAL
;
2680 Base the value as an index from the base of the section
2682 dst
->symbol
.value
= (src
->u
.syment
.n_value
) - dst
->symbol
.section
->vma
;
2686 case C_EXTDEF
: /* external definition */
2687 case C_ULABEL
: /* undefined label */
2688 case C_USTATIC
: /* undefined static */
2689 #ifndef COFF_WITH_PE
2690 /* C_LINE in regular coff is 0x68. NT has taken over this storage
2691 class to represent a section symbol */
2692 case C_LINE
: /* line # reformatted as symbol table entry */
2694 case C_ALIAS
: /* duplicate tag */
2695 case C_HIDDEN
: /* ext symbol in dmert public lib */
2697 (*_bfd_error_handler
)
2698 ("%s: Unrecognized storage class %d for %s symbol `%s'",
2699 bfd_get_filename (abfd
), src
->u
.syment
.n_sclass
,
2700 dst
->symbol
.section
->name
, dst
->symbol
.name
);
2701 dst
->symbol
.flags
= BSF_DEBUGGING
;
2702 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2706 /* BFD_ASSERT(dst->symbol.flags != 0);*/
2710 dst
->symbol
.udata
.i
= 0;
2711 dst
->lineno
= (alent
*) NULL
;
2712 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
2714 number_of_symbols
++;
2715 } /* walk the native symtab */
2716 } /* bfdize the native symtab */
2718 obj_symbols (abfd
) = cached_area
;
2719 obj_raw_syments (abfd
) = native_symbols
;
2721 bfd_get_symcount (abfd
) = number_of_symbols
;
2722 obj_convert (abfd
) = table_ptr
;
2723 /* Slurp the line tables for each section too */
2729 coff_slurp_line_table (abfd
, p
);
2734 } /* coff_slurp_symbol_table() */
2736 /* Check whether a symbol is globally visible. This is used by the
2737 COFF backend linker code in cofflink.c, since a couple of targets
2738 have globally visible symbols which are not class C_EXT. This
2739 function need not handle the case of n_class == C_EXT. */
2741 #undef OTHER_GLOBAL_CLASS
2744 #define OTHER_GLOBAL_CLASS C_LEAFEXT
2748 #define OTHER_GLOBAL_CLASS C_SECTION
2751 #ifdef OTHER_GLOBAL_CLASS
2754 coff_sym_is_global (abfd
, syment
)
2756 struct internal_syment
*syment
;
2758 if (syment
->n_sclass
== OTHER_GLOBAL_CLASS
)
2763 #undef OTHER_GLOBAL_CLASS
2765 #else /* ! defined (OTHER_GLOBAL_CLASS) */
2767 /* sym_is_global should not be defined if it has nothing to do. */
2769 #define coff_sym_is_global 0
2771 #endif /* ! defined (OTHER_GLOBAL_CLASS) */
2777 Coff relocations are easily transformed into the internal BFD form
2780 Reading a coff relocation table is done in the following stages:
2782 o Read the entire coff relocation table into memory.
2784 o Process each relocation in turn; first swap it from the
2785 external to the internal form.
2787 o Turn the symbol referenced in the relocation's symbol index
2788 into a pointer into the canonical symbol table.
2789 This table is the same as the one returned by a call to
2790 @code{bfd_canonicalize_symtab}. The back end will call that
2791 routine and save the result if a canonicalization hasn't been done.
2793 o The reloc index is turned into a pointer to a howto
2794 structure, in a back end specific way. For instance, the 386
2795 and 960 use the @code{r_type} to directly produce an index
2796 into a howto table vector; the 88k subtracts a number from the
2797 @code{r_type} field and creates an addend field.
2803 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
2805 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
2806 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
2807 coffsym = (obj_symbols (abfd) \
2808 + (cache_ptr->sym_ptr_ptr - symbols)); \
2810 coffsym = coff_symbol_from (abfd, ptr); \
2811 if (coffsym != (coff_symbol_type *) NULL \
2812 && coffsym->native->u.syment.n_scnum == 0) \
2813 cache_ptr->addend = 0; \
2814 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
2815 && ptr->section != (asection *) NULL) \
2816 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
2818 cache_ptr->addend = 0; \
2823 coff_slurp_reloc_table (abfd
, asect
, symbols
)
2828 RELOC
*native_relocs
;
2829 arelent
*reloc_cache
;
2834 if (asect
->relocation
)
2836 if (asect
->reloc_count
== 0)
2838 if (asect
->flags
& SEC_CONSTRUCTOR
)
2840 if (!coff_slurp_symbol_table (abfd
))
2843 (RELOC
*) buy_and_read (abfd
,
2847 asect
->reloc_count
));
2848 reloc_cache
= (arelent
*)
2849 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
2851 if (reloc_cache
== NULL
)
2853 bfd_set_error (bfd_error_no_memory
);
2858 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
2860 #ifdef RELOC_PROCESSING
2861 struct internal_reloc dst
;
2862 struct external_reloc
*src
;
2864 cache_ptr
= reloc_cache
+ idx
;
2865 src
= native_relocs
+ idx
;
2866 coff_swap_reloc_in (abfd
, src
, &dst
);
2868 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
2870 struct internal_reloc dst
;
2872 struct external_reloc
*src
;
2874 cache_ptr
= reloc_cache
+ idx
;
2875 src
= native_relocs
+ idx
;
2877 coff_swap_reloc_in (abfd
, src
, &dst
);
2880 cache_ptr
->address
= dst
.r_vaddr
;
2882 if (dst
.r_symndx
!= -1)
2884 /* @@ Should never be greater than count of symbols! */
2885 if (dst
.r_symndx
>= obj_conv_table_size (abfd
))
2887 cache_ptr
->sym_ptr_ptr
= symbols
+ obj_convert (abfd
)[dst
.r_symndx
];
2888 ptr
= *(cache_ptr
->sym_ptr_ptr
);
2892 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
2896 /* The symbols definitions that we have read in have been
2897 relocated as if their sections started at 0. But the offsets
2898 refering to the symbols in the raw data have not been
2899 modified, so we have to have a negative addend to compensate.
2901 Note that symbols which used to be common must be left alone */
2903 /* Calculate any reloc addend by looking at the symbol */
2904 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
2906 cache_ptr
->address
-= asect
->vma
;
2907 /* !! cache_ptr->section = (asection *) NULL;*/
2909 /* Fill in the cache_ptr->howto field from dst.r_type */
2910 RTYPE2HOWTO (cache_ptr
, &dst
);
2915 asect
->relocation
= reloc_cache
;
2919 #ifndef coff_rtype_to_howto
2922 /* Get the howto structure for a reloc. This is only used if the file
2923 including this one defines coff_relocate_section to be
2924 _bfd_coff_generic_relocate_section, so it is OK if it does not
2925 always work. It is the responsibility of the including file to
2926 make sure it is reasonable if it is needed. */
2928 static reloc_howto_type
*coff_rtype_to_howto
2929 PARAMS ((bfd
*, asection
*, struct internal_reloc
*,
2930 struct coff_link_hash_entry
*, struct internal_syment
*,
2934 static reloc_howto_type
*
2935 coff_rtype_to_howto (abfd
, sec
, rel
, h
, sym
, addendp
)
2938 struct internal_reloc
*rel
;
2939 struct coff_link_hash_entry
*h
;
2940 struct internal_syment
*sym
;
2945 RTYPE2HOWTO (&genrel
, rel
);
2946 return genrel
.howto
;
2949 #else /* ! defined (RTYPE2HOWTO) */
2951 #define coff_rtype_to_howto NULL
2953 #endif /* ! defined (RTYPE2HOWTO) */
2954 #endif /* ! defined (coff_rtype_to_howto) */
2956 /* This is stupid. This function should be a boolean predicate. */
2958 coff_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
2964 arelent
*tblptr
= section
->relocation
;
2965 unsigned int count
= 0;
2968 if (section
->flags
& SEC_CONSTRUCTOR
)
2970 /* this section has relocs made up by us, they are not in the
2971 file, so take them out of their chain and place them into
2972 the data area provided */
2973 arelent_chain
*chain
= section
->constructor_chain
;
2974 for (count
= 0; count
< section
->reloc_count
; count
++)
2976 *relptr
++ = &chain
->relent
;
2977 chain
= chain
->next
;
2983 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
2986 tblptr
= section
->relocation
;
2988 for (; count
++ < section
->reloc_count
;)
2989 *relptr
++ = tblptr
++;
2994 return section
->reloc_count
;
2999 coff_sym_filepos (abfd
)
3002 return obj_sym_filepos (abfd
);
3006 #ifndef coff_reloc16_estimate
3007 #define coff_reloc16_estimate dummy_reloc16_estimate
3010 dummy_reloc16_estimate (abfd
, input_section
, reloc
, shrink
, link_info
)
3012 asection
*input_section
;
3014 unsigned int shrink
;
3015 struct bfd_link_info
*link_info
;
3022 #ifndef coff_reloc16_extra_cases
3023 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
3024 /* This works even if abort is not declared in any header file. */
3026 dummy_reloc16_extra_cases (abfd
, link_info
, link_order
, reloc
, data
, src_ptr
,
3029 struct bfd_link_info
*link_info
;
3030 struct bfd_link_order
*link_order
;
3033 unsigned int *src_ptr
;
3034 unsigned int *dst_ptr
;
3040 /* If coff_relocate_section is defined, we can use the optimized COFF
3041 backend linker. Otherwise we must continue to use the old linker. */
3042 #ifdef coff_relocate_section
3043 #ifndef coff_bfd_link_hash_table_create
3044 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
3046 #ifndef coff_bfd_link_add_symbols
3047 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
3049 #ifndef coff_bfd_final_link
3050 #define coff_bfd_final_link _bfd_coff_final_link
3052 #else /* ! defined (coff_relocate_section) */
3053 #define coff_relocate_section NULL
3054 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
3055 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
3056 #define coff_bfd_final_link _bfd_generic_final_link
3057 #endif /* ! defined (coff_relocate_section) */
3058 #define coff_bfd_link_split_section _bfd_generic_link_split_section
3060 #ifndef coff_start_final_link
3061 #define coff_start_final_link NULL
3064 #ifndef coff_adjust_symndx
3065 #define coff_adjust_symndx NULL
3068 static CONST bfd_coff_backend_data bfd_coff_std_swap_table
=
3070 coff_swap_aux_in
, coff_swap_sym_in
, coff_swap_lineno_in
,
3071 coff_swap_aux_out
, coff_swap_sym_out
,
3072 coff_swap_lineno_out
, coff_swap_reloc_out
,
3073 coff_swap_filehdr_out
, coff_swap_aouthdr_out
,
3074 coff_swap_scnhdr_out
,
3075 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
,
3076 #ifdef COFF_LONG_FILENAMES
3081 coff_swap_filehdr_in
, coff_swap_aouthdr_in
, coff_swap_scnhdr_in
,
3082 coff_swap_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
3083 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
3084 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
3085 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
3086 coff_sym_is_global
, coff_compute_section_file_positions
,
3087 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
3091 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
3092 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
3093 #define coff_get_section_contents _bfd_generic_get_section_contents
3095 #ifndef coff_bfd_copy_private_symbol_data
3096 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
3099 #ifndef coff_bfd_copy_private_section_data
3100 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
3103 #ifndef coff_bfd_copy_private_bfd_data
3104 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
3107 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
3108 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
3110 #ifndef coff_bfd_print_private_bfd_data
3111 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
3114 #ifndef coff_bfd_is_local_label
3115 #define coff_bfd_is_local_label bfd_generic_is_local_label
3117 #ifndef coff_read_minisymbols
3118 #define coff_read_minisymbols _bfd_generic_read_minisymbols
3120 #ifndef coff_minisymbol_to_symbol
3121 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
3124 /* The reloc lookup routine must be supplied by each individual COFF
3126 #ifndef coff_bfd_reloc_type_lookup
3127 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
3130 #ifndef coff_bfd_get_relocated_section_contents
3131 #define coff_bfd_get_relocated_section_contents \
3132 bfd_generic_get_relocated_section_contents
3134 #ifndef coff_bfd_relax_section
3135 #define coff_bfd_relax_section bfd_generic_relax_section