1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright (C) 1990-1991 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
22 @section coff backends
24 BFD supports a number of different flavours of coff format. The major
25 difference between formats are the sizes and alignments of fields in
26 structures on disk, and the occasional extra field.
28 Coff in all its varieties is implimented with a few common files and a
29 number of implementation specific files. For example, The 88k bcs coff
30 format is implemented in the file @code{coff-m88k.c}. This file
31 @code{#include}s @code{coff-m88k.h} which defines the external
32 structure of the coff format for the 88k, and @code{internalcoff.h}
33 which defines the internal structure. @code{coff-m88k.c} also defines
34 the relocations used by the 88k format @xref{Relocations}. Then the
35 major portion of coff code is included (@code{coffcode.h}) which
36 defines the methods used to act upon the types defined in
37 @code{coff-m88k.h} and @code{internalcoff.h}.
39 The Intel i960 processor version of coff is implemented in
40 @code{coff-i960.c}. This file has the same structure as
41 @code{coff-m88k.c}, except that it includes @code{coff-i960.h} rather
42 than @code{coff-m88k.h}.
44 @subsection Porting To A New Version of Coff
46 The recommended method is to select from the existing implimentations
47 the version of coff which is most like the one you want to use, for
48 our purposes, we'll say that i386 coff is the one you select, and that
49 your coff flavour is called foo. Copy the @code{i386coff.c} to @code{foocoff.c},
50 copy @code{../include/i386coff.h} to @code{../include/foocoff.h} and
51 add the lines to @code{targets.c} and @code{Makefile.in} so that your
54 Alter the shapes of the structures in @code{../include/foocoff.h} so
55 that they match what you need. You will probably also have to add
56 @code{#ifdef}s to the code in @code{internalcoff.h} and
57 @code{coffcode.h} if your version of coff is too wild.
59 You can verify that your new BFD backend works quite simply by
60 building @code{objdump} from the @code{binutils} directory, and
61 making sure that its version of what's going on at your host systems
62 idea (assuming it has the pretty standard coff dump utility (usually
63 called @code{att-dump} or just @code{dump})) are the same.
65 Then clean up your code, and send what you've done to Cygnus. Then your stuff
66 will be in the next release, and you won't have to keep integrating
69 @subsection How The Coff Backend Works
71 @subsubsection Bit Twiddling
72 Each flavour of coff supported in BFD has its own header file
73 descibing the external layout of the structures. There is also an
74 internal description of the coff layout (in @code{internalcoff.h})
75 file (@code{}). A major function of the coff backend is swapping the
76 bytes and twiddling the bits to translate the external form of the
77 structures into the normal internal form. This is all performed in the
78 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some elements are
79 different sizes between different versions of coff, it is the duty of
80 the coff version specific include file to override the definitions of
81 various packing routines in @code{coffcode.h}. Eg the size of line
82 number entry in coff is sometimes 16 bits, and sometimes 32 bits.
83 @code{#define}ing @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will
84 select the correct one. No doubt, some day someone will find a version
85 of coff which has a varying field size not catered for at the moment.
86 To port BFD, that person will have to add more @code{#defines}.
88 Three of the bit twiddling routines are exported to @code{gdb};
89 @code{coff_swap_aux_in}, @code{coff_swap_sym_in} and
90 @code{coff_swap_linno_in}. @code{GDB} reads the symbol table on its
91 own, but uses BFD to fix things up.
93 More of the bit twiddlers are exported for @code{gas};
94 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
95 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
96 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
97 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track of all
98 the symbol table and reloc drudgery itself, thereby saving the
99 internal BFD overhead, but uses BFD to swap things on the way out,
100 making cross ports much safer. This also allows BFD (and thus the
101 linker) to use the same header files as @code{gas}, which makes one
102 avenue to disaster disappear.
104 @subsubsection Symbol Reading
105 The simple canonical form for symbols used by BFD is not rich enough
106 to keep all the information available in a coff symbol table. The back
107 end gets around this by keeping the original symbol table around,
110 When a symbol table is requested (through a call to
111 @code{bfd_canonicalize_symtab}, a request gets through to
112 @code{get_normalized_symtab}. This reads the symbol table from the
113 coff file and swaps all the structures inside into the internal form.
114 It also fixes up all the pointers in the table (represented in the file
115 by offsets from the first symbol in the table) into physical pointers
116 to elements in the new internal table. This involves some work since
117 the meanings of fields changes depending upon context; a field that is a
118 pointer to another structure in the symbol table at one moment may be
119 the size in bytes of a structure in the next.
121 Another pass is made over the table. All symbols which mark file names
122 (@code{C_FILE} symbols) are modified so that the internal string
123 points to the value in the auxent (the real filename) rather than the
124 normal text associated with the symbol (@code{".file"}).
126 At this time the symbol names are moved around. Coff stores all
127 symbols less than nine characters long physically within the symbol
128 table, longer strings are kept at the end of the file in the string
129 table. This pass moves all strings into memory, and replaces them with
130 pointers to the strings.
132 The symbol table is massaged once again, this time to create the
133 canonical table used by the BFD application. Each symbol is inspected
134 in turn, and a decision made (using the @code{sclass} field) about the
135 various flags to set in the @code{asymbol} @xref{Symbols}. The
136 generated canonical table shares strings with the hidden internal
139 Any linenumbers are read from the coff file too, and attached to the
140 symbols which own the functions the linenumbers belong to.
142 @subsubsection Symbol Writing
143 Writing a symbol to a coff file which didn't come from a coff file
144 will lose any debugging information. The @code{asymbol} structure
145 remembers the BFD from which was born, and on output the back end
146 makes sure that the same destination target as source target is
149 When the symbols have come from a coff file then all the debugging
150 information is preserved.
152 Symbol tables are provided for writing to the back end in a vector of
153 pointers to pointers. This allows applications like the linker to
154 accumulate and output large symbol tables without having to do too
157 The symbol table is not output to a writable BFD until it is closed.
158 The order of operations on the canonical symbol table at that point
161 @item coff_renumber_symbols
162 This function runs through the provided symbol table and patches each
163 symbol marked as a file place holder (@code{C_FILE}) to point to the
164 next file place holder in the list. It also marks each @code{offset}
165 field in the list with the offset from the first symbol of the current
168 Another function of this procedure is to turn the canonical value form
169 of BFD into the form used by coff. Internally, BFD expects symbol
170 values to be offsets from a section base; so a symbol physically at
171 0x120, but in a section starting at 0x100, would have the value 0x20.
172 Coff expects symbols to contain their final value, so symbols have
173 their values changed at this point to reflect their sum with their
174 owning section. Note that this transformation uses the
175 @code{output_section} field of the @code{asymbol}'s @code{asection}
177 @item coff_mangle_symbols
178 This routine runs though the provided symbol table and uses the
179 offsets generated by the previous pass and the pointers generated when
180 the symbol table was read in to create the structured hierachy
181 required by coff. It changes each pointer to a symbol to an index into
182 the symbol table of the symbol being referenced.
183 @item coff_write_symbols
184 This routine runs through the symbol table and patches up the symbols
185 from their internal form into the coff way, calls the bit twiddlers
186 and writes out the tabel to the file.
192 The hidden information for an asymbol is:
196 $ typedef struct coff_ptr_struct
199 Remembers the offset from the first symbol in the file for this
200 symbol. Generated by @code{coff_renumber_symbols}.
202 $ unsigned int offset;
204 Should the tag field of this symbol be renumbered.
205 Created by @code{coff_pointerize_aux}.
209 Should the endidx field of this symbol be renumbered.
210 Created by @code{coff_pointerize_aux}.
214 The container for the symbol structure as read and translated from the file.
217 $ union internal_auxent auxent;
218 $ struct internal_syment syment;
220 $ } combined_entry_type;
225 Each canonical asymbol really looks like this:
229 $ typedef struct coff_symbol_struct
232 The actual symbol which the rest of BFD works with
236 A pointer to the hidden information for this symbol
238 $ combined_entry_type *native;
240 A pointer to the linenumber information for this symbol
242 $ struct lineno_cache_entry *lineno;
243 $ } coff_symbol_type;
249 /* Most of this hacked by Steve Chamberlain, steve@cygnus.com */
252 #define PUTWORD bfd_h_put_32
253 #define PUTHALF bfd_h_put_16
254 #define PUTBYTE bfd_h_put_8
256 #ifndef GET_FCN_LNNOPTR
257 #define GET_FCN_LNNOPTR(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
260 #ifndef GET_FCN_ENDNDX
261 #define GET_FCN_ENDNDX(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
264 #ifndef PUT_FCN_LNNOPTR
265 #define PUT_FCN_LNNOPTR(abfd, in, ext) PUTWORD(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
267 #ifndef PUT_FCN_ENDNDX
268 #define PUT_FCN_ENDNDX(abfd, in, ext) PUTWORD(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
270 #ifndef GET_LNSZ_LNNO
271 #define GET_LNSZ_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_lnno)
273 #ifndef GET_LNSZ_SIZE
274 #define GET_LNSZ_SIZE(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_size)
276 #ifndef PUT_LNSZ_LNNO
277 #define PUT_LNSZ_LNNO(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_sym.x_misc.x_lnsz.x_lnno)
279 #ifndef PUT_LNSZ_SIZE
280 #define PUT_LNSZ_SIZE(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte*) ext->x_sym.x_misc.x_lnsz.x_size)
282 #ifndef GET_SCN_SCNLEN
283 #define GET_SCN_SCNLEN(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_scn.x_scnlen)
285 #ifndef GET_SCN_NRELOC
286 #define GET_SCN_NRELOC(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nreloc)
288 #ifndef GET_SCN_NLINNO
289 #define GET_SCN_NLINNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nlinno)
291 #ifndef PUT_SCN_SCNLEN
292 #define PUT_SCN_SCNLEN(abfd,in, ext) bfd_h_put_32(abfd, in, (bfd_byte *) ext->x_scn.x_scnlen)
294 #ifndef PUT_SCN_NRELOC
295 #define PUT_SCN_NRELOC(abfd,in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_scn.x_nreloc)
297 #ifndef PUT_SCN_NLINNO
298 #define PUT_SCN_NLINNO(abfd,in, ext) bfd_h_put_16(abfd,in, (bfd_byte *) ext->x_scn.x_nlinno)
300 #ifndef GET_LINENO_LNNO
301 #define GET_LINENO_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) (ext->l_lnno));
303 #ifndef PUT_LINENO_LNNO
304 #define PUT_LINENO_LNNO(abfd,val, ext) bfd_h_put_16(abfd,val, (bfd_byte *) (ext->l_lnno));
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 DEFUN(sec_to_styp_flags
, (sec_name
, sec_flags
),
318 CONST
char * sec_name AND
323 if (!strcmp(sec_name
, _TEXT
)) {
324 return((long)STYP_TEXT
);
325 } else if (!strcmp(sec_name
, _DATA
)) {
326 return((long)STYP_DATA
);
327 } else if (!strcmp(sec_name
, _BSS
)) {
328 return((long)STYP_BSS
);
330 } else if (!strcmp(sec_name
, _COMMENT
)) {
331 return((long)STYP_INFO
);
332 #endif /* _COMMENT */
335 /* Try and figure out what it should be */
336 if (sec_flags
& SEC_CODE
) styp_flags
= STYP_TEXT
;
337 if (sec_flags
& SEC_DATA
) styp_flags
= STYP_DATA
;
338 else if (sec_flags
& SEC_READONLY
)
339 #ifdef STYP_LIT /* 29k readonly text/data section */
340 styp_flags
= STYP_LIT
;
342 styp_flags
= STYP_TEXT
;
343 #endif /* STYP_LIT */
344 else if (sec_flags
& SEC_LOAD
) styp_flags
= STYP_TEXT
;
346 if (styp_flags
== 0) styp_flags
= STYP_BSS
;
351 * Return a word with SEC_* flags set to represent the incoming
352 * STYP_* flags (from scnhdr.s_flags). The inverse of this
353 * function is sec_to_styp_flags().
354 * NOTE: If you add to/change this routine, you should mirror the changes
355 * in sec_to_styp_flags().
358 DEFUN(styp_to_sec_flags
, (styp_flags
),
361 flagword sec_flags
=0;
363 if ((styp_flags
& STYP_TEXT
) || (styp_flags
& STYP_DATA
))
364 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
365 else if (styp_flags
& STYP_BSS
)
366 sec_flags
= SEC_ALLOC
;
368 #ifdef STYP_LIT /* A29k readonly text/data section type */
369 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
370 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
371 #endif /* STYP_LIT */
372 #ifdef STYP_OTHER_LOAD /* Other loaded sections */
373 if (styp_flags
& STYP_OTHER_LOAD
)
374 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
375 #endif /* STYP_SDATA */
380 #define get_index(symbol) ((int) (symbol)->value)
381 #define set_index(symbol, idx) ((symbol)->value = (idx))
383 /* **********************************************************************
384 Here are all the routines for swapping the structures seen in the
385 outside world into the internal forms.
390 DEFUN(bfd_swap_reloc_in
,(abfd
, reloc_src
, reloc_dst
),
393 struct internal_reloc
*reloc_dst
)
395 reloc_dst
->r_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*)reloc_src
->r_vaddr
);
396 reloc_dst
->r_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) reloc_src
->r_symndx
);
399 reloc_dst
->r_type
= bfd_h_get_8(abfd
, reloc_src
->r_type
);
400 reloc_dst
->r_size
= bfd_h_get_8(abfd
, reloc_src
->r_size
);
402 reloc_dst
->r_type
= bfd_h_get_16(abfd
, (bfd_byte
*) reloc_src
->r_type
);
405 #ifdef SWAP_IN_RELOC_OFFSET
406 reloc_dst
->r_offset
= SWAP_IN_RELOC_OFFSET(abfd
, reloc_src
->r_offset
);
412 DEFUN(coff_swap_reloc_out
,(abfd
, src
, dst
),
417 struct internal_reloc
*reloc_src
= (struct internal_reloc
*)src
;
418 struct external_reloc
*reloc_dst
= (struct external_reloc
*)dst
;
419 bfd_h_put_32(abfd
, reloc_src
->r_vaddr
, (bfd_byte
*) reloc_dst
->r_vaddr
);
420 bfd_h_put_32(abfd
, reloc_src
->r_symndx
, (bfd_byte
*) reloc_dst
->r_symndx
);
421 bfd_h_put_16(abfd
, reloc_src
->r_type
, (bfd_byte
*)
424 #ifdef SWAP_OUT_RELOC_OFFSET
425 SWAP_OUT_RELOC_OFFSET(abfd
,
427 (bfd_byte
*) reloc_dst
->r_offset
);
429 #ifdef SWAP_OUT_RELOC_EXTRA
430 SWAP_OUT_RELOC_EXTRA(abfd
,reloc_src
, reloc_dst
);
433 return sizeof(struct external_reloc
);
437 DEFUN(bfd_swap_filehdr_in
,(abfd
, filehdr_src
, filehdr_dst
),
439 FILHDR
*filehdr_src AND
440 struct internal_filehdr
*filehdr_dst
)
442 filehdr_dst
->f_magic
= bfd_h_get_16(abfd
, (bfd_byte
*) filehdr_src
->f_magic
);
443 filehdr_dst
->f_nscns
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_nscns
);
444 filehdr_dst
->f_timdat
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_timdat
);
445 filehdr_dst
->f_symptr
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_symptr
);
446 filehdr_dst
->f_nsyms
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_nsyms
);
447 filehdr_dst
->f_opthdr
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_opthdr
);
448 filehdr_dst
->f_flags
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_flags
);
452 DEFUN(coff_swap_filehdr_out
,(abfd
, in
, out
),
457 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*)in
;
458 FILHDR
*filehdr_out
= (FILHDR
*)out
;
459 bfd_h_put_16(abfd
, filehdr_in
->f_magic
, (bfd_byte
*) filehdr_out
->f_magic
);
460 bfd_h_put_16(abfd
, filehdr_in
->f_nscns
, (bfd_byte
*) filehdr_out
->f_nscns
);
461 bfd_h_put_32(abfd
, filehdr_in
->f_timdat
, (bfd_byte
*) filehdr_out
->f_timdat
);
462 bfd_h_put_32(abfd
, filehdr_in
->f_symptr
, (bfd_byte
*) filehdr_out
->f_symptr
);
463 bfd_h_put_32(abfd
, filehdr_in
->f_nsyms
, (bfd_byte
*) filehdr_out
->f_nsyms
);
464 bfd_h_put_16(abfd
, filehdr_in
->f_opthdr
, (bfd_byte
*) filehdr_out
->f_opthdr
);
465 bfd_h_put_16(abfd
, filehdr_in
->f_flags
, (bfd_byte
*) filehdr_out
->f_flags
);
466 return sizeof(FILHDR
);
470 #ifndef NO_COFF_SYMBOLS
473 DEFUN(coff_swap_sym_in
,(abfd
, ext1
, in1
),
478 SYMENT
*ext
= (SYMENT
*)ext1
;
479 struct internal_syment
*in
= (struct internal_syment
*)in1
;
481 if( ext
->e
.e_name
[0] == 0) {
482 in
->_n
._n_n
._n_zeroes
= 0;
483 in
->_n
._n_n
._n_offset
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e
.e
.e_offset
);
486 #if SYMNMLEN != E_SYMNMLEN
487 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
489 memcpy(in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
492 in
->n_value
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_value
);
493 in
->n_scnum
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_scnum
);
494 if (sizeof(ext
->e_type
) == 2){
495 in
->n_type
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_type
);
498 in
->n_type
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_type
);
500 in
->n_sclass
= bfd_h_get_8(abfd
, ext
->e_sclass
);
501 in
->n_numaux
= bfd_h_get_8(abfd
, ext
->e_numaux
);
505 DEFUN(coff_swap_sym_out
,(abfd
, inp
, extp
),
510 struct internal_syment
*in
= (struct internal_syment
*)inp
;
511 SYMENT
*ext
=(SYMENT
*)extp
;
512 if(in
->_n
._n_name
[0] == 0) {
513 bfd_h_put_32(abfd
, 0, (bfd_byte
*) ext
->e
.e
.e_zeroes
);
514 bfd_h_put_32(abfd
, in
->_n
._n_n
._n_offset
, (bfd_byte
*) ext
->e
.e
.e_offset
);
517 #if SYMNMLEN != E_SYMNMLEN
518 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
520 memcpy(ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
523 bfd_h_put_32(abfd
, in
->n_value
, (bfd_byte
*) ext
->e_value
);
524 bfd_h_put_16(abfd
, in
->n_scnum
, (bfd_byte
*) ext
->e_scnum
);
525 if (sizeof(ext
->e_type
) == 2)
527 bfd_h_put_16(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
531 bfd_h_put_32(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
533 bfd_h_put_8(abfd
, in
->n_sclass
, ext
->e_sclass
);
534 bfd_h_put_8(abfd
, in
->n_numaux
, ext
->e_numaux
);
535 return sizeof(SYMENT
);
539 DEFUN(coff_swap_aux_in
,(abfd
, ext1
, type
, class, in1
),
546 AUXENT
*ext
= (AUXENT
*)ext1
;
547 union internal_auxent
*in
= (union internal_auxent
*)in1
;
550 if (ext
->x_file
.x_fname
[0] == 0) {
551 in
->x_file
.x_n
.x_zeroes
= 0;
552 in
->x_file
.x_n
.x_offset
=
553 bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
555 #if FILNMLEN != E_FILNMLEN
556 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
558 memcpy (in
->x_file
.x_fname
, ext
->x_file
.x_fname
, FILNMLEN
);
563 /* RS/6000 "csect" auxents */
567 in
->x_csect
.x_scnlen
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_scnlen
);
568 in
->x_csect
.x_parmhash
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_parmhash
);
569 in
->x_csect
.x_snhash
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snhash
);
570 /* We don't have to hack bitfields in x_smtyp because it's defined by
571 shifts-and-ands, which are equivalent on all byte orders. */
572 in
->x_csect
.x_smtyp
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smtyp
);
573 in
->x_csect
.x_smclas
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smclas
);
574 in
->x_csect
.x_stab
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_stab
);
575 in
->x_csect
.x_snstab
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snstab
);
584 if (type
== T_NULL
) {
585 in
->x_scn
.x_scnlen
= GET_SCN_SCNLEN(abfd
, ext
);
586 in
->x_scn
.x_nreloc
= GET_SCN_NRELOC(abfd
, ext
);
587 in
->x_scn
.x_nlinno
= GET_SCN_NLINNO(abfd
, ext
);
591 in
->x_sym
.x_tagndx
.l
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
593 in
->x_sym
.x_tvndx
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
596 if (ISARY(type
) || class == C_BLOCK
) {
597 #if DIMNUM != E_DIMNUM
598 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
600 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0] = bfd_h_get_16(abfd
, (bfd_byte
*) ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0]);
601 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1] = bfd_h_get_16(abfd
, (bfd_byte
*) ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1]);
602 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2] = bfd_h_get_16(abfd
, (bfd_byte
*) ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2]);
603 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3] = bfd_h_get_16(abfd
, (bfd_byte
*) ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3]);
606 in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= GET_FCN_LNNOPTR(abfd
, ext
);
607 in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= GET_FCN_ENDNDX(abfd
, ext
);
610 in
->x_sym
.x_misc
.x_fsize
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
613 in
->x_sym
.x_misc
.x_lnsz
.x_lnno
= GET_LNSZ_LNNO(abfd
, ext
);
614 in
->x_sym
.x_misc
.x_lnsz
.x_size
= GET_LNSZ_SIZE(abfd
, ext
);
620 DEFUN(coff_swap_aux_out
,(abfd
, inp
, type
, class, extp
),
627 union internal_auxent
*in
= (union internal_auxent
*)inp
;
628 AUXENT
*ext
= (AUXENT
*)extp
;
631 if (in
->x_file
.x_fname
[0] == 0) {
632 PUTWORD(abfd
, 0, (bfd_byte
*) ext
->x_file
.x_n
.x_zeroes
);
634 in
->x_file
.x_n
.x_offset
,
635 (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
638 #if FILNMLEN != E_FILNMLEN
639 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
641 memcpy (ext
->x_file
.x_fname
, in
->x_file
.x_fname
, FILNMLEN
);
647 /* RS/6000 "csect" auxents */
650 PUTWORD (abfd
, in
->x_csect
.x_scnlen
, ext
->x_csect
.x_scnlen
);
651 PUTWORD (abfd
, in
->x_csect
.x_parmhash
, ext
->x_csect
.x_parmhash
);
652 PUTHALF (abfd
, in
->x_csect
.x_snhash
, ext
->x_csect
.x_snhash
);
653 /* We don't have to hack bitfields in x_smtyp because it's defined by
654 shifts-and-ands, which are equivalent on all byte orders. */
655 PUTBYTE (abfd
, in
->x_csect
.x_smtyp
, ext
->x_csect
.x_smtyp
);
656 PUTBYTE (abfd
, in
->x_csect
.x_smclas
, ext
->x_csect
.x_smclas
);
657 PUTWORD (abfd
, in
->x_csect
.x_stab
, ext
->x_csect
.x_stab
);
658 PUTHALF (abfd
, in
->x_csect
.x_snstab
, ext
->x_csect
.x_snstab
);
667 if (type
== T_NULL
) {
668 PUT_SCN_SCNLEN(abfd
, in
->x_scn
.x_scnlen
, ext
);
669 PUT_SCN_NRELOC(abfd
, in
->x_scn
.x_nreloc
, ext
);
670 PUT_SCN_NLINNO(abfd
, in
->x_scn
.x_nlinno
, ext
);
674 PUTWORD(abfd
, in
->x_sym
.x_tagndx
.l
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
676 PUTWORD(abfd
, in
->x_sym
.x_tvndx
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
680 PUTWORD(abfd
, in
->x_sym
.x_misc
.x_fsize
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
681 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
682 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
686 if (ISARY(type
) || class == C_BLOCK
) {
687 #if DIMNUM != E_DIMNUM
688 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
690 bfd_h_put_16(abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0], (bfd_byte
*)ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0]);
691 bfd_h_put_16(abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1], (bfd_byte
*)ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1]);
692 bfd_h_put_16(abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2], (bfd_byte
*)ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2]);
693 bfd_h_put_16(abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3], (bfd_byte
*)ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3]);
696 PUT_LNSZ_LNNO(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
697 PUT_LNSZ_SIZE(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
699 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
700 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
705 return sizeof(AUXENT
);
708 #endif /* NO_COFF_SYMBOLS */
710 #ifndef NO_COFF_LINENOS
713 DEFUN(coff_swap_lineno_in
,(abfd
, ext1
, in1
),
718 LINENO
*ext
= (LINENO
*)ext1
;
719 struct internal_lineno
*in
= (struct internal_lineno
*)in1
;
721 in
->l_addr
.l_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->l_addr
.l_symndx
);
722 in
->l_lnno
= GET_LINENO_LNNO(abfd
, ext
);
726 DEFUN(coff_swap_lineno_out
,(abfd
, inp
, outp
),
731 struct internal_lineno
*in
= (struct internal_lineno
*)inp
;
732 struct external_lineno
*ext
= (struct external_lineno
*)outp
;
733 PUTWORD(abfd
, in
->l_addr
.l_symndx
, (bfd_byte
*)
734 ext
->l_addr
.l_symndx
);
736 PUT_LINENO_LNNO (abfd
, in
->l_lnno
, ext
);
737 return sizeof(struct external_lineno
);
740 #endif /* NO_COFF_LINENOS */
744 DEFUN(bfd_swap_aouthdr_in
,(abfd
, aouthdr_ext1
, aouthdr_int1
),
749 AOUTHDR
*aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
750 struct internal_aouthdr
*aouthdr_int
= (struct internal_aouthdr
*)aouthdr_int1
;
752 aouthdr_int
->magic
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->magic
);
753 aouthdr_int
->vstamp
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->vstamp
);
754 aouthdr_int
->tsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tsize
);
755 aouthdr_int
->dsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->dsize
);
756 aouthdr_int
->bsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->bsize
);
757 aouthdr_int
->entry
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->entry
);
758 aouthdr_int
->text_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->text_start
);
759 aouthdr_int
->data_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->data_start
);
761 aouthdr_int
->tagentries
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tagentries
);
765 aouthdr_int
->o_toc
= bfd_h_get_32(abfd
, aouthdr_ext
->o_toc
);
766 aouthdr_int
->o_snentry
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snentry
);
767 aouthdr_int
->o_sntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntext
);
768 aouthdr_int
->o_sndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sndata
);
769 aouthdr_int
->o_sntoc
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntoc
);
770 aouthdr_int
->o_snloader
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snloader
);
771 aouthdr_int
->o_snbss
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snbss
);
772 aouthdr_int
->o_algntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algntext
);
773 aouthdr_int
->o_algndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algndata
);
774 aouthdr_int
->o_modtype
= bfd_h_get_16(abfd
, aouthdr_ext
->o_modtype
);
775 aouthdr_int
->o_maxstack
= bfd_h_get_32(abfd
, aouthdr_ext
->o_maxstack
);
780 DEFUN(coff_swap_aouthdr_out
,(abfd
, in
, out
),
785 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*)in
;
786 AOUTHDR
*aouthdr_out
= (AOUTHDR
*)out
;
787 bfd_h_put_16(abfd
, aouthdr_in
->magic
, (bfd_byte
*) aouthdr_out
->magic
);
788 bfd_h_put_16(abfd
, aouthdr_in
->vstamp
, (bfd_byte
*) aouthdr_out
->vstamp
);
789 bfd_h_put_32(abfd
, aouthdr_in
->tsize
, (bfd_byte
*) aouthdr_out
->tsize
);
790 bfd_h_put_32(abfd
, aouthdr_in
->dsize
, (bfd_byte
*) aouthdr_out
->dsize
);
791 bfd_h_put_32(abfd
, aouthdr_in
->bsize
, (bfd_byte
*) aouthdr_out
->bsize
);
792 bfd_h_put_32(abfd
, aouthdr_in
->entry
, (bfd_byte
*) aouthdr_out
->entry
);
793 bfd_h_put_32(abfd
, aouthdr_in
->text_start
,
794 (bfd_byte
*) aouthdr_out
->text_start
);
795 bfd_h_put_32(abfd
, aouthdr_in
->data_start
, (bfd_byte
*) aouthdr_out
->data_start
);
797 bfd_h_put_32(abfd
, aouthdr_in
->tagentries
, (bfd_byte
*) aouthdr_out
->tagentries
);
799 return sizeof(AOUTHDR
);
803 DEFUN(coff_swap_scnhdr_in
,(abfd
, scnhdr_ext
, scnhdr_int
),
805 SCNHDR
*scnhdr_ext AND
806 struct internal_scnhdr
*scnhdr_int
)
808 memcpy(scnhdr_int
->s_name
, scnhdr_ext
->s_name
, sizeof(scnhdr_int
->s_name
));
809 scnhdr_int
->s_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
810 scnhdr_int
->s_paddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
811 scnhdr_int
->s_size
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_size
);
812 scnhdr_int
->s_scnptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
813 scnhdr_int
->s_relptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
814 scnhdr_int
->s_lnnoptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
815 scnhdr_int
->s_flags
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_flags
);
817 scnhdr_int
->s_nreloc
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
818 scnhdr_int
->s_nlnno
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
820 scnhdr_int
->s_nreloc
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
821 scnhdr_int
->s_nlnno
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
824 scnhdr_int
->s_align
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_align
);
829 DEFUN(coff_swap_scnhdr_out
,(abfd
, in
, out
),
834 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*)in
;
835 SCNHDR
*scnhdr_ext
= (SCNHDR
*)out
;
836 memcpy(scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof(scnhdr_int
->s_name
));
837 PUTWORD(abfd
, scnhdr_int
->s_vaddr
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
838 PUTWORD(abfd
, scnhdr_int
->s_paddr
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
839 PUTWORD(abfd
, scnhdr_int
->s_size
, (bfd_byte
*) scnhdr_ext
->s_size
);
840 PUTWORD(abfd
, scnhdr_int
->s_scnptr
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
841 PUTWORD(abfd
, scnhdr_int
->s_relptr
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
842 PUTWORD(abfd
, scnhdr_int
->s_lnnoptr
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
843 PUTWORD(abfd
, scnhdr_int
->s_flags
, (bfd_byte
*) scnhdr_ext
->s_flags
);
845 PUTWORD(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
846 PUTWORD(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
848 PUTHALF(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
849 PUTHALF(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
853 PUTWORD(abfd
, scnhdr_int
->s_align
, (bfd_byte
*) scnhdr_ext
->s_align
);
855 return sizeof(SCNHDR
);
860 initialize a section structure with information peculiar to this
861 particular implementation of coff
865 DEFUN(coff_new_section_hook
,(abfd_ignore
, section_ignore
),
867 asection
*section_ignore
)
869 section_ignore
->alignment_power
= abfd_ignore
->xvec
->align_power_min
;
873 /* Take a section header read from a coff file (in HOST byte order),
874 and make a BFD "section" out of it. */
876 DEFUN(make_a_section_from_file
,(abfd
, hdr
),
878 struct internal_scnhdr
*hdr
)
880 asection
*return_section
;
883 /* Assorted wastage to null-terminate the name, thanks AT&T! */
884 char *name
= bfd_alloc(abfd
, sizeof (hdr
->s_name
)+1);
886 bfd_error
= no_memory
;
889 strncpy(name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
890 name
[sizeof (hdr
->s_name
)] = 0;
892 return_section
= bfd_make_section(abfd
, name
);
893 if (return_section
== NULL
)
897 /* s_paddr is presumed to be = to s_vaddr */
898 #define assign(to, from) return_section->to = hdr->from
899 assign(vma
, s_vaddr
);
900 /* assign (vma, s_vaddr); */
901 assign(size
, s_size
);
902 assign(filepos
, s_scnptr
);
903 assign(rel_filepos
, s_relptr
);
904 assign(reloc_count
, s_nreloc
);
907 /* FIXME, use a temp var rather than alignment_power */
908 assign(alignment_power
, s_align
);
911 for (i
= 0; i
< 32; i
++) {
912 if ((1 << i
) >= (int) (return_section
->alignment_power
)) {
913 return_section
->alignment_power
= i
;
920 assign(line_filepos
, s_lnnoptr
);
922 return_section->linesize = hdr->s_nlnno * sizeof (struct lineno);
925 return_section
->lineno_count
= hdr
->s_nlnno
;
926 return_section
->userdata
= NULL
;
927 return_section
->next
= (asection
*) NULL
;
928 return_section
->flags
= styp_to_sec_flags(hdr
->s_flags
);
931 if (hdr
->s_nreloc
!= 0)
932 return_section
->flags
|= SEC_RELOC
;
933 /* FIXME: should this check 'hdr->s_size > 0' */
934 if (hdr
->s_scnptr
!= 0)
935 return_section
->flags
|= SEC_HAS_CONTENTS
;
939 DEFUN(coff_mkobject
,(abfd
),
942 set_tdata (abfd
, bfd_zalloc (abfd
,sizeof(coff_data_type
)));
943 if (coff_data(abfd
) == 0) {
944 bfd_error
= no_memory
;
947 coff_data(abfd
)->relocbase
= 0;
953 DEFUN(coff_real_object_p
,(abfd
, nscns
, internal_f
, internal_a
),
956 struct internal_filehdr
*internal_f AND
957 struct internal_aouthdr
*internal_a
)
959 coff_data_type
*coff
;
960 enum bfd_architecture arch
;
962 size_t readsize
; /* length of file_info */
963 SCNHDR
*external_sections
;
965 /* Build a play area */
966 if (coff_mkobject(abfd
) != true)
968 coff
= coff_data(abfd
);
971 external_sections
= (SCNHDR
*)bfd_alloc(abfd
, readsize
= (nscns
* SCNHSZ
));
973 if (bfd_read((PTR
)external_sections
, 1, readsize
, abfd
) != readsize
) {
978 /* Now copy data as required; construct all asections etc */
979 coff
->symbol_index_slew
= 0;
981 coff
->raw_syment_count
= 0;
982 coff
->raw_linenos
= 0;
983 coff
->raw_syments
= 0;
984 coff
->sym_filepos
=0;
985 coff
->flags
= internal_f
->f_flags
;
988 for (i
= 0; i
< nscns
; i
++) {
989 struct internal_scnhdr tmp
;
990 coff_swap_scnhdr_in(abfd
, external_sections
+ i
, &tmp
);
991 make_a_section_from_file(abfd
,&tmp
);
994 /* Determine the machine architecture and type. */
996 switch (internal_f
->f_magic
) {
999 arch
= bfd_arch_i386
;
1004 #ifdef A29K_MAGIC_BIG
1005 case A29K_MAGIC_BIG
:
1006 case A29K_MAGIC_LITTLE
:
1007 arch
= bfd_arch_a29k
;
1016 arch
= bfd_arch_mips
;
1024 arch
= bfd_arch_m68k
;
1032 arch
= bfd_arch_m88k
;
1040 arch
= bfd_arch_i960
;
1041 switch (F_I960TYPE
& internal_f
->f_flags
)
1045 machine
= bfd_mach_i960_core
;
1048 machine
= bfd_mach_i960_kb_sb
;
1051 machine
= bfd_mach_i960_mc
;
1054 machine
= bfd_mach_i960_xa
;
1057 machine
= bfd_mach_i960_ca
;
1060 machine
= bfd_mach_i960_ka_sa
;
1071 arch
= bfd_arch_rs6000
;
1078 arch
= bfd_arch_h8300
;
1083 default: /* Unreadable input file type */
1084 arch
= bfd_arch_obscure
;
1088 bfd_default_set_arch_mach(abfd
, arch
, machine
);
1089 if (!(internal_f
->f_flags
& F_RELFLG
))
1090 abfd
->flags
|= HAS_RELOC
;
1091 if ((internal_f
->f_flags
& F_EXEC
))
1092 abfd
->flags
|= EXEC_P
;
1093 if (!(internal_f
->f_flags
& F_LNNO
))
1094 abfd
->flags
|= HAS_LINENO
;
1095 if (!(internal_f
->f_flags
& F_LSYMS
))
1096 abfd
->flags
|= HAS_LOCALS
;
1099 bfd_get_symcount(abfd
) = internal_f
->f_nsyms
;
1100 if (internal_f
->f_nsyms
)
1101 abfd
->flags
|= HAS_SYMS
;
1103 coff
->sym_filepos
= internal_f
->f_symptr
;
1105 /* These members communicate important constants about the symbol table
1106 to GDB's symbol-reading code. These `constants' unfortunately vary
1107 from coff implementation to implementation... */
1108 #ifndef NO_COFF_SYMBOLS
1109 coff
->local_n_btmask
= N_BTMASK
;
1110 coff
->local_n_btshft
= N_BTSHFT
;
1111 coff
->local_n_tmask
= N_TMASK
;
1112 coff
->local_n_tshift
= N_TSHIFT
;
1113 coff
->local_symesz
= SYMESZ
;
1114 coff
->local_auxesz
= AUXESZ
;
1115 coff
->local_linesz
= LINESZ
;
1118 coff
->symbols
= (coff_symbol_type
*) NULL
;
1119 bfd_get_start_address(abfd
) = internal_f
->f_opthdr
? internal_a
->entry
: 0;
1123 bfd_release(abfd
, coff
);
1124 return (bfd_target
*)NULL
;
1128 DEFUN(coff_object_p
,(abfd
),
1134 struct internal_filehdr internal_f
;
1135 struct internal_aouthdr internal_a
;
1137 bfd_error
= system_call_error
;
1139 /* figure out how much to read */
1140 if (bfd_read((PTR
) &filehdr
, 1, FILHSZ
, abfd
) != FILHSZ
)
1143 bfd_swap_filehdr_in(abfd
, &filehdr
, &internal_f
);
1145 if (BADMAG(internal_f
)) {
1146 bfd_error
= wrong_format
;
1149 nscns
=internal_f
.f_nscns
;
1151 if (internal_f
.f_opthdr
) {
1152 if (bfd_read((PTR
) &opthdr
, 1,AOUTSZ
, abfd
) != AOUTSZ
) {
1155 bfd_swap_aouthdr_in(abfd
, (char *)&opthdr
, (char *)&internal_a
);
1158 /* Seek past the opt hdr stuff */
1159 bfd_seek(abfd
, internal_f
.f_opthdr
+ FILHSZ
, SEEK_SET
);
1161 /* if the optional header is NULL or not the correct size then
1162 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1163 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1164 optional header is of a different size.
1166 But the mips keeps extra stuff in it's opthdr, so dont check
1170 #if defined(M88) || defined(I960)
1171 if (internal_f
.f_opthdr
!= 0 && AOUTSZ
!= internal_f
.f_opthdr
)
1172 return (bfd_target
*)NULL
;
1175 return coff_real_object_p(abfd
, nscns
, &internal_f
, &internal_a
);
1180 #ifndef NO_COFF_LINENOS
1183 DEFUN(coff_count_linenumbers
,(abfd
),
1186 unsigned int limit
= bfd_get_symcount(abfd
);
1190 asection
*s
= abfd
->sections
->output_section
;
1192 BFD_ASSERT(s
->lineno_count
== 0);
1198 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++) {
1199 asymbol
*q_maybe
= *p
;
1200 if (q_maybe
->the_bfd
->xvec
->flavour
== bfd_target_coff_flavour
) {
1201 coff_symbol_type
*q
= coffsymbol(q_maybe
);
1204 This symbol has a linenumber, increment the owning
1205 section's linenumber count
1207 alent
*l
= q
->lineno
;
1208 q
->symbol
.section
->output_section
->lineno_count
++;
1210 while (l
->line_number
) {
1211 q
->symbol
.section
->output_section
->lineno_count
++;
1219 #endif /* NO_COFF_LINENOS */
1221 #ifndef NO_COFF_SYMBOLS
1224 Takes a bfd and a symbol, returns a pointer to the coff specific area
1225 of the symbol if there is one.
1227 static coff_symbol_type
*
1228 DEFUN(coff_symbol_from
,(ignore_abfd
, symbol
),
1229 bfd
*ignore_abfd AND
1232 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
1233 return (coff_symbol_type
*)NULL
;
1235 if (symbol
->the_bfd
->tdata
== (PTR
)NULL
)
1236 return (coff_symbol_type
*)NULL
;
1238 return (coff_symbol_type
*) symbol
;
1244 DEFUN(fixup_symbol_value
,(coff_symbol_ptr
, syment
),
1245 coff_symbol_type
*coff_symbol_ptr AND
1246 struct internal_syment
*syment
)
1249 /* Normalize the symbol flags */
1250 if (coff_symbol_ptr
->symbol
.flags
& BSF_FORT_COMM
) {
1251 /* a common symbol is undefined with a value */
1252 syment
->n_scnum
= N_UNDEF
;
1253 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1255 else if (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) {
1256 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1258 else if (coff_symbol_ptr
->symbol
.flags
& BSF_UNDEFINED
) {
1259 syment
->n_scnum
= N_UNDEF
;
1260 syment
->n_value
= 0;
1262 else if (coff_symbol_ptr
->symbol
.flags
& BSF_ABSOLUTE
) {
1263 syment
->n_scnum
= N_ABS
;
1264 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1267 if (coff_symbol_ptr
->symbol
.section
) {
1269 coff_symbol_ptr
->symbol
.section
->output_section
->index
+1;
1272 coff_symbol_ptr
->symbol
.value
+
1273 coff_symbol_ptr
->symbol
.section
->output_offset
+
1274 coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
1277 /* This can happen, but I don't know why yet (steve@cygnus.com) */
1278 syment
->n_scnum
= N_ABS
;
1279 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1284 /* run through all the symbols in the symbol table and work out what
1285 their indexes into the symbol table will be when output
1287 Coff requires that each C_FILE symbol points to the next one in the
1288 chain, and that the last one points to the first external symbol. We
1293 DEFUN(coff_renumber_symbols
,(bfd_ptr
),
1296 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1297 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1298 unsigned int native_index
= 0;
1299 struct internal_syment
*last_file
= (struct internal_syment
*)NULL
;
1300 unsigned int symbol_index
;
1301 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1303 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1304 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1305 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1308 if (s
->u
.syment
.n_sclass
== C_FILE
)
1310 if (last_file
!= (struct internal_syment
*)NULL
) {
1311 last_file
->n_value
= native_index
;
1313 last_file
= &(s
->u
.syment
);
1317 /* Modify the symbol values according to their section and
1320 fixup_symbol_value(coff_symbol_ptr
, &(s
->u
.syment
));
1322 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++) {
1323 s
[i
].offset
= native_index
++;
1334 Run thorough the symbol table again, and fix it so that all pointers to
1335 entries are changed to the entries' index in the output symbol table.
1339 DEFUN(coff_mangle_symbols
,(bfd_ptr
),
1342 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1343 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1344 unsigned int symbol_index
;
1346 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1348 coff_symbol_type
*coff_symbol_ptr
=
1349 coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1351 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1353 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1355 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++) {
1356 combined_entry_type
*a
= s
+ i
+ 1;
1358 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
1359 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
1362 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
1363 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
1371 static int string_size
;
1373 DEFUN(coff_fix_symbol_name
,(ignore_abfd
, symbol
, native
),
1374 bfd
*ignore_abfd AND
1376 combined_entry_type
*native
)
1378 unsigned int name_length
;
1379 union internal_auxent
*auxent
;
1380 char * name
= ( char *)(symbol
->name
);
1382 if (name
== (char *) NULL
) {
1383 /* coff symbols always have names, so we'll make one up */
1384 symbol
->name
= "strange";
1385 name
= (char *)symbol
->name
;
1387 name_length
= strlen(name
);
1389 if (native
->u
.syment
.n_sclass
== C_FILE
) {
1390 strncpy(native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
1391 auxent
= &(native
+1)->u
.auxent
;
1393 #ifdef COFF_LONG_FILENAMES
1394 if (name_length
<= FILNMLEN
) {
1395 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1398 auxent
->x_file
.x_n
.x_offset
= string_size
+ 4;
1399 auxent
->x_file
.x_n
.x_zeroes
= 0;
1400 string_size
+= name_length
+ 1;
1403 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1404 if (name_length
> FILNMLEN
) {
1405 name
[FILNMLEN
] = '\0';
1410 { /* NOT A C_FILE SYMBOL */
1411 if (name_length
<= SYMNMLEN
) {
1412 /* This name will fit into the symbol neatly */
1413 strncpy(native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
1416 native
->u
.syment
._n
._n_n
._n_offset
= string_size
+ 4;
1417 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1418 string_size
+= name_length
+ 1;
1426 DEFUN(coff_write_symbol
,(abfd
, symbol
, native
, written
),
1429 combined_entry_type
*native AND
1430 unsigned int written
)
1432 unsigned int numaux
= native
->u
.syment
.n_numaux
;
1433 int type
= native
->u
.syment
.n_type
;
1434 int class = native
->u
.syment
.n_sclass
;
1438 coff_fix_symbol_name(abfd
, symbol
, native
);
1439 coff_swap_sym_out(abfd
, &native
->u
.syment
, &buf
);
1440 bfd_write((PTR
)& buf
, 1, SYMESZ
, abfd
);
1441 for (j
= 0; j
!= native
->u
.syment
.n_numaux
; j
++)
1444 bzero((PTR
)&buf
, AUXESZ
);
1445 coff_swap_aux_out(abfd
,
1446 &( (native
+ j
+ 1)->u
.auxent
), type
, class, &buf1
);
1447 bfd_write((PTR
) (&buf1
), 1, AUXESZ
, abfd
);
1450 Reuse somewhere in the symbol to keep the index
1452 set_index(symbol
, written
);
1453 return written
+ 1 + numaux
;
1458 DEFUN(coff_write_alien_symbol
,(abfd
, symbol
, written
),
1461 unsigned int written
)
1464 This symbol has been created by the loader, or come from a non
1465 coff format. It has no native element to inherit, make our
1468 combined_entry_type
*native
;
1469 combined_entry_type dummy
;
1471 native
->u
.syment
.n_type
= T_NULL
;
1473 native
->u
.syment
.n_flags
= 0;
1475 if (symbol
->flags
& BSF_ABSOLUTE
) {
1476 native
->u
.syment
.n_scnum
= N_ABS
;
1477 native
->u
.syment
.n_value
= symbol
->value
;
1479 else if (symbol
->flags
& (BSF_UNDEFINED
| BSF_FORT_COMM
)) {
1480 native
->u
.syment
.n_scnum
= N_UNDEF
;
1481 native
->u
.syment
.n_value
= symbol
->value
;
1483 else if (symbol
->flags
& BSF_DEBUGGING
) {
1485 remove name so it doesn't take up any space
1490 native
->u
.syment
.n_scnum
= symbol
->section
->output_section
->index
+
1492 native
->u
.syment
.n_value
= symbol
->value
+
1493 symbol
->section
->output_section
->vma
+
1494 symbol
->section
->output_offset
;
1496 /* Copy the any flags from the the file hdr into the symbol */
1498 coff_symbol_type
*c
= coff_symbol_from(abfd
, symbol
);
1499 if (c
!= (coff_symbol_type
*)NULL
) {
1500 native
->u
.syment
.n_flags
= c
->symbol
.the_bfd
->flags
;
1507 native
->u
.syment
.pad1
[0] = 0;
1508 native
->u
.syment
.pad1
[0] = 0;
1511 native
->u
.syment
.n_type
= 0;
1512 if (symbol
->flags
& BSF_LOCAL
)
1513 native
->u
.syment
.n_sclass
= C_STAT
;
1515 native
->u
.syment
.n_sclass
= C_EXT
;
1516 native
->u
.syment
.n_numaux
= 0;
1518 return coff_write_symbol(abfd
, symbol
, native
, written
);
1522 DEFUN(coff_write_native_symbol
,(abfd
, symbol
, written
),
1524 coff_symbol_type
*symbol AND
1525 unsigned int written
)
1528 Does this symbol have an ascociated line number - if so then
1529 make it remember this symbol index. Also tag the auxent of
1530 this symbol to point to the right place in the lineno table
1532 combined_entry_type
*native
= symbol
->native
;
1534 alent
*lineno
= symbol
->lineno
;
1537 unsigned int count
= 0;
1538 lineno
[count
].u
.offset
= written
;
1539 if (native
->u
.syment
.n_numaux
) {
1540 union internal_auxent
*a
= &((native
+1)->u
.auxent
);
1542 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1543 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1546 And count and relocate all other linenumbers
1549 while (lineno
[count
].line_number
) {
1550 lineno
[count
].u
.offset
+=
1551 symbol
->symbol
.section
->output_section
->vma
+
1552 symbol
->symbol
.section
->output_offset
;
1555 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1558 return coff_write_symbol(abfd
, &( symbol
->symbol
), native
,written
);
1562 DEFUN(coff_write_symbols
,(abfd
),
1566 unsigned int limit
= bfd_get_symcount(abfd
);
1567 unsigned int written
= 0;
1574 /* Seek to the right place */
1575 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
1577 /* Output all the symbols we have */
1580 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1582 asymbol
*symbol
= *p
;
1583 coff_symbol_type
*c_symbol
= coff_symbol_from(abfd
, symbol
);
1585 if (c_symbol
== (coff_symbol_type
*) NULL
||
1586 c_symbol
->native
== (combined_entry_type
*)NULL
)
1588 written
= coff_write_alien_symbol(abfd
, symbol
, written
);
1592 written
= coff_write_native_symbol(abfd
, c_symbol
, written
);
1597 bfd_get_symcount(abfd
) = written
;
1599 /* Now write out strings */
1601 if (string_size
!= 0)
1603 unsigned int size
= string_size
+ 4;
1606 bfd_h_put_32(abfd
, size
, buffer
);
1607 bfd_write((PTR
) buffer
, 1, sizeof(buffer
), abfd
);
1608 for (p
= abfd
->outsymbols
, i
= 0;
1613 size_t name_length
= strlen(q
->name
);
1615 coff_symbol_type
* c_symbol
= coff_symbol_from(abfd
, q
);
1616 maxlen
= ((c_symbol
!= NULL
&& c_symbol
->native
!= NULL
) &&
1617 (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
)) ?
1618 FILNMLEN
: SYMNMLEN
;
1620 if (name_length
> maxlen
) {
1621 bfd_write((PTR
) (q
->name
), 1, name_length
+ 1, abfd
);
1626 /* We would normally not write anything here, but we'll write
1627 out 4 so that any stupid coff reader which tries to read
1628 the string table even when there isn't one won't croak.
1631 uint32e_type size
= 4;
1633 bfd_write((PTR
)&size
, 1, sizeof(size
), abfd
);
1639 @subsubsection Writing Relocations
1640 To write a relocations, all the back end does is step though the
1641 canonical relocation table, and create an @code{internal_reloc}. The
1642 symbol index to use is removed from the @code{offset} field in the
1643 symbol table supplied, the address comes directly from the sum of the
1644 section base address and the relocation offset and the type is dug
1645 directly from the howto field.
1647 Then the @code{internal_reloc} is swapped into the shape of an
1648 @code{external_reloc} and written out to disk.
1652 DEFUN(coff_write_relocs
,(abfd
),
1656 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1658 struct external_reloc dst
;
1660 arelent
**p
= s
->orelocation
;
1661 bfd_seek(abfd
, s
->rel_filepos
, SEEK_SET
);
1662 for (i
= 0; i
< s
->reloc_count
; i
++) {
1663 struct internal_reloc n
;
1665 memset((PTR
)&n
, 0, sizeof(n
));
1666 n
.r_vaddr
= q
->address
+ s
->vma
;
1667 if (q
->sym_ptr_ptr
) {
1668 n
.r_symndx
= get_index((*(q
->sym_ptr_ptr
)));
1671 /* Work out reloc type from what is required */
1672 SELECT_RELOC(n
.r_type
, q
->howto
);
1674 n
.r_type
= q
->howto
->type
;
1676 coff_swap_reloc_out(abfd
, &n
, &dst
);
1677 bfd_write((PTR
) &n
, 1, RELSZ
, abfd
);
1681 #endif /* NO_COFF_SYMBOLS */
1683 #ifndef NO_COFF_LINENOS
1686 DEFUN(coff_write_linenumbers
,(abfd
),
1690 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1691 if (s
->lineno_count
) {
1692 asymbol
**q
= abfd
->outsymbols
;
1693 bfd_seek(abfd
, s
->line_filepos
, SEEK_SET
);
1694 /* Find all the linenumbers in this section */
1697 alent
*l
= BFD_SEND(p
->the_bfd
, _get_lineno
, (p
->the_bfd
, p
));
1699 /* Found a linenumber entry, output */
1700 struct internal_lineno out
;
1702 memset( (PTR
)&out
, 0, sizeof(out
));
1704 out
.l_addr
.l_symndx
= l
->u
.offset
;
1705 coff_swap_lineno_out(abfd
, &out
, &buff
);
1706 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1708 while (l
->line_number
) {
1709 out
.l_lnno
= l
->line_number
;
1710 out
.l_addr
.l_symndx
= l
->u
.offset
;
1711 coff_swap_lineno_out(abfd
, &out
, &buff
);
1712 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1723 DEFUN(coff_get_lineno
,(ignore_abfd
, symbol
),
1724 bfd
*ignore_abfd AND
1727 return coffsymbol(symbol
)->lineno
;
1730 #endif /* NO_COFF_LINENOS */
1733 coff_make_empty_symbol(abfd
)
1736 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc(abfd
, sizeof(coff_symbol_type
));
1738 bfd_error
= no_memory
;
1742 new->lineno
= (alent
*) NULL
;
1743 new->symbol
.the_bfd
= abfd
;
1744 return &new->symbol
;
1747 #ifndef NO_COFF_SYMBOLS
1750 DEFUN(coff_print_symbol
,(ignore_abfd
, filep
, symbol
, how
),
1751 bfd
*ignore_abfd AND
1754 bfd_print_symbol_type how
)
1756 FILE *file
= (FILE *)filep
;
1758 case bfd_print_symbol_name
:
1759 fprintf(file
, "%s", symbol
->name
);
1761 case bfd_print_symbol_more
:
1762 fprintf(file
, "coff %lx %lx", (unsigned long) coffsymbol(symbol
)->native
,
1763 (unsigned long) coffsymbol(symbol
)->lineno
);
1765 case bfd_print_symbol_nm
:
1768 CONST
char *section_name
= symbol
->section
== (asection
*) NULL
?
1769 "*abs" : symbol
->section
->name
;
1770 bfd_print_symbol_vandf((PTR
) file
, symbol
);
1773 fprintf(file
, " %-5s %s %s %s",
1775 coffsymbol(symbol
)->native
? "n" : "g",
1776 coffsymbol(symbol
)->lineno
? "l" : " ",
1782 case bfd_print_symbol_all
:
1783 /* Print out the symbols in a reasonable way */
1785 CONST
char *section_name
= symbol
->section
== (asection
*) NULL
?
1786 "*abs" : symbol
->section
->name
;
1789 if (coffsymbol(symbol
)->native
)
1792 combined_entry_type
*combined
= coffsymbol(symbol
)->native
;
1793 combined_entry_type
*root
= obj_raw_syments(ignore_abfd
);
1795 fprintf(file
,"[%3d]",
1799 fprintf(file
, "(sc %2d)(fl%4x)(ty%3x)(sc%3d) nx(%d) %08x %s",
1800 combined
->u
.syment
.n_scnum
,
1801 combined
->u
.syment
.n_flags
,
1802 combined
->u
.syment
.n_type
,
1803 combined
->u
.syment
.n_sclass
,
1804 combined
->u
.syment
.n_numaux
,
1805 combined
->u
.syment
.n_value
,
1808 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
1811 switch (combined
->u
.syment
.n_sclass
) {
1813 fprintf(file
, "File ");
1816 fprintf(file
, "AUX tv %x lnno %x size %x",
1817 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
1818 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
);
1831 bfd_print_symbol_vandf((PTR
) file
, symbol
);
1832 fprintf(file
, " %-5s %s %s %s",
1834 coffsymbol(symbol
)->native
? "n" : "g",
1835 coffsymbol(symbol
)->lineno
? "l" : " ",
1844 #endif /* NO_COFF_SYMBOLS */
1846 /* Set flags and magic number of a coff file from architecture and machine
1847 type. Result is true if we can represent the arch&type, false if not. */
1850 DEFUN(coff_set_flags
,(abfd
, magicp
, flagsp
),
1852 unsigned *magicp AND
1853 unsigned short *flagsp
)
1855 switch (bfd_get_arch(abfd
)) {
1863 *magicp
= I960ROMAGIC
;
1865 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1866 I960RWMAGIC); FIXME???
1868 switch (bfd_get_mach(abfd
)) {
1869 case bfd_mach_i960_core
:
1872 case bfd_mach_i960_kb_sb
:
1875 case bfd_mach_i960_mc
:
1878 case bfd_mach_i960_xa
:
1881 case bfd_mach_i960_ca
:
1884 case bfd_mach_i960_ka_sa
:
1897 *magicp
= MIPS_MAGIC_2
;
1903 *magicp
= I386MAGIC
;
1908 *magicp
= MC68MAGIC
;
1914 *magicp
= MC88OMAGIC
;
1919 case bfd_arch_h8300
:
1920 *magicp
= H8300MAGIC
;
1924 #ifdef A29K_MAGIC_BIG
1926 if (abfd
->xvec
->byteorder_big_p
)
1927 *magicp
= A29K_MAGIC_BIG
;
1929 *magicp
= A29K_MAGIC_LITTLE
;
1935 case bfd_arch_rs6000
:
1936 *magicp
= U802TOCMAGIC
;
1940 default: /* Unknown architecture */
1941 /* return false; -- fall through to "return false" below, to avoid
1942 "statement never reached" errors on the one below. */
1951 DEFUN(coff_set_arch_mach
,(abfd
, arch
, machine
),
1953 enum bfd_architecture arch AND
1954 unsigned long machine
)
1957 unsigned short dummy2
;
1958 bfd_default_set_arch_mach(abfd
, arch
, machine
);
1960 if (arch
!= bfd_arch_unknown
&&
1961 coff_set_flags(abfd
, &dummy1
, &dummy2
) != true)
1962 return false; /* We can't represent this type */
1963 return true; /* We're easy ... */
1967 /* Calculate the file position for each section. */
1970 DEFUN(coff_compute_section_file_positions
,(abfd
),
1974 asection
*previous
= (asection
*)NULL
;
1975 file_ptr sofar
= FILHSZ
;
1977 if (bfd_get_start_address(abfd
))
1979 /* A start address may have been added to the original file. In this
1980 case it will need an optional header to record it. */
1981 abfd
->flags
|= EXEC_P
;
1984 if (abfd
->flags
& EXEC_P
)
1987 sofar
+= abfd
->section_count
* SCNHSZ
;
1988 for (current
= abfd
->sections
;
1989 current
!= (asection
*)NULL
;
1990 current
= current
->next
) {
1992 /* Only deal with sections which have contents */
1993 if (!(current
->flags
& SEC_HAS_CONTENTS
))
1996 /* Align the sections in the file to the same boundary on
1997 which they are aligned in virtual memory. I960 doesn't
1998 do this (FIXME) so we can stay in sync with Intel. 960
1999 doesn't yet page from files... */
2002 /* make sure this section is aligned on the right boundary - by
2003 padding the previous section up if necessary */
2006 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2007 if (previous
!= (asection
*)NULL
) {
2008 previous
->size
+= sofar
- old_sofar
;
2013 /* FIXME, in demand paged files, the low order bits of the file
2014 offset must match the low order bits of the virtual address.
2015 "Low order" is apparently implementation defined. Add code
2016 here to round sofar up to match the virtual address. */
2018 current
->filepos
= sofar
;
2020 /* make sure that this section is of the right size too */
2021 old_sofar
= sofar
+= current
->size
;
2022 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2023 current
->size
+= sofar
- old_sofar
;
2027 obj_relocbase(abfd
) = sofar
;
2036 DEFUN(coff_write_object_contents
,(abfd
),
2040 boolean hasrelocs
= false;
2041 boolean haslinno
= false;
2042 file_ptr reloc_base
;
2043 file_ptr lineno_base
;
2047 unsigned long reloc_size
= 0;
2048 unsigned long lnno_size
= 0;
2049 asection
*text_sec
= NULL
;
2050 asection
*data_sec
= NULL
;
2051 asection
*bss_sec
= NULL
;
2053 struct internal_filehdr internal_f
;
2054 struct internal_aouthdr internal_a
;
2057 bfd_error
= system_call_error
;
2060 if(abfd
->output_has_begun
== false) {
2061 coff_compute_section_file_positions(abfd
);
2064 if (abfd
->sections
!= (asection
*)NULL
) {
2065 scn_base
= abfd
->sections
->filepos
;
2070 if (bfd_seek(abfd
, scn_base
, SEEK_SET
) != 0)
2072 reloc_base
= obj_relocbase(abfd
);
2074 /* Make a pass through the symbol table to count line number entries and
2075 put them into the correct asections */
2077 #ifndef NO_COFF_LINENOS
2078 coff_count_linenumbers(abfd
);
2080 data_base
= scn_base
;
2082 /* Work out the size of the reloc and linno areas */
2084 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
) {
2085 reloc_size
+= current
->reloc_count
* RELSZ
;
2086 #ifndef NO_COFF_LINENOS
2087 lnno_size
+= current
->lineno_count
* LINESZ
;
2089 data_base
+= SCNHSZ
;
2092 lineno_base
= reloc_base
+ reloc_size
;
2093 sym_base
= lineno_base
+ lnno_size
;
2095 /* Indicate in each section->line_filepos its actual file address */
2096 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
) {
2097 if (current
->lineno_count
) {
2098 current
->line_filepos
= lineno_base
;
2099 current
->moving_line_filepos
= lineno_base
;
2100 #ifndef NO_COFF_LINENOS
2101 lineno_base
+= current
->lineno_count
* LINESZ
;
2105 current
->line_filepos
= 0;
2107 if (current
->reloc_count
) {
2108 current
->rel_filepos
= reloc_base
;
2109 reloc_base
+= current
->reloc_count
* sizeof(struct internal_reloc
);
2112 current
->rel_filepos
= 0;
2116 /* Write section headers to the file. */
2119 (file_ptr
) ((abfd
->flags
& EXEC_P
) ?
2120 (FILHSZ
+ AOUTSZ
) : FILHSZ
),
2125 unsigned int pad
= abfd
->flags
& D_PAGED
? data_base
: 0;
2127 unsigned int pad
= 0;
2129 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
) {
2130 struct internal_scnhdr section
;
2131 strncpy(&(section
.s_name
[0]), current
->name
, 8);
2132 section
.s_vaddr
= current
->vma
+ pad
;
2133 section
.s_paddr
= current
->vma
+ pad
;
2134 section
.s_size
= current
->size
- pad
;
2136 If this section has no size or is unloadable then the scnptr
2139 if (current
->size
- pad
== 0 ||
2140 (current
->flags
& SEC_LOAD
) == 0) {
2141 section
.s_scnptr
= 0;
2144 section
.s_scnptr
= current
->filepos
;
2146 section
.s_relptr
= current
->rel_filepos
;
2147 section
.s_lnnoptr
= current
->line_filepos
;
2148 section
.s_nreloc
= current
->reloc_count
;
2149 section
.s_nlnno
= current
->lineno_count
;
2150 if (current
->reloc_count
!= 0)
2152 if (current
->lineno_count
!= 0)
2155 section
.s_flags
= sec_to_styp_flags(current
->name
,current
->flags
);
2157 if (!strcmp(current
->name
, _TEXT
)) {
2159 } else if (!strcmp(current
->name
, _DATA
)) {
2161 } else if (!strcmp(current
->name
, _BSS
)) {
2166 section
.s_align
= (current
->alignment_power
2167 ? 1 << current
->alignment_power
2174 coff_swap_scnhdr_out(abfd
, §ion
, &buff
);
2175 bfd_write((PTR
) (&buff
), 1, SCNHSZ
, abfd
);
2182 /* OK, now set up the filehdr... */
2183 internal_f
.f_nscns
= abfd
->section_count
;
2185 We will NOT put a fucking timestamp in the header here. Every time you
2186 put it back, I will come in and take it out again. I'm sorry. This
2187 field does not belong here. We fill it with a 0 so it compares the
2188 same but is not a reasonable time. -- gnu@cygnus.com
2191 Well, I like it, so I'm conditionally compiling it in.
2194 #ifdef COFF_TIMESTAMP
2195 internal_f
.f_timdat
= time(0);
2197 internal_f
.f_timdat
= 0;
2200 if (bfd_get_symcount(abfd
) != 0)
2201 internal_f
.f_symptr
= sym_base
;
2203 internal_f
.f_symptr
= 0;
2205 internal_f
.f_flags
= 0;
2207 if (abfd
->flags
& EXEC_P
)
2208 internal_f
.f_opthdr
= AOUTSZ
;
2210 internal_f
.f_opthdr
= 0;
2213 internal_f
.f_flags
|= F_RELFLG
;
2215 internal_f
.f_flags
|= F_LNNO
;
2216 if (0 == bfd_get_symcount(abfd
))
2217 internal_f
.f_flags
|= F_LSYMS
;
2218 if (abfd
->flags
& EXEC_P
)
2219 internal_f
.f_flags
|= F_EXEC
;
2221 internal_f
.f_flags
|= F_AR32W
;
2223 if (!abfd
->xvec
->byteorder_big_p
)
2224 internal_f
.f_flags
|= F_AR32WR
;
2227 FIXME, should do something about the other byte orders and
2231 /* Set up architecture-dependent stuff */
2233 { unsigned int magic
= 0;
2234 unsigned short flags
= 0;
2235 coff_set_flags(abfd
, &magic
, &flags
);
2236 internal_f
.f_magic
= magic
;
2237 internal_f
.f_flags
|= flags
;
2238 /* ...and the "opt"hdr... */
2241 # ifdef ULTRA3 /* NYU's machine */
2242 /* FIXME: This is a bogus check. I really want to see if there
2243 * is a .shbss or a .shdata section, if so then set the magic
2244 * number to indicate a shared data executable.
2246 if (internal_f
.f_nscns
>= 7)
2247 internal_a
.magic
= SHMAGIC
; /* Shared magic */
2249 # endif /* ULTRA3 */
2250 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
2251 #define __A_MAGIC_SET__
2254 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
2255 #define __A_MAGIC_SET__
2258 #define __A_MAGIC_SET__
2259 internal_a
.magic
= PAGEMAGICBCS
;
2262 #if M68 || I386 || MIPS
2263 #define __A_MAGIC_SET__
2264 /* Never was anything here for the 68k */
2268 #define __A_MAGIC_SET__
2269 internal_a
.magic
= (abfd
->flags
& D_PAGED
)? RS6K_AOUTHDR_ZMAGIC
:
2270 (abfd
->flags
& WP_TEXT
)? RS6K_AOUTHDR_NMAGIC
:
2271 RS6K_AOUTHDR_OMAGIC
;
2274 #ifndef __A_MAGIC_SET__
2275 # include "Your aouthdr magic number is not being set!"
2277 # undef __A_MAGIC_SET__
2280 /* Now should write relocs, strings, syms */
2281 obj_sym_filepos(abfd
) = sym_base
;
2283 #ifndef NO_COFF_SYMBOLS
2284 if (bfd_get_symcount(abfd
) != 0) {
2285 coff_renumber_symbols(abfd
);
2286 coff_mangle_symbols(abfd
);
2287 coff_write_symbols(abfd
);
2288 coff_write_linenumbers(abfd
);
2289 coff_write_relocs(abfd
);
2291 #endif /* NO_COFF_SYMBOLS */
2293 internal_a
.tsize
= text_sec
->size
;
2294 internal_a
.text_start
=text_sec
->size
? text_sec
->vma
: 0;
2297 internal_a
.dsize
= data_sec
->size
;
2298 internal_a
.data_start
= data_sec
->size
? data_sec
->vma
: 0;
2301 internal_a
.bsize
= bss_sec
->size
;
2304 internal_a
.entry
= bfd_get_start_address(abfd
);
2305 internal_f
.f_nsyms
= bfd_get_symcount(abfd
);
2307 /* now write them */
2308 if (bfd_seek(abfd
, 0L, SEEK_SET
) != 0)
2312 coff_swap_filehdr_out(abfd
, &internal_f
, &buff
);
2313 bfd_write((PTR
) &buff
, 1, FILHSZ
, abfd
);
2315 if (abfd
->flags
& EXEC_P
) {
2317 coff_swap_aouthdr_out(abfd
, &internal_a
, &buff
);
2318 bfd_write((PTR
) &buff
, 1, AOUTSZ
, abfd
);
2323 #ifndef NO_COFF_SYMBOLS
2326 this function transforms the offsets into the symbol table into
2327 pointers to syments.
2332 DEFUN(coff_pointerize_aux
,(ignore_abfd
, table_base
, type
, class, auxent
),
2333 bfd
*ignore_abfd AND
2334 combined_entry_type
*table_base AND
2337 combined_entry_type
*auxent
)
2339 /* Don't bother if this is a file or a section */
2340 if (class == C_STAT
&& type
== T_NULL
) return;
2341 if (class == C_FILE
) return;
2343 /* Otherwise patch up */
2344 if (ISFCN(type
) || ISTAG(class) || class == C_BLOCK
) {
2345 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
= table_base
+
2346 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2347 auxent
->fix_end
= 1;
2349 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
!= 0) {
2350 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
= table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
2351 auxent
->fix_tag
= 1;
2355 #endif /* NO_COFF_SYMBOLS */
2358 DEFUN(coff_set_section_contents
,(abfd
, section
, location
, offset
, count
),
2363 bfd_size_type count
)
2365 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
2366 coff_compute_section_file_positions(abfd
);
2368 bfd_seek(abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
);
2371 return (bfd_write(location
, 1, count
, abfd
) == count
) ? true : false;
2377 coff_close_and_cleanup(abfd
)
2380 if (!bfd_read_p(abfd
))
2381 switch (abfd
->format
) {
2383 if (!_bfd_write_archive_contents(abfd
))
2387 if (!coff_write_object_contents(abfd
))
2391 bfd_error
= invalid_operation
;
2395 /* We depend on bfd_close to free all the memory on the obstack. */
2396 /* FIXME if bfd_release is not using obstacks! */
2402 buy_and_read(abfd
, where
, seek_direction
, size
)
2408 PTR area
= (PTR
) bfd_alloc(abfd
, size
);
2410 bfd_error
= no_memory
;
2413 bfd_seek(abfd
, where
, seek_direction
);
2414 if (bfd_read(area
, 1, size
, abfd
) != size
) {
2415 bfd_error
= system_call_error
;
2419 } /* buy_and_read() */
2422 #ifndef NO_COFF_SYMBOLS
2425 DEFUN(build_string_table
,(abfd
),
2428 char string_table_size_buffer
[4];
2429 unsigned int string_table_size
;
2432 /* At this point we should be "seek"'d to the end of the
2433 symbols === the symbol table size. */
2434 if (bfd_read((char *) string_table_size_buffer
,
2435 sizeof(string_table_size_buffer
),
2436 1, abfd
) != sizeof(string_table_size
)) {
2437 bfd_error
= system_call_error
;
2441 string_table_size
= bfd_h_get_32(abfd
, (bfd_byte
*) string_table_size_buffer
);
2443 if ((string_table
= (PTR
) bfd_alloc(abfd
, string_table_size
-= 4)) == NULL
) {
2444 bfd_error
= no_memory
;
2446 } /* on mallocation error */
2447 if (bfd_read(string_table
, string_table_size
, 1, abfd
) != string_table_size
) {
2448 bfd_error
= system_call_error
;
2451 return string_table
;
2454 /* Allocate space for the ".debug" section, and read it.
2455 We did not read the debug section until now, because
2456 we didn't want to go to the trouble until someone needed it. */
2459 DEFUN(build_debug_section
,(abfd
),
2462 char *debug_section
;
2465 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
2468 bfd_error
= no_debug_section
;
2472 debug_section
= (PTR
) bfd_alloc (abfd
, bfd_section_size (abfd
, sect
));
2473 if (debug_section
== NULL
) {
2474 bfd_error
= no_memory
;
2478 /* Seek to the beginning of the `.debug' section and read it.
2479 Save the current position first; it is needed by our caller.
2480 Then read debug section and reset the file pointer. */
2482 position
= bfd_tell (abfd
);
2483 bfd_seek (abfd
, sect
->filepos
, SEEK_SET
);
2484 if (bfd_read (debug_section
, bfd_section_size (abfd
, sect
), 1, abfd
)
2485 != bfd_section_size (abfd
, sect
)) {
2486 bfd_error
= system_call_error
;
2489 bfd_seek (abfd
, position
, SEEK_SET
);
2490 return debug_section
;
2494 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
2495 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
2496 be \0-terminated. */
2498 DEFUN(copy_name
,(abfd
, name
, maxlen
),
2506 for (len
= 0; len
< maxlen
; ++len
) {
2507 if (name
[len
] == '\0') {
2512 if ((newname
= (PTR
) bfd_alloc(abfd
, len
+1)) == NULL
) {
2513 bfd_error
= no_memory
;
2516 strncpy(newname
, name
, len
);
2517 newname
[len
] = '\0';
2522 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
2523 knit the symbol names into a normalized form. By normalized here I
2524 mean that all symbols have an n_offset pointer that points to a null-
2525 terminated string. */
2527 #ifndef SYMNAME_IN_DEBUG
2528 #define SYMNAME_IN_DEBUG(x) 0
2531 static combined_entry_type
*
2532 DEFUN(get_normalized_symtab
,(abfd
),
2535 combined_entry_type
*internal
;
2536 combined_entry_type
*internal_ptr
;
2537 combined_entry_type
*internal_end
;
2541 char *string_table
= NULL
;
2542 char *debug_section
= NULL
;
2545 unsigned int raw_size
;
2546 if (obj_raw_syments(abfd
) != (combined_entry_type
*)NULL
) {
2547 return obj_raw_syments(abfd
);
2549 if ((size
= bfd_get_symcount(abfd
) * sizeof(combined_entry_type
)) == 0) {
2550 bfd_error
= no_symbols
;
2554 internal
= (combined_entry_type
*)bfd_alloc(abfd
, size
);
2555 internal_end
= internal
+ bfd_get_symcount(abfd
);
2557 raw_size
= bfd_get_symcount(abfd
) * SYMESZ
;
2558 raw
= (SYMENT
*)bfd_alloc(abfd
,raw_size
);
2560 if (bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
) == -1
2561 || bfd_read((PTR
)raw
, raw_size
, 1, abfd
) != raw_size
) {
2562 bfd_error
= system_call_error
;
2565 /* mark the end of the symbols */
2566 raw_end
= raw
+ bfd_get_symcount(abfd
);
2568 FIXME SOMEDAY. A string table size of zero is very weird, but
2569 probably possible. If one shows up, it will probably kill us.
2572 /* Swap all the raw entries */
2573 for (raw_src
= raw
, internal_ptr
= internal
;
2575 raw_src
++, internal_ptr
++) {
2578 coff_swap_sym_in(abfd
, (char *)raw_src
, (char *)&internal_ptr
->u
.syment
);
2579 internal_ptr
->fix_tag
= 0;
2580 internal_ptr
->fix_end
= 0;
2582 for (i
= internal_ptr
->u
.syment
.n_numaux
;
2584 --i
, raw_src
++, internal_ptr
++) {
2586 (internal_ptr
+1)->fix_tag
= 0;
2587 (internal_ptr
+1)->fix_end
= 0;
2589 coff_swap_aux_in(abfd
, (char *)(raw_src
+1),
2590 internal_ptr
->u
.syment
.n_type
,
2591 internal_ptr
->u
.syment
.n_sclass
,
2592 &(internal_ptr
+1)->u
.auxent
);
2594 coff_pointerize_aux(abfd
,
2596 internal_ptr
->u
.syment
.n_type
,
2597 internal_ptr
->u
.syment
.n_sclass
,
2602 /* Free all the raw stuff */
2603 bfd_release(abfd
, raw
);
2605 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
2608 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
) {
2609 /* make a file symbol point to the name in the auxent, since
2610 the text ".file" is redundant */
2611 if ((internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_zeroes
== 0) {
2612 /* the filename is a long one, point into the string table */
2613 if (string_table
== NULL
) {
2614 string_table
= build_string_table(abfd
);
2617 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
2618 (int) (string_table
- 4 +
2619 (internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_offset
);
2622 /* ordinary short filename, put into memory anyway */
2623 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2624 copy_name(abfd
, (internal_ptr
+1)->u
.auxent
.x_file
.x_fname
,
2629 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0) {
2630 /* This is a "short" name. Make it long. */
2631 unsigned long i
= 0;
2632 char *newstring
= NULL
;
2634 /* find the length of this string without walking into memory
2636 for (i
= 0; i
< 8; ++i
) {
2637 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0') {
2639 } /* if end of string */
2640 } /* possible lengths of this string. */
2642 if ((newstring
= (PTR
) bfd_alloc(abfd
, ++i
)) == NULL
) {
2643 bfd_error
= no_memory
;
2646 bzero(newstring
, i
);
2647 strncpy(newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
-1);
2648 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int) newstring
;
2649 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
2651 else if (!SYMNAME_IN_DEBUG(&internal_ptr
->u
.syment
)) {
2652 /* Long name already. Point symbol at the string in the table. */
2653 if (string_table
== NULL
) {
2654 string_table
= build_string_table(abfd
);
2656 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2657 (string_table
- 4 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
2660 /* Long name in debug section. Very similar. */
2661 if (debug_section
== NULL
) {
2662 debug_section
= build_debug_section(abfd
);
2664 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2665 (debug_section
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
2668 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
2671 obj_raw_syments(abfd
) = internal
;
2674 } /* get_normalized_symtab() */
2676 #endif /* NO_COFF_SYMBOLS */
2680 DEFUN(section_from_bfd_index
,(abfd
, index
),
2685 struct sec
*answer
= abfd
->sections
;
2687 answer
= answer
->next
;
2694 #ifndef NO_COFF_LINENOS
2697 @subsubsection Reading Linenumbers
2698 Createing the linenumber table is done by reading in the entire coff
2699 linenumber table, and creating another table for internal use.
2701 A coff line number table is structured so that each
2702 function is marked as having a line number of 0. Each line within the
2703 function is an offset from the first line in the function. The base of
2704 the line number information for the table is stored in the symbol
2705 associated with the function.
2707 The information is copied from the external to the internal table, and
2708 each symbol which marks a function is marked by pointing its...
2710 **How does this work ?**
2715 coff_slurp_line_table(abfd
, asect
)
2719 LINENO
*native_lineno
;
2720 alent
*lineno_cache
;
2722 BFD_ASSERT(asect
->lineno
== (alent
*) NULL
);
2724 native_lineno
= (LINENO
*) buy_and_read(abfd
,
2725 asect
->line_filepos
,
2728 asect
->lineno_count
));
2730 (alent
*) bfd_alloc(abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof(alent
)));
2731 if (lineno_cache
== NULL
) {
2732 bfd_error
= no_memory
;
2735 unsigned int counter
= 0;
2736 alent
*cache_ptr
= lineno_cache
;
2737 LINENO
*src
= native_lineno
;
2739 while (counter
< asect
->lineno_count
) {
2740 struct internal_lineno dst
;
2741 coff_swap_lineno_in(abfd
, src
, &dst
);
2742 cache_ptr
->line_number
= dst
.l_lnno
;
2744 if (cache_ptr
->line_number
== 0) {
2745 coff_symbol_type
*sym
=
2746 (coff_symbol_type
*) (dst
.l_addr
.l_symndx
2747 + obj_raw_syments(abfd
))->u
.syment
._n
._n_n
._n_zeroes
;
2748 cache_ptr
->u
.sym
= (asymbol
*) sym
;
2749 sym
->lineno
= cache_ptr
;
2752 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
2753 - bfd_section_vma(abfd
, asect
);
2754 } /* If no linenumber expect a symbol index */
2760 cache_ptr
->line_number
= 0;
2763 asect
->lineno
= lineno_cache
;
2764 /* FIXME, free native_lineno here, or use alloca or something. */
2766 } /* coff_slurp_line_table() */
2768 #endif /* NO_COFF_LINENOS */
2770 #ifndef NO_COFF_LINENOS
2773 DEFUN(coff_slurp_symbol_table
,(abfd
),
2776 combined_entry_type
*native_symbols
;
2777 coff_symbol_type
*cached_area
;
2778 unsigned int *table_ptr
;
2780 unsigned int number_of_symbols
= 0;
2781 if (obj_symbols(abfd
))
2783 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
2785 /* Read in the symbol table */
2786 if ((native_symbols
= get_normalized_symtab(abfd
)) == NULL
) {
2790 /* Allocate enough room for all the symbols in cached form */
2792 (coff_symbol_type
*)
2793 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(coff_symbol_type
)));
2795 if (cached_area
== NULL
) {
2796 bfd_error
= no_memory
;
2801 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(unsigned int)));
2803 if (table_ptr
== NULL
) {
2804 bfd_error
= no_memory
;
2809 coff_symbol_type
*dst
= cached_area
;
2810 unsigned int last_native_index
= bfd_get_symcount(abfd
);
2811 unsigned int this_index
= 0;
2812 while (this_index
< last_native_index
) {
2813 combined_entry_type
*src
= native_symbols
+ this_index
;
2814 table_ptr
[this_index
] = number_of_symbols
;
2815 dst
->symbol
.the_bfd
= abfd
;
2817 dst
->symbol
.name
= (char *)(src
->u
.syment
._n
._n_n
._n_offset
);
2819 We use the native name field to point to the cached field
2821 src
->u
.syment
._n
._n_n
._n_zeroes
= (int) dst
;
2822 dst
->symbol
.section
= section_from_bfd_index(abfd
,
2823 src
->u
.syment
.n_scnum
);
2824 switch (src
->u
.syment
.n_sclass
) {
2828 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
2829 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2830 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
2832 /* Fall through to next case */
2840 if ((src
->u
.syment
.n_scnum
) == 0) {
2841 if ((src
->u
.syment
.n_value
) == 0) {
2842 dst
->symbol
.flags
= BSF_UNDEFINED
;
2843 dst
->symbol
.value
= 0;
2846 dst
->symbol
.flags
= BSF_FORT_COMM
;
2847 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2852 Base the value as an index from the base of the
2855 if (dst
->symbol
.section
== (asection
*) NULL
) {
2856 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
| BSF_ABSOLUTE
;
2857 dst
->symbol
.value
= src
->u
.syment
.n_value
;
2860 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2861 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
2863 if (ISFCN((src
->u
.syment
.n_type
))) {
2865 A function ext does not go at the end of a file
2867 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
2874 case C_STAT
: /* static */
2876 case C_LEAFSTAT
: /* static leaf procedure */
2878 case C_LABEL
: /* label */
2879 if (src
->u
.syment
.n_scnum
== -2)
2880 dst
->symbol
.flags
= BSF_DEBUGGING
;
2882 dst
->symbol
.flags
= BSF_LOCAL
;
2884 Base the value as an index from the base of the section, if
2887 if (dst
->symbol
.section
)
2888 dst
->symbol
.value
= (src
->u
.syment
.n_value
) -
2889 dst
->symbol
.section
->vma
;
2891 dst
->symbol
.value
= (src
->u
.syment
.n_value
) ;
2894 case C_MOS
: /* member of structure */
2895 case C_EOS
: /* end of structure */
2896 #ifdef NOTDEF /* C_AUTOARG has the same value */
2898 case C_GLBLREG
: /* A29k-specific storage class */
2901 case C_REGPARM
: /* register parameter */
2902 case C_REG
: /* register variable */
2904 case C_AUTOARG
: /* 960-specific storage class */
2906 case C_TPDEF
: /* type definition */
2908 case C_AUTO
: /* automatic variable */
2909 case C_FIELD
: /* bit field */
2910 case C_ENTAG
: /* enumeration tag */
2911 case C_MOE
: /* member of enumeration */
2912 case C_MOU
: /* member of union */
2913 case C_UNTAG
: /* union tag */
2914 dst
->symbol
.flags
= BSF_DEBUGGING
;
2915 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2918 case C_FILE
: /* file name */
2919 case C_STRTAG
: /* structure tag */
2921 case C_BINCL
: /* beginning of include file */
2922 case C_EINCL
: /* ending of include file */
2935 dst
->symbol
.flags
= BSF_DEBUGGING
;
2936 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2939 case C_BLOCK
: /* ".bb" or ".eb" */
2940 case C_FCN
: /* ".bf" or ".ef" */
2941 case C_EFCN
: /* physical end of function */
2942 dst
->symbol
.flags
= BSF_LOCAL
;
2944 Base the value as an index from the base of the section
2946 dst
->symbol
.value
= (src
->u
.syment
.n_value
) - dst
->symbol
.section
->vma
;
2950 case C_EXTDEF
: /* external definition */
2951 case C_ULABEL
: /* undefined label */
2952 case C_USTATIC
: /* undefined static */
2953 case C_LINE
: /* line # reformatted as symbol table entry */
2954 case C_ALIAS
: /* duplicate tag */
2955 case C_HIDDEN
: /* ext symbol in dmert public lib */
2958 fprintf(stderr
,"Unrecognized storage class %d\n",
2959 src
->u
.syment
.n_sclass
);
2961 dst
->symbol
.flags
= BSF_DEBUGGING
;
2962 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2966 BFD_ASSERT(dst
->symbol
.flags
!= 0);
2970 dst
->symbol
.udata
= 0;
2971 dst
->lineno
= (alent
*) NULL
;
2972 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
2974 number_of_symbols
++;
2975 } /* walk the native symtab */
2976 } /* bfdize the native symtab */
2978 obj_symbols(abfd
) = cached_area
;
2979 obj_raw_syments(abfd
) = native_symbols
;
2981 bfd_get_symcount(abfd
) = number_of_symbols
;
2982 obj_convert(abfd
) = table_ptr
;
2983 /* Slurp the line tables for each section too */
2988 coff_slurp_line_table(abfd
, p
);
2993 } /* coff_slurp_symbol_table() */
2996 coff_get_symtab_upper_bound(abfd
)
2999 if (!coff_slurp_symbol_table(abfd
))
3002 return (bfd_get_symcount(abfd
) + 1) * (sizeof(coff_symbol_type
*));
3007 DEFUN(coff_get_symtab
, (abfd
, alocation
),
3009 asymbol
**alocation
)
3011 unsigned int counter
= 0;
3012 coff_symbol_type
*symbase
;
3013 coff_symbol_type
**location
= (coff_symbol_type
**) (alocation
);
3014 if (!coff_slurp_symbol_table(abfd
))
3017 symbase
= obj_symbols(abfd
);
3018 while (counter
< bfd_get_symcount(abfd
))
3020 /* This nasty code looks at the symbol to decide whether or
3021 not it is descibes a constructor/destructor entry point. It
3022 is structured this way to (hopefully) speed non matches */
3024 if (0 && symbase
->symbol
.name
[9] == '$')
3026 bfd_constructor_entry(abfd
,
3027 (asymbol
**)location
,
3028 symbase
->symbol
.name
[10] == 'I' ?
3032 *(location
++) = symbase
++;
3036 return bfd_get_symcount(abfd
);
3039 #endif /* NO_COFF_SYMBOLS */
3042 coff_get_reloc_upper_bound(abfd
, asect
)
3046 if (bfd_get_format(abfd
) != bfd_object
) {
3047 bfd_error
= invalid_operation
;
3050 return (asect
->reloc_count
+ 1) * sizeof(arelent
*);
3054 @subsubsection Reading Relocations
3055 Coff relocations are easily transformed into the internal BFD form
3058 Reading a coff relocation table is done in the following stages:
3061 The entire coff relocation table is read into memory.
3063 Each relocation is processed in turn, first it is swapped from the
3064 external to the internal form.
3066 The symbol referenced in the relocation's symbol index is turned into
3067 a pointer into the canonical symbol table. Note that this table is the
3068 same as the one returned by a call to @code{bfd_canonicalize_symtab}.
3069 The back end will call the routine and save the result if a
3070 canonicalization hasn't been done.
3072 The reloc index is turned into a pointer to a howto structure, in a
3073 back end specific way. For instance, the 386 and 960 use the
3074 @code{r_type} to directly produce an index into a howto table vector;
3075 the 88k subtracts a number from the @code{r_type} field and creates an
3081 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
3082 if (ptr && ptr->the_bfd == abfd \
3083 && ptr->section != (asection *) NULL \
3084 && ((ptr->flags & BSF_OLD_COMMON)== 0)) \
3086 cache_ptr->addend = -(ptr->section->vma + ptr->value); \
3089 cache_ptr->addend = 0; \
3094 DEFUN(coff_slurp_reloc_table
,(abfd
, asect
, symbols
),
3099 RELOC
*native_relocs
;
3100 arelent
*reloc_cache
;
3105 if (asect
->relocation
)
3107 if (asect
->reloc_count
== 0)
3109 if (asect
->flags
& SEC_CONSTRUCTOR
)
3111 #ifndef NO_COFF_SYMBOLS
3112 if (!coff_slurp_symbol_table(abfd
))
3116 (RELOC
*) buy_and_read(abfd
,
3120 asect
->reloc_count
));
3121 reloc_cache
= (arelent
*)
3122 bfd_alloc(abfd
, (size_t) (asect
->reloc_count
* sizeof(arelent
)));
3124 if (reloc_cache
== NULL
) {
3125 bfd_error
= no_memory
;
3130 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
3132 struct internal_reloc dst
;
3134 struct external_reloc
*src
;
3136 cache_ptr
= reloc_cache
+ idx
;
3137 src
= native_relocs
+ idx
;
3139 bfd_swap_reloc_in(abfd
, src
, &dst
);
3142 if (dst
.r_symndx
!= -1)
3144 cache_ptr
->sym_ptr_ptr
= symbols
+ obj_convert(abfd
)[dst
.r_symndx
];
3148 cache_ptr
->sym_ptr_ptr
= 0;
3155 /* AMD has two relocation entries for the 'consth' instruction.
3156 * The first is R_IHIHALF (part 1), the second is R_IHCONST
3157 * (part 2). The second entry's r_symndx does not contain
3158 * an index to a symbol but rather a value (apparently).
3159 * Also, see the ifdef below for saving the r_symndx value in addend.
3161 if (dst
.r_type
== R_IHCONST
) {
3166 ptr
= *(cache_ptr
->sym_ptr_ptr
);
3167 cache_ptr
->address
= dst
.r_vaddr
;
3169 The symbols definitions that we have read in have been
3170 relocated as if their sections started at 0. But the offsets
3171 refering to the symbols in the raw data have not been
3172 modified, so we have to have a negative addend to compensate.
3174 Note that symbols which used to be common must be left alone */
3177 cache_ptr
->address
= dst
.r_vaddr
;
3179 The symbols definitions that we have read in have been
3180 relocated as if their sections started at 0. But the offsets
3181 refering to the symbols in the raw data have not been
3182 modified, so we have to have a negative addend to compensate.
3184 Note that symbols which used to be common must be left alone */
3186 /* Calculate any reloc addend by looking at the symbol */
3187 CALC_ADDEND(abfd
, ptr
, dst
, cache_ptr
);
3189 cache_ptr
->address
-= asect
->vma
;
3190 cache_ptr
->section
= (asection
*) NULL
;
3192 /* Fill in the cache_ptr->howto field from dst.r_type */
3193 RTYPE2HOWTO(cache_ptr
, dst
);
3196 asect
->relocation
= reloc_cache
;
3201 /* This is stupid. This function should be a boolean predicate */
3203 DEFUN(coff_canonicalize_reloc
, (abfd
, section
, relptr
, symbols
),
3206 arelent
**relptr AND
3209 arelent
*tblptr
= section
->relocation
;
3210 unsigned int count
= 0;
3213 if (section
->flags
& SEC_CONSTRUCTOR
)
3215 /* this section has relocs made up by us, they are not in the
3216 file, so take them out of their chain and place them into
3217 the data area provided */
3218 arelent_chain
*chain
= section
->constructor_chain
;
3219 for (count
= 0; count
< section
->reloc_count
; count
++)
3221 *relptr
++ = &chain
->relent
;
3222 chain
= chain
->next
;
3228 coff_slurp_reloc_table(abfd
, section
, symbols
);
3231 tblptr
= section
->relocation
;
3235 for (; count
++ < section
->reloc_count
;)
3236 *relptr
++ = tblptr
++;
3241 return section
->reloc_count
;
3244 #ifndef NO_COFF_SYMBOLS
3247 provided a BFD, a section and an offset into the section, calculate and
3248 return the name of the source file and the line nearest to the wanted
3253 DEFUN(coff_find_nearest_line
,(abfd
,
3261 asection
*section AND
3262 asymbol
**ignore_symbols AND
3264 CONST
char **filename_ptr AND
3265 CONST
char **functionname_ptr AND
3266 unsigned int *line_ptr
)
3268 static bfd
*cache_abfd
;
3269 static asection
*cache_section
;
3270 static bfd_vma cache_offset
;
3271 static unsigned int cache_i
;
3272 static alent
*cache_l
;
3275 coff_data_type
*cof
= coff_data(abfd
);
3276 /* Run through the raw syments if available */
3277 combined_entry_type
*p
;
3279 unsigned int line_base
= 0;
3283 *functionname_ptr
= 0;
3286 /* Don't try and find line numbers in a non coff file */
3287 if (abfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
3293 p
= cof
->raw_syments
;
3295 for (i
= 0; i
< cof
->raw_syment_count
; i
++) {
3296 if (p
->u
.syment
.n_sclass
== C_FILE
) {
3297 /* File name has been moved into symbol */
3298 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
3301 p
+= 1 + p
->u
.syment
.n_numaux
;
3303 /* Now wander though the raw linenumbers of the section */
3305 If this is the same BFD as we were previously called with and this is
3306 the same section, and the offset we want is further down then we can
3307 prime the lookup loop
3309 if (abfd
== cache_abfd
&&
3310 section
== cache_section
&&
3311 offset
>= cache_offset
) {
3317 l
= section
->lineno
;
3320 for (; i
< section
->lineno_count
; i
++) {
3321 if (l
->line_number
== 0) {
3322 /* Get the symbol this line number points at */
3323 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
3324 *functionname_ptr
= coff
->symbol
.name
;
3326 combined_entry_type
*s
= coff
->native
;
3327 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
3329 S should now point to the .bf of the function
3331 if (s
->u
.syment
.n_numaux
) {
3333 The linenumber is stored in the auxent
3335 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
3336 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
3341 if (l
->u
.offset
> offset
)
3343 *line_ptr
= l
->line_number
+ line_base
+ 1;
3349 cache_section
= section
;
3350 cache_offset
= offset
;
3359 coff_sym_filepos(abfd
)
3362 return obj_sym_filepos(abfd
);
3366 #endif /* NO_COFF_SYMBOLS */
3370 DEFUN(coff_sizeof_headers
,(abfd
, reloc
),
3376 if (reloc
== false) {
3377 size
= FILHSZ
+ AOUTSZ
;
3383 size
+= abfd
->section_count
* SCNHSZ
;
3388 #define coff_core_file_failing_command _bfd_dummy_core_file_failing_command
3389 #define coff_core_file_failing_signal _bfd_dummy_core_file_failing_signal
3390 #define coff_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
3391 #define coff_slurp_armap bfd_slurp_coff_armap
3392 #define coff_slurp_extended_name_table _bfd_slurp_extended_name_table
3393 #define coff_truncate_arname bfd_dont_truncate_arname
3394 #define coff_openr_next_archived_file bfd_generic_openr_next_archived_file
3395 #define coff_generic_stat_arch_elt bfd_generic_stat_arch_elt
3396 #define coff_get_section_contents bfd_generic_get_section_contents
3397 #define coff_close_and_cleanup bfd_generic_close_and_cleanup
3399 #define coff_bfd_debug_info_start bfd_void
3400 #define coff_bfd_debug_info_end bfd_void
3401 #define coff_bfd_debug_info_accumulate (PROTO(void,(*),(bfd*, struct sec *))) bfd_void