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;
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_LINNO_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
);
331 /* Try and figure out what it should be */
332 if (sec_flags
& SEC_CODE
) styp_flags
= STYP_TEXT
;
333 if (sec_flags
& SEC_DATA
) styp_flags
= STYP_DATA
;
334 else if (sec_flags
& SEC_READONLY
)
335 #ifdef STYP_LIT /* 29k readonly text/data section */
336 styp_flags
= STYP_LIT
;
338 styp_flags
= STYP_TEXT
;
339 #endif /* STYP_LIT */
340 else if (sec_flags
& SEC_LOAD
) styp_flags
= STYP_TEXT
;
342 if (styp_flags
== 0) styp_flags
= STYP_BSS
;
347 * Return a word with SEC_* flags set to represent the incoming
348 * STYP_* flags (from scnhdr.s_flags). The inverse of this
349 * function is sec_to_styp_flags().
350 * NOTE: If you add to/change this routine, you should mirror the changes
351 * in sec_to_styp_flags().
354 DEFUN(styp_to_sec_flags
, (styp_flags
),
357 flagword sec_flags
=0;
359 if ((styp_flags
& STYP_TEXT
) || (styp_flags
& STYP_DATA
))
360 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
361 else if (styp_flags
& STYP_BSS
)
362 sec_flags
= SEC_ALLOC
;
364 #ifdef STYP_LIT /* A29k readonly text/data section type */
365 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
366 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
367 #endif /* STYP_LIT */
372 #define get_index(symbol) ((int) (symbol)->value)
373 #define set_index(symbol, idx) ((symbol)->value = (idx))
375 /* **********************************************************************
376 Here are all the routines for swapping the structures seen in the
377 outside world into the internal forms.
382 DEFUN(bfd_swap_reloc_in
,(abfd
, reloc_src
, reloc_dst
),
385 struct internal_reloc
*reloc_dst
)
387 reloc_dst
->r_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*)reloc_src
->r_vaddr
);
388 reloc_dst
->r_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) reloc_src
->r_symndx
);
391 reloc_dst
->r_type
= bfd_h_get_8(abfd
, reloc_src
->r_type
);
392 reloc_dst
->r_size
= bfd_h_get_8(abfd
, reloc_src
->r_size
);
394 reloc_dst
->r_type
= bfd_h_get_16(abfd
, (bfd_byte
*) reloc_src
->r_type
);
398 reloc_dst
->r_offset
= bfd_h_get_16(abfd
, (bfd_byte
*) reloc_src
->r_offset
);
404 DEFUN(coff_swap_reloc_out
,(abfd
, src
, dst
),
409 struct internal_reloc
*reloc_src
= (struct internal_reloc
*)src
;
410 struct external_reloc
*reloc_dst
= (struct external_reloc
*)dst
;
411 bfd_h_put_32(abfd
, reloc_src
->r_vaddr
, (bfd_byte
*) reloc_dst
->r_vaddr
);
412 bfd_h_put_32(abfd
, reloc_src
->r_symndx
, (bfd_byte
*) reloc_dst
->r_symndx
);
413 bfd_h_put_16(abfd
, reloc_src
->r_type
, (bfd_byte
*) reloc_dst
->r_type
);
415 bfd_h_put_16(abfd
, reloc_src
->r_offset
, (bfd_byte
*) reloc_dst
->r_offset
);
417 return sizeof(struct external_reloc
);
421 DEFUN(bfd_swap_filehdr_in
,(abfd
, filehdr_src
, filehdr_dst
),
423 FILHDR
*filehdr_src AND
424 struct internal_filehdr
*filehdr_dst
)
426 filehdr_dst
->f_magic
= bfd_h_get_16(abfd
, (bfd_byte
*) filehdr_src
->f_magic
);
427 filehdr_dst
->f_nscns
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_nscns
);
428 filehdr_dst
->f_timdat
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_timdat
);
429 filehdr_dst
->f_symptr
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_symptr
);
430 filehdr_dst
->f_nsyms
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_nsyms
);
431 filehdr_dst
->f_opthdr
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_opthdr
);
432 filehdr_dst
->f_flags
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_flags
);
436 DEFUN(coff_swap_filehdr_out
,(abfd
, in
, out
),
441 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*)in
;
442 FILHDR
*filehdr_out
= (FILHDR
*)out
;
443 bfd_h_put_16(abfd
, filehdr_in
->f_magic
, (bfd_byte
*) filehdr_out
->f_magic
);
444 bfd_h_put_16(abfd
, filehdr_in
->f_nscns
, (bfd_byte
*) filehdr_out
->f_nscns
);
445 bfd_h_put_32(abfd
, filehdr_in
->f_timdat
, (bfd_byte
*) filehdr_out
->f_timdat
);
446 bfd_h_put_32(abfd
, filehdr_in
->f_symptr
, (bfd_byte
*) filehdr_out
->f_symptr
);
447 bfd_h_put_32(abfd
, filehdr_in
->f_nsyms
, (bfd_byte
*) filehdr_out
->f_nsyms
);
448 bfd_h_put_16(abfd
, filehdr_in
->f_opthdr
, (bfd_byte
*) filehdr_out
->f_opthdr
);
449 bfd_h_put_16(abfd
, filehdr_in
->f_flags
, (bfd_byte
*) filehdr_out
->f_flags
);
450 return sizeof(FILHDR
);
454 #ifndef NO_COFF_SYMBOLS
457 DEFUN(coff_swap_sym_in
,(abfd
, ext1
, in1
),
462 SYMENT
*ext
= (SYMENT
*)ext1
;
463 struct internal_syment
*in
= (struct internal_syment
*)in1
;
465 if( ext
->e
.e_name
[0] == 0) {
466 in
->_n
._n_n
._n_zeroes
= 0;
467 in
->_n
._n_n
._n_offset
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e
.e
.e_offset
);
470 #if SYMNMLEN != E_SYMNMLEN
471 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
473 memcpy(in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
476 in
->n_value
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_value
);
477 in
->n_scnum
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_scnum
);
478 if (sizeof(ext
->e_type
) == 2){
479 in
->n_type
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_type
);
482 in
->n_type
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_type
);
484 in
->n_sclass
= bfd_h_get_8(abfd
, ext
->e_sclass
);
485 in
->n_numaux
= bfd_h_get_8(abfd
, ext
->e_numaux
);
489 DEFUN(coff_swap_sym_out
,(abfd
, inp
, extp
),
494 struct internal_syment
*in
= (struct internal_syment
*)inp
;
495 SYMENT
*ext
=(SYMENT
*)extp
;
496 if(in
->_n
._n_name
[0] == 0) {
497 bfd_h_put_32(abfd
, 0, (bfd_byte
*) ext
->e
.e
.e_zeroes
);
498 bfd_h_put_32(abfd
, in
->_n
._n_n
._n_offset
, (bfd_byte
*) ext
->e
.e
.e_offset
);
501 #if SYMNMLEN != E_SYMNMLEN
502 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
504 memcpy(ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
507 bfd_h_put_32(abfd
, in
->n_value
, (bfd_byte
*) ext
->e_value
);
508 bfd_h_put_16(abfd
, in
->n_scnum
, (bfd_byte
*) ext
->e_scnum
);
509 if (sizeof(ext
->e_type
) == 2)
511 bfd_h_put_16(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
515 bfd_h_put_32(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
517 bfd_h_put_8(abfd
, in
->n_sclass
, ext
->e_sclass
);
518 bfd_h_put_8(abfd
, in
->n_numaux
, ext
->e_numaux
);
519 return sizeof(SYMENT
);
523 DEFUN(coff_swap_aux_in
,(abfd
, ext1
, type
, class, in1
),
530 AUXENT
*ext
= (AUXENT
*)ext1
;
531 union internal_auxent
*in
= (union internal_auxent
*)in1
;
534 if (ext
->x_file
.x_fname
[0] == 0) {
535 in
->x_file
.x_n
.x_zeroes
= 0;
536 in
->x_file
.x_n
.x_offset
=
537 bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
539 #if FILNMLEN != E_FILNMLEN
540 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
542 memcpy (in
->x_file
.x_fname
, ext
->x_file
.x_fname
, FILNMLEN
);
547 /* RS/6000 "csect" auxents */
551 in
->x_csect
.x_scnlen
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_scnlen
);
552 in
->x_csect
.x_parmhash
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_parmhash
);
553 in
->x_csect
.x_snhash
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snhash
);
554 /* We don't have to hack bitfields in x_smtyp because it's defined by
555 shifts-and-ands, which are equivalent on all byte orders. */
556 in
->x_csect
.x_smtyp
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smtyp
);
557 in
->x_csect
.x_smclas
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smclas
);
558 in
->x_csect
.x_stab
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_stab
);
559 in
->x_csect
.x_snstab
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snstab
);
568 if (type
== T_NULL
) {
569 in
->x_scn
.x_scnlen
= GET_SCN_SCNLEN(abfd
, ext
);
570 in
->x_scn
.x_nreloc
= GET_SCN_NRELOC(abfd
, ext
);
571 in
->x_scn
.x_nlinno
= GET_SCN_NLINNO(abfd
, ext
);
575 in
->x_sym
.x_tagndx
.l
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
577 in
->x_sym
.x_tvndx
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
580 if (ISARY(type
) || class == C_BLOCK
) {
581 #if DIMNUM != E_DIMNUM
582 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
584 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]);
585 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]);
586 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]);
587 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]);
590 in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= GET_FCN_LNNOPTR(abfd
, ext
);
591 in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= GET_FCN_ENDNDX(abfd
, ext
);
594 in
->x_sym
.x_misc
.x_fsize
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
597 in
->x_sym
.x_misc
.x_lnsz
.x_lnno
= GET_LNSZ_LNNO(abfd
, ext
);
598 in
->x_sym
.x_misc
.x_lnsz
.x_size
= GET_LNSZ_SIZE(abfd
, ext
);
604 DEFUN(coff_swap_aux_out
,(abfd
, inp
, type
, class, extp
),
611 union internal_auxent
*in
= (union internal_auxent
*)inp
;
612 AUXENT
*ext
= (AUXENT
*)extp
;
615 if (in
->x_file
.x_fname
[0] == 0) {
616 PUTWORD(abfd
, 0, (bfd_byte
*) ext
->x_file
.x_n
.x_zeroes
);
618 in
->x_file
.x_n
.x_offset
,
619 (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
622 #if FILNMLEN != E_FILNMLEN
623 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
625 memcpy (ext
->x_file
.x_fname
, in
->x_file
.x_fname
, FILNMLEN
);
631 /* RS/6000 "csect" auxents */
634 PUTWORD (abfd
, in
->x_csect
.x_scnlen
, ext
->x_csect
.x_scnlen
);
635 PUTWORD (abfd
, in
->x_csect
.x_parmhash
, ext
->x_csect
.x_parmhash
);
636 PUTHALF (abfd
, in
->x_csect
.x_snhash
, ext
->x_csect
.x_snhash
);
637 /* We don't have to hack bitfields in x_smtyp because it's defined by
638 shifts-and-ands, which are equivalent on all byte orders. */
639 PUTBYTE (abfd
, in
->x_csect
.x_smtyp
, ext
->x_csect
.x_smtyp
);
640 PUTBYTE (abfd
, in
->x_csect
.x_smclas
, ext
->x_csect
.x_smclas
);
641 PUTWORD (abfd
, in
->x_csect
.x_stab
, ext
->x_csect
.x_stab
);
642 PUTHALF (abfd
, in
->x_csect
.x_snstab
, ext
->x_csect
.x_snstab
);
651 if (type
== T_NULL
) {
652 PUT_SCN_SCNLEN(abfd
, in
->x_scn
.x_scnlen
, ext
);
653 PUT_SCN_NRELOC(abfd
, in
->x_scn
.x_nreloc
, ext
);
654 PUT_SCN_NLINNO(abfd
, in
->x_scn
.x_nlinno
, ext
);
658 PUTWORD(abfd
, in
->x_sym
.x_tagndx
.l
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
660 PUTWORD(abfd
, in
->x_sym
.x_tvndx
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
664 PUTWORD(abfd
, in
->x_sym
.x_misc
.x_fsize
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
665 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
666 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
670 if (ISARY(type
) || class == C_BLOCK
) {
671 #if DIMNUM != E_DIMNUM
672 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
674 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]);
675 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]);
676 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]);
677 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]);
680 PUT_LNSZ_LNNO(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
681 PUT_LNSZ_SIZE(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
683 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
684 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
689 return sizeof(AUXENT
);
692 #endif /* NO_COFF_SYMBOLS */
694 #ifndef NO_COFF_LINENOS
697 DEFUN(coff_swap_lineno_in
,(abfd
, ext1
, in1
),
702 LINENO
*ext
= (LINENO
*)ext1
;
703 struct internal_lineno
*in
= (struct internal_lineno
*)in1
;
705 in
->l_addr
.l_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->l_addr
.l_symndx
);
706 in
->l_lnno
= GET_LINENO_LNNO(abfd
, ext
);
710 DEFUN(coff_swap_lineno_out
,(abfd
, inp
, outp
),
715 struct internal_lineno
*in
= (struct internal_lineno
*)inp
;
716 struct external_lineno
*ext
= (struct external_lineno
*)outp
;
717 PUTWORD(abfd
, in
->l_addr
.l_symndx
, (bfd_byte
*)
718 ext
->l_addr
.l_symndx
);
720 PUT_LINENO_LNNO (abfd
, in
->l_lnno
, ext
);
721 return sizeof(struct external_lineno
);
724 #endif /* NO_COFF_LINENOS */
728 DEFUN(bfd_swap_aouthdr_in
,(abfd
, aouthdr_ext1
, aouthdr_int1
),
733 AOUTHDR
*aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
734 struct internal_aouthdr
*aouthdr_int
= (struct internal_aouthdr
*)aouthdr_int1
;
736 aouthdr_int
->magic
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->magic
);
737 aouthdr_int
->vstamp
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->vstamp
);
738 aouthdr_int
->tsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tsize
);
739 aouthdr_int
->dsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->dsize
);
740 aouthdr_int
->bsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->bsize
);
741 aouthdr_int
->entry
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->entry
);
742 aouthdr_int
->text_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->text_start
);
743 aouthdr_int
->data_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->data_start
);
745 aouthdr_int
->tagentries
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tagentries
);
749 aouthdr_int
->o_toc
= bfd_h_get_32(abfd
, aouthdr_ext
->o_toc
);
750 aouthdr_int
->o_snentry
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snentry
);
751 aouthdr_int
->o_sntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntext
);
752 aouthdr_int
->o_sndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sndata
);
753 aouthdr_int
->o_sntoc
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntoc
);
754 aouthdr_int
->o_snloader
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snloader
);
755 aouthdr_int
->o_snbss
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snbss
);
756 aouthdr_int
->o_algntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algntext
);
757 aouthdr_int
->o_algndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algndata
);
758 aouthdr_int
->o_modtype
= bfd_h_get_16(abfd
, aouthdr_ext
->o_modtype
);
759 aouthdr_int
->o_maxstack
= bfd_h_get_32(abfd
, aouthdr_ext
->o_maxstack
);
764 DEFUN(coff_swap_aouthdr_out
,(abfd
, in
, out
),
769 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*)in
;
770 AOUTHDR
*aouthdr_out
= (AOUTHDR
*)out
;
771 bfd_h_put_16(abfd
, aouthdr_in
->magic
, (bfd_byte
*) aouthdr_out
->magic
);
772 bfd_h_put_16(abfd
, aouthdr_in
->vstamp
, (bfd_byte
*) aouthdr_out
->vstamp
);
773 bfd_h_put_32(abfd
, aouthdr_in
->tsize
, (bfd_byte
*) aouthdr_out
->tsize
);
774 bfd_h_put_32(abfd
, aouthdr_in
->dsize
, (bfd_byte
*) aouthdr_out
->dsize
);
775 bfd_h_put_32(abfd
, aouthdr_in
->bsize
, (bfd_byte
*) aouthdr_out
->bsize
);
776 bfd_h_put_32(abfd
, aouthdr_in
->entry
, (bfd_byte
*) aouthdr_out
->entry
);
777 bfd_h_put_32(abfd
, aouthdr_in
->text_start
,
778 (bfd_byte
*) aouthdr_out
->text_start
);
779 bfd_h_put_32(abfd
, aouthdr_in
->data_start
, (bfd_byte
*) aouthdr_out
->data_start
);
781 bfd_h_put_32(abfd
, aouthdr_in
->tagentries
, (bfd_byte
*) aouthdr_out
->tagentries
);
783 return sizeof(AOUTHDR
);
787 DEFUN(coff_swap_scnhdr_in
,(abfd
, scnhdr_ext
, scnhdr_int
),
789 SCNHDR
*scnhdr_ext AND
790 struct internal_scnhdr
*scnhdr_int
)
792 memcpy(scnhdr_int
->s_name
, scnhdr_ext
->s_name
, sizeof(scnhdr_int
->s_name
));
793 scnhdr_int
->s_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
794 scnhdr_int
->s_paddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
795 scnhdr_int
->s_size
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_size
);
796 scnhdr_int
->s_scnptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
797 scnhdr_int
->s_relptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
798 scnhdr_int
->s_lnnoptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
799 scnhdr_int
->s_flags
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_flags
);
801 scnhdr_int
->s_nreloc
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
802 scnhdr_int
->s_nlnno
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
804 scnhdr_int
->s_nreloc
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
805 scnhdr_int
->s_nlnno
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
808 scnhdr_int
->s_align
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_align
);
813 DEFUN(coff_swap_scnhdr_out
,(abfd
, in
, out
),
818 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*)in
;
819 SCNHDR
*scnhdr_ext
= (SCNHDR
*)out
;
820 memcpy(scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof(scnhdr_int
->s_name
));
821 PUTWORD(abfd
, scnhdr_int
->s_vaddr
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
822 PUTWORD(abfd
, scnhdr_int
->s_paddr
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
823 PUTWORD(abfd
, scnhdr_int
->s_size
, (bfd_byte
*) scnhdr_ext
->s_size
);
824 PUTWORD(abfd
, scnhdr_int
->s_scnptr
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
825 PUTWORD(abfd
, scnhdr_int
->s_relptr
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
826 PUTWORD(abfd
, scnhdr_int
->s_lnnoptr
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
827 PUTWORD(abfd
, scnhdr_int
->s_flags
, (bfd_byte
*) scnhdr_ext
->s_flags
);
829 PUTWORD(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
830 PUTWORD(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
832 PUTHALF(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
833 PUTHALF(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
837 PUTWORD(abfd
, scnhdr_int
->s_align
, (bfd_byte
*) scnhdr_ext
->s_align
);
839 return sizeof(SCNHDR
);
844 initialize a section structure with information peculiar to this
845 particular implementation of coff
849 DEFUN(coff_new_section_hook
,(abfd_ignore
, section_ignore
),
851 asection
*section_ignore
)
853 section_ignore
->alignment_power
= abfd_ignore
->xvec
->align_power_min
;
857 /* Take a section header read from a coff file (in HOST byte order),
858 and make a BFD "section" out of it. */
860 DEFUN(make_a_section_from_file
,(abfd
, hdr
),
862 struct internal_scnhdr
*hdr
)
864 asection
*return_section
;
867 /* Assorted wastage to null-terminate the name, thanks AT&T! */
868 char *name
= bfd_alloc(abfd
, sizeof (hdr
->s_name
)+1);
870 bfd_error
= no_memory
;
873 strncpy(name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
874 name
[sizeof (hdr
->s_name
)] = 0;
876 return_section
= bfd_make_section(abfd
, name
);
877 if (return_section
== NULL
)
881 /* s_paddr is presumed to be = to s_vaddr */
882 #define assign(to, from) return_section->to = hdr->from
883 assign(vma
, s_vaddr
);
884 /* assign (vma, s_vaddr); */
885 assign(size
, s_size
);
886 assign(filepos
, s_scnptr
);
887 assign(rel_filepos
, s_relptr
);
888 assign(reloc_count
, s_nreloc
);
891 /* FIXME, use a temp var rather than alignment_power */
892 assign(alignment_power
, s_align
);
895 for (i
= 0; i
< 32; i
++) {
896 if ((1 << i
) >= (int) (return_section
->alignment_power
)) {
897 return_section
->alignment_power
= i
;
904 assign(line_filepos
, s_lnnoptr
);
906 return_section->linesize = hdr->s_nlnno * sizeof (struct lineno);
909 return_section
->lineno_count
= hdr
->s_nlnno
;
910 return_section
->userdata
= NULL
;
911 return_section
->next
= (asection
*) NULL
;
912 return_section
->flags
= styp_to_sec_flags(hdr
->s_flags
);
915 if (hdr
->s_nreloc
!= 0)
916 return_section
->flags
|= SEC_RELOC
;
917 /* FIXME: should this check 'hdr->s_size > 0' */
918 if (hdr
->s_scnptr
!= 0)
919 return_section
->flags
|= SEC_HAS_CONTENTS
;
923 DEFUN(coff_mkobject
,(abfd
),
926 set_tdata (abfd
, bfd_zalloc (abfd
,sizeof(coff_data_type
)));
927 if (coff_data(abfd
) == 0) {
928 bfd_error
= no_memory
;
931 coff_data(abfd
)->relocbase
= 0;
937 DEFUN(coff_real_object_p
,(abfd
, nscns
, internal_f
, internal_a
),
940 struct internal_filehdr
*internal_f AND
941 struct internal_aouthdr
*internal_a
)
943 coff_data_type
*coff
;
944 enum bfd_architecture arch
;
946 size_t readsize
; /* length of file_info */
947 SCNHDR
*external_sections
;
949 /* Build a play area */
950 if (coff_mkobject(abfd
) != true)
952 coff
= coff_data(abfd
);
955 external_sections
= (SCNHDR
*)bfd_alloc(abfd
, readsize
= (nscns
* SCNHSZ
));
957 if (bfd_read((PTR
)external_sections
, 1, readsize
, abfd
) != readsize
) {
962 /* Now copy data as required; construct all asections etc */
963 coff
->symbol_index_slew
= 0;
965 coff
->raw_syment_count
= 0;
966 coff
->raw_linenos
= 0;
967 coff
->raw_syments
= 0;
968 coff
->sym_filepos
=0;
969 coff
->flags
= internal_f
->f_flags
;
972 for (i
= 0; i
< nscns
; i
++) {
973 struct internal_scnhdr tmp
;
974 coff_swap_scnhdr_in(abfd
, external_sections
+ i
, &tmp
);
975 make_a_section_from_file(abfd
,&tmp
);
978 /* Determine the machine architecture and type. */
980 switch (internal_f
->f_magic
) {
983 arch
= bfd_arch_i386
;
988 #ifdef A29K_MAGIC_BIG
990 case A29K_MAGIC_LITTLE
:
991 arch
= bfd_arch_a29k
;
1000 arch
= bfd_arch_mips
;
1008 arch
= bfd_arch_m68k
;
1016 arch
= bfd_arch_m88k
;
1024 arch
= bfd_arch_i960
;
1025 switch (F_I960TYPE
& internal_f
->f_flags
)
1029 machine
= bfd_mach_i960_core
;
1032 machine
= bfd_mach_i960_kb_sb
;
1035 machine
= bfd_mach_i960_mc
;
1038 machine
= bfd_mach_i960_xa
;
1041 machine
= bfd_mach_i960_ca
;
1044 machine
= bfd_mach_i960_ka_sa
;
1055 arch
= bfd_arch_rs6000
;
1061 default: /* Unreadable input file type */
1062 arch
= bfd_arch_obscure
;
1066 bfd_default_set_arch_mach(abfd
, arch
, machine
);
1067 if (!(internal_f
->f_flags
& F_RELFLG
))
1068 abfd
->flags
|= HAS_RELOC
;
1069 if ((internal_f
->f_flags
& F_EXEC
))
1070 abfd
->flags
|= EXEC_P
;
1071 if (!(internal_f
->f_flags
& F_LNNO
))
1072 abfd
->flags
|= HAS_LINENO
;
1073 if (!(internal_f
->f_flags
& F_LSYMS
))
1074 abfd
->flags
|= HAS_LOCALS
;
1077 bfd_get_symcount(abfd
) = internal_f
->f_nsyms
;
1078 if (internal_f
->f_nsyms
)
1079 abfd
->flags
|= HAS_SYMS
;
1081 coff
->sym_filepos
= internal_f
->f_symptr
;
1083 /* These members communicate important constants about the symbol table
1084 to GDB's symbol-reading code. These `constants' unfortunately vary
1085 from coff implementation to implementation... */
1086 #ifndef NO_COFF_SYMBOLS
1087 coff
->local_n_btmask
= N_BTMASK
;
1088 coff
->local_n_btshft
= N_BTSHFT
;
1089 coff
->local_n_tmask
= N_TMASK
;
1090 coff
->local_n_tshift
= N_TSHIFT
;
1091 coff
->local_symesz
= SYMESZ
;
1092 coff
->local_auxesz
= AUXESZ
;
1093 coff
->local_linesz
= LINESZ
;
1096 coff
->symbols
= (coff_symbol_type
*) NULL
;
1097 bfd_get_start_address(abfd
) = internal_f
->f_opthdr
? internal_a
->entry
: 0;
1101 bfd_release(abfd
, coff
);
1102 return (bfd_target
*)NULL
;
1106 DEFUN(coff_object_p
,(abfd
),
1112 struct internal_filehdr internal_f
;
1113 struct internal_aouthdr internal_a
;
1115 bfd_error
= system_call_error
;
1117 /* figure out how much to read */
1118 if (bfd_read((PTR
) &filehdr
, 1, FILHSZ
, abfd
) != FILHSZ
)
1121 bfd_swap_filehdr_in(abfd
, &filehdr
, &internal_f
);
1123 if (BADMAG(internal_f
)) {
1124 bfd_error
= wrong_format
;
1127 nscns
=internal_f
.f_nscns
;
1129 if (internal_f
.f_opthdr
) {
1130 if (bfd_read((PTR
) &opthdr
, 1,AOUTSZ
, abfd
) != AOUTSZ
) {
1133 bfd_swap_aouthdr_in(abfd
, (char *)&opthdr
, (char *)&internal_a
);
1136 /* Seek past the opt hdr stuff */
1137 bfd_seek(abfd
, internal_f
.f_opthdr
+ FILHSZ
, SEEK_SET
);
1139 /* if the optional header is NULL or not the correct size then
1140 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1141 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1142 optional header is of a different size.
1144 But the mips keeps extra stuff in it's opthdr, so dont check
1148 #if defined(M88) || defined(I960)
1149 if (internal_f
.f_opthdr
!= 0 && AOUTSZ
!= internal_f
.f_opthdr
)
1150 return (bfd_target
*)NULL
;
1153 return coff_real_object_p(abfd
, nscns
, &internal_f
, &internal_a
);
1158 #ifndef NO_COFF_LINENOS
1161 DEFUN(coff_count_linenumbers
,(abfd
),
1164 unsigned int limit
= bfd_get_symcount(abfd
);
1168 asection
*s
= abfd
->sections
->output_section
;
1170 BFD_ASSERT(s
->lineno_count
== 0);
1176 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++) {
1177 asymbol
*q_maybe
= *p
;
1178 if (q_maybe
->the_bfd
->xvec
->flavour
== bfd_target_coff_flavour
) {
1179 coff_symbol_type
*q
= coffsymbol(q_maybe
);
1182 This symbol has a linenumber, increment the owning
1183 section's linenumber count
1185 alent
*l
= q
->lineno
;
1186 q
->symbol
.section
->output_section
->lineno_count
++;
1188 while (l
->line_number
) {
1189 q
->symbol
.section
->output_section
->lineno_count
++;
1197 #endif /* NO_COFF_LINENOS */
1199 #ifndef NO_COFF_SYMBOLS
1202 Takes a bfd and a symbol, returns a pointer to the coff specific area
1203 of the symbol if there is one.
1205 static coff_symbol_type
*
1206 DEFUN(coff_symbol_from
,(ignore_abfd
, symbol
),
1207 bfd
*ignore_abfd AND
1210 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
1211 return (coff_symbol_type
*)NULL
;
1213 if (symbol
->the_bfd
->tdata
== (PTR
)NULL
)
1214 return (coff_symbol_type
*)NULL
;
1216 return (coff_symbol_type
*) symbol
;
1222 DEFUN(fixup_symbol_value
,(coff_symbol_ptr
, syment
),
1223 coff_symbol_type
*coff_symbol_ptr AND
1224 struct internal_syment
*syment
)
1227 /* Normalize the symbol flags */
1228 if (coff_symbol_ptr
->symbol
.flags
& BSF_FORT_COMM
) {
1229 /* a common symbol is undefined with a value */
1230 syment
->n_scnum
= N_UNDEF
;
1231 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1233 else if (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) {
1234 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1236 else if (coff_symbol_ptr
->symbol
.flags
& BSF_UNDEFINED
) {
1237 syment
->n_scnum
= N_UNDEF
;
1238 syment
->n_value
= 0;
1240 else if (coff_symbol_ptr
->symbol
.flags
& BSF_ABSOLUTE
) {
1241 syment
->n_scnum
= N_ABS
;
1242 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1245 if (coff_symbol_ptr
->symbol
.section
) {
1247 coff_symbol_ptr
->symbol
.section
->output_section
->index
+1;
1250 coff_symbol_ptr
->symbol
.value
+
1251 coff_symbol_ptr
->symbol
.section
->output_offset
+
1252 coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
1255 /* This can happen, but I don't know why yet (steve@cygnus.com) */
1256 syment
->n_scnum
= N_ABS
;
1257 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1262 /* run through all the symbols in the symbol table and work out what
1263 their indexes into the symbol table will be when output
1265 Coff requires that each C_FILE symbol points to the next one in the
1266 chain, and that the last one points to the first external symbol. We
1271 DEFUN(coff_renumber_symbols
,(bfd_ptr
),
1274 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1275 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1276 unsigned int native_index
= 0;
1277 struct internal_syment
*last_file
= (struct internal_syment
*)NULL
;
1278 unsigned int symbol_index
;
1279 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1281 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1282 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1283 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1286 if (s
->u
.syment
.n_sclass
== C_FILE
)
1288 if (last_file
!= (struct internal_syment
*)NULL
) {
1289 last_file
->n_value
= native_index
;
1291 last_file
= &(s
->u
.syment
);
1295 /* Modify the symbol values according to their section and
1298 fixup_symbol_value(coff_symbol_ptr
, &(s
->u
.syment
));
1300 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++) {
1301 s
[i
].offset
= native_index
++;
1312 Run thorough the symbol table again, and fix it so that all pointers to
1313 entries are changed to the entries' index in the output symbol table.
1317 DEFUN(coff_mangle_symbols
,(bfd_ptr
),
1320 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1321 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1322 unsigned int symbol_index
;
1324 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1326 coff_symbol_type
*coff_symbol_ptr
=
1327 coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1329 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1331 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1333 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++) {
1334 combined_entry_type
*a
= s
+ i
+ 1;
1336 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
1337 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
1340 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
1341 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
1349 static int string_size
;
1351 DEFUN(coff_fix_symbol_name
,(ignore_abfd
, symbol
, native
),
1352 bfd
*ignore_abfd AND
1354 combined_entry_type
*native
)
1356 unsigned int name_length
;
1357 union internal_auxent
*auxent
;
1358 char * name
= ( char *)(symbol
->name
);
1360 if (name
== (char *) NULL
) {
1361 /* coff symbols always have names, so we'll make one up */
1362 symbol
->name
= "strange";
1363 name
= (char *)symbol
->name
;
1365 name_length
= strlen(name
);
1367 if (native
->u
.syment
.n_sclass
== C_FILE
) {
1368 strncpy(native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
1369 auxent
= &(native
+1)->u
.auxent
;
1371 #ifdef COFF_LONG_FILENAMES
1372 if (name_length
<= FILNMLEN
) {
1373 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1376 auxent
->x_file
.x_n
.x_offset
= string_size
+ 4;
1377 auxent
->x_file
.x_n
.x_zeroes
= 0;
1378 string_size
+= name_length
+ 1;
1381 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1382 if (name_length
> FILNMLEN
) {
1383 name
[FILNMLEN
] = '\0';
1388 { /* NOT A C_FILE SYMBOL */
1389 if (name_length
<= SYMNMLEN
) {
1390 /* This name will fit into the symbol neatly */
1391 strncpy(native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
1394 native
->u
.syment
._n
._n_n
._n_offset
= string_size
+ 4;
1395 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1396 string_size
+= name_length
+ 1;
1404 DEFUN(coff_write_symbol
,(abfd
, symbol
, native
, written
),
1407 combined_entry_type
*native AND
1408 unsigned int written
)
1410 unsigned int numaux
= native
->u
.syment
.n_numaux
;
1411 int type
= native
->u
.syment
.n_type
;
1412 int class = native
->u
.syment
.n_sclass
;
1416 coff_fix_symbol_name(abfd
, symbol
, native
);
1417 coff_swap_sym_out(abfd
, &native
->u
.syment
, &buf
);
1418 bfd_write((PTR
)& buf
, 1, SYMESZ
, abfd
);
1419 for (j
= 0; j
!= native
->u
.syment
.n_numaux
; j
++)
1422 bzero((PTR
)&buf
, AUXESZ
);
1423 coff_swap_aux_out(abfd
,
1424 &( (native
+ j
+ 1)->u
.auxent
), type
, class, &buf1
);
1425 bfd_write((PTR
) (&buf1
), 1, AUXESZ
, abfd
);
1428 Reuse somewhere in the symbol to keep the index
1430 set_index(symbol
, written
);
1431 return written
+ 1 + numaux
;
1436 DEFUN(coff_write_alien_symbol
,(abfd
, symbol
, written
),
1439 unsigned int written
)
1442 This symbol has been created by the loader, or come from a non
1443 coff format. It has no native element to inherit, make our
1446 combined_entry_type
*native
;
1447 combined_entry_type dummy
;
1449 native
->u
.syment
.n_type
= T_NULL
;
1451 native
->u
.syment
.n_flags
= 0;
1453 if (symbol
->flags
& BSF_ABSOLUTE
) {
1454 native
->u
.syment
.n_scnum
= N_ABS
;
1455 native
->u
.syment
.n_value
= symbol
->value
;
1457 else if (symbol
->flags
& (BSF_UNDEFINED
| BSF_FORT_COMM
)) {
1458 native
->u
.syment
.n_scnum
= N_UNDEF
;
1459 native
->u
.syment
.n_value
= symbol
->value
;
1461 else if (symbol
->flags
& BSF_DEBUGGING
) {
1463 remove name so it doesn't take up any space
1468 native
->u
.syment
.n_scnum
= symbol
->section
->output_section
->index
+
1470 native
->u
.syment
.n_value
= symbol
->value
+
1471 symbol
->section
->output_section
->vma
+
1472 symbol
->section
->output_offset
;
1474 /* Copy the any flags from the the file hdr into the symbol */
1476 coff_symbol_type
*c
= coff_symbol_from(abfd
, symbol
);
1477 if (c
!= (coff_symbol_type
*)NULL
) {
1478 native
->u
.syment
.n_flags
= c
->symbol
.the_bfd
->flags
;
1485 native
->u
.syment
.pad1
[0] = 0;
1486 native
->u
.syment
.pad1
[0] = 0;
1489 native
->u
.syment
.n_type
= 0;
1490 if (symbol
->flags
& BSF_LOCAL
)
1491 native
->u
.syment
.n_sclass
= C_STAT
;
1493 native
->u
.syment
.n_sclass
= C_EXT
;
1494 native
->u
.syment
.n_numaux
= 0;
1496 return coff_write_symbol(abfd
, symbol
, native
, written
);
1500 DEFUN(coff_write_native_symbol
,(abfd
, symbol
, written
),
1502 coff_symbol_type
*symbol AND
1503 unsigned int written
)
1506 Does this symbol have an ascociated line number - if so then
1507 make it remember this symbol index. Also tag the auxent of
1508 this symbol to point to the right place in the lineno table
1510 combined_entry_type
*native
= symbol
->native
;
1512 alent
*lineno
= symbol
->lineno
;
1515 unsigned int count
= 0;
1516 lineno
[count
].u
.offset
= written
;
1517 if (native
->u
.syment
.n_numaux
) {
1518 union internal_auxent
*a
= &((native
+1)->u
.auxent
);
1520 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1521 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1524 And count and relocate all other linenumbers
1527 while (lineno
[count
].line_number
) {
1528 lineno
[count
].u
.offset
+=
1529 symbol
->symbol
.section
->output_section
->vma
+
1530 symbol
->symbol
.section
->output_offset
;
1533 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1536 return coff_write_symbol(abfd
, &( symbol
->symbol
), native
,written
);
1540 DEFUN(coff_write_symbols
,(abfd
),
1544 unsigned int limit
= bfd_get_symcount(abfd
);
1545 unsigned int written
= 0;
1552 /* Seek to the right place */
1553 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
1555 /* Output all the symbols we have */
1558 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1560 asymbol
*symbol
= *p
;
1561 coff_symbol_type
*c_symbol
= coff_symbol_from(abfd
, symbol
);
1563 if (c_symbol
== (coff_symbol_type
*) NULL
||
1564 c_symbol
->native
== (combined_entry_type
*)NULL
)
1566 written
= coff_write_alien_symbol(abfd
, symbol
, written
);
1570 written
= coff_write_native_symbol(abfd
, c_symbol
, written
);
1575 bfd_get_symcount(abfd
) = written
;
1577 /* Now write out strings */
1579 if (string_size
!= 0)
1581 unsigned int size
= string_size
+ 4;
1584 bfd_h_put_32(abfd
, size
, buffer
);
1585 bfd_write((PTR
) buffer
, 1, sizeof(buffer
), abfd
);
1586 for (p
= abfd
->outsymbols
, i
= 0;
1591 size_t name_length
= strlen(q
->name
);
1593 coff_symbol_type
* c_symbol
= coff_symbol_from(abfd
, q
);
1594 maxlen
= ((c_symbol
!= NULL
&& c_symbol
->native
!= NULL
) &&
1595 (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
)) ?
1596 FILNMLEN
: SYMNMLEN
;
1598 if (name_length
> maxlen
) {
1599 bfd_write((PTR
) (q
->name
), 1, name_length
+ 1, abfd
);
1604 /* We would normally not write anything here, but we'll write
1605 out 4 so that any stupid coff reader which tries to read
1606 the string table even when there isn't one won't croak.
1609 uint32e_type size
= 4;
1611 bfd_write((PTR
)&size
, 1, sizeof(size
), abfd
);
1617 @subsubsection Writing Relocations
1618 To write a relocations, all the back end does is step though the
1619 canonical relocation table, and create an @code{internal_reloc}. The
1620 symbol index to use is removed from the @code{offset} field in the
1621 symbol table supplied, the address comes directly from the sum of the
1622 section base address and the relocation offset and the type is dug
1623 directly from the howto field.
1625 Then the @code{internal_reloc} is swapped into the shape of an
1626 @code{external_reloc} and written out to disk.
1630 DEFUN(coff_write_relocs
,(abfd
),
1634 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1636 struct external_reloc dst
;
1638 arelent
**p
= s
->orelocation
;
1639 bfd_seek(abfd
, s
->rel_filepos
, SEEK_SET
);
1640 for (i
= 0; i
< s
->reloc_count
; i
++) {
1641 struct internal_reloc n
;
1643 memset((PTR
)&n
, 0, sizeof(n
));
1644 n
.r_vaddr
= q
->address
+ s
->vma
;
1645 if (q
->sym_ptr_ptr
) {
1646 n
.r_symndx
= get_index((*(q
->sym_ptr_ptr
)));
1649 /* Work out reloc type from what is required */
1650 SELECT_RELOC(n
.r_type
, q
->howto
);
1652 n
.r_type
= q
->howto
->type
;
1654 coff_swap_reloc_out(abfd
, &n
, &dst
);
1655 bfd_write((PTR
) &n
, 1, RELSZ
, abfd
);
1659 #endif /* NO_COFF_SYMBOLS */
1661 #ifndef NO_COFF_LINENOS
1664 DEFUN(coff_write_linenumbers
,(abfd
),
1668 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1669 if (s
->lineno_count
) {
1670 asymbol
**q
= abfd
->outsymbols
;
1671 bfd_seek(abfd
, s
->line_filepos
, SEEK_SET
);
1672 /* Find all the linenumbers in this section */
1675 alent
*l
= BFD_SEND(p
->the_bfd
, _get_lineno
, (p
->the_bfd
, p
));
1677 /* Found a linenumber entry, output */
1678 struct internal_lineno out
;
1680 memset( (PTR
)&out
, 0, sizeof(out
));
1682 out
.l_addr
.l_symndx
= l
->u
.offset
;
1683 coff_swap_lineno_out(abfd
, &out
, &buff
);
1684 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1686 while (l
->line_number
) {
1687 out
.l_lnno
= l
->line_number
;
1688 out
.l_addr
.l_symndx
= l
->u
.offset
;
1689 coff_swap_lineno_out(abfd
, &out
, &buff
);
1690 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1701 DEFUN(coff_get_lineno
,(ignore_abfd
, symbol
),
1702 bfd
*ignore_abfd AND
1705 return coffsymbol(symbol
)->lineno
;
1708 #endif /* NO_COFF_LINENOS */
1711 coff_make_empty_symbol(abfd
)
1714 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc(abfd
, sizeof(coff_symbol_type
));
1716 bfd_error
= no_memory
;
1720 new->lineno
= (alent
*) NULL
;
1721 new->symbol
.the_bfd
= abfd
;
1722 return &new->symbol
;
1725 #ifndef NO_COFF_SYMBOLS
1728 DEFUN(coff_print_symbol
,(ignore_abfd
, filep
, symbol
, how
),
1729 bfd
*ignore_abfd AND
1732 bfd_print_symbol_type how
)
1734 FILE *file
= (FILE *)filep
;
1736 case bfd_print_symbol_name
:
1737 fprintf(file
, "%s", symbol
->name
);
1739 case bfd_print_symbol_more
:
1740 fprintf(file
, "coff %lx %lx", (unsigned long) coffsymbol(symbol
)->native
,
1741 (unsigned long) coffsymbol(symbol
)->lineno
);
1743 case bfd_print_symbol_nm
:
1744 case bfd_print_symbol_all
:
1746 CONST
char *section_name
= symbol
->section
== (asection
*) NULL
?
1747 "*abs" : symbol
->section
->name
;
1748 bfd_print_symbol_vandf((PTR
) file
, symbol
);
1750 fprintf(file
, " %-5s %s %s %s",
1752 coffsymbol(symbol
)->native
? "n" : "g",
1753 coffsymbol(symbol
)->lineno
? "l" : " ",
1762 #endif /* NO_COFF_SYMBOLS */
1764 /* Set flags and magic number of a coff file from architecture and machine
1765 type. Result is true if we can represent the arch&type, false if not. */
1768 DEFUN(coff_set_flags
,(abfd
, magicp
, flagsp
),
1770 unsigned *magicp AND
1771 unsigned short *flagsp
)
1773 switch (bfd_get_arch(abfd
)) {
1781 *magicp
= I960ROMAGIC
;
1783 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1784 I960RWMAGIC); FIXME???
1786 switch (bfd_get_mach(abfd
)) {
1787 case bfd_mach_i960_core
:
1790 case bfd_mach_i960_kb_sb
:
1793 case bfd_mach_i960_mc
:
1796 case bfd_mach_i960_xa
:
1799 case bfd_mach_i960_ca
:
1802 case bfd_mach_i960_ka_sa
:
1815 *magicp
= MIPS_MAGIC_2
;
1821 *magicp
= I386MAGIC
;
1826 *magicp
= MC68MAGIC
;
1832 *magicp
= MC88OMAGIC
;
1837 #ifdef A29K_MAGIC_BIG
1839 if (abfd
->xvec
->byteorder_big_p
)
1840 *magicp
= A29K_MAGIC_BIG
;
1842 *magicp
= A29K_MAGIC_LITTLE
;
1848 case bfd_arch_rs6000
:
1849 *magicp
= U802TOCMAGIC
;
1853 default: /* Unknown architecture */
1854 /* return false; -- fall through to "return false" below, to avoid
1855 "statement never reached" errors on the one below. */
1864 DEFUN(coff_set_arch_mach
,(abfd
, arch
, machine
),
1866 enum bfd_architecture arch AND
1867 unsigned long machine
)
1870 unsigned short dummy2
;
1871 bfd_default_set_arch_mach(abfd
, arch
, machine
);
1873 if (arch
!= bfd_arch_unknown
&&
1874 coff_set_flags(abfd
, &dummy1
, &dummy2
) != true)
1875 return false; /* We can't represent this type */
1876 return true; /* We're easy ... */
1880 /* Calculate the file position for each section. */
1883 DEFUN(coff_compute_section_file_positions
,(abfd
),
1887 asection
*previous
= (asection
*)NULL
;
1888 file_ptr sofar
= FILHSZ
;
1890 if (bfd_get_start_address(abfd
))
1892 /* A start address may have been added to the original file. In this
1893 case it will need an optional header to record it. */
1894 abfd
->flags
|= EXEC_P
;
1897 if (abfd
->flags
& EXEC_P
)
1900 sofar
+= abfd
->section_count
* SCNHSZ
;
1901 for (current
= abfd
->sections
;
1902 current
!= (asection
*)NULL
;
1903 current
= current
->next
) {
1905 /* Only deal with sections which have contents */
1906 if (!(current
->flags
& SEC_HAS_CONTENTS
))
1909 /* Align the sections in the file to the same boundary on
1910 which they are aligned in virtual memory. I960 doesn't
1911 do this (FIXME) so we can stay in sync with Intel. 960
1912 doesn't yet page from files... */
1915 /* make sure this section is aligned on the right boundary - by
1916 padding the previous section up if necessary */
1919 sofar
= ALIGN(sofar
, 1 << current
->alignment_power
);
1920 if (previous
!= (asection
*)NULL
) {
1921 previous
->size
+= sofar
- old_sofar
;
1926 /* FIXME, in demand paged files, the low order bits of the file
1927 offset must match the low order bits of the virtual address.
1928 "Low order" is apparently implementation defined. Add code
1929 here to round sofar up to match the virtual address. */
1931 current
->filepos
= sofar
;
1933 /* make sure that this section is of the right size too */
1934 old_sofar
= sofar
+= current
->size
;
1935 sofar
= ALIGN(sofar
, 1 << current
->alignment_power
);
1936 current
->size
+= sofar
- old_sofar
;
1940 obj_relocbase(abfd
) = sofar
;
1949 DEFUN(coff_write_object_contents
,(abfd
),
1953 boolean hasrelocs
= false;
1954 boolean haslinno
= false;
1955 file_ptr reloc_base
;
1956 file_ptr lineno_base
;
1960 unsigned long reloc_size
= 0;
1961 unsigned long lnno_size
= 0;
1962 asection
*text_sec
= NULL
;
1963 asection
*data_sec
= NULL
;
1964 asection
*bss_sec
= NULL
;
1966 struct internal_filehdr internal_f
;
1967 struct internal_aouthdr internal_a
;
1970 bfd_error
= system_call_error
;
1973 if(abfd
->output_has_begun
== false) {
1974 coff_compute_section_file_positions(abfd
);
1977 if (abfd
->sections
!= (asection
*)NULL
) {
1978 scn_base
= abfd
->sections
->filepos
;
1983 if (bfd_seek(abfd
, scn_base
, SEEK_SET
) != 0)
1985 reloc_base
= obj_relocbase(abfd
);
1987 /* Make a pass through the symbol table to count line number entries and
1988 put them into the correct asections */
1990 #ifndef NO_COFF_LINENOS
1991 coff_count_linenumbers(abfd
);
1993 data_base
= scn_base
;
1995 /* Work out the size of the reloc and linno areas */
1997 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
) {
1998 reloc_size
+= current
->reloc_count
* RELSZ
;
1999 #ifndef NO_COFF_LINENOS
2000 lnno_size
+= current
->lineno_count
* LINESZ
;
2002 data_base
+= SCNHSZ
;
2005 lineno_base
= reloc_base
+ reloc_size
;
2006 sym_base
= lineno_base
+ lnno_size
;
2008 /* Indicate in each section->line_filepos its actual file address */
2009 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
) {
2010 if (current
->lineno_count
) {
2011 current
->line_filepos
= lineno_base
;
2012 current
->moving_line_filepos
= lineno_base
;
2013 #ifndef NO_COFF_LINENOS
2014 lineno_base
+= current
->lineno_count
* LINESZ
;
2018 current
->line_filepos
= 0;
2020 if (current
->reloc_count
) {
2021 current
->rel_filepos
= reloc_base
;
2022 reloc_base
+= current
->reloc_count
* sizeof(struct internal_reloc
);
2025 current
->rel_filepos
= 0;
2029 /* Write section headers to the file. */
2032 (file_ptr
) ((abfd
->flags
& EXEC_P
) ?
2033 (FILHSZ
+ AOUTSZ
) : FILHSZ
),
2038 unsigned int pad
= abfd
->flags
& D_PAGED
? data_base
: 0;
2040 unsigned int pad
= 0;
2042 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
) {
2043 struct internal_scnhdr section
;
2044 strncpy(&(section
.s_name
[0]), current
->name
, 8);
2045 section
.s_vaddr
= current
->vma
+ pad
;
2046 section
.s_paddr
= current
->vma
+ pad
;
2047 section
.s_size
= current
->size
- pad
;
2049 If this section has no size or is unloadable then the scnptr
2052 if (current
->size
- pad
== 0 ||
2053 (current
->flags
& SEC_LOAD
) == 0) {
2054 section
.s_scnptr
= 0;
2057 section
.s_scnptr
= current
->filepos
;
2059 section
.s_relptr
= current
->rel_filepos
;
2060 section
.s_lnnoptr
= current
->line_filepos
;
2061 section
.s_nreloc
= current
->reloc_count
;
2062 section
.s_nlnno
= current
->lineno_count
;
2063 if (current
->reloc_count
!= 0)
2065 if (current
->lineno_count
!= 0)
2068 section
.s_flags
= sec_to_styp_flags(current
->name
,current
->flags
);
2070 if (!strcmp(current
->name
, _TEXT
)) {
2072 } else if (!strcmp(current
->name
, _DATA
)) {
2074 } else if (!strcmp(current
->name
, _BSS
)) {
2079 section
.s_align
= (current
->alignment_power
2080 ? 1 << current
->alignment_power
2087 coff_swap_scnhdr_out(abfd
, §ion
, &buff
);
2088 bfd_write((PTR
) (&buff
), 1, SCNHSZ
, abfd
);
2095 /* OK, now set up the filehdr... */
2096 internal_f
.f_nscns
= abfd
->section_count
;
2098 We will NOT put a fucking timestamp in the header here. Every time you
2099 put it back, I will come in and take it out again. I'm sorry. This
2100 field does not belong here. We fill it with a 0 so it compares the
2101 same but is not a reasonable time. -- gnu@cygnus.com
2104 Well, I like it, so I'm conditionally compiling it in.
2107 #ifdef COFF_TIMESTAMP
2108 internal_f
.f_timdat
= time(0);
2110 internal_f
.f_timdat
= 0;
2113 if (bfd_get_symcount(abfd
) != 0)
2114 internal_f
.f_symptr
= sym_base
;
2116 internal_f
.f_symptr
= 0;
2118 internal_f
.f_flags
= 0;
2120 if (abfd
->flags
& EXEC_P
)
2121 internal_f
.f_opthdr
= AOUTSZ
;
2123 internal_f
.f_opthdr
= 0;
2126 internal_f
.f_flags
|= F_RELFLG
;
2128 internal_f
.f_flags
|= F_LNNO
;
2129 if (0 == bfd_get_symcount(abfd
))
2130 internal_f
.f_flags
|= F_LSYMS
;
2131 if (abfd
->flags
& EXEC_P
)
2132 internal_f
.f_flags
|= F_EXEC
;
2134 internal_f
.f_flags
|= F_AR32W
;
2136 if (!abfd
->xvec
->byteorder_big_p
)
2137 internal_f
.f_flags
|= F_AR32WR
;
2140 FIXME, should do something about the other byte orders and
2144 /* Set up architecture-dependent stuff */
2146 { unsigned int magic
= 0;
2147 unsigned short flags
= 0;
2148 coff_set_flags(abfd
, &magic
, &flags
);
2149 internal_f
.f_magic
= magic
;
2150 internal_f
.f_flags
|= flags
;
2151 /* ...and the "opt"hdr... */
2154 # ifdef ULTRA3 /* NYU's machine */
2155 /* FIXME: This is a bogus check. I really want to see if there
2156 * is a .shbss or a .shdata section, if so then set the magic
2157 * number to indicate a shared data executable.
2159 if (internal_f
.f_nscns
>= 7)
2160 internal_a
.magic
= SHMAGIC
; /* Shared magic */
2162 # endif /* ULTRA3 */
2163 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
2164 #define __A_MAGIC_SET__
2167 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
2168 #define __A_MAGIC_SET__
2171 #define __A_MAGIC_SET__
2172 internal_a
.magic
= PAGEMAGICBCS
;
2175 #if M68 || I386 || MIPS
2176 #define __A_MAGIC_SET__
2177 /* Never was anything here for the 68k */
2181 #define __A_MAGIC_SET__
2182 internal_a
.magic
= (abfd
->flags
& D_PAGED
)? RS6K_AOUTHDR_ZMAGIC
:
2183 (abfd
->flags
& WP_TEXT
)? RS6K_AOUTHDR_NMAGIC
:
2184 RS6K_AOUTHDR_OMAGIC
;
2187 #ifndef __A_MAGIC_SET__
2188 # include "Your aouthdr magic number is not being set!"
2190 # undef __A_MAGIC_SET__
2193 /* Now should write relocs, strings, syms */
2194 obj_sym_filepos(abfd
) = sym_base
;
2196 #ifndef NO_COFF_SYMBOLS
2197 if (bfd_get_symcount(abfd
) != 0) {
2198 coff_renumber_symbols(abfd
);
2199 coff_mangle_symbols(abfd
);
2200 coff_write_symbols(abfd
);
2201 coff_write_linenumbers(abfd
);
2202 coff_write_relocs(abfd
);
2204 #endif /* NO_COFF_SYMBOLS */
2206 internal_a
.tsize
= text_sec
->size
;
2207 internal_a
.text_start
=text_sec
->size
? text_sec
->vma
: 0;
2210 internal_a
.dsize
= data_sec
->size
;
2211 internal_a
.data_start
= data_sec
->size
? data_sec
->vma
: 0;
2214 internal_a
.bsize
= bss_sec
->size
;
2217 internal_a
.entry
= bfd_get_start_address(abfd
);
2218 internal_f
.f_nsyms
= bfd_get_symcount(abfd
);
2220 /* now write them */
2221 if (bfd_seek(abfd
, 0L, SEEK_SET
) != 0)
2225 coff_swap_filehdr_out(abfd
, &internal_f
, &buff
);
2226 bfd_write((PTR
) &buff
, 1, FILHSZ
, abfd
);
2228 if (abfd
->flags
& EXEC_P
) {
2230 coff_swap_aouthdr_out(abfd
, &internal_a
, &buff
);
2231 bfd_write((PTR
) &buff
, 1, AOUTSZ
, abfd
);
2236 #ifndef NO_COFF_SYMBOLS
2239 this function transforms the offsets into the symbol table into
2240 pointers to syments.
2245 DEFUN(coff_pointerize_aux
,(ignore_abfd
, table_base
, type
, class, auxent
),
2246 bfd
*ignore_abfd AND
2247 combined_entry_type
*table_base AND
2250 combined_entry_type
*auxent
)
2252 /* Don't bother if this is a file or a section */
2253 if (class == C_STAT
&& type
== T_NULL
) return;
2254 if (class == C_FILE
) return;
2256 /* Otherwise patch up */
2257 if (ISFCN(type
) || ISTAG(class) || class == C_BLOCK
) {
2258 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
= table_base
+
2259 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2260 auxent
->fix_end
= 1;
2262 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
!= 0) {
2263 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
= table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
2264 auxent
->fix_tag
= 1;
2268 #endif /* NO_COFF_SYMBOLS */
2271 DEFUN(coff_set_section_contents
,(abfd
, section
, location
, offset
, count
),
2276 bfd_size_type count
)
2278 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
2279 coff_compute_section_file_positions(abfd
);
2281 bfd_seek(abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
);
2284 return (bfd_write(location
, 1, count
, abfd
) == count
) ? true : false;
2290 coff_close_and_cleanup(abfd
)
2293 if (!bfd_read_p(abfd
))
2294 switch (abfd
->format
) {
2296 if (!_bfd_write_archive_contents(abfd
))
2300 if (!coff_write_object_contents(abfd
))
2304 bfd_error
= invalid_operation
;
2308 /* We depend on bfd_close to free all the memory on the obstack. */
2309 /* FIXME if bfd_release is not using obstacks! */
2315 buy_and_read(abfd
, where
, seek_direction
, size
)
2321 PTR area
= (PTR
) bfd_alloc(abfd
, size
);
2323 bfd_error
= no_memory
;
2326 bfd_seek(abfd
, where
, seek_direction
);
2327 if (bfd_read(area
, 1, size
, abfd
) != size
) {
2328 bfd_error
= system_call_error
;
2332 } /* buy_and_read() */
2335 #ifndef NO_COFF_SYMBOLS
2338 DEFUN(build_string_table
,(abfd
),
2341 char string_table_size_buffer
[4];
2342 unsigned int string_table_size
;
2345 /* At this point we should be "seek"'d to the end of the
2346 symbols === the symbol table size. */
2347 if (bfd_read((char *) string_table_size_buffer
,
2348 sizeof(string_table_size_buffer
),
2349 1, abfd
) != sizeof(string_table_size
)) {
2350 bfd_error
= system_call_error
;
2354 string_table_size
= bfd_h_get_32(abfd
, (bfd_byte
*) string_table_size_buffer
);
2356 if ((string_table
= (PTR
) bfd_alloc(abfd
, string_table_size
-= 4)) == NULL
) {
2357 bfd_error
= no_memory
;
2359 } /* on mallocation error */
2360 if (bfd_read(string_table
, string_table_size
, 1, abfd
) != string_table_size
) {
2361 bfd_error
= system_call_error
;
2364 return string_table
;
2367 /* Allocate space for the ".debug" section, and read it.
2368 We did not read the debug section until now, because
2369 we didn't want to go to the trouble until someone needed it. */
2372 DEFUN(build_debug_section
,(abfd
),
2375 char *debug_section
;
2378 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
2381 bfd_error
= no_debug_section
;
2385 debug_section
= (PTR
) bfd_alloc (abfd
, bfd_section_size (abfd
, sect
));
2386 if (debug_section
== NULL
) {
2387 bfd_error
= no_memory
;
2391 /* Seek to the beginning of the `.debug' section and read it.
2392 Save the current position first; it is needed by our caller.
2393 Then read debug section and reset the file pointer. */
2395 position
= bfd_tell (abfd
);
2396 bfd_seek (abfd
, sect
->filepos
, SEEK_SET
);
2397 if (bfd_read (debug_section
, bfd_section_size (abfd
, sect
), 1, abfd
)
2398 != bfd_section_size (abfd
, sect
)) {
2399 bfd_error
= system_call_error
;
2402 bfd_seek (abfd
, position
, SEEK_SET
);
2403 return debug_section
;
2407 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
2408 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
2409 be \0-terminated. */
2411 DEFUN(copy_name
,(abfd
, name
, maxlen
),
2419 for (len
= 0; len
< maxlen
; ++len
) {
2420 if (name
[len
] == '\0') {
2425 if ((newname
= (PTR
) bfd_alloc(abfd
, len
+1)) == NULL
) {
2426 bfd_error
= no_memory
;
2429 strncpy(newname
, name
, len
);
2430 newname
[len
] = '\0';
2435 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
2436 knit the symbol names into a normalized form. By normalized here I
2437 mean that all symbols have an n_offset pointer that points to a null-
2438 terminated string. */
2440 #ifndef SYMNAME_IN_DEBUG
2441 #define SYMNAME_IN_DEBUG(x) 0
2444 static combined_entry_type
*
2445 DEFUN(get_normalized_symtab
,(abfd
),
2448 combined_entry_type
*internal
;
2449 combined_entry_type
*internal_ptr
;
2450 combined_entry_type
*internal_end
;
2454 char *string_table
= NULL
;
2455 char *debug_section
= NULL
;
2458 unsigned int raw_size
;
2459 if (obj_raw_syments(abfd
) != (combined_entry_type
*)NULL
) {
2460 return obj_raw_syments(abfd
);
2462 if ((size
= bfd_get_symcount(abfd
) * sizeof(combined_entry_type
)) == 0) {
2463 bfd_error
= no_symbols
;
2467 internal
= (combined_entry_type
*)bfd_alloc(abfd
, size
);
2468 internal_end
= internal
+ bfd_get_symcount(abfd
);
2470 raw_size
= bfd_get_symcount(abfd
) * SYMESZ
;
2471 raw
= (SYMENT
*)bfd_alloc(abfd
,raw_size
);
2473 if (bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
) == -1
2474 || bfd_read((PTR
)raw
, raw_size
, 1, abfd
) != raw_size
) {
2475 bfd_error
= system_call_error
;
2478 /* mark the end of the symbols */
2479 raw_end
= raw
+ bfd_get_symcount(abfd
);
2481 FIXME SOMEDAY. A string table size of zero is very weird, but
2482 probably possible. If one shows up, it will probably kill us.
2485 /* Swap all the raw entries */
2486 for (raw_src
= raw
, internal_ptr
= internal
;
2488 raw_src
++, internal_ptr
++) {
2491 coff_swap_sym_in(abfd
, (char *)raw_src
, (char *)&internal_ptr
->u
.syment
);
2492 internal_ptr
->fix_tag
= 0;
2493 internal_ptr
->fix_end
= 0;
2495 for (i
= internal_ptr
->u
.syment
.n_numaux
;
2497 --i
, raw_src
++, internal_ptr
++) {
2499 (internal_ptr
+1)->fix_tag
= 0;
2500 (internal_ptr
+1)->fix_end
= 0;
2502 coff_swap_aux_in(abfd
, (char *)(raw_src
+1),
2503 internal_ptr
->u
.syment
.n_type
,
2504 internal_ptr
->u
.syment
.n_sclass
,
2505 &(internal_ptr
+1)->u
.auxent
);
2507 coff_pointerize_aux(abfd
,
2509 internal_ptr
->u
.syment
.n_type
,
2510 internal_ptr
->u
.syment
.n_sclass
,
2515 /* Free all the raw stuff */
2516 bfd_release(abfd
, raw
);
2518 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
2521 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
) {
2522 /* make a file symbol point to the name in the auxent, since
2523 the text ".file" is redundant */
2524 if ((internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_zeroes
== 0) {
2525 /* the filename is a long one, point into the string table */
2526 if (string_table
== NULL
) {
2527 string_table
= build_string_table(abfd
);
2530 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
2531 (int) (string_table
- 4 +
2532 (internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_offset
);
2535 /* ordinary short filename, put into memory anyway */
2536 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2537 copy_name(abfd
, (internal_ptr
+1)->u
.auxent
.x_file
.x_fname
,
2542 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0) {
2543 /* This is a "short" name. Make it long. */
2544 unsigned long i
= 0;
2545 char *newstring
= NULL
;
2547 /* find the length of this string without walking into memory
2549 for (i
= 0; i
< 8; ++i
) {
2550 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0') {
2552 } /* if end of string */
2553 } /* possible lengths of this string. */
2555 if ((newstring
= (PTR
) bfd_alloc(abfd
, ++i
)) == NULL
) {
2556 bfd_error
= no_memory
;
2559 bzero(newstring
, i
);
2560 strncpy(newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
-1);
2561 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int) newstring
;
2562 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
2564 else if (!SYMNAME_IN_DEBUG(&internal_ptr
->u
.syment
)) {
2565 /* Long name already. Point symbol at the string in the table. */
2566 if (string_table
== NULL
) {
2567 string_table
= build_string_table(abfd
);
2569 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2570 (string_table
- 4 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
2573 /* Long name in debug section. Very similar. */
2574 if (debug_section
== NULL
) {
2575 debug_section
= build_debug_section(abfd
);
2577 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2578 (debug_section
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
2581 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
2584 obj_raw_syments(abfd
) = internal
;
2587 } /* get_normalized_symtab() */
2589 #endif /* NO_COFF_SYMBOLS */
2593 DEFUN(section_from_bfd_index
,(abfd
, index
),
2598 struct sec
*answer
= abfd
->sections
;
2600 answer
= answer
->next
;
2607 #ifndef NO_COFF_LINENOS
2610 @subsubsection Reading Linenumbers
2611 Createing the linenumber table is done by reading in the entire coff
2612 linenumber table, and creating another table for internal use.
2614 A coff line number table is structured so that each
2615 function is marked as having a line number of 0. Each line within the
2616 function is an offset from the first line in the function. The base of
2617 the line number information for the table is stored in the symbol
2618 associated with the function.
2620 The information is copied from the external to the internal table, and
2621 each symbol which marks a function is marked by pointing its...
2623 **How does this work ?**
2628 coff_slurp_line_table(abfd
, asect
)
2632 LINENO
*native_lineno
;
2633 alent
*lineno_cache
;
2635 BFD_ASSERT(asect
->lineno
== (alent
*) NULL
);
2637 native_lineno
= (LINENO
*) buy_and_read(abfd
,
2638 asect
->line_filepos
,
2641 asect
->lineno_count
));
2643 (alent
*) bfd_alloc(abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof(alent
)));
2644 if (lineno_cache
== NULL
) {
2645 bfd_error
= no_memory
;
2648 unsigned int counter
= 0;
2649 alent
*cache_ptr
= lineno_cache
;
2650 LINENO
*src
= native_lineno
;
2652 while (counter
< asect
->lineno_count
) {
2653 struct internal_lineno dst
;
2654 coff_swap_lineno_in(abfd
, src
, &dst
);
2655 cache_ptr
->line_number
= dst
.l_lnno
;
2657 if (cache_ptr
->line_number
== 0) {
2658 coff_symbol_type
*sym
=
2659 (coff_symbol_type
*) (dst
.l_addr
.l_symndx
2660 + obj_symbol_slew(abfd
)
2661 + obj_raw_syments(abfd
))->u
.syment
._n
._n_n
._n_zeroes
;
2662 cache_ptr
->u
.sym
= (asymbol
*) sym
;
2663 sym
->lineno
= cache_ptr
;
2666 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
2667 - bfd_section_vma(abfd
, asect
);
2668 } /* If no linenumber expect a symbol index */
2674 cache_ptr
->line_number
= 0;
2677 asect
->lineno
= lineno_cache
;
2678 /* FIXME, free native_lineno here, or use alloca or something. */
2680 } /* coff_slurp_line_table() */
2682 #endif /* NO_COFF_LINENOS */
2684 #ifndef NO_COFF_LINENOS
2687 DEFUN(coff_slurp_symbol_table
,(abfd
),
2690 combined_entry_type
*native_symbols
;
2691 coff_symbol_type
*cached_area
;
2692 unsigned int *table_ptr
;
2694 unsigned int number_of_symbols
= 0;
2695 if (obj_symbols(abfd
))
2697 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
2699 /* Read in the symbol table */
2700 if ((native_symbols
= get_normalized_symtab(abfd
)) == NULL
) {
2704 /* Allocate enough room for all the symbols in cached form */
2706 (coff_symbol_type
*)
2707 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(coff_symbol_type
)));
2709 if (cached_area
== NULL
) {
2710 bfd_error
= no_memory
;
2715 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(unsigned int)));
2717 if (table_ptr
== NULL
) {
2718 bfd_error
= no_memory
;
2723 coff_symbol_type
*dst
= cached_area
;
2724 unsigned int last_native_index
= bfd_get_symcount(abfd
);
2725 unsigned int this_index
= 0;
2726 while (this_index
< last_native_index
) {
2727 combined_entry_type
*src
= native_symbols
+ this_index
;
2728 table_ptr
[this_index
] = number_of_symbols
;
2729 dst
->symbol
.the_bfd
= abfd
;
2731 dst
->symbol
.name
= (char *)(src
->u
.syment
._n
._n_n
._n_offset
);
2733 We use the native name field to point to the cached field
2735 src
->u
.syment
._n
._n_n
._n_zeroes
= (int) dst
;
2736 dst
->symbol
.section
= section_from_bfd_index(abfd
,
2737 src
->u
.syment
.n_scnum
);
2738 switch (src
->u
.syment
.n_sclass
) {
2742 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
2743 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2744 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
2746 /* Fall through to next case */
2754 if ((src
->u
.syment
.n_scnum
) == 0) {
2755 if ((src
->u
.syment
.n_value
) == 0) {
2756 dst
->symbol
.flags
= BSF_UNDEFINED
;
2757 dst
->symbol
.value
= 0;
2760 dst
->symbol
.flags
= BSF_FORT_COMM
;
2761 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2766 Base the value as an index from the base of the
2769 if (dst
->symbol
.section
== (asection
*) NULL
) {
2770 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
| BSF_ABSOLUTE
;
2771 dst
->symbol
.value
= src
->u
.syment
.n_value
;
2774 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2775 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
2777 if (ISFCN((src
->u
.syment
.n_type
))) {
2779 A function ext does not go at the end of a file
2781 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
2788 case C_STAT
: /* static */
2790 case C_LEAFSTAT
: /* static leaf procedure */
2792 case C_LABEL
: /* label */
2793 if (src
->u
.syment
.n_scnum
== -2)
2794 dst
->symbol
.flags
= BSF_DEBUGGING
;
2796 dst
->symbol
.flags
= BSF_LOCAL
;
2798 Base the value as an index from the base of the section, if
2801 if (dst
->symbol
.section
)
2802 dst
->symbol
.value
= (src
->u
.syment
.n_value
) -
2803 dst
->symbol
.section
->vma
;
2805 dst
->symbol
.value
= (src
->u
.syment
.n_value
) ;
2808 case C_MOS
: /* member of structure */
2809 case C_EOS
: /* end of structure */
2810 #ifdef NOTDEF /* C_AUTOARG has the same value */
2812 case C_GLBLREG
: /* A29k-specific storage class */
2815 case C_REGPARM
: /* register parameter */
2816 case C_REG
: /* register variable */
2818 case C_AUTOARG
: /* 960-specific storage class */
2820 case C_TPDEF
: /* type definition */
2822 case C_AUTO
: /* automatic variable */
2823 case C_FIELD
: /* bit field */
2824 case C_ENTAG
: /* enumeration tag */
2825 case C_MOE
: /* member of enumeration */
2826 case C_MOU
: /* member of union */
2827 case C_UNTAG
: /* union tag */
2828 dst
->symbol
.flags
= BSF_DEBUGGING
;
2829 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2832 case C_FILE
: /* file name */
2833 case C_STRTAG
: /* structure tag */
2835 case C_BINCL
: /* beginning of include file */
2836 case C_EINCL
: /* ending of include file */
2849 dst
->symbol
.flags
= BSF_DEBUGGING
;
2850 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2853 case C_BLOCK
: /* ".bb" or ".eb" */
2854 case C_FCN
: /* ".bf" or ".ef" */
2855 case C_EFCN
: /* physical end of function */
2856 dst
->symbol
.flags
= BSF_LOCAL
;
2858 Base the value as an index from the base of the section
2860 dst
->symbol
.value
= (src
->u
.syment
.n_value
) - dst
->symbol
.section
->vma
;
2864 case C_EXTDEF
: /* external definition */
2865 case C_ULABEL
: /* undefined label */
2866 case C_USTATIC
: /* undefined static */
2867 case C_LINE
: /* line # reformatted as symbol table entry */
2868 case C_ALIAS
: /* duplicate tag */
2869 case C_HIDDEN
: /* ext symbol in dmert public lib */
2872 fprintf(stderr
,"Unrecognized storage class %d\n",
2873 src
->u
.syment
.n_sclass
);
2875 dst
->symbol
.flags
= BSF_DEBUGGING
;
2876 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2880 BFD_ASSERT(dst
->symbol
.flags
!= 0);
2884 dst
->symbol
.udata
= 0;
2885 dst
->lineno
= (alent
*) NULL
;
2886 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
2888 number_of_symbols
++;
2889 } /* walk the native symtab */
2890 } /* bfdize the native symtab */
2892 obj_symbols(abfd
) = cached_area
;
2893 obj_raw_syments(abfd
) = native_symbols
;
2895 bfd_get_symcount(abfd
) = number_of_symbols
;
2896 obj_convert(abfd
) = table_ptr
;
2897 /* Slurp the line tables for each section too */
2902 coff_slurp_line_table(abfd
, p
);
2907 } /* coff_slurp_symbol_table() */
2910 coff_get_symtab_upper_bound(abfd
)
2913 if (!coff_slurp_symbol_table(abfd
))
2916 return (bfd_get_symcount(abfd
) + 1) * (sizeof(coff_symbol_type
*));
2921 DEFUN(coff_get_symtab
, (abfd
, alocation
),
2923 asymbol
**alocation
)
2925 unsigned int counter
= 0;
2926 coff_symbol_type
*symbase
;
2927 coff_symbol_type
**location
= (coff_symbol_type
**) (alocation
);
2928 if (!coff_slurp_symbol_table(abfd
))
2931 symbase
= obj_symbols(abfd
);
2932 while (counter
< bfd_get_symcount(abfd
))
2934 /* This nasty code looks at the symbol to decide whether or
2935 not it is descibes a constructor/destructor entry point. It
2936 is structured this way to (hopefully) speed non matches */
2938 if (symbase
->symbol
.name
[9] == '$')
2940 bfd_constructor_entry(abfd
,
2941 (asymbol
**)location
,
2942 symbase
->symbol
.name
[10] == 'I' ?
2946 *(location
++) = symbase
++;
2950 return bfd_get_symcount(abfd
);
2953 #endif /* NO_COFF_SYMBOLS */
2956 coff_get_reloc_upper_bound(abfd
, asect
)
2960 if (bfd_get_format(abfd
) != bfd_object
) {
2961 bfd_error
= invalid_operation
;
2964 return (asect
->reloc_count
+ 1) * sizeof(arelent
*);
2968 @subsubsection Reading Relocations
2969 Coff relocations are easily transformed into the internal BFD form
2972 Reading a coff relocation table is done in the following stages:
2975 The entire coff relocation table is read into memory.
2977 Each relocation is processed in turn, first it is swapped from the
2978 external to the internal form.
2980 The symbol referenced in the relocation's symbol index is turned into
2981 a pointer into the canonical symbol table. Note that this table is the
2982 same as the one returned by a call to @code{bfd_canonicalize_symtab}.
2983 The back end will call the routine and save the result if a
2984 canonicalization hasn't been done.
2986 The reloc index is turned into a pointer to a howto structure, in a
2987 back end specific way. For instance, the 386 and 960 use the
2988 @code{r_type} to directly produce an index into a howto table vector;
2989 the 88k subtracts a number from the @code{r_type} field and creates an
2995 DEFUN(coff_slurp_reloc_table
,(abfd
, asect
, symbols
),
3000 RELOC
*native_relocs
;
3001 arelent
*reloc_cache
;
3002 if (asect
->relocation
)
3004 if (asect
->reloc_count
== 0)
3006 if (asect
->flags
& SEC_CONSTRUCTOR
)
3008 #ifndef NO_COFF_SYMBOLS
3009 if (!coff_slurp_symbol_table(abfd
))
3013 (RELOC
*) buy_and_read(abfd
,
3017 asect
->reloc_count
));
3018 reloc_cache
= (arelent
*)
3019 bfd_alloc(abfd
, (size_t) (asect
->reloc_count
* sizeof(arelent
)));
3021 if (reloc_cache
== NULL
) {
3022 bfd_error
= no_memory
;
3027 for (cache_ptr
= reloc_cache
,
3028 src
= native_relocs
;
3029 cache_ptr
< reloc_cache
+ asect
->reloc_count
;
3032 struct internal_reloc dst
;
3034 bfd_swap_reloc_in(abfd
, src
, &dst
);
3036 dst
.r_symndx
+= obj_symbol_slew(abfd
);
3037 cache_ptr
->sym_ptr_ptr
= symbols
+ obj_convert(abfd
)[dst
.r_symndx
];
3039 /* AMD has two relocation entries for the 'consth' instruction.
3040 * The first is R_IHIHALF (part 1), the second is R_IHCONST
3041 * (part 2). The second entry's r_symndx does not contain
3042 * an index to a symbol but rather a value (apparently).
3043 * Also, see the ifdef below for saving the r_symndx value in addend.
3045 if (dst
.r_type
== R_IHCONST
) {
3049 ptr
= *(cache_ptr
->sym_ptr_ptr
);
3050 cache_ptr
->address
= dst
.r_vaddr
;
3052 The symbols definitions that we have read in have been
3053 relocated as if their sections started at 0. But the offsets
3054 refering to the symbols in the raw data have not been
3055 modified, so we have to have a negative addend to compensate.
3057 Note that symbols which used to be common must be left alone */
3059 if (ptr
&& ptr
->the_bfd
== abfd
3060 && ptr
->section
!= (asection
*) NULL
3061 && ((ptr
->flags
& BSF_OLD_COMMON
)== 0))
3064 cache_ptr
->addend
= -(ptr
->section
->vma
+ ptr
->value
);
3066 cache_ptr
->addend
= 0;
3071 cache_ptr
->addend
= 0;
3074 cache_ptr
->address
-= asect
->vma
;
3076 cache_ptr
->section
= (asection
*) NULL
;
3079 if (dst
.r_type
== R_IHCONST
) {
3080 /* Add in the value which was stored in the symbol index */
3081 /* See above comment */
3082 cache_ptr
->addend
+= dst
.r_symndx
;
3083 /* Throw away the bogus symbol pointer */
3084 cache_ptr
->sym_ptr_ptr
= 0;
3086 cache_ptr
->howto
= howto_table
+ dst
.r_type
;
3089 cache_ptr
->howto
= howto_table
+ dst
.r_type
;
3092 cache_ptr
->howto
= howto_table
+ dst
.r_type
;
3095 cache_ptr
->howto
= howto_table
+ dst
.r_type
- R_RELBYTE
;
3098 if (dst
.r_type
>= R_PCR16L
&& dst
.r_type
<= R_VRT32
) {
3099 cache_ptr
->howto
= howto_table
+ dst
.r_type
- R_PCR16L
;
3100 cache_ptr
->addend
+= dst
.r_offset
<< 16;
3109 asect
->relocation
= reloc_cache
;
3114 /* This is stupid. This function should be a boolean predicate */
3116 DEFUN(coff_canonicalize_reloc
, (abfd
, section
, relptr
, symbols
),
3119 arelent
**relptr AND
3122 arelent
*tblptr
= section
->relocation
;
3123 unsigned int count
= 0;
3126 if (section
->flags
& SEC_CONSTRUCTOR
)
3128 /* this section has relocs made up by us, they are not in the
3129 file, so take them out of their chain and place them into
3130 the data area provided */
3131 arelent_chain
*chain
= section
->constructor_chain
;
3132 for (count
= 0; count
< section
->reloc_count
; count
++)
3134 *relptr
++ = &chain
->relent
;
3135 chain
= chain
->next
;
3141 coff_slurp_reloc_table(abfd
, section
, symbols
);
3144 tblptr
= section
->relocation
;
3148 for (; count
++ < section
->reloc_count
;)
3149 *relptr
++ = tblptr
++;
3154 return section
->reloc_count
;
3157 #ifndef NO_COFF_SYMBOLS
3160 provided a BFD, a section and an offset into the section, calculate and
3161 return the name of the source file and the line nearest to the wanted
3166 DEFUN(coff_find_nearest_line
,(abfd
,
3174 asection
*section AND
3175 asymbol
**ignore_symbols AND
3177 CONST
char **filename_ptr AND
3178 CONST
char **functionname_ptr AND
3179 unsigned int *line_ptr
)
3181 static bfd
*cache_abfd
;
3182 static asection
*cache_section
;
3183 static bfd_vma cache_offset
;
3184 static unsigned int cache_i
;
3185 static alent
*cache_l
;
3188 coff_data_type
*cof
= coff_data(abfd
);
3189 /* Run through the raw syments if available */
3190 combined_entry_type
*p
;
3192 unsigned int line_base
= 0;
3196 *functionname_ptr
= 0;
3199 /* Don't try and find line numbers in a non coff file */
3200 if (abfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
3206 p
= cof
->raw_syments
;
3208 for (i
= 0; i
< cof
->raw_syment_count
; i
++) {
3209 if (p
->u
.syment
.n_sclass
== C_FILE
) {
3210 /* File name has been moved into symbol */
3211 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
3214 p
+= 1 + p
->u
.syment
.n_numaux
;
3216 /* Now wander though the raw linenumbers of the section */
3218 If this is the same BFD as we were previously called with and this is
3219 the same section, and the offset we want is further down then we can
3220 prime the lookup loop
3222 if (abfd
== cache_abfd
&&
3223 section
== cache_section
&&
3224 offset
>= cache_offset
) {
3230 l
= section
->lineno
;
3233 for (; i
< section
->lineno_count
; i
++) {
3234 if (l
->line_number
== 0) {
3235 /* Get the symbol this line number points at */
3236 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
3237 *functionname_ptr
= coff
->symbol
.name
;
3239 combined_entry_type
*s
= coff
->native
;
3240 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
3242 S should now point to the .bf of the function
3244 if (s
->u
.syment
.n_numaux
) {
3246 The linenumber is stored in the auxent
3248 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
3249 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
3254 if (l
->u
.offset
> offset
)
3256 *line_ptr
= l
->line_number
+ line_base
+ 1;
3262 cache_section
= section
;
3263 cache_offset
= offset
;
3272 coff_sym_filepos(abfd
)
3275 return obj_sym_filepos(abfd
);
3279 #endif /* NO_COFF_SYMBOLS */
3283 DEFUN(coff_sizeof_headers
,(abfd
, reloc
),
3289 if (reloc
== false) {
3290 size
= FILHSZ
+ AOUTSZ
;
3296 size
+= abfd
->section_count
* SCNHSZ
;
3301 #define coff_core_file_failing_command _bfd_dummy_core_file_failing_command
3302 #define coff_core_file_failing_signal _bfd_dummy_core_file_failing_signal
3303 #define coff_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
3304 #define coff_slurp_armap bfd_slurp_coff_armap
3305 #define coff_slurp_extended_name_table _bfd_slurp_extended_name_table
3306 #define coff_truncate_arname bfd_dont_truncate_arname
3307 #define coff_openr_next_archived_file bfd_generic_openr_next_archived_file
3308 #define coff_generic_stat_arch_elt bfd_generic_stat_arch_elt
3309 #define coff_get_section_contents bfd_generic_get_section_contents
3310 #define coff_close_and_cleanup bfd_generic_close_and_cleanup
3312 #define coff_bfd_debug_info_start bfd_void
3313 #define coff_bfd_debug_info_end bfd_void
3314 #define coff_bfd_debug_info_accumulate (PROTO(void,(*),(bfd*, struct sec *))) bfd_void