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{m88k-bcs.c}. This file
31 @code{#include}s @code{m88k-bcs.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{m88k-bcs.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{m88k-bcs.h} and @code{internalcoff.h}.
39 The Intel i960 processor version of coff is implemented in
40 @code{icoff.c}. This file has the same structure as
41 @code{m88k-bcs.c}, except that it includes @code{intel-coff.h} rather
42 than @code{m88k-bcs.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;
250 /* Most of this hacked by Steve Chamberlain, steve@cygnus.com */
253 #define PUTWORD bfd_h_put_32
254 #define PUTHALF bfd_h_put_16
255 #define PUTBYTE bfd_h_put_8
257 #ifndef GET_FCN_LNNOPTR
258 #define GET_FCN_LNNOPTR(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
261 #ifndef GET_FCN_ENDNDX
262 #define GET_FCN_ENDNDX(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
265 #ifndef PUT_FCN_LNNOPTR
266 #define PUT_FCN_LNNOPTR(abfd, in, ext) PUTWORD(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
268 #ifndef PUT_FCN_ENDNDX
269 #define PUT_FCN_ENDNDX(abfd, in, ext) PUTWORD(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
271 #ifndef GET_LNSZ_LNNO
272 #define GET_LNSZ_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_lnno)
274 #ifndef GET_LNSZ_SIZE
275 #define GET_LNSZ_SIZE(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_size)
277 #ifndef PUT_LNSZ_LNNO
278 #define PUT_LNSZ_LNNO(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_sym.x_misc.x_lnsz.x_lnno)
280 #ifndef PUT_LNSZ_SIZE
281 #define PUT_LNSZ_SIZE(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte*) ext->x_sym.x_misc.x_lnsz.x_size)
283 #ifndef GET_SCN_SCNLEN
284 #define GET_SCN_SCNLEN(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_scn.x_scnlen)
286 #ifndef GET_SCN_NRELOC
287 #define GET_SCN_NRELOC(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nreloc)
289 #ifndef GET_SCN_NLINNO
290 #define GET_SCN_NLINNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nlinno)
292 #ifndef PUT_SCN_SCNLEN
293 #define PUT_SCN_SCNLEN(abfd,in, ext) bfd_h_put_32(abfd, in, (bfd_byte *) ext->x_scn.x_scnlen)
295 #ifndef PUT_SCN_NRELOC
296 #define PUT_SCN_NRELOC(abfd,in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_scn.x_nreloc)
298 #ifndef PUT_SCN_NLINNO
299 #define PUT_SCN_NLINNO(abfd,in, ext) bfd_h_put_16(abfd,in, (bfd_byte *) ext->x_scn.x_nlinno)
304 /* void warning(); */
307 * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the
308 * incoming SEC_* flags. The inverse of this function is styp_to_sec_flags().
309 * NOTE: If you add to/change this routine, you should mirror the changes
310 * in styp_to_sec_flags().
313 DEFUN(sec_to_styp_flags
, (sec_name
, sec_flags
),
314 CONST
char * sec_name AND
319 if (!strcmp(sec_name
, _TEXT
)) {
320 return((long)STYP_TEXT
);
321 } else if (!strcmp(sec_name
, _DATA
)) {
322 return((long)STYP_DATA
);
323 } else if (!strcmp(sec_name
, _BSS
)) {
324 return((long)STYP_BSS
);
327 /* Try and figure out what it should be */
328 if (sec_flags
& SEC_CODE
) styp_flags
= STYP_TEXT
;
329 if (sec_flags
& SEC_DATA
) styp_flags
= STYP_DATA
;
330 else if (sec_flags
& SEC_READONLY
)
331 #ifdef STYP_LIT /* 29k readonly text/data section */
332 styp_flags
= STYP_LIT
;
334 styp_flags
= STYP_TEXT
;
335 #endif /* STYP_LIT */
336 else if (sec_flags
& SEC_LOAD
) styp_flags
= STYP_TEXT
;
338 if (styp_flags
== 0) styp_flags
= STYP_BSS
;
343 * Return a word with SEC_* flags set to represent the incoming
344 * STYP_* flags (from scnhdr.s_flags). The inverse of this
345 * function is sec_to_styp_flags().
346 * NOTE: If you add to/change this routine, you should mirror the changes
347 * in sec_to_styp_flags().
350 DEFUN(styp_to_sec_flags
, (styp_flags
),
353 flagword sec_flags
=0;
355 if ((styp_flags
& STYP_TEXT
) || (styp_flags
& STYP_DATA
))
356 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
357 else if (styp_flags
& STYP_BSS
)
358 sec_flags
= SEC_ALLOC
;
360 #ifdef STYP_LIT /* A29k readonly text/data section type */
361 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
362 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
363 #endif /* STYP_LIT */
368 #define get_index(symbol) ((int) (symbol)->value)
369 #define set_index(symbol, idx) ((symbol)->value = (idx))
371 /* **********************************************************************
372 Here are all the routines for swapping the structures seen in the
373 outside world into the internal forms.
378 DEFUN(bfd_swap_reloc_in
,(abfd
, reloc_src
, reloc_dst
),
381 struct internal_reloc
*reloc_dst
)
383 reloc_dst
->r_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*)reloc_src
->r_vaddr
);
384 reloc_dst
->r_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) reloc_src
->r_symndx
);
387 reloc_dst
->r_type
= bfd_h_get_8(abfd
, reloc_src
->r_type
);
388 reloc_dst
->r_size
= bfd_h_get_8(abfd
, reloc_src
->r_size
);
390 reloc_dst
->r_type
= bfd_h_get_16(abfd
, (bfd_byte
*) reloc_src
->r_type
);
394 reloc_dst
->r_offset
= bfd_h_get_16(abfd
, (bfd_byte
*) reloc_src
->r_offset
);
400 DEFUN(coff_swap_reloc_out
,(abfd
, src
, dst
),
405 struct internal_reloc
*reloc_src
= (struct internal_reloc
*)src
;
406 struct external_reloc
*reloc_dst
= (struct external_reloc
*)dst
;
407 bfd_h_put_32(abfd
, reloc_src
->r_vaddr
, (bfd_byte
*) reloc_dst
->r_vaddr
);
408 bfd_h_put_32(abfd
, reloc_src
->r_symndx
, (bfd_byte
*) reloc_dst
->r_symndx
);
409 bfd_h_put_16(abfd
, reloc_src
->r_type
, (bfd_byte
*) reloc_dst
->r_type
);
411 bfd_h_put_16(abfd
, reloc_src
->r_offset
, (bfd_byte
*) reloc_dst
->r_offset
);
413 return sizeof(struct external_reloc
);
417 DEFUN(bfd_swap_filehdr_in
,(abfd
, filehdr_src
, filehdr_dst
),
419 FILHDR
*filehdr_src AND
420 struct internal_filehdr
*filehdr_dst
)
422 filehdr_dst
->f_magic
= bfd_h_get_16(abfd
, (bfd_byte
*) filehdr_src
->f_magic
);
423 filehdr_dst
->f_nscns
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_nscns
);
424 filehdr_dst
->f_timdat
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_timdat
);
425 filehdr_dst
->f_symptr
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_symptr
);
426 filehdr_dst
->f_nsyms
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_nsyms
);
427 filehdr_dst
->f_opthdr
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_opthdr
);
428 filehdr_dst
->f_flags
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_flags
);
432 DEFUN(coff_swap_filehdr_out
,(abfd
, in
, out
),
437 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*)in
;
438 FILHDR
*filehdr_out
= (FILHDR
*)out
;
439 bfd_h_put_16(abfd
, filehdr_in
->f_magic
, (bfd_byte
*) filehdr_out
->f_magic
);
440 bfd_h_put_16(abfd
, filehdr_in
->f_nscns
, (bfd_byte
*) filehdr_out
->f_nscns
);
441 bfd_h_put_32(abfd
, filehdr_in
->f_timdat
, (bfd_byte
*) filehdr_out
->f_timdat
);
442 bfd_h_put_32(abfd
, filehdr_in
->f_symptr
, (bfd_byte
*) filehdr_out
->f_symptr
);
443 bfd_h_put_32(abfd
, filehdr_in
->f_nsyms
, (bfd_byte
*) filehdr_out
->f_nsyms
);
444 bfd_h_put_16(abfd
, filehdr_in
->f_opthdr
, (bfd_byte
*) filehdr_out
->f_opthdr
);
445 bfd_h_put_16(abfd
, filehdr_in
->f_flags
, (bfd_byte
*) filehdr_out
->f_flags
);
446 return sizeof(FILHDR
);
450 #ifndef NO_COFF_SYMBOLS
453 DEFUN(coff_swap_sym_in
,(abfd
, ext1
, in1
),
458 SYMENT
*ext
= (SYMENT
*)ext1
;
459 struct internal_syment
*in
= (struct internal_syment
*)in1
;
461 if( ext
->e
.e_name
[0] == 0) {
462 in
->_n
._n_n
._n_zeroes
= 0;
463 in
->_n
._n_n
._n_offset
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e
.e
.e_offset
);
466 #if SYMNMLEN != E_SYMNMLEN
467 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
469 memcpy(in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
472 in
->n_value
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_value
);
473 in
->n_scnum
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_scnum
);
474 if (sizeof(ext
->e_type
) == 2){
475 in
->n_type
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_type
);
478 in
->n_type
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_type
);
480 in
->n_sclass
= bfd_h_get_8(abfd
, ext
->e_sclass
);
481 in
->n_numaux
= bfd_h_get_8(abfd
, ext
->e_numaux
);
485 DEFUN(coff_swap_sym_out
,(abfd
, inp
, extp
),
490 struct internal_syment
*in
= (struct internal_syment
*)inp
;
491 SYMENT
*ext
=(SYMENT
*)extp
;
492 if(in
->_n
._n_name
[0] == 0) {
493 bfd_h_put_32(abfd
, 0, (bfd_byte
*) ext
->e
.e
.e_zeroes
);
494 bfd_h_put_32(abfd
, in
->_n
._n_n
._n_offset
, (bfd_byte
*) ext
->e
.e
.e_offset
);
497 #if SYMNMLEN != E_SYMNMLEN
498 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
500 memcpy(ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
503 bfd_h_put_32(abfd
, in
->n_value
, (bfd_byte
*) ext
->e_value
);
504 bfd_h_put_16(abfd
, in
->n_scnum
, (bfd_byte
*) ext
->e_scnum
);
505 if (sizeof(ext
->e_type
) == 2)
507 bfd_h_put_16(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
511 bfd_h_put_32(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
513 bfd_h_put_8(abfd
, in
->n_sclass
, ext
->e_sclass
);
514 bfd_h_put_8(abfd
, in
->n_numaux
, ext
->e_numaux
);
515 return sizeof(SYMENT
);
519 DEFUN(coff_swap_aux_in
,(abfd
, ext1
, type
, class, in1
),
526 AUXENT
*ext
= (AUXENT
*)ext1
;
527 union internal_auxent
*in
= (union internal_auxent
*)in1
;
531 if (ext
->x_file
.x_fname
[0] == 0) {
532 in
->x_file
.x_n
.x_zeroes
= 0;
533 in
->x_file
.x_n
.x_offset
=
534 bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
536 #if FILNMLEN != E_FILNMLEN
537 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
539 memcpy (in
->x_file
.x_fname
, ext
->x_file
.x_fname
, FILNMLEN
);
544 /* RS/6000 "csect" auxents */
548 in
->x_csect
.x_scnlen
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_scnlen
);
549 in
->x_csect
.x_parmhash
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_parmhash
);
550 in
->x_csect
.x_snhash
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snhash
);
551 /* We don't have to hack bitfields in x_smtyp because it's defined by
552 shifts-and-ands, which are equivalent on all byte orders. */
553 in
->x_csect
.x_smtyp
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smtyp
);
554 in
->x_csect
.x_smclas
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smclas
);
555 in
->x_csect
.x_stab
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_stab
);
556 in
->x_csect
.x_snstab
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snstab
);
565 if (type
== T_NULL
) {
566 in
->x_scn
.x_scnlen
= GET_SCN_SCNLEN(abfd
, ext
);
567 in
->x_scn
.x_nreloc
= GET_SCN_NRELOC(abfd
, ext
);
568 in
->x_scn
.x_nlinno
= GET_SCN_NLINNO(abfd
, ext
);
572 in
->x_sym
.x_tagndx
.l
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
574 in
->x_sym
.x_tvndx
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
577 if (ISARY(type
) || class == C_BLOCK
) {
578 #if DIMNUM != E_DIMNUM
579 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
581 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]);
582 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]);
583 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]);
584 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]);
587 in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= GET_FCN_LNNOPTR(abfd
, ext
);
588 in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= GET_FCN_ENDNDX(abfd
, ext
);
591 in
->x_sym
.x_misc
.x_fsize
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
594 in
->x_sym
.x_misc
.x_lnsz
.x_lnno
= GET_LNSZ_LNNO(abfd
, ext
);
595 in
->x_sym
.x_misc
.x_lnsz
.x_size
= GET_LNSZ_SIZE(abfd
, ext
);
601 DEFUN(coff_swap_aux_out
,(abfd
, inp
, type
, class, extp
),
608 union internal_auxent
*in
= (union internal_auxent
*)inp
;
609 AUXENT
*ext
= (AUXENT
*)extp
;
613 if (in
->x_file
.x_fname
[0] == 0) {
614 PUTWORD(abfd
, 0, (bfd_byte
*) ext
->x_file
.x_n
.x_zeroes
);
616 in
->x_file
.x_n
.x_offset
,
617 (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
620 #if FILNMLEN != E_FILNMLEN
621 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
623 memcpy (ext
->x_file
.x_fname
, in
->x_file
.x_fname
, FILNMLEN
);
629 /* RS/6000 "csect" auxents */
632 PUTWORD (abfd
, in
->x_csect
.x_scnlen
, ext
->x_csect
.x_scnlen
);
633 PUTWORD (abfd
, in
->x_csect
.x_parmhash
, ext
->x_csect
.x_parmhash
);
634 PUTHALF (abfd
, in
->x_csect
.x_snhash
, ext
->x_csect
.x_snhash
);
635 /* We don't have to hack bitfields in x_smtyp because it's defined by
636 shifts-and-ands, which are equivalent on all byte orders. */
637 PUTBYTE (abfd
, in
->x_csect
.x_smtyp
, ext
->x_csect
.x_smtyp
);
638 PUTBYTE (abfd
, in
->x_csect
.x_smclas
, ext
->x_csect
.x_smclas
);
639 PUTWORD (abfd
, in
->x_csect
.x_stab
, ext
->x_csect
.x_stab
);
640 PUTHALF (abfd
, in
->x_csect
.x_snstab
, ext
->x_csect
.x_snstab
);
649 if (type
== T_NULL
) {
650 PUT_SCN_SCNLEN(abfd
, in
->x_scn
.x_scnlen
, ext
);
651 PUT_SCN_NRELOC(abfd
, in
->x_scn
.x_nreloc
, ext
);
652 PUT_SCN_NLINNO(abfd
, in
->x_scn
.x_nlinno
, ext
);
656 PUTWORD(abfd
, in
->x_sym
.x_tagndx
.l
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
658 PUTWORD(abfd
, in
->x_sym
.x_tvndx
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
662 PUTWORD(abfd
, in
->x_sym
.x_misc
.x_fsize
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
663 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
664 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
668 if (ISARY(type
) || class == C_BLOCK
) {
669 #if DIMNUM != E_DIMNUM
670 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
672 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]);
673 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]);
674 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]);
675 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]);
678 PUT_LNSZ_LNNO(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
679 PUT_LNSZ_SIZE(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
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
);
687 return sizeof(AUXENT
);
690 #endif /* NO_COFF_SYMBOLS */
692 #ifndef NO_COFF_LINENOS
695 DEFUN(coff_swap_lineno_in
,(abfd
, ext1
, in1
),
700 LINENO
*ext
= (LINENO
*)ext1
;
701 struct internal_lineno
*in
= (struct internal_lineno
*)in1
;
703 in
->l_addr
.l_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->l_addr
.l_symndx
);
705 in
->l_lnno
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->l_lnno
);
707 in
->l_lnno
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->l_lnno
);
712 DEFUN(coff_swap_lineno_out
,(abfd
, inp
, outp
),
717 struct internal_lineno
*in
= (struct internal_lineno
*)inp
;
718 struct external_lineno
*ext
= (struct external_lineno
*)outp
;
719 PUTWORD(abfd
, in
->l_addr
.l_symndx
, (bfd_byte
*) ext
->l_addr
.l_symndx
);
721 PUTWORD(abfd
, in
->l_lnno
, (bfd_byte
*) ext
->l_lnno
);
723 PUTHALF(abfd
, in
->l_lnno
, (bfd_byte
*) ext
->l_lnno
);
725 return sizeof(struct external_lineno
);
728 #endif /* NO_COFF_LINENOS */
732 DEFUN(bfd_swap_aouthdr_in
,(abfd
, aouthdr_ext1
, aouthdr_int1
),
737 AOUTHDR
*aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
738 struct internal_aouthdr
*aouthdr_int
= (struct internal_aouthdr
*)aouthdr_int1
;
740 aouthdr_int
->magic
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->magic
);
741 aouthdr_int
->vstamp
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->vstamp
);
742 aouthdr_int
->tsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tsize
);
743 aouthdr_int
->dsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->dsize
);
744 aouthdr_int
->bsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->bsize
);
745 aouthdr_int
->entry
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->entry
);
746 aouthdr_int
->text_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->text_start
);
747 aouthdr_int
->data_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->data_start
);
749 aouthdr_int
->tagentries
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tagentries
);
753 aouthdr_int
->o_toc
= bfd_h_get_32(abfd
, aouthdr_ext
->o_toc
);
754 aouthdr_int
->o_snentry
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snentry
);
755 aouthdr_int
->o_sntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntext
);
756 aouthdr_int
->o_sndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sndata
);
757 aouthdr_int
->o_sntoc
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntoc
);
758 aouthdr_int
->o_snloader
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snloader
);
759 aouthdr_int
->o_snbss
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snbss
);
760 aouthdr_int
->o_algntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algntext
);
761 aouthdr_int
->o_algndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algndata
);
762 aouthdr_int
->o_modtype
= bfd_h_get_16(abfd
, aouthdr_ext
->o_modtype
);
763 aouthdr_int
->o_maxstack
= bfd_h_get_32(abfd
, aouthdr_ext
->o_maxstack
);
768 DEFUN(coff_swap_aouthdr_out
,(abfd
, in
, out
),
773 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*)in
;
774 AOUTHDR
*aouthdr_out
= (AOUTHDR
*)out
;
775 bfd_h_put_16(abfd
, aouthdr_in
->magic
, (bfd_byte
*) aouthdr_out
->magic
);
776 bfd_h_put_16(abfd
, aouthdr_in
->vstamp
, (bfd_byte
*) aouthdr_out
->vstamp
);
777 bfd_h_put_32(abfd
, aouthdr_in
->tsize
, (bfd_byte
*) aouthdr_out
->tsize
);
778 bfd_h_put_32(abfd
, aouthdr_in
->dsize
, (bfd_byte
*) aouthdr_out
->dsize
);
779 bfd_h_put_32(abfd
, aouthdr_in
->bsize
, (bfd_byte
*) aouthdr_out
->bsize
);
780 bfd_h_put_32(abfd
, aouthdr_in
->entry
, (bfd_byte
*) aouthdr_out
->entry
);
781 bfd_h_put_32(abfd
, aouthdr_in
->text_start
,
782 (bfd_byte
*) aouthdr_out
->text_start
);
783 bfd_h_put_32(abfd
, aouthdr_in
->data_start
, (bfd_byte
*) aouthdr_out
->data_start
);
785 bfd_h_put_32(abfd
, aouthdr_in
->tagentries
, (bfd_byte
*) aouthdr_out
->tagentries
);
787 return sizeof(AOUTHDR
);
791 DEFUN(coff_swap_scnhdr_in
,(abfd
, scnhdr_ext
, scnhdr_int
),
793 SCNHDR
*scnhdr_ext AND
794 struct internal_scnhdr
*scnhdr_int
)
796 memcpy(scnhdr_int
->s_name
, scnhdr_ext
->s_name
, sizeof(scnhdr_int
->s_name
));
797 scnhdr_int
->s_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
798 scnhdr_int
->s_paddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
799 scnhdr_int
->s_size
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_size
);
800 scnhdr_int
->s_scnptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
801 scnhdr_int
->s_relptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
802 scnhdr_int
->s_lnnoptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
803 scnhdr_int
->s_flags
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_flags
);
805 scnhdr_int
->s_nreloc
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
806 scnhdr_int
->s_nlnno
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
808 scnhdr_int
->s_nreloc
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
809 scnhdr_int
->s_nlnno
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
812 scnhdr_int
->s_align
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_align
);
817 DEFUN(coff_swap_scnhdr_out
,(abfd
, in
, out
),
822 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*)in
;
823 SCNHDR
*scnhdr_ext
= (SCNHDR
*)out
;
824 memcpy(scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof(scnhdr_int
->s_name
));
825 PUTWORD(abfd
, scnhdr_int
->s_vaddr
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
826 PUTWORD(abfd
, scnhdr_int
->s_paddr
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
827 PUTWORD(abfd
, scnhdr_int
->s_size
, (bfd_byte
*) scnhdr_ext
->s_size
);
828 PUTWORD(abfd
, scnhdr_int
->s_scnptr
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
829 PUTWORD(abfd
, scnhdr_int
->s_relptr
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
830 PUTWORD(abfd
, scnhdr_int
->s_lnnoptr
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
831 PUTWORD(abfd
, scnhdr_int
->s_flags
, (bfd_byte
*) scnhdr_ext
->s_flags
);
833 PUTWORD(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
834 PUTWORD(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
836 PUTHALF(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
837 PUTHALF(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
841 PUTWORD(abfd
, scnhdr_int
->s_align
, (bfd_byte
*) scnhdr_ext
->s_align
);
843 return sizeof(SCNHDR
);
848 initialize a section structure with information peculiar to this
849 particular implementation of coff
853 DEFUN(coff_new_section_hook
,(abfd_ignore
, section_ignore
),
855 asection
*section_ignore
)
857 section_ignore
->alignment_power
= abfd_ignore
->xvec
->align_power_min
;
861 /* Take a section header read from a coff file (in HOST byte order),
862 and make a BFD "section" out of it. */
864 DEFUN(make_a_section_from_file
,(abfd
, hdr
),
866 struct internal_scnhdr
*hdr
)
868 asection
*return_section
;
871 /* Assorted wastage to null-terminate the name, thanks AT&T! */
872 char *name
= bfd_alloc(abfd
, sizeof (hdr
->s_name
)+1);
874 bfd_error
= no_memory
;
877 strncpy(name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
878 name
[sizeof (hdr
->s_name
)] = 0;
880 return_section
= bfd_make_section(abfd
, name
);
881 if (return_section
== NULL
)
885 /* s_paddr is presumed to be = to s_vaddr */
886 #define assign(to, from) return_section->to = hdr->from
887 assign(vma
, s_vaddr
);
888 /* assign (vma, s_vaddr); */
889 assign(size
, s_size
);
890 assign(filepos
, s_scnptr
);
891 assign(rel_filepos
, s_relptr
);
892 assign(reloc_count
, s_nreloc
);
895 /* FIXME, use a temp var rather than alignment_power */
896 assign(alignment_power
, s_align
);
899 for (i
= 0; i
< 32; i
++) {
900 if ((1 << i
) >= (int) (return_section
->alignment_power
)) {
901 return_section
->alignment_power
= i
;
908 assign(line_filepos
, s_lnnoptr
);
910 return_section->linesize = hdr->s_nlnno * sizeof (struct lineno);
913 return_section
->lineno_count
= hdr
->s_nlnno
;
914 return_section
->userdata
= NULL
;
915 return_section
->next
= (asection
*) NULL
;
916 return_section
->flags
= styp_to_sec_flags(hdr
->s_flags
);
919 if (hdr
->s_nreloc
!= 0)
920 return_section
->flags
|= SEC_RELOC
;
921 /* FIXME: should this check 'hdr->s_size > 0' */
922 if (hdr
->s_scnptr
!= 0)
923 return_section
->flags
|= SEC_HAS_CONTENTS
;
927 DEFUN(coff_mkobject
,(abfd
),
930 set_tdata (abfd
, bfd_zalloc (abfd
,sizeof(coff_data_type
)));
931 if (coff_data(abfd
) == 0) {
932 bfd_error
= no_memory
;
935 coff_data(abfd
)->relocbase
= 0;
941 DEFUN(coff_real_object_p
,(abfd
, nscns
, internal_f
, internal_a
),
944 struct internal_filehdr
*internal_f AND
945 struct internal_aouthdr
*internal_a
)
947 coff_data_type
*coff
;
948 enum bfd_architecture arch
;
950 size_t readsize
; /* length of file_info */
951 SCNHDR
*external_sections
;
953 /* Build a play area */
954 if (coff_mkobject(abfd
) != true)
956 coff
= coff_data(abfd
);
959 external_sections
= (SCNHDR
*)bfd_alloc(abfd
, readsize
= (nscns
* SCNHSZ
));
961 if (bfd_read((PTR
)external_sections
, 1, readsize
, abfd
) != readsize
) {
966 /* Now copy data as required; construct all asections etc */
967 coff
->symbol_index_slew
= 0;
969 coff
->raw_syment_count
= 0;
970 coff
->raw_linenos
= 0;
971 coff
->raw_syments
= 0;
972 coff
->sym_filepos
=0;
973 coff
->flags
= internal_f
->f_flags
;
976 for (i
= 0; i
< nscns
; i
++) {
977 struct internal_scnhdr tmp
;
978 coff_swap_scnhdr_in(abfd
, external_sections
+ i
, &tmp
);
979 make_a_section_from_file(abfd
,&tmp
);
982 /* Determine the machine architecture and type. */
984 switch (internal_f
->f_magic
) {
987 arch
= bfd_arch_i386
;
992 #ifdef A29K_MAGIC_BIG
994 case A29K_MAGIC_LITTLE
:
995 arch
= bfd_arch_a29k
;
1004 arch
= bfd_arch_mips
;
1012 arch
= bfd_arch_m68k
;
1020 arch
= bfd_arch_m88k
;
1028 arch
= bfd_arch_i960
;
1029 switch (F_I960TYPE
& internal_f
->f_flags
)
1033 machine
= bfd_mach_i960_core
;
1036 machine
= bfd_mach_i960_kb_sb
;
1039 machine
= bfd_mach_i960_mc
;
1042 machine
= bfd_mach_i960_xa
;
1045 machine
= bfd_mach_i960_ca
;
1048 machine
= bfd_mach_i960_ka_sa
;
1059 arch
= bfd_arch_rs6000
;
1065 default: /* Unreadable input file type */
1066 arch
= bfd_arch_obscure
;
1070 bfd_default_set_arch_mach(abfd
, arch
, machine
);
1071 if (!(internal_f
->f_flags
& F_RELFLG
))
1072 abfd
->flags
|= HAS_RELOC
;
1073 if ((internal_f
->f_flags
& F_EXEC
))
1074 abfd
->flags
|= EXEC_P
;
1075 if (!(internal_f
->f_flags
& F_LNNO
))
1076 abfd
->flags
|= HAS_LINENO
;
1077 if (!(internal_f
->f_flags
& F_LSYMS
))
1078 abfd
->flags
|= HAS_LOCALS
;
1081 bfd_get_symcount(abfd
) = internal_f
->f_nsyms
;
1082 if (internal_f
->f_nsyms
)
1083 abfd
->flags
|= HAS_SYMS
;
1085 coff
->sym_filepos
= internal_f
->f_symptr
;
1087 /* These members communicate important constants about the symbol table
1088 to GDB's symbol-reading code. These `constants' unfortunately vary
1089 from coff implementation to implementation... */
1090 #ifndef NO_COFF_SYMBOLS
1091 coff
->local_n_btmask
= N_BTMASK
;
1092 coff
->local_n_btshft
= N_BTSHFT
;
1093 coff
->local_n_tmask
= N_TMASK
;
1094 coff
->local_n_tshift
= N_TSHIFT
;
1095 coff
->local_symesz
= SYMESZ
;
1096 coff
->local_auxesz
= AUXESZ
;
1097 coff
->local_linesz
= LINESZ
;
1100 coff
->symbols
= (coff_symbol_type
*) NULL
;
1101 bfd_get_start_address(abfd
) = internal_f
->f_opthdr
? internal_a
->entry
: 0;
1105 bfd_release(abfd
, coff
);
1106 return (bfd_target
*)NULL
;
1110 DEFUN(coff_object_p
,(abfd
),
1116 struct internal_filehdr internal_f
;
1117 struct internal_aouthdr internal_a
;
1119 bfd_error
= system_call_error
;
1121 /* figure out how much to read */
1122 if (bfd_read((PTR
) &filehdr
, 1, FILHSZ
, abfd
) != FILHSZ
)
1125 bfd_swap_filehdr_in(abfd
, &filehdr
, &internal_f
);
1127 if (BADMAG(internal_f
)) {
1128 bfd_error
= wrong_format
;
1131 nscns
=internal_f
.f_nscns
;
1133 if (internal_f
.f_opthdr
) {
1134 if (bfd_read((PTR
) &opthdr
, 1,AOUTSZ
, abfd
) != AOUTSZ
) {
1137 bfd_swap_aouthdr_in(abfd
, (char *)&opthdr
, (char *)&internal_a
);
1140 /* Seek past the opt hdr stuff */
1141 bfd_seek(abfd
, internal_f
.f_opthdr
+ FILHSZ
, SEEK_SET
);
1143 /* if the optional header is NULL or not the correct size then
1144 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1145 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1146 optional header is of a different size.
1148 But the mips keeps extra stuff in it's opthdr, so dont check
1152 #if defined(M88) || defined(I960)
1153 if (internal_f
.f_opthdr
!= 0 && AOUTSZ
!= internal_f
.f_opthdr
)
1154 return (bfd_target
*)NULL
;
1157 return coff_real_object_p(abfd
, nscns
, &internal_f
, &internal_a
);
1162 #ifndef NO_COFF_LINENOS
1165 DEFUN(coff_count_linenumbers
,(abfd
),
1168 unsigned int limit
= bfd_get_symcount(abfd
);
1172 asection
*s
= abfd
->sections
->output_section
;
1174 BFD_ASSERT(s
->lineno_count
== 0);
1180 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++) {
1181 asymbol
*q_maybe
= *p
;
1182 if (q_maybe
->the_bfd
->xvec
->flavour
== bfd_target_coff_flavour
) {
1183 coff_symbol_type
*q
= coffsymbol(q_maybe
);
1186 This symbol has a linenumber, increment the owning
1187 section's linenumber count
1189 alent
*l
= q
->lineno
;
1190 q
->symbol
.section
->output_section
->lineno_count
++;
1192 while (l
->line_number
) {
1193 q
->symbol
.section
->output_section
->lineno_count
++;
1201 #endif /* NO_COFF_LINENOS */
1203 #ifndef NO_COFF_SYMBOLS
1206 Takes a bfd and a symbol, returns a pointer to the coff specific area
1207 of the symbol if there is one.
1209 static coff_symbol_type
*
1210 DEFUN(coff_symbol_from
,(ignore_abfd
, symbol
),
1211 bfd
*ignore_abfd AND
1214 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
1215 return (coff_symbol_type
*)NULL
;
1217 if (symbol
->the_bfd
->tdata
== (PTR
)NULL
)
1218 return (coff_symbol_type
*)NULL
;
1220 return (coff_symbol_type
*) symbol
;
1226 DEFUN(fixup_symbol_value
,(coff_symbol_ptr
, syment
),
1227 coff_symbol_type
*coff_symbol_ptr AND
1228 struct internal_syment
*syment
)
1231 /* Normalize the symbol flags */
1232 if (coff_symbol_ptr
->symbol
.flags
& BSF_FORT_COMM
) {
1233 /* a common symbol is undefined with a value */
1234 syment
->n_scnum
= N_UNDEF
;
1235 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1237 else if (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) {
1238 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1240 else if (coff_symbol_ptr
->symbol
.flags
& BSF_UNDEFINED
) {
1241 syment
->n_scnum
= N_UNDEF
;
1242 syment
->n_value
= 0;
1244 else if (coff_symbol_ptr
->symbol
.flags
& BSF_ABSOLUTE
) {
1245 syment
->n_scnum
= N_ABS
;
1246 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1249 if (coff_symbol_ptr
->symbol
.section
) {
1251 coff_symbol_ptr
->symbol
.section
->output_section
->index
+1;
1254 coff_symbol_ptr
->symbol
.value
+
1255 coff_symbol_ptr
->symbol
.section
->output_offset
+
1256 coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
1259 /* This can happen, but I don't know why yet (steve@cygnus.com) */
1260 syment
->n_scnum
= N_ABS
;
1261 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1266 /* run through all the symbols in the symbol table and work out what
1267 their indexes into the symbol table will be when output
1269 Coff requires that each C_FILE symbol points to the next one in the
1270 chain, and that the last one points to the first external symbol. We
1275 DEFUN(coff_renumber_symbols
,(bfd_ptr
),
1278 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1279 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1280 unsigned int native_index
= 0;
1281 struct internal_syment
*last_file
= (struct internal_syment
*)NULL
;
1282 unsigned int symbol_index
;
1283 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1285 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1286 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1287 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1290 if (s
->u
.syment
.n_sclass
== C_FILE
)
1292 if (last_file
!= (struct internal_syment
*)NULL
) {
1293 last_file
->n_value
= native_index
;
1295 last_file
= &(s
->u
.syment
);
1299 /* Modify the symbol values according to their section and
1302 fixup_symbol_value(coff_symbol_ptr
, &(s
->u
.syment
));
1304 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++) {
1305 s
[i
].offset
= native_index
++;
1316 Run thorough the symbol table again, and fix it so that all pointers to
1317 entries are changed to the entries' index in the output symbol table.
1321 DEFUN(coff_mangle_symbols
,(bfd_ptr
),
1324 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1325 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1326 unsigned int symbol_index
;
1328 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1330 coff_symbol_type
*coff_symbol_ptr
=
1331 coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1333 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1335 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1337 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++) {
1338 combined_entry_type
*a
= s
+ i
+ 1;
1340 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
1341 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
1344 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
1345 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
1354 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1355 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1356 struct internal_syment
*last_tagndx
= (struct internal_syment
*)NULL
;
1357 struct internal_syment
*last_file
= (struct internal_syment
*)NULL
;
1358 struct internal_syment
*last_fcn
= (struct internal_syment
*)NULL
;
1359 struct internal_syment
*block_stack
[50];
1360 struct internal_syment
**last_block
= &block_stack
[0];
1361 boolean first_time
= true;
1362 unsigned int symbol_index
;
1363 unsigned int native_index
= 0;
1365 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++) {
1366 coff_symbol_type
*coff_symbol_ptr
=
1367 coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1368 if (coff_symbol_ptr
== (coff_symbol_type
*)NULL
) {
1370 This symbol has no coff information in it, it will take up
1371 only one slot in the output symbol table
1376 struct internal_syment
*syment
= coff_symbol_ptr
->native
;
1377 if (syment
== (struct internal_syment
*)NULL
) {
1381 /* Normalize the symbol flags */
1382 if (coff_symbol_ptr
->symbol
.flags
& BSF_FORT_COMM
) {
1383 /* a common symbol is undefined with a value */
1384 syment
->n_scnum
= N_UNDEF
;
1385 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1387 else if (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) {
1388 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1390 else if (coff_symbol_ptr
->symbol
.flags
& BSF_UNDEFINED
) {
1391 syment
->n_scnum
= N_UNDEF
;
1392 syment
->n_value
= 0;
1394 else if (coff_symbol_ptr
->symbol
.flags
& BSF_ABSOLUTE
) {
1395 syment
->n_scnum
= N_ABS
;
1396 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1400 coff_symbol_ptr
->symbol
.section
->output_section
->index
+1;
1403 coff_symbol_ptr
->symbol
.value
+
1404 coff_symbol_ptr
->symbol
.section
->output_offset
+
1405 coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
1408 /* If this symbol ties up something then do it */
1410 if (syment
->n_sclass
== C_FILE
&& last_file
!= (struct internal_syment
*)NULL
)
1412 last_file
->n_value
= native_index
;
1414 else if ((syment
->n_sclass
== C_EXT
/* FIXME - may need C_HIDEXT */
1415 || syment
->n_sclass
== C_STAT
1417 || syment
->n_sclass
== C_LEAFEXT
1418 || syment
->n_sclass
== C_LEAFSTAT
1421 && last_fcn
!= (struct internal_syment
*)NULL
)
1423 union internal_auxent
*auxent
= (union internal_auxent
*)(last_fcn
+1);
1424 auxent
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= native_index
;
1425 last_fcn
= (struct internal_syment
*)NULL
;
1427 else if (syment
->n_sclass
== C_EOS
&& last_tagndx
!= (struct internal_syment
*)NULL
)
1429 union internal_auxent
*auxent
= (union internal_auxent
*)(last_tagndx
+1);
1430 /* Remember that we keep the native index in the offset
1431 so patch the beginning of the struct to point to this
1434 auxent->x_sym.x_tagndx = last_tagndx->_n._n_n._n_offset;*/
1435 auxent
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= syment
->n_numaux
+ 1 + native_index
;
1436 /* Now point the eos to the structure */
1437 auxent
= (union internal_auxent
*)(syment
+1);
1438 auxent
->x_sym
.x_tagndx
.l
= last_tagndx
->_n
._n_n
._n_offset
;
1440 else if (syment
->n_sclass
== C_BLOCK
1441 && coff_symbol_ptr
->symbol
.name
[1] == 'e')
1443 union internal_auxent
*auxent
= (union internal_auxent
*)((*(--last_block
))+1);
1444 auxent
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= native_index
+ syment
->n_numaux
+ 1;
1446 if (syment
->n_sclass
== C_EXT
1447 && !ISFCN(syment
->n_type
)
1448 && first_time
== true
1449 && last_file
!= (struct internal_syment
*)NULL
) {
1450 /* This is the first external symbol seen which isn't a
1451 function place it in the last .file entry */
1452 last_file
->n_value
= native_index
;
1456 if (syment
->n_sclass
== C_LEAFPROC
&&
1457 syment
->n_numaux
== 2) {
1458 union internal_auxent
*auxent
= (union internal_auxent
*)(syment
+2);
1459 /* This is the definition of a leaf proc, we'll relocate the
1461 auxent
->x_bal
.x_balntry
=
1462 coff_symbol_ptr
->symbol
.section
->output_offset
+
1463 coff_symbol_ptr
->symbol
.section
->output_section
->vma
+
1464 auxent
->x_bal
.x_balntry
;
1467 /* If this symbol needs to be tied up then remember some facts */
1468 if (syment
->n_sclass
== C_FILE
)
1472 if (syment
->n_numaux
!= 0) {
1474 If this symbol would like to point to something in the
1475 future then remember where it is
1477 if (uses_x_sym_x_tagndx_p(bfd_ptr
, syment
)) {
1479 If this is a ref to a structure then we'll tie it up
1480 now - there are never any forward refs for one
1482 if (syment
->n_sclass
== C_STRTAG
||
1483 syment
->n_sclass
== C_ENTAG
||
1484 syment
->n_sclass
== C_UNTAG
) {
1485 last_tagndx
= syment
;
1489 This is a ref to a structure - the structure must
1490 have been defined within the same file, and previous
1491 to this point, so we can deduce the new tagndx
1494 union internal_auxent
*auxent
= (union internal_auxent
*)(syment
+1);
1495 bfd
*bfd_ptr
= coff_symbol_ptr
->symbol
.the_bfd
;
1496 struct internal_syment
*base
= obj_raw_syments(bfd_ptr
);
1497 /* auxent->x_sym.x_tagndx = base[auxent->x_sym.x_tagndx]._n._n_n._n_offset;*/
1500 if (ISFCN(syment
->n_type
)) {
1503 if (syment
->n_sclass
== C_BLOCK
1504 && coff_symbol_ptr
->symbol
.name
[1] == 'b')
1506 *last_block
++ = syment
;
1509 syment
->_n
._n_n
._n_offset
= native_index
;
1510 native_index
= native_index
+ 1 + syment
->n_numaux
;
1518 static int string_size
;
1520 DEFUN(coff_fix_symbol_name
,(ignore_abfd
, symbol
, native
),
1521 bfd
*ignore_abfd AND
1523 combined_entry_type
*native
)
1525 unsigned int name_length
;
1526 union internal_auxent
*auxent
;
1527 char * name
= ( char *)(symbol
->name
);
1529 if (name
== (char *) NULL
) {
1530 /* coff symbols always have names, so we'll make one up */
1531 symbol
->name
= "strange";
1532 name
= (char *)symbol
->name
;
1534 name_length
= strlen(name
);
1536 if (native
->u
.syment
.n_sclass
== C_FILE
) {
1537 strncpy(native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
1538 auxent
= &(native
+1)->u
.auxent
;
1540 #ifdef COFF_LONG_FILENAMES
1541 if (name_length
<= FILNMLEN
) {
1542 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1545 auxent
->x_file
.x_n
.x_offset
= string_size
+ 4;
1546 auxent
->x_file
.x_n
.x_zeroes
= 0;
1547 string_size
+= name_length
+ 1;
1550 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1551 if (name_length
> FILNMLEN
) {
1552 name
[FILNMLEN
] = '\0';
1557 { /* NOT A C_FILE SYMBOL */
1558 if (name_length
<= SYMNMLEN
) {
1559 /* This name will fit into the symbol neatly */
1560 strncpy(native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
1563 native
->u
.syment
._n
._n_n
._n_offset
= string_size
+ 4;
1564 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1565 string_size
+= name_length
+ 1;
1573 DEFUN(coff_write_symbol
,(abfd
, symbol
, native
, written
),
1576 combined_entry_type
*native AND
1577 unsigned int written
)
1579 unsigned int numaux
= native
->u
.syment
.n_numaux
;
1580 int type
= native
->u
.syment
.n_type
;
1581 int class = native
->u
.syment
.n_sclass
;
1585 coff_fix_symbol_name(abfd
, symbol
, native
);
1586 coff_swap_sym_out(abfd
, &native
->u
.syment
, &buf
);
1587 bfd_write((PTR
)& buf
, 1, SYMESZ
, abfd
);
1588 for (j
= 0; j
!= native
->u
.syment
.n_numaux
; j
++)
1591 bzero((PTR
)&buf
, AUXESZ
);
1592 coff_swap_aux_out(abfd
,
1593 &( (native
+ j
+ 1)->u
.auxent
), type
, class, &buf1
);
1594 bfd_write((PTR
) (&buf1
), 1, AUXESZ
, abfd
);
1597 Reuse somewhere in the symbol to keep the index
1599 set_index(symbol
, written
);
1600 return written
+ 1 + numaux
;
1605 DEFUN(coff_write_alien_symbol
,(abfd
, symbol
, written
),
1608 unsigned int written
)
1611 This symbol has been created by the loader, or come from a non
1612 coff format. It has no native element to inherit, make our
1615 combined_entry_type
*native
;
1616 combined_entry_type dummy
;
1618 native
->u
.syment
.n_type
= T_NULL
;
1620 native
->u
.syment
.n_flags
= 0;
1622 if (symbol
->flags
& BSF_ABSOLUTE
) {
1623 native
->u
.syment
.n_scnum
= N_ABS
;
1624 native
->u
.syment
.n_value
= symbol
->value
;
1626 else if (symbol
->flags
& (BSF_UNDEFINED
| BSF_FORT_COMM
)) {
1627 native
->u
.syment
.n_scnum
= N_UNDEF
;
1628 native
->u
.syment
.n_value
= symbol
->value
;
1630 else if (symbol
->flags
& BSF_DEBUGGING
) {
1632 remove name so it doesn't take up any space
1637 native
->u
.syment
.n_scnum
= symbol
->section
->output_section
->index
+
1639 native
->u
.syment
.n_value
= symbol
->value
+
1640 symbol
->section
->output_section
->vma
+
1641 symbol
->section
->output_offset
;
1643 /* Copy the any flags from the the file hdr into the symbol */
1645 coff_symbol_type
*c
= coff_symbol_from(abfd
, symbol
);
1646 if (c
!= (coff_symbol_type
*)NULL
) {
1647 native
->u
.syment
.n_flags
= c
->symbol
.the_bfd
->flags
;
1654 native
->u
.syment
.pad1
[0] = 0;
1655 native
->u
.syment
.pad1
[0] = 0;
1658 native
->u
.syment
.n_type
= 0;
1659 if (symbol
->flags
& BSF_LOCAL
)
1660 native
->u
.syment
.n_sclass
= C_STAT
;
1662 native
->u
.syment
.n_sclass
= C_EXT
;
1663 native
->u
.syment
.n_numaux
= 0;
1665 return coff_write_symbol(abfd
, symbol
, native
, written
);
1669 DEFUN(coff_write_native_symbol
,(abfd
, symbol
, written
),
1671 coff_symbol_type
*symbol AND
1672 unsigned int written
)
1675 Does this symbol have an ascociated line number - if so then
1676 make it remember this symbol index. Also tag the auxent of
1677 this symbol to point to the right place in the lineno table
1679 combined_entry_type
*native
= symbol
->native
;
1681 alent
*lineno
= symbol
->lineno
;
1684 unsigned int count
= 0;
1685 lineno
[count
].u
.offset
= written
;
1686 if (native
->u
.syment
.n_numaux
) {
1687 union internal_auxent
*a
= &((native
+1)->u
.auxent
);
1689 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1690 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1693 And count and relocate all other linenumbers
1696 while (lineno
[count
].line_number
) {
1697 lineno
[count
].u
.offset
+=
1698 symbol
->symbol
.section
->output_section
->vma
+
1699 symbol
->symbol
.section
->output_offset
;
1702 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1705 return coff_write_symbol(abfd
, &( symbol
->symbol
), native
,written
);
1709 DEFUN(coff_write_symbols
,(abfd
),
1713 unsigned int limit
= bfd_get_symcount(abfd
);
1714 unsigned int written
= 0;
1721 /* Seek to the right place */
1722 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
1724 /* Output all the symbols we have */
1727 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1729 asymbol
*symbol
= *p
;
1730 coff_symbol_type
*c_symbol
= coff_symbol_from(abfd
, symbol
);
1732 if (c_symbol
== (coff_symbol_type
*) NULL
||
1733 c_symbol
->native
== (combined_entry_type
*)NULL
)
1735 written
= coff_write_alien_symbol(abfd
, symbol
, written
);
1739 written
= coff_write_native_symbol(abfd
, c_symbol
, written
);
1744 bfd_get_symcount(abfd
) = written
;
1746 /* Now write out strings */
1748 if (string_size
!= 0)
1750 unsigned int size
= string_size
+ 4;
1753 bfd_h_put_32(abfd
, size
, buffer
);
1754 bfd_write((PTR
) buffer
, 1, sizeof(buffer
), abfd
);
1755 for (p
= abfd
->outsymbols
, i
= 0;
1760 size_t name_length
= strlen(q
->name
);
1762 coff_symbol_type
* c_symbol
= coff_symbol_from(abfd
, q
);
1763 maxlen
= ((c_symbol
!= NULL
&& c_symbol
->native
!= NULL
) &&
1764 (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
)) ?
1765 FILNMLEN
: SYMNMLEN
;
1767 if (name_length
> maxlen
) {
1768 bfd_write((PTR
) (q
->name
), 1, name_length
+ 1, abfd
);
1773 /* We would normally not write anything here, but we'll write
1774 out 4 so that any stupid coff reader which tries to read
1775 the string table even when there isn't one won't croak.
1778 uint32e_type size
= 4;
1780 bfd_write((PTR
)&size
, 1, sizeof(size
), abfd
);
1786 @subsubsection Writing Relocations
1787 To write a relocations, all the back end does is step though the
1788 canonical relocation table, and create an @code{internal_reloc}. The
1789 symbol index to use is removed from the @code{offset} field in the
1790 symbol table supplied, the address comes directly from the sum of the
1791 section base address and the relocation offset and the type is dug
1792 directly from the howto field.
1794 Then the @code{internal_reloc} is swapped into the shape of an
1795 @code{external_reloc} and written out to disk.
1799 DEFUN(coff_write_relocs
,(abfd
),
1803 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1805 struct external_reloc dst
;
1807 arelent
**p
= s
->orelocation
;
1808 bfd_seek(abfd
, s
->rel_filepos
, SEEK_SET
);
1809 for (i
= 0; i
< s
->reloc_count
; i
++) {
1810 struct internal_reloc n
;
1812 memset((PTR
)&n
, 0, sizeof(n
));
1813 n
.r_vaddr
= q
->address
+ s
->vma
;
1814 if (q
->sym_ptr_ptr
) {
1815 n
.r_symndx
= get_index((*(q
->sym_ptr_ptr
)));
1818 /* Work out reloc type from what is required */
1819 SELECT_RELOC(n
.r_type
, q
->howto
);
1821 n
.r_type
= q
->howto
->type
;
1823 coff_swap_reloc_out(abfd
, &n
, &dst
);
1824 bfd_write((PTR
) &n
, 1, RELSZ
, abfd
);
1828 #endif /* NO_COFF_SYMBOLS */
1830 #ifndef NO_COFF_LINENOS
1833 DEFUN(coff_write_linenumbers
,(abfd
),
1837 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1838 if (s
->lineno_count
) {
1839 asymbol
**q
= abfd
->outsymbols
;
1840 bfd_seek(abfd
, s
->line_filepos
, SEEK_SET
);
1841 /* Find all the linenumbers in this section */
1844 alent
*l
= BFD_SEND(p
->the_bfd
, _get_lineno
, (p
->the_bfd
, p
));
1846 /* Found a linenumber entry, output */
1847 struct internal_lineno out
;
1849 memset( (PTR
)&out
, 0, sizeof(out
));
1851 out
.l_addr
.l_symndx
= l
->u
.offset
;
1852 coff_swap_lineno_out(abfd
, &out
, &buff
);
1853 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1855 while (l
->line_number
) {
1856 out
.l_lnno
= l
->line_number
;
1857 out
.l_addr
.l_symndx
= l
->u
.offset
;
1858 coff_swap_lineno_out(abfd
, &out
, &buff
);
1859 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1870 DEFUN(coff_get_lineno
,(ignore_abfd
, symbol
),
1871 bfd
*ignore_abfd AND
1874 return coffsymbol(symbol
)->lineno
;
1877 #endif /* NO_COFF_LINENOS */
1880 coff_make_empty_symbol(abfd
)
1883 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc(abfd
, sizeof(coff_symbol_type
));
1885 bfd_error
= no_memory
;
1889 new->lineno
= (alent
*) NULL
;
1890 new->symbol
.the_bfd
= abfd
;
1891 return &new->symbol
;
1894 #ifndef NO_COFF_SYMBOLS
1897 DEFUN(coff_print_symbol
,(ignore_abfd
, filep
, symbol
, how
),
1898 bfd
*ignore_abfd AND
1901 bfd_print_symbol_type how
)
1903 FILE *file
= (FILE *)filep
;
1905 case bfd_print_symbol_name
:
1906 fprintf(file
, "%s", symbol
->name
);
1908 case bfd_print_symbol_more
:
1909 fprintf(file
, "coff %lx %lx", (unsigned long) coffsymbol(symbol
)->native
,
1910 (unsigned long) coffsymbol(symbol
)->lineno
);
1912 case bfd_print_symbol_all
:
1914 CONST
char *section_name
= symbol
->section
== (asection
*) NULL
?
1915 "*abs" : symbol
->section
->name
;
1916 bfd_print_symbol_vandf((PTR
) file
, symbol
);
1918 fprintf(file
, " %-5s %s %s %s",
1920 coffsymbol(symbol
)->native
? "n" : "g",
1921 coffsymbol(symbol
)->lineno
? "l" : " ",
1930 #endif /* NO_COFF_SYMBOLS */
1932 /* Set flags and magic number of a coff file from architecture and machine
1933 type. Result is true if we can represent the arch&type, false if not. */
1936 DEFUN(coff_set_flags
,(abfd
, magicp
, flagsp
),
1938 unsigned *magicp AND
1939 unsigned short *flagsp
)
1941 switch (bfd_get_arch(abfd
)) {
1949 *magicp
= I960ROMAGIC
;
1951 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1952 I960RWMAGIC); FIXME???
1954 switch (bfd_get_mach(abfd
)) {
1955 case bfd_mach_i960_core
:
1958 case bfd_mach_i960_kb_sb
:
1961 case bfd_mach_i960_mc
:
1964 case bfd_mach_i960_xa
:
1967 case bfd_mach_i960_ca
:
1970 case bfd_mach_i960_ka_sa
:
1983 *magicp
= MIPS_MAGIC_2
;
1989 *magicp
= I386MAGIC
;
1994 *magicp
= MC68MAGIC
;
2000 *magicp
= MC88OMAGIC
;
2005 #ifdef A29K_MAGIC_BIG
2007 if (abfd
->xvec
->byteorder_big_p
)
2008 *magicp
= A29K_MAGIC_BIG
;
2010 *magicp
= A29K_MAGIC_LITTLE
;
2016 case bfd_arch_rs6000
:
2017 *magicp
= U802TOCMAGIC
;
2021 default: /* Unknown architecture */
2022 /* return false; -- fall through to "return false" below, to avoid
2023 "statement never reached" errors on the one below. */
2032 DEFUN(coff_set_arch_mach
,(abfd
, arch
, machine
),
2034 enum bfd_architecture arch AND
2035 unsigned long machine
)
2038 unsigned short dummy2
;
2039 bfd_default_set_arch_mach(abfd
, arch
, machine
);
2041 if (arch
!= bfd_arch_unknown
&&
2042 coff_set_flags(abfd
, &dummy1
, &dummy2
) != true)
2043 return false; /* We can't represent this type */
2044 return true; /* We're easy ... */
2048 /* Calculate the file position for each section. */
2051 DEFUN(coff_compute_section_file_positions
,(abfd
),
2055 file_ptr sofar
= FILHSZ
;
2056 if (bfd_get_start_address(abfd
)) {
2058 A start address may have been added to the original file. In this
2059 case it will need an optional header to record it.
2061 abfd
->flags
|= EXEC_P
;
2063 if (abfd
->flags
& EXEC_P
)
2067 sofar
+= abfd
->section_count
* SCNHSZ
;
2068 for (current
= abfd
->sections
;
2069 current
!= (asection
*)NULL
;
2070 current
= current
->next
) {
2071 /* Only deal with sections which have contents */
2072 if (!(current
->flags
& SEC_HAS_CONTENTS
))
2075 /* Align the sections in the file to the same boundary on
2076 which they are aligned in virtual memory. I960 doesn't
2077 do this (FIXME) so we can stay in sync with Intel. 960
2078 doesn't yet page from files... */
2081 /* Whatever the alignment, make sure that the sections are big
2082 enough to cover the gap */
2083 bfd_vma old_sofar
= sofar
;
2084 sofar
= ALIGN(sofar
, 1 << current
->alignment_power
);
2085 current
->size
+= sofar
- old_sofar
;
2088 /* FIXME, in demand paged files, the low order bits of the file
2089 offset must match the low order bits of the virtual address.
2090 "Low order" is apparently implementation defined. Add code
2091 here to round sofar up to match the virtual address. */
2093 current
->filepos
= sofar
;
2094 sofar
+= current
->size
;
2096 obj_relocbase(abfd
) = sofar
;
2105 DEFUN(coff_write_object_contents
,(abfd
),
2109 boolean hasrelocs
= false;
2110 boolean haslinno
= false;
2111 file_ptr reloc_base
;
2112 file_ptr lineno_base
;
2116 unsigned long reloc_size
= 0;
2117 unsigned long lnno_size
= 0;
2118 asection
*text_sec
= NULL
;
2119 asection
*data_sec
= NULL
;
2120 asection
*bss_sec
= NULL
;
2122 struct internal_filehdr internal_f
;
2123 struct internal_aouthdr internal_a
;
2126 bfd_error
= system_call_error
;
2129 if(abfd
->output_has_begun
== false) {
2130 coff_compute_section_file_positions(abfd
);
2133 if (abfd
->sections
!= (asection
*)NULL
) {
2134 scn_base
= abfd
->sections
->filepos
;
2139 if (bfd_seek(abfd
, scn_base
, SEEK_SET
) != 0)
2141 reloc_base
= obj_relocbase(abfd
);
2143 /* Make a pass through the symbol table to count line number entries and
2144 put them into the correct asections */
2146 #ifndef NO_COFF_LINENOS
2147 coff_count_linenumbers(abfd
);
2149 data_base
= scn_base
;
2151 /* Work out the size of the reloc and linno areas */
2153 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
) {
2154 reloc_size
+= current
->reloc_count
* RELSZ
;
2155 #ifndef NO_COFF_LINENOS
2156 lnno_size
+= current
->lineno_count
* LINESZ
;
2158 data_base
+= SCNHSZ
;
2161 lineno_base
= reloc_base
+ reloc_size
;
2162 sym_base
= lineno_base
+ lnno_size
;
2164 /* Indicate in each section->line_filepos its actual file address */
2165 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
) {
2166 if (current
->lineno_count
) {
2167 current
->line_filepos
= lineno_base
;
2168 current
->moving_line_filepos
= lineno_base
;
2169 #ifndef NO_COFF_LINENOS
2170 lineno_base
+= current
->lineno_count
* LINESZ
;
2174 current
->line_filepos
= 0;
2176 if (current
->reloc_count
) {
2177 current
->rel_filepos
= reloc_base
;
2178 reloc_base
+= current
->reloc_count
* sizeof(struct internal_reloc
);
2181 current
->rel_filepos
= 0;
2185 /* Write section headers to the file. */
2188 (file_ptr
) ((abfd
->flags
& EXEC_P
) ?
2189 (FILHSZ
+ AOUTSZ
) : FILHSZ
),
2194 unsigned int pad
= abfd
->flags
& D_PAGED
? data_base
: 0;
2196 unsigned int pad
= 0;
2198 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
) {
2199 struct internal_scnhdr section
;
2200 strncpy(&(section
.s_name
[0]), current
->name
, 8);
2201 section
.s_vaddr
= current
->vma
+ pad
;
2202 section
.s_paddr
= current
->vma
+ pad
;
2203 section
.s_size
= current
->size
- pad
;
2205 If this section has no size or is unloadable then the scnptr
2208 if (current
->size
- pad
== 0 ||
2209 (current
->flags
& SEC_LOAD
) == 0) {
2210 section
.s_scnptr
= 0;
2213 section
.s_scnptr
= current
->filepos
;
2215 section
.s_relptr
= current
->rel_filepos
;
2216 section
.s_lnnoptr
= current
->line_filepos
;
2217 section
.s_nreloc
= current
->reloc_count
;
2218 section
.s_nlnno
= current
->lineno_count
;
2219 if (current
->reloc_count
!= 0)
2221 if (current
->lineno_count
!= 0)
2224 section
.s_flags
= sec_to_styp_flags(current
->name
,current
->flags
);
2226 if (!strcmp(current
->name
, _TEXT
)) {
2228 } else if (!strcmp(current
->name
, _DATA
)) {
2230 } else if (!strcmp(current
->name
, _BSS
)) {
2235 section
.s_align
= (current
->alignment_power
2236 ? 1 << current
->alignment_power
2243 coff_swap_scnhdr_out(abfd
, §ion
, &buff
);
2244 bfd_write((PTR
) (&buff
), 1, SCNHSZ
, abfd
);
2251 /* OK, now set up the filehdr... */
2252 internal_f
.f_nscns
= abfd
->section_count
;
2254 We will NOT put a fucking timestamp in the header here. Every time you
2255 put it back, I will come in and take it out again. I'm sorry. This
2256 field does not belong here. We fill it with a 0 so it compares the
2257 same but is not a reasonable time. -- gnu@cygnus.com
2260 Well, I like it, so I'm conditionally compiling it in.
2263 #ifdef COFF_TIMESTAMP
2264 internal_f
.f_timdat
= time(0);
2266 internal_f
.f_timdat
= 0;
2269 if (bfd_get_symcount(abfd
) != 0)
2270 internal_f
.f_symptr
= sym_base
;
2272 internal_f
.f_symptr
= 0;
2274 internal_f
.f_flags
= 0;
2276 if (abfd
->flags
& EXEC_P
)
2277 internal_f
.f_opthdr
= AOUTSZ
;
2279 internal_f
.f_opthdr
= 0;
2282 internal_f
.f_flags
|= F_RELFLG
;
2284 internal_f
.f_flags
|= F_LNNO
;
2285 if (0 == bfd_get_symcount(abfd
))
2286 internal_f
.f_flags
|= F_LSYMS
;
2287 if (abfd
->flags
& EXEC_P
)
2288 internal_f
.f_flags
|= F_EXEC
;
2290 internal_f
.f_flags
|= F_AR32W
;
2292 if (!abfd
->xvec
->byteorder_big_p
)
2293 internal_f
.f_flags
|= F_AR32WR
;
2296 FIXME, should do something about the other byte orders and
2300 /* Set up architecture-dependent stuff */
2302 { unsigned int magic
= 0;
2303 unsigned short flags
= 0;
2304 coff_set_flags(abfd
, &magic
, &flags
);
2305 internal_f
.f_magic
= magic
;
2306 internal_f
.f_flags
|= flags
;
2307 /* ...and the "opt"hdr... */
2310 # ifdef ULTRA3 /* NYU's machine */
2311 /* FIXME: This is a bogus check. I really want to see if there
2312 * is a .shbss or a .shdata section, if so then set the magic
2313 * number to indicate a shared data executable.
2315 if (internal_f
.f_nscns
>= 7)
2316 internal_a
.magic
= SHMAGIC
; /* Shared magic */
2318 # endif /* ULTRA3 */
2319 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
2320 #define __A_MAGIC_SET__
2323 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
2324 #define __A_MAGIC_SET__
2327 #define __A_MAGIC_SET__
2328 internal_a
.magic
= PAGEMAGICBCS
;
2331 #if M68 || I386 || MIPS
2332 #define __A_MAGIC_SET__
2333 /* Never was anything here for the 68k */
2337 #define __A_MAGIC_SET__
2338 internal_a
.magic
= (abfd
->flags
& D_PAGED
)? RS6K_AOUTHDR_ZMAGIC
:
2339 (abfd
->flags
& WP_TEXT
)? RS6K_AOUTHDR_NMAGIC
:
2340 RS6K_AOUTHDR_OMAGIC
;
2343 #ifndef __A_MAGIC_SET__
2344 # include "Your aouthdr magic number is not being set!"
2346 # undef __A_MAGIC_SET__
2349 /* Now should write relocs, strings, syms */
2350 obj_sym_filepos(abfd
) = sym_base
;
2352 #ifndef NO_COFF_SYMBOLS
2353 if (bfd_get_symcount(abfd
) != 0) {
2354 coff_renumber_symbols(abfd
);
2355 coff_mangle_symbols(abfd
);
2356 coff_write_symbols(abfd
);
2357 coff_write_linenumbers(abfd
);
2358 coff_write_relocs(abfd
);
2360 #endif /* NO_COFF_SYMBOLS */
2362 internal_a
.tsize
= text_sec
->size
;
2363 internal_a
.text_start
=text_sec
->size
? text_sec
->vma
: 0;
2366 internal_a
.dsize
= data_sec
->size
;
2367 internal_a
.data_start
= data_sec
->size
? data_sec
->vma
: 0;
2370 internal_a
.bsize
= bss_sec
->size
;
2373 internal_a
.entry
= bfd_get_start_address(abfd
);
2374 internal_f
.f_nsyms
= bfd_get_symcount(abfd
);
2376 /* now write them */
2377 if (bfd_seek(abfd
, 0L, SEEK_SET
) != 0)
2381 coff_swap_filehdr_out(abfd
, &internal_f
, &buff
);
2382 bfd_write((PTR
) &buff
, 1, FILHSZ
, abfd
);
2384 if (abfd
->flags
& EXEC_P
) {
2386 coff_swap_aouthdr_out(abfd
, &internal_a
, &buff
);
2387 bfd_write((PTR
) &buff
, 1, AOUTSZ
, abfd
);
2392 #ifndef NO_COFF_SYMBOLS
2395 this function transforms the offsets into the symbol table into
2396 pointers to syments.
2401 DEFUN(coff_pointerize_aux
,(ignore_abfd
, table_base
, type
, class, auxent
),
2402 bfd
*ignore_abfd AND
2403 combined_entry_type
*table_base AND
2406 combined_entry_type
*auxent
)
2408 /* Don't bother if this is a file or a section */
2409 if (class == C_STAT
&& type
== T_NULL
) return;
2410 if (class == C_FILE
) return;
2412 /* Otherwise patch up */
2413 if (ISFCN(type
) || ISTAG(class) || class == C_BLOCK
) {
2414 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
= table_base
+
2415 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2416 auxent
->fix_end
= 1;
2418 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
!= 0) {
2419 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
= table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
2420 auxent
->fix_tag
= 1;
2424 #endif /* NO_COFF_SYMBOLS */
2427 DEFUN(coff_set_section_contents
,(abfd
, section
, location
, offset
, count
),
2432 bfd_size_type count
)
2434 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
2435 coff_compute_section_file_positions(abfd
);
2437 bfd_seek(abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
);
2440 return (bfd_write(location
, 1, count
, abfd
) == count
) ? true : false;
2446 coff_close_and_cleanup(abfd
)
2449 if (!bfd_read_p(abfd
))
2450 switch (abfd
->format
) {
2452 if (!_bfd_write_archive_contents(abfd
))
2456 if (!coff_write_object_contents(abfd
))
2460 bfd_error
= invalid_operation
;
2464 /* We depend on bfd_close to free all the memory on the obstack. */
2465 /* FIXME if bfd_release is not using obstacks! */
2471 buy_and_read(abfd
, where
, seek_direction
, size
)
2477 PTR area
= (PTR
) bfd_alloc(abfd
, size
);
2479 bfd_error
= no_memory
;
2482 bfd_seek(abfd
, where
, seek_direction
);
2483 if (bfd_read(area
, 1, size
, abfd
) != size
) {
2484 bfd_error
= system_call_error
;
2488 } /* buy_and_read() */
2491 #ifndef NO_COFF_SYMBOLS
2494 DEFUN(build_string_table
,(abfd
),
2497 char string_table_size_buffer
[4];
2498 unsigned int string_table_size
;
2501 /* At this point we should be "seek"'d to the end of the
2502 symbols === the symbol table size. */
2503 if (bfd_read((char *) string_table_size_buffer
,
2504 sizeof(string_table_size_buffer
),
2505 1, abfd
) != sizeof(string_table_size
)) {
2506 bfd_error
= system_call_error
;
2510 string_table_size
= bfd_h_get_32(abfd
, (bfd_byte
*) string_table_size_buffer
);
2512 if ((string_table
= (PTR
) bfd_alloc(abfd
, string_table_size
-= 4)) == NULL
) {
2513 bfd_error
= no_memory
;
2515 } /* on mallocation error */
2516 if (bfd_read(string_table
, string_table_size
, 1, abfd
) != string_table_size
) {
2517 bfd_error
= system_call_error
;
2520 return string_table
;
2523 /* Allocate space for the ".debug" section, and read it.
2524 We did not read the debug section until now, because
2525 we didn't want to go to the trouble until someone needed it. */
2528 DEFUN(build_debug_section
,(abfd
),
2531 char *debug_section
;
2534 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
2537 bfd_error
= no_debug_section
;
2541 debug_section
= (PTR
) bfd_alloc (abfd
, bfd_section_size (abfd
, sect
));
2542 if (debug_section
== NULL
) {
2543 bfd_error
= no_memory
;
2547 /* Seek to the beginning of the `.debug' section and read it.
2548 Save the current position first; it is needed by our caller.
2549 Then read debug section and reset the file pointer. */
2551 position
= bfd_tell (abfd
);
2552 bfd_seek (abfd
, sect
->filepos
, SEEK_SET
);
2553 if (bfd_read (debug_section
, bfd_section_size (abfd
, sect
), 1, abfd
)
2554 != bfd_section_size (abfd
, sect
)) {
2555 bfd_error
= system_call_error
;
2558 bfd_seek (abfd
, position
, SEEK_SET
);
2559 return debug_section
;
2563 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
2564 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
2565 be \0-terminated. */
2567 DEFUN(copy_name
,(abfd
, name
, maxlen
),
2575 for (len
= 0; len
< maxlen
; ++len
) {
2576 if (name
[len
] == '\0') {
2581 if ((newname
= (PTR
) bfd_alloc(abfd
, len
+1)) == NULL
) {
2582 bfd_error
= no_memory
;
2585 strncpy(newname
, name
, len
);
2586 newname
[len
] = '\0';
2591 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
2592 knit the symbol names into a normalized form. By normalized here I
2593 mean that all symbols have an n_offset pointer that points to a null-
2594 terminated string. */
2596 #ifndef SYMNAME_IN_DEBUG
2597 #define SYMNAME_IN_DEBUG(x) 0
2600 static combined_entry_type
*
2601 DEFUN(get_normalized_symtab
,(abfd
),
2604 combined_entry_type
*internal
;
2605 combined_entry_type
*internal_ptr
;
2606 combined_entry_type
*internal_end
;
2610 char *string_table
= NULL
;
2611 char *debug_section
= NULL
;
2614 unsigned int raw_size
;
2615 if (obj_raw_syments(abfd
) != (combined_entry_type
*)NULL
) {
2616 return obj_raw_syments(abfd
);
2618 if ((size
= bfd_get_symcount(abfd
) * sizeof(combined_entry_type
)) == 0) {
2619 bfd_error
= no_symbols
;
2623 internal
= (combined_entry_type
*)bfd_alloc(abfd
, size
);
2624 internal_end
= internal
+ bfd_get_symcount(abfd
);
2626 raw_size
= bfd_get_symcount(abfd
) * SYMESZ
;
2627 raw
= (SYMENT
*)bfd_alloc(abfd
,raw_size
);
2629 if (bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
) == -1
2630 || bfd_read((PTR
)raw
, raw_size
, 1, abfd
) != raw_size
) {
2631 bfd_error
= system_call_error
;
2634 /* mark the end of the symbols */
2635 raw_end
= raw
+ bfd_get_symcount(abfd
);
2637 FIXME SOMEDAY. A string table size of zero is very weird, but
2638 probably possible. If one shows up, it will probably kill us.
2641 /* Swap all the raw entries */
2642 for (raw_src
= raw
, internal_ptr
= internal
;
2644 raw_src
++, internal_ptr
++) {
2647 coff_swap_sym_in(abfd
, (char *)raw_src
, (char *)&internal_ptr
->u
.syment
);
2648 internal_ptr
->fix_tag
= 0;
2649 internal_ptr
->fix_end
= 0;
2651 for (i
= internal_ptr
->u
.syment
.n_numaux
;
2653 --i
, raw_src
++, internal_ptr
++) {
2655 (internal_ptr
+1)->fix_tag
= 0;
2656 (internal_ptr
+1)->fix_end
= 0;
2658 coff_swap_aux_in(abfd
, (char *)(raw_src
+1),
2659 internal_ptr
->u
.syment
.n_type
,
2660 internal_ptr
->u
.syment
.n_sclass
,
2661 &(internal_ptr
+1)->u
.auxent
);
2663 coff_pointerize_aux(abfd
,
2665 internal_ptr
->u
.syment
.n_type
,
2666 internal_ptr
->u
.syment
.n_sclass
,
2671 /* Free all the raw stuff */
2672 bfd_release(abfd
, raw
);
2674 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
2677 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
) {
2678 /* make a file symbol point to the name in the auxent, since
2679 the text ".file" is redundant */
2680 if ((internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_zeroes
== 0) {
2681 /* the filename is a long one, point into the string table */
2682 if (string_table
== NULL
) {
2683 string_table
= build_string_table(abfd
);
2686 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
2687 (int) (string_table
- 4 +
2688 (internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_offset
);
2691 /* ordinary short filename, put into memory anyway */
2692 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2693 copy_name(abfd
, (internal_ptr
+1)->u
.auxent
.x_file
.x_fname
,
2698 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0) {
2699 /* This is a "short" name. Make it long. */
2700 unsigned long i
= 0;
2701 char *newstring
= NULL
;
2703 /* find the length of this string without walking into memory
2705 for (i
= 0; i
< 8; ++i
) {
2706 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0') {
2708 } /* if end of string */
2709 } /* possible lengths of this string. */
2711 if ((newstring
= (PTR
) bfd_alloc(abfd
, ++i
)) == NULL
) {
2712 bfd_error
= no_memory
;
2715 bzero(newstring
, i
);
2716 strncpy(newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
-1);
2717 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int) newstring
;
2718 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
2720 else if (!SYMNAME_IN_DEBUG(&internal_ptr
->u
.syment
)) {
2721 /* Long name already. Point symbol at the string in the table. */
2722 if (string_table
== NULL
) {
2723 string_table
= build_string_table(abfd
);
2725 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2726 (string_table
- 4 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
2729 /* Long name in debug section. Very similar. */
2730 if (debug_section
== NULL
) {
2731 debug_section
= build_debug_section(abfd
);
2733 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2734 (debug_section
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
2737 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
2740 obj_raw_syments(abfd
) = internal
;
2743 } /* get_normalized_symtab() */
2745 #endif /* NO_COFF_SYMBOLS */
2749 DEFUN(section_from_bfd_index
,(abfd
, index
),
2754 struct sec
*answer
= abfd
->sections
;
2756 answer
= answer
->next
;
2763 #ifndef NO_COFF_LINENOS
2766 @subsubsection Reading Linenumbers
2767 Createing the linenumber table is done by reading in the entire coff
2768 linenumber table, and creating another table for internal use.
2770 A coff line number table is structured so that each
2771 function is marked as having a line number of 0. Each line within the
2772 function is an offset from the first line in the function. The base of
2773 the line number information for the table is stored in the symbol
2774 associated with the function.
2776 The information is copied from the external to the internal table, and
2777 each symbol which marks a function is marked by pointing its...
2779 **How does this work ?**
2784 coff_slurp_line_table(abfd
, asect
)
2788 LINENO
*native_lineno
;
2789 alent
*lineno_cache
;
2791 BFD_ASSERT(asect
->lineno
== (alent
*) NULL
);
2793 native_lineno
= (LINENO
*) buy_and_read(abfd
,
2794 asect
->line_filepos
,
2797 asect
->lineno_count
));
2799 (alent
*) bfd_alloc(abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof(alent
)));
2800 if (lineno_cache
== NULL
) {
2801 bfd_error
= no_memory
;
2804 unsigned int counter
= 0;
2805 alent
*cache_ptr
= lineno_cache
;
2806 LINENO
*src
= native_lineno
;
2808 while (counter
< asect
->lineno_count
) {
2809 struct internal_lineno dst
;
2810 coff_swap_lineno_in(abfd
, src
, &dst
);
2811 cache_ptr
->line_number
= dst
.l_lnno
;
2813 if (cache_ptr
->line_number
== 0) {
2814 coff_symbol_type
*sym
=
2815 (coff_symbol_type
*) (dst
.l_addr
.l_symndx
2816 + obj_symbol_slew(abfd
)
2817 + obj_raw_syments(abfd
))->u
.syment
._n
._n_n
._n_zeroes
;
2818 cache_ptr
->u
.sym
= (asymbol
*) sym
;
2819 sym
->lineno
= cache_ptr
;
2822 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
2823 - bfd_section_vma(abfd
, asect
);
2824 } /* If no linenumber expect a symbol index */
2830 cache_ptr
->line_number
= 0;
2833 asect
->lineno
= lineno_cache
;
2834 /* FIXME, free native_lineno here, or use alloca or something. */
2836 } /* coff_slurp_line_table() */
2838 #endif /* NO_COFF_LINENOS */
2840 #ifndef NO_COFF_LINENOS
2843 DEFUN(coff_slurp_symbol_table
,(abfd
),
2846 combined_entry_type
*native_symbols
;
2847 coff_symbol_type
*cached_area
;
2848 unsigned int *table_ptr
;
2850 unsigned int number_of_symbols
= 0;
2851 if (obj_symbols(abfd
))
2853 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
2855 /* Read in the symbol table */
2856 if ((native_symbols
= get_normalized_symtab(abfd
)) == NULL
) {
2860 /* Allocate enough room for all the symbols in cached form */
2862 (coff_symbol_type
*)
2863 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(coff_symbol_type
)));
2865 if (cached_area
== NULL
) {
2866 bfd_error
= no_memory
;
2871 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(unsigned int)));
2873 if (table_ptr
== NULL
) {
2874 bfd_error
= no_memory
;
2877 coff_symbol_type
*dst
= cached_area
;
2878 unsigned int last_native_index
= bfd_get_symcount(abfd
);
2879 unsigned int this_index
= 0;
2880 while (this_index
< last_native_index
) {
2881 combined_entry_type
*src
= native_symbols
+ this_index
;
2882 table_ptr
[this_index
] = number_of_symbols
;
2883 dst
->symbol
.the_bfd
= abfd
;
2885 dst
->symbol
.name
= (char *)(src
->u
.syment
._n
._n_n
._n_offset
);
2887 We use the native name field to point to the cached field
2889 src
->u
.syment
._n
._n_n
._n_zeroes
= (int) dst
;
2890 dst
->symbol
.section
= section_from_bfd_index(abfd
,
2891 src
->u
.syment
.n_scnum
);
2892 switch (src
->u
.syment
.n_sclass
) {
2896 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
2897 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2898 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
2900 /* Fall through to next case */
2908 if ((src
->u
.syment
.n_scnum
) == 0) {
2909 if ((src
->u
.syment
.n_value
) == 0) {
2910 dst
->symbol
.flags
= BSF_UNDEFINED
;
2911 dst
->symbol
.value
= 0;
2914 dst
->symbol
.flags
= BSF_FORT_COMM
;
2915 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2920 Base the value as an index from the base of the
2923 if (dst
->symbol
.section
== (asection
*) NULL
) {
2924 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
| BSF_ABSOLUTE
;
2925 dst
->symbol
.value
= src
->u
.syment
.n_value
;
2928 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2929 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
2931 if (ISFCN((src
->u
.syment
.n_type
))) {
2933 A function ext does not go at the end of a file
2935 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
2940 case C_STAT
: /* static */
2942 case C_LEAFSTAT
: /* static leaf procedure */
2944 case C_LABEL
: /* label */
2945 if (src
->u
.syment
.n_scnum
== -2)
2946 dst
->symbol
.flags
= BSF_DEBUGGING
;
2948 dst
->symbol
.flags
= BSF_LOCAL
;
2950 Base the value as an index from the base of the section, if
2953 if (dst
->symbol
.section
)
2954 dst
->symbol
.value
= (src
->u
.syment
.n_value
) -
2955 dst
->symbol
.section
->vma
;
2957 dst
->symbol
.value
= (src
->u
.syment
.n_value
) ;
2960 case C_MOS
: /* member of structure */
2961 case C_EOS
: /* end of structure */
2962 #ifdef NOTDEF /* C_AUTOARG has the same value */
2964 case C_GLBLREG
: /* A29k-specific storage class */
2967 case C_REGPARM
: /* register parameter */
2968 case C_REG
: /* register variable */
2970 case C_AUTOARG
: /* 960-specific storage class */
2972 case C_TPDEF
: /* type definition */
2974 case C_AUTO
: /* automatic variable */
2975 case C_FIELD
: /* bit field */
2976 case C_ENTAG
: /* enumeration tag */
2977 case C_MOE
: /* member of enumeration */
2978 case C_MOU
: /* member of union */
2979 case C_UNTAG
: /* union tag */
2980 dst
->symbol
.flags
= BSF_DEBUGGING
;
2981 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2984 case C_FILE
: /* file name */
2985 case C_STRTAG
: /* structure tag */
2987 case C_BINCL
: /* beginning of include file */
2988 case C_EINCL
: /* ending of include file */
3001 dst
->symbol
.flags
= BSF_DEBUGGING
;
3002 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3005 case C_BLOCK
: /* ".bb" or ".eb" */
3006 case C_FCN
: /* ".bf" or ".ef" */
3007 case C_EFCN
: /* physical end of function */
3008 dst
->symbol
.flags
= BSF_LOCAL
;
3010 Base the value as an index from the base of the section
3012 dst
->symbol
.value
= (src
->u
.syment
.n_value
) - dst
->symbol
.section
->vma
;
3016 case C_EXTDEF
: /* external definition */
3017 case C_ULABEL
: /* undefined label */
3018 case C_USTATIC
: /* undefined static */
3019 case C_LINE
: /* line # reformatted as symbol table entry */
3020 case C_ALIAS
: /* duplicate tag */
3021 case C_HIDDEN
: /* ext symbol in dmert public lib */
3024 fprintf(stderr
,"Unrecognized storage class %d\n",
3025 src
->u
.syment
.n_sclass
);
3027 dst
->symbol
.flags
= BSF_DEBUGGING
;
3028 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3032 BFD_ASSERT(dst
->symbol
.flags
!= 0);
3036 dst
->symbol
.udata
= 0;
3037 dst
->lineno
= (alent
*) NULL
;
3038 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
3040 number_of_symbols
++;
3041 } /* walk the native symtab */
3042 } /* bfdize the native symtab */
3044 obj_symbols(abfd
) = cached_area
;
3045 obj_raw_syments(abfd
) = native_symbols
;
3047 bfd_get_symcount(abfd
) = number_of_symbols
;
3048 obj_convert(abfd
) = table_ptr
;
3049 /* Slurp the line tables for each section too */
3054 coff_slurp_line_table(abfd
, p
);
3059 } /* coff_slurp_symbol_table() */
3062 coff_get_symtab_upper_bound(abfd
)
3065 if (!coff_slurp_symbol_table(abfd
))
3068 return (bfd_get_symcount(abfd
) + 1) * (sizeof(coff_symbol_type
*));
3073 coff_get_symtab(abfd
, alocation
)
3075 asymbol
**alocation
;
3077 unsigned int counter
= 0;
3078 coff_symbol_type
*symbase
;
3079 coff_symbol_type
**location
= (coff_symbol_type
**) (alocation
);
3080 if (!coff_slurp_symbol_table(abfd
))
3083 for (symbase
= obj_symbols(abfd
); counter
++ < bfd_get_symcount(abfd
);)
3084 *(location
++) = symbase
++;
3086 return bfd_get_symcount(abfd
);
3089 #endif /* NO_COFF_SYMBOLS */
3092 coff_get_reloc_upper_bound(abfd
, asect
)
3096 if (bfd_get_format(abfd
) != bfd_object
) {
3097 bfd_error
= invalid_operation
;
3100 return (asect
->reloc_count
+ 1) * sizeof(arelent
*);
3104 @subsubsection Reading Relocations
3105 Coff relocations are easily transformed into the internal BFD form
3108 Reading a coff relocation table is done in the following stages:
3111 The entire coff relocation table is read into memory.
3113 Each relocation is processed in turn, first it is swapped from the
3114 external to the internal form.
3116 The symbol referenced in the relocation's symbol index is turned into
3117 a pointer into the canonical symbol table. Note that this table is the
3118 same as the one returned by a call to @code{bfd_canonicalize_symtab}.
3119 The back end will call the routine and save the result if a
3120 canonicalization hasn't been done.
3122 The reloc index is turned into a pointer to a howto structure, in a
3123 back end specific way. For instance, the 386 and 960 use the
3124 @code{r_type} to directly produce an index into a howto table vector;
3125 the 88k subtracts a number from the @code{r_type} field and creates an
3131 DEFUN(coff_slurp_reloc_table
,(abfd
, asect
, symbols
),
3136 RELOC
*native_relocs
;
3137 arelent
*reloc_cache
;
3138 if (asect
->relocation
)
3140 if (asect
->reloc_count
== 0)
3142 #ifndef NO_COFF_SYMBOLS
3143 if (!coff_slurp_symbol_table(abfd
))
3147 (RELOC
*) buy_and_read(abfd
,
3151 asect
->reloc_count
));
3152 reloc_cache
= (arelent
*)
3153 bfd_alloc(abfd
, (size_t) (asect
->reloc_count
* sizeof(arelent
)));
3155 if (reloc_cache
== NULL
) {
3156 bfd_error
= no_memory
;
3161 for (cache_ptr
= reloc_cache
,
3162 src
= native_relocs
;
3163 cache_ptr
< reloc_cache
+ asect
->reloc_count
;
3166 struct internal_reloc dst
;
3168 bfd_swap_reloc_in(abfd
, src
, &dst
);
3170 dst
.r_symndx
+= obj_symbol_slew(abfd
);
3171 cache_ptr
->sym_ptr_ptr
= symbols
+ obj_convert(abfd
)[dst
.r_symndx
];
3173 /* AMD has two relocation entries for the 'consth' instruction.
3174 * The first is R_IHIHALF (part 1), the second is R_IHCONST
3175 * (part 2). The second entry's r_symndx does not contain
3176 * an index to a symbol but rather a value (apparently).
3177 * Also, see the ifdef below for saving the r_symndx value in addend.
3179 if (dst
.r_type
== R_IHCONST
) {
3183 ptr
= *(cache_ptr
->sym_ptr_ptr
);
3184 cache_ptr
->address
= dst
.r_vaddr
;
3186 The symbols definitions that we have read in have been
3187 relocated as if their sections started at 0. But the offsets
3188 refering to the symbols in the raw data have not been
3189 modified, so we have to have a negative addend to compensate.
3191 Note that symbols which used to be common must be left alone */
3193 if (ptr
&& ptr
->the_bfd
== abfd
3194 && ptr
->section
!= (asection
*) NULL
3195 && ((ptr
->flags
& BSF_OLD_COMMON
)== 0))
3198 cache_ptr
->addend
= -(ptr
->section
->vma
+ ptr
->value
);
3200 cache_ptr
->addend
= 0;
3205 cache_ptr
->addend
= 0;
3208 cache_ptr
->address
-= asect
->vma
;
3210 cache_ptr
->section
= (asection
*) NULL
;
3213 if (dst
.r_type
== R_IHCONST
) {
3214 /* Add in the value which was stored in the symbol index */
3215 /* See above comment */
3216 cache_ptr
->addend
+= dst
.r_symndx
;
3217 /* Throw away the bogus symbol pointer */
3218 cache_ptr
->sym_ptr_ptr
= 0;
3220 cache_ptr
->howto
= howto_table
+ dst
.r_type
;
3223 cache_ptr
->howto
= howto_table
+ dst
.r_type
;
3226 cache_ptr
->howto
= howto_table
+ dst
.r_type
;
3229 cache_ptr
->howto
= howto_table
+ dst
.r_type
- R_RELBYTE
;
3232 if (dst
.r_type
>= R_PCR16L
&& dst
.r_type
<= R_VRT32
) {
3233 cache_ptr
->howto
= howto_table
+ dst
.r_type
- R_PCR16L
;
3234 cache_ptr
->addend
+= dst
.r_offset
<< 16;
3243 asect
->relocation
= reloc_cache
;
3248 /* This is stupid. This function should be a boolean predicate */
3250 coff_canonicalize_reloc(abfd
, section
, relptr
, symbols
)
3256 arelent
*tblptr
= section
->relocation
;
3257 unsigned int count
= 0;
3258 if (!(tblptr
|| coff_slurp_reloc_table(abfd
, section
, symbols
)))
3260 tblptr
= section
->relocation
;
3264 for (; count
++ < section
->reloc_count
;)
3265 *relptr
++ = tblptr
++;
3269 return section
->reloc_count
;
3272 #ifndef NO_COFF_SYMBOLS
3275 provided a BFD, a section and an offset into the section, calculate and
3276 return the name of the source file and the line nearest to the wanted
3281 DEFUN(coff_find_nearest_line
,(abfd
,
3289 asection
*section AND
3290 asymbol
**ignore_symbols AND
3292 CONST
char **filename_ptr AND
3293 CONST
char **functionname_ptr AND
3294 unsigned int *line_ptr
)
3296 static bfd
*cache_abfd
;
3297 static asection
*cache_section
;
3298 static bfd_vma cache_offset
;
3299 static unsigned int cache_i
;
3300 static alent
*cache_l
;
3303 coff_data_type
*cof
= coff_data(abfd
);
3304 /* Run through the raw syments if available */
3305 combined_entry_type
*p
;
3307 unsigned int line_base
= 0;
3311 *functionname_ptr
= 0;
3314 /* Don't try and find line numbers in a non coff file */
3315 if (abfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
3321 p
= cof
->raw_syments
;
3323 for (i
= 0; i
< cof
->raw_syment_count
; i
++) {
3324 if (p
->u
.syment
.n_sclass
== C_FILE
) {
3325 /* File name has been moved into symbol */
3326 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
3329 p
+= 1 + p
->u
.syment
.n_numaux
;
3331 /* Now wander though the raw linenumbers of the section */
3333 If this is the same BFD as we were previously called with and this is
3334 the same section, and the offset we want is further down then we can
3335 prime the lookup loop
3337 if (abfd
== cache_abfd
&&
3338 section
== cache_section
&&
3339 offset
>= cache_offset
) {
3345 l
= section
->lineno
;
3348 for (; i
< section
->lineno_count
; i
++) {
3349 if (l
->line_number
== 0) {
3350 /* Get the symbol this line number points at */
3351 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
3352 *functionname_ptr
= coff
->symbol
.name
;
3354 combined_entry_type
*s
= coff
->native
;
3355 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
3357 S should now point to the .bf of the function
3359 if (s
->u
.syment
.n_numaux
) {
3361 The linenumber is stored in the auxent
3363 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
3364 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
3369 if (l
->u
.offset
> offset
)
3371 *line_ptr
= l
->line_number
+ line_base
+ 1;
3377 cache_section
= section
;
3378 cache_offset
= offset
;
3387 coff_sym_filepos(abfd
)
3390 return obj_sym_filepos(abfd
);
3394 #endif /* NO_COFF_SYMBOLS */
3398 DEFUN(coff_sizeof_headers
,(abfd
, reloc
),
3404 if (reloc
== false) {
3405 size
= FILHSZ
+ AOUTSZ
;
3411 size
+= abfd
->section_count
* SCNHSZ
;
3416 #define coff_core_file_failing_command _bfd_dummy_core_file_failing_command
3417 #define coff_core_file_failing_signal _bfd_dummy_core_file_failing_signal
3418 #define coff_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
3419 #define coff_slurp_armap bfd_slurp_coff_armap
3420 #define coff_slurp_extended_name_table _bfd_slurp_extended_name_table
3421 #define coff_truncate_arname bfd_dont_truncate_arname
3422 #define coff_openr_next_archived_file bfd_generic_openr_next_archived_file
3423 #define coff_generic_stat_arch_elt bfd_generic_stat_arch_elt
3424 #define coff_get_section_contents bfd_generic_get_section_contents
3425 #define coff_close_and_cleanup bfd_generic_close_and_cleanup
3427 #define coff_bfd_debug_info_start bfd_void
3428 #define coff_bfd_debug_info_end bfd_void
3429 #define coff_bfd_debug_info_accumulate (PROTO(void,(*),(bfd*, struct sec *))) bfd_void