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_LINENO_LNNO
304 #define PUT_LINENO_LNNO(abfd,val, ext) bfd_h_put_16(abfd,val, (bfd_byte *) (ext->l_lnno));
308 /* void warning(); */
311 * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the
312 * incoming SEC_* flags. The inverse of this function is styp_to_sec_flags().
313 * NOTE: If you add to/change this routine, you should mirror the changes
314 * in styp_to_sec_flags().
317 DEFUN(sec_to_styp_flags
, (sec_name
, sec_flags
),
318 CONST
char * sec_name AND
323 if (!strcmp(sec_name
, _TEXT
)) {
324 return((long)STYP_TEXT
);
325 } else if (!strcmp(sec_name
, _DATA
)) {
326 return((long)STYP_DATA
);
327 } else if (!strcmp(sec_name
, _BSS
)) {
328 return((long)STYP_BSS
);
330 } else if (!strcmp(sec_name
, _COMMENT
)) {
331 return((long)STYP_INFO
);
332 #endif /* _COMMENT */
335 /* Try and figure out what it should be */
336 if (sec_flags
& SEC_CODE
) styp_flags
= STYP_TEXT
;
337 if (sec_flags
& SEC_DATA
) styp_flags
= STYP_DATA
;
338 else if (sec_flags
& SEC_READONLY
)
339 #ifdef STYP_LIT /* 29k readonly text/data section */
340 styp_flags
= STYP_LIT
;
342 styp_flags
= STYP_TEXT
;
343 #endif /* STYP_LIT */
344 else if (sec_flags
& SEC_LOAD
) styp_flags
= STYP_TEXT
;
346 if (styp_flags
== 0) styp_flags
= STYP_BSS
;
351 * Return a word with SEC_* flags set to represent the incoming
352 * STYP_* flags (from scnhdr.s_flags). The inverse of this
353 * function is sec_to_styp_flags().
354 * NOTE: If you add to/change this routine, you should mirror the changes
355 * in sec_to_styp_flags().
358 DEFUN(styp_to_sec_flags
, (styp_flags
),
361 flagword sec_flags
=0;
363 if ((styp_flags
& STYP_TEXT
) || (styp_flags
& STYP_DATA
))
364 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
365 else if (styp_flags
& STYP_BSS
)
366 sec_flags
= SEC_ALLOC
;
368 #ifdef STYP_LIT /* A29k readonly text/data section type */
369 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
370 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
371 #endif /* STYP_LIT */
372 #ifdef STYP_OTHER_LOAD /* Other loaded sections */
373 if (styp_flags
& STYP_OTHER_LOAD
)
374 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
375 #endif /* STYP_SDATA */
380 #define get_index(symbol) ((int) (symbol)->value)
381 #define set_index(symbol, idx) ((symbol)->value = (idx))
383 /* **********************************************************************
384 Here are all the routines for swapping the structures seen in the
385 outside world into the internal forms.
390 DEFUN(bfd_swap_reloc_in
,(abfd
, reloc_src
, reloc_dst
),
393 struct internal_reloc
*reloc_dst
)
395 reloc_dst
->r_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*)reloc_src
->r_vaddr
);
396 reloc_dst
->r_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) reloc_src
->r_symndx
);
399 reloc_dst
->r_type
= bfd_h_get_8(abfd
, reloc_src
->r_type
);
400 reloc_dst
->r_size
= bfd_h_get_8(abfd
, reloc_src
->r_size
);
402 reloc_dst
->r_type
= bfd_h_get_16(abfd
, (bfd_byte
*) reloc_src
->r_type
);
406 reloc_dst
->r_offset
= bfd_h_get_16(abfd
, (bfd_byte
*) reloc_src
->r_offset
);
412 DEFUN(coff_swap_reloc_out
,(abfd
, src
, dst
),
417 struct internal_reloc
*reloc_src
= (struct internal_reloc
*)src
;
418 struct external_reloc
*reloc_dst
= (struct external_reloc
*)dst
;
419 bfd_h_put_32(abfd
, reloc_src
->r_vaddr
, (bfd_byte
*) reloc_dst
->r_vaddr
);
420 bfd_h_put_32(abfd
, reloc_src
->r_symndx
, (bfd_byte
*) reloc_dst
->r_symndx
);
421 bfd_h_put_16(abfd
, reloc_src
->r_type
, (bfd_byte
*) reloc_dst
->r_type
);
423 bfd_h_put_16(abfd
, reloc_src
->r_offset
, (bfd_byte
*) reloc_dst
->r_offset
);
425 return sizeof(struct external_reloc
);
429 DEFUN(bfd_swap_filehdr_in
,(abfd
, filehdr_src
, filehdr_dst
),
431 FILHDR
*filehdr_src AND
432 struct internal_filehdr
*filehdr_dst
)
434 filehdr_dst
->f_magic
= bfd_h_get_16(abfd
, (bfd_byte
*) filehdr_src
->f_magic
);
435 filehdr_dst
->f_nscns
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_nscns
);
436 filehdr_dst
->f_timdat
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_timdat
);
437 filehdr_dst
->f_symptr
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_symptr
);
438 filehdr_dst
->f_nsyms
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_nsyms
);
439 filehdr_dst
->f_opthdr
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_opthdr
);
440 filehdr_dst
->f_flags
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_flags
);
444 DEFUN(coff_swap_filehdr_out
,(abfd
, in
, out
),
449 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*)in
;
450 FILHDR
*filehdr_out
= (FILHDR
*)out
;
451 bfd_h_put_16(abfd
, filehdr_in
->f_magic
, (bfd_byte
*) filehdr_out
->f_magic
);
452 bfd_h_put_16(abfd
, filehdr_in
->f_nscns
, (bfd_byte
*) filehdr_out
->f_nscns
);
453 bfd_h_put_32(abfd
, filehdr_in
->f_timdat
, (bfd_byte
*) filehdr_out
->f_timdat
);
454 bfd_h_put_32(abfd
, filehdr_in
->f_symptr
, (bfd_byte
*) filehdr_out
->f_symptr
);
455 bfd_h_put_32(abfd
, filehdr_in
->f_nsyms
, (bfd_byte
*) filehdr_out
->f_nsyms
);
456 bfd_h_put_16(abfd
, filehdr_in
->f_opthdr
, (bfd_byte
*) filehdr_out
->f_opthdr
);
457 bfd_h_put_16(abfd
, filehdr_in
->f_flags
, (bfd_byte
*) filehdr_out
->f_flags
);
458 return sizeof(FILHDR
);
462 #ifndef NO_COFF_SYMBOLS
465 DEFUN(coff_swap_sym_in
,(abfd
, ext1
, in1
),
470 SYMENT
*ext
= (SYMENT
*)ext1
;
471 struct internal_syment
*in
= (struct internal_syment
*)in1
;
473 if( ext
->e
.e_name
[0] == 0) {
474 in
->_n
._n_n
._n_zeroes
= 0;
475 in
->_n
._n_n
._n_offset
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e
.e
.e_offset
);
478 #if SYMNMLEN != E_SYMNMLEN
479 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
481 memcpy(in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
484 in
->n_value
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_value
);
485 in
->n_scnum
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_scnum
);
486 if (sizeof(ext
->e_type
) == 2){
487 in
->n_type
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_type
);
490 in
->n_type
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_type
);
492 in
->n_sclass
= bfd_h_get_8(abfd
, ext
->e_sclass
);
493 in
->n_numaux
= bfd_h_get_8(abfd
, ext
->e_numaux
);
497 DEFUN(coff_swap_sym_out
,(abfd
, inp
, extp
),
502 struct internal_syment
*in
= (struct internal_syment
*)inp
;
503 SYMENT
*ext
=(SYMENT
*)extp
;
504 if(in
->_n
._n_name
[0] == 0) {
505 bfd_h_put_32(abfd
, 0, (bfd_byte
*) ext
->e
.e
.e_zeroes
);
506 bfd_h_put_32(abfd
, in
->_n
._n_n
._n_offset
, (bfd_byte
*) ext
->e
.e
.e_offset
);
509 #if SYMNMLEN != E_SYMNMLEN
510 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
512 memcpy(ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
515 bfd_h_put_32(abfd
, in
->n_value
, (bfd_byte
*) ext
->e_value
);
516 bfd_h_put_16(abfd
, in
->n_scnum
, (bfd_byte
*) ext
->e_scnum
);
517 if (sizeof(ext
->e_type
) == 2)
519 bfd_h_put_16(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
523 bfd_h_put_32(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
525 bfd_h_put_8(abfd
, in
->n_sclass
, ext
->e_sclass
);
526 bfd_h_put_8(abfd
, in
->n_numaux
, ext
->e_numaux
);
527 return sizeof(SYMENT
);
531 DEFUN(coff_swap_aux_in
,(abfd
, ext1
, type
, class, in1
),
538 AUXENT
*ext
= (AUXENT
*)ext1
;
539 union internal_auxent
*in
= (union internal_auxent
*)in1
;
542 if (ext
->x_file
.x_fname
[0] == 0) {
543 in
->x_file
.x_n
.x_zeroes
= 0;
544 in
->x_file
.x_n
.x_offset
=
545 bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
547 #if FILNMLEN != E_FILNMLEN
548 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
550 memcpy (in
->x_file
.x_fname
, ext
->x_file
.x_fname
, FILNMLEN
);
555 /* RS/6000 "csect" auxents */
559 in
->x_csect
.x_scnlen
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_scnlen
);
560 in
->x_csect
.x_parmhash
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_parmhash
);
561 in
->x_csect
.x_snhash
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snhash
);
562 /* We don't have to hack bitfields in x_smtyp because it's defined by
563 shifts-and-ands, which are equivalent on all byte orders. */
564 in
->x_csect
.x_smtyp
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smtyp
);
565 in
->x_csect
.x_smclas
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smclas
);
566 in
->x_csect
.x_stab
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_stab
);
567 in
->x_csect
.x_snstab
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snstab
);
576 if (type
== T_NULL
) {
577 in
->x_scn
.x_scnlen
= GET_SCN_SCNLEN(abfd
, ext
);
578 in
->x_scn
.x_nreloc
= GET_SCN_NRELOC(abfd
, ext
);
579 in
->x_scn
.x_nlinno
= GET_SCN_NLINNO(abfd
, ext
);
583 in
->x_sym
.x_tagndx
.l
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
585 in
->x_sym
.x_tvndx
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
588 if (ISARY(type
) || class == C_BLOCK
) {
589 #if DIMNUM != E_DIMNUM
590 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
592 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]);
593 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]);
594 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]);
595 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]);
598 in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= GET_FCN_LNNOPTR(abfd
, ext
);
599 in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= GET_FCN_ENDNDX(abfd
, ext
);
602 in
->x_sym
.x_misc
.x_fsize
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
605 in
->x_sym
.x_misc
.x_lnsz
.x_lnno
= GET_LNSZ_LNNO(abfd
, ext
);
606 in
->x_sym
.x_misc
.x_lnsz
.x_size
= GET_LNSZ_SIZE(abfd
, ext
);
612 DEFUN(coff_swap_aux_out
,(abfd
, inp
, type
, class, extp
),
619 union internal_auxent
*in
= (union internal_auxent
*)inp
;
620 AUXENT
*ext
= (AUXENT
*)extp
;
623 if (in
->x_file
.x_fname
[0] == 0) {
624 PUTWORD(abfd
, 0, (bfd_byte
*) ext
->x_file
.x_n
.x_zeroes
);
626 in
->x_file
.x_n
.x_offset
,
627 (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
630 #if FILNMLEN != E_FILNMLEN
631 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
633 memcpy (ext
->x_file
.x_fname
, in
->x_file
.x_fname
, FILNMLEN
);
639 /* RS/6000 "csect" auxents */
642 PUTWORD (abfd
, in
->x_csect
.x_scnlen
, ext
->x_csect
.x_scnlen
);
643 PUTWORD (abfd
, in
->x_csect
.x_parmhash
, ext
->x_csect
.x_parmhash
);
644 PUTHALF (abfd
, in
->x_csect
.x_snhash
, ext
->x_csect
.x_snhash
);
645 /* We don't have to hack bitfields in x_smtyp because it's defined by
646 shifts-and-ands, which are equivalent on all byte orders. */
647 PUTBYTE (abfd
, in
->x_csect
.x_smtyp
, ext
->x_csect
.x_smtyp
);
648 PUTBYTE (abfd
, in
->x_csect
.x_smclas
, ext
->x_csect
.x_smclas
);
649 PUTWORD (abfd
, in
->x_csect
.x_stab
, ext
->x_csect
.x_stab
);
650 PUTHALF (abfd
, in
->x_csect
.x_snstab
, ext
->x_csect
.x_snstab
);
659 if (type
== T_NULL
) {
660 PUT_SCN_SCNLEN(abfd
, in
->x_scn
.x_scnlen
, ext
);
661 PUT_SCN_NRELOC(abfd
, in
->x_scn
.x_nreloc
, ext
);
662 PUT_SCN_NLINNO(abfd
, in
->x_scn
.x_nlinno
, ext
);
666 PUTWORD(abfd
, in
->x_sym
.x_tagndx
.l
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
668 PUTWORD(abfd
, in
->x_sym
.x_tvndx
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
672 PUTWORD(abfd
, in
->x_sym
.x_misc
.x_fsize
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
673 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
674 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
678 if (ISARY(type
) || class == C_BLOCK
) {
679 #if DIMNUM != E_DIMNUM
680 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
682 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]);
683 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]);
684 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]);
685 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]);
688 PUT_LNSZ_LNNO(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
689 PUT_LNSZ_SIZE(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
691 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
692 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
697 return sizeof(AUXENT
);
700 #endif /* NO_COFF_SYMBOLS */
702 #ifndef NO_COFF_LINENOS
705 DEFUN(coff_swap_lineno_in
,(abfd
, ext1
, in1
),
710 LINENO
*ext
= (LINENO
*)ext1
;
711 struct internal_lineno
*in
= (struct internal_lineno
*)in1
;
713 in
->l_addr
.l_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->l_addr
.l_symndx
);
714 in
->l_lnno
= GET_LINENO_LNNO(abfd
, ext
);
718 DEFUN(coff_swap_lineno_out
,(abfd
, inp
, outp
),
723 struct internal_lineno
*in
= (struct internal_lineno
*)inp
;
724 struct external_lineno
*ext
= (struct external_lineno
*)outp
;
725 PUTWORD(abfd
, in
->l_addr
.l_symndx
, (bfd_byte
*)
726 ext
->l_addr
.l_symndx
);
728 PUT_LINENO_LNNO (abfd
, in
->l_lnno
, ext
);
729 return sizeof(struct external_lineno
);
732 #endif /* NO_COFF_LINENOS */
736 DEFUN(bfd_swap_aouthdr_in
,(abfd
, aouthdr_ext1
, aouthdr_int1
),
741 AOUTHDR
*aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
742 struct internal_aouthdr
*aouthdr_int
= (struct internal_aouthdr
*)aouthdr_int1
;
744 aouthdr_int
->magic
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->magic
);
745 aouthdr_int
->vstamp
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->vstamp
);
746 aouthdr_int
->tsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tsize
);
747 aouthdr_int
->dsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->dsize
);
748 aouthdr_int
->bsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->bsize
);
749 aouthdr_int
->entry
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->entry
);
750 aouthdr_int
->text_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->text_start
);
751 aouthdr_int
->data_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->data_start
);
753 aouthdr_int
->tagentries
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tagentries
);
757 aouthdr_int
->o_toc
= bfd_h_get_32(abfd
, aouthdr_ext
->o_toc
);
758 aouthdr_int
->o_snentry
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snentry
);
759 aouthdr_int
->o_sntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntext
);
760 aouthdr_int
->o_sndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sndata
);
761 aouthdr_int
->o_sntoc
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntoc
);
762 aouthdr_int
->o_snloader
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snloader
);
763 aouthdr_int
->o_snbss
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snbss
);
764 aouthdr_int
->o_algntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algntext
);
765 aouthdr_int
->o_algndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algndata
);
766 aouthdr_int
->o_modtype
= bfd_h_get_16(abfd
, aouthdr_ext
->o_modtype
);
767 aouthdr_int
->o_maxstack
= bfd_h_get_32(abfd
, aouthdr_ext
->o_maxstack
);
772 DEFUN(coff_swap_aouthdr_out
,(abfd
, in
, out
),
777 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*)in
;
778 AOUTHDR
*aouthdr_out
= (AOUTHDR
*)out
;
779 bfd_h_put_16(abfd
, aouthdr_in
->magic
, (bfd_byte
*) aouthdr_out
->magic
);
780 bfd_h_put_16(abfd
, aouthdr_in
->vstamp
, (bfd_byte
*) aouthdr_out
->vstamp
);
781 bfd_h_put_32(abfd
, aouthdr_in
->tsize
, (bfd_byte
*) aouthdr_out
->tsize
);
782 bfd_h_put_32(abfd
, aouthdr_in
->dsize
, (bfd_byte
*) aouthdr_out
->dsize
);
783 bfd_h_put_32(abfd
, aouthdr_in
->bsize
, (bfd_byte
*) aouthdr_out
->bsize
);
784 bfd_h_put_32(abfd
, aouthdr_in
->entry
, (bfd_byte
*) aouthdr_out
->entry
);
785 bfd_h_put_32(abfd
, aouthdr_in
->text_start
,
786 (bfd_byte
*) aouthdr_out
->text_start
);
787 bfd_h_put_32(abfd
, aouthdr_in
->data_start
, (bfd_byte
*) aouthdr_out
->data_start
);
789 bfd_h_put_32(abfd
, aouthdr_in
->tagentries
, (bfd_byte
*) aouthdr_out
->tagentries
);
791 return sizeof(AOUTHDR
);
795 DEFUN(coff_swap_scnhdr_in
,(abfd
, scnhdr_ext
, scnhdr_int
),
797 SCNHDR
*scnhdr_ext AND
798 struct internal_scnhdr
*scnhdr_int
)
800 memcpy(scnhdr_int
->s_name
, scnhdr_ext
->s_name
, sizeof(scnhdr_int
->s_name
));
801 scnhdr_int
->s_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
802 scnhdr_int
->s_paddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
803 scnhdr_int
->s_size
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_size
);
804 scnhdr_int
->s_scnptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
805 scnhdr_int
->s_relptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
806 scnhdr_int
->s_lnnoptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
807 scnhdr_int
->s_flags
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_flags
);
809 scnhdr_int
->s_nreloc
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
810 scnhdr_int
->s_nlnno
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
812 scnhdr_int
->s_nreloc
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
813 scnhdr_int
->s_nlnno
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
816 scnhdr_int
->s_align
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_align
);
821 DEFUN(coff_swap_scnhdr_out
,(abfd
, in
, out
),
826 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*)in
;
827 SCNHDR
*scnhdr_ext
= (SCNHDR
*)out
;
828 memcpy(scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof(scnhdr_int
->s_name
));
829 PUTWORD(abfd
, scnhdr_int
->s_vaddr
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
830 PUTWORD(abfd
, scnhdr_int
->s_paddr
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
831 PUTWORD(abfd
, scnhdr_int
->s_size
, (bfd_byte
*) scnhdr_ext
->s_size
);
832 PUTWORD(abfd
, scnhdr_int
->s_scnptr
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
833 PUTWORD(abfd
, scnhdr_int
->s_relptr
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
834 PUTWORD(abfd
, scnhdr_int
->s_lnnoptr
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
835 PUTWORD(abfd
, scnhdr_int
->s_flags
, (bfd_byte
*) scnhdr_ext
->s_flags
);
837 PUTWORD(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
838 PUTWORD(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
840 PUTHALF(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
841 PUTHALF(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
845 PUTWORD(abfd
, scnhdr_int
->s_align
, (bfd_byte
*) scnhdr_ext
->s_align
);
847 return sizeof(SCNHDR
);
852 initialize a section structure with information peculiar to this
853 particular implementation of coff
857 DEFUN(coff_new_section_hook
,(abfd_ignore
, section_ignore
),
859 asection
*section_ignore
)
861 section_ignore
->alignment_power
= abfd_ignore
->xvec
->align_power_min
;
865 /* Take a section header read from a coff file (in HOST byte order),
866 and make a BFD "section" out of it. */
868 DEFUN(make_a_section_from_file
,(abfd
, hdr
),
870 struct internal_scnhdr
*hdr
)
872 asection
*return_section
;
875 /* Assorted wastage to null-terminate the name, thanks AT&T! */
876 char *name
= bfd_alloc(abfd
, sizeof (hdr
->s_name
)+1);
878 bfd_error
= no_memory
;
881 strncpy(name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
882 name
[sizeof (hdr
->s_name
)] = 0;
884 return_section
= bfd_make_section(abfd
, name
);
885 if (return_section
== NULL
)
889 /* s_paddr is presumed to be = to s_vaddr */
890 #define assign(to, from) return_section->to = hdr->from
891 assign(vma
, s_vaddr
);
892 /* assign (vma, s_vaddr); */
893 assign(size
, s_size
);
894 assign(filepos
, s_scnptr
);
895 assign(rel_filepos
, s_relptr
);
896 assign(reloc_count
, s_nreloc
);
899 /* FIXME, use a temp var rather than alignment_power */
900 assign(alignment_power
, s_align
);
903 for (i
= 0; i
< 32; i
++) {
904 if ((1 << i
) >= (int) (return_section
->alignment_power
)) {
905 return_section
->alignment_power
= i
;
912 assign(line_filepos
, s_lnnoptr
);
914 return_section->linesize = hdr->s_nlnno * sizeof (struct lineno);
917 return_section
->lineno_count
= hdr
->s_nlnno
;
918 return_section
->userdata
= NULL
;
919 return_section
->next
= (asection
*) NULL
;
920 return_section
->flags
= styp_to_sec_flags(hdr
->s_flags
);
923 if (hdr
->s_nreloc
!= 0)
924 return_section
->flags
|= SEC_RELOC
;
925 /* FIXME: should this check 'hdr->s_size > 0' */
926 if (hdr
->s_scnptr
!= 0)
927 return_section
->flags
|= SEC_HAS_CONTENTS
;
931 DEFUN(coff_mkobject
,(abfd
),
934 set_tdata (abfd
, bfd_zalloc (abfd
,sizeof(coff_data_type
)));
935 if (coff_data(abfd
) == 0) {
936 bfd_error
= no_memory
;
939 coff_data(abfd
)->relocbase
= 0;
945 DEFUN(coff_real_object_p
,(abfd
, nscns
, internal_f
, internal_a
),
948 struct internal_filehdr
*internal_f AND
949 struct internal_aouthdr
*internal_a
)
951 coff_data_type
*coff
;
952 enum bfd_architecture arch
;
954 size_t readsize
; /* length of file_info */
955 SCNHDR
*external_sections
;
957 /* Build a play area */
958 if (coff_mkobject(abfd
) != true)
960 coff
= coff_data(abfd
);
963 external_sections
= (SCNHDR
*)bfd_alloc(abfd
, readsize
= (nscns
* SCNHSZ
));
965 if (bfd_read((PTR
)external_sections
, 1, readsize
, abfd
) != readsize
) {
970 /* Now copy data as required; construct all asections etc */
971 coff
->symbol_index_slew
= 0;
973 coff
->raw_syment_count
= 0;
974 coff
->raw_linenos
= 0;
975 coff
->raw_syments
= 0;
976 coff
->sym_filepos
=0;
977 coff
->flags
= internal_f
->f_flags
;
980 for (i
= 0; i
< nscns
; i
++) {
981 struct internal_scnhdr tmp
;
982 coff_swap_scnhdr_in(abfd
, external_sections
+ i
, &tmp
);
983 make_a_section_from_file(abfd
,&tmp
);
986 /* Determine the machine architecture and type. */
988 switch (internal_f
->f_magic
) {
991 arch
= bfd_arch_i386
;
996 #ifdef A29K_MAGIC_BIG
998 case A29K_MAGIC_LITTLE
:
999 arch
= bfd_arch_a29k
;
1008 arch
= bfd_arch_mips
;
1016 arch
= bfd_arch_m68k
;
1024 arch
= bfd_arch_m88k
;
1032 arch
= bfd_arch_i960
;
1033 switch (F_I960TYPE
& internal_f
->f_flags
)
1037 machine
= bfd_mach_i960_core
;
1040 machine
= bfd_mach_i960_kb_sb
;
1043 machine
= bfd_mach_i960_mc
;
1046 machine
= bfd_mach_i960_xa
;
1049 machine
= bfd_mach_i960_ca
;
1052 machine
= bfd_mach_i960_ka_sa
;
1063 arch
= bfd_arch_rs6000
;
1069 default: /* Unreadable input file type */
1070 arch
= bfd_arch_obscure
;
1074 bfd_default_set_arch_mach(abfd
, arch
, machine
);
1075 if (!(internal_f
->f_flags
& F_RELFLG
))
1076 abfd
->flags
|= HAS_RELOC
;
1077 if ((internal_f
->f_flags
& F_EXEC
))
1078 abfd
->flags
|= EXEC_P
;
1079 if (!(internal_f
->f_flags
& F_LNNO
))
1080 abfd
->flags
|= HAS_LINENO
;
1081 if (!(internal_f
->f_flags
& F_LSYMS
))
1082 abfd
->flags
|= HAS_LOCALS
;
1085 bfd_get_symcount(abfd
) = internal_f
->f_nsyms
;
1086 if (internal_f
->f_nsyms
)
1087 abfd
->flags
|= HAS_SYMS
;
1089 coff
->sym_filepos
= internal_f
->f_symptr
;
1091 /* These members communicate important constants about the symbol table
1092 to GDB's symbol-reading code. These `constants' unfortunately vary
1093 from coff implementation to implementation... */
1094 #ifndef NO_COFF_SYMBOLS
1095 coff
->local_n_btmask
= N_BTMASK
;
1096 coff
->local_n_btshft
= N_BTSHFT
;
1097 coff
->local_n_tmask
= N_TMASK
;
1098 coff
->local_n_tshift
= N_TSHIFT
;
1099 coff
->local_symesz
= SYMESZ
;
1100 coff
->local_auxesz
= AUXESZ
;
1101 coff
->local_linesz
= LINESZ
;
1104 coff
->symbols
= (coff_symbol_type
*) NULL
;
1105 bfd_get_start_address(abfd
) = internal_f
->f_opthdr
? internal_a
->entry
: 0;
1109 bfd_release(abfd
, coff
);
1110 return (bfd_target
*)NULL
;
1114 DEFUN(coff_object_p
,(abfd
),
1120 struct internal_filehdr internal_f
;
1121 struct internal_aouthdr internal_a
;
1123 bfd_error
= system_call_error
;
1125 /* figure out how much to read */
1126 if (bfd_read((PTR
) &filehdr
, 1, FILHSZ
, abfd
) != FILHSZ
)
1129 bfd_swap_filehdr_in(abfd
, &filehdr
, &internal_f
);
1131 if (BADMAG(internal_f
)) {
1132 bfd_error
= wrong_format
;
1135 nscns
=internal_f
.f_nscns
;
1137 if (internal_f
.f_opthdr
) {
1138 if (bfd_read((PTR
) &opthdr
, 1,AOUTSZ
, abfd
) != AOUTSZ
) {
1141 bfd_swap_aouthdr_in(abfd
, (char *)&opthdr
, (char *)&internal_a
);
1144 /* Seek past the opt hdr stuff */
1145 bfd_seek(abfd
, internal_f
.f_opthdr
+ FILHSZ
, SEEK_SET
);
1147 /* if the optional header is NULL or not the correct size then
1148 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1149 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1150 optional header is of a different size.
1152 But the mips keeps extra stuff in it's opthdr, so dont check
1156 #if defined(M88) || defined(I960)
1157 if (internal_f
.f_opthdr
!= 0 && AOUTSZ
!= internal_f
.f_opthdr
)
1158 return (bfd_target
*)NULL
;
1161 return coff_real_object_p(abfd
, nscns
, &internal_f
, &internal_a
);
1166 #ifndef NO_COFF_LINENOS
1169 DEFUN(coff_count_linenumbers
,(abfd
),
1172 unsigned int limit
= bfd_get_symcount(abfd
);
1176 asection
*s
= abfd
->sections
->output_section
;
1178 BFD_ASSERT(s
->lineno_count
== 0);
1184 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++) {
1185 asymbol
*q_maybe
= *p
;
1186 if (q_maybe
->the_bfd
->xvec
->flavour
== bfd_target_coff_flavour
) {
1187 coff_symbol_type
*q
= coffsymbol(q_maybe
);
1190 This symbol has a linenumber, increment the owning
1191 section's linenumber count
1193 alent
*l
= q
->lineno
;
1194 q
->symbol
.section
->output_section
->lineno_count
++;
1196 while (l
->line_number
) {
1197 q
->symbol
.section
->output_section
->lineno_count
++;
1205 #endif /* NO_COFF_LINENOS */
1207 #ifndef NO_COFF_SYMBOLS
1210 Takes a bfd and a symbol, returns a pointer to the coff specific area
1211 of the symbol if there is one.
1213 static coff_symbol_type
*
1214 DEFUN(coff_symbol_from
,(ignore_abfd
, symbol
),
1215 bfd
*ignore_abfd AND
1218 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
1219 return (coff_symbol_type
*)NULL
;
1221 if (symbol
->the_bfd
->tdata
== (PTR
)NULL
)
1222 return (coff_symbol_type
*)NULL
;
1224 return (coff_symbol_type
*) symbol
;
1230 DEFUN(fixup_symbol_value
,(coff_symbol_ptr
, syment
),
1231 coff_symbol_type
*coff_symbol_ptr AND
1232 struct internal_syment
*syment
)
1235 /* Normalize the symbol flags */
1236 if (coff_symbol_ptr
->symbol
.flags
& BSF_FORT_COMM
) {
1237 /* a common symbol is undefined with a value */
1238 syment
->n_scnum
= N_UNDEF
;
1239 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1241 else if (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) {
1242 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1244 else if (coff_symbol_ptr
->symbol
.flags
& BSF_UNDEFINED
) {
1245 syment
->n_scnum
= N_UNDEF
;
1246 syment
->n_value
= 0;
1248 else if (coff_symbol_ptr
->symbol
.flags
& BSF_ABSOLUTE
) {
1249 syment
->n_scnum
= N_ABS
;
1250 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1253 if (coff_symbol_ptr
->symbol
.section
) {
1255 coff_symbol_ptr
->symbol
.section
->output_section
->index
+1;
1258 coff_symbol_ptr
->symbol
.value
+
1259 coff_symbol_ptr
->symbol
.section
->output_offset
+
1260 coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
1263 /* This can happen, but I don't know why yet (steve@cygnus.com) */
1264 syment
->n_scnum
= N_ABS
;
1265 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1270 /* run through all the symbols in the symbol table and work out what
1271 their indexes into the symbol table will be when output
1273 Coff requires that each C_FILE symbol points to the next one in the
1274 chain, and that the last one points to the first external symbol. We
1279 DEFUN(coff_renumber_symbols
,(bfd_ptr
),
1282 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1283 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1284 unsigned int native_index
= 0;
1285 struct internal_syment
*last_file
= (struct internal_syment
*)NULL
;
1286 unsigned int symbol_index
;
1287 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1289 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1290 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1291 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1294 if (s
->u
.syment
.n_sclass
== C_FILE
)
1296 if (last_file
!= (struct internal_syment
*)NULL
) {
1297 last_file
->n_value
= native_index
;
1299 last_file
= &(s
->u
.syment
);
1303 /* Modify the symbol values according to their section and
1306 fixup_symbol_value(coff_symbol_ptr
, &(s
->u
.syment
));
1308 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++) {
1309 s
[i
].offset
= native_index
++;
1320 Run thorough the symbol table again, and fix it so that all pointers to
1321 entries are changed to the entries' index in the output symbol table.
1325 DEFUN(coff_mangle_symbols
,(bfd_ptr
),
1328 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1329 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1330 unsigned int symbol_index
;
1332 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1334 coff_symbol_type
*coff_symbol_ptr
=
1335 coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1337 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1339 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1341 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++) {
1342 combined_entry_type
*a
= s
+ i
+ 1;
1344 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
1345 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
1348 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
1349 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
1357 static int string_size
;
1359 DEFUN(coff_fix_symbol_name
,(ignore_abfd
, symbol
, native
),
1360 bfd
*ignore_abfd AND
1362 combined_entry_type
*native
)
1364 unsigned int name_length
;
1365 union internal_auxent
*auxent
;
1366 char * name
= ( char *)(symbol
->name
);
1368 if (name
== (char *) NULL
) {
1369 /* coff symbols always have names, so we'll make one up */
1370 symbol
->name
= "strange";
1371 name
= (char *)symbol
->name
;
1373 name_length
= strlen(name
);
1375 if (native
->u
.syment
.n_sclass
== C_FILE
) {
1376 strncpy(native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
1377 auxent
= &(native
+1)->u
.auxent
;
1379 #ifdef COFF_LONG_FILENAMES
1380 if (name_length
<= FILNMLEN
) {
1381 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1384 auxent
->x_file
.x_n
.x_offset
= string_size
+ 4;
1385 auxent
->x_file
.x_n
.x_zeroes
= 0;
1386 string_size
+= name_length
+ 1;
1389 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1390 if (name_length
> FILNMLEN
) {
1391 name
[FILNMLEN
] = '\0';
1396 { /* NOT A C_FILE SYMBOL */
1397 if (name_length
<= SYMNMLEN
) {
1398 /* This name will fit into the symbol neatly */
1399 strncpy(native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
1402 native
->u
.syment
._n
._n_n
._n_offset
= string_size
+ 4;
1403 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1404 string_size
+= name_length
+ 1;
1412 DEFUN(coff_write_symbol
,(abfd
, symbol
, native
, written
),
1415 combined_entry_type
*native AND
1416 unsigned int written
)
1418 unsigned int numaux
= native
->u
.syment
.n_numaux
;
1419 int type
= native
->u
.syment
.n_type
;
1420 int class = native
->u
.syment
.n_sclass
;
1424 coff_fix_symbol_name(abfd
, symbol
, native
);
1425 coff_swap_sym_out(abfd
, &native
->u
.syment
, &buf
);
1426 bfd_write((PTR
)& buf
, 1, SYMESZ
, abfd
);
1427 for (j
= 0; j
!= native
->u
.syment
.n_numaux
; j
++)
1430 bzero((PTR
)&buf
, AUXESZ
);
1431 coff_swap_aux_out(abfd
,
1432 &( (native
+ j
+ 1)->u
.auxent
), type
, class, &buf1
);
1433 bfd_write((PTR
) (&buf1
), 1, AUXESZ
, abfd
);
1436 Reuse somewhere in the symbol to keep the index
1438 set_index(symbol
, written
);
1439 return written
+ 1 + numaux
;
1444 DEFUN(coff_write_alien_symbol
,(abfd
, symbol
, written
),
1447 unsigned int written
)
1450 This symbol has been created by the loader, or come from a non
1451 coff format. It has no native element to inherit, make our
1454 combined_entry_type
*native
;
1455 combined_entry_type dummy
;
1457 native
->u
.syment
.n_type
= T_NULL
;
1459 native
->u
.syment
.n_flags
= 0;
1461 if (symbol
->flags
& BSF_ABSOLUTE
) {
1462 native
->u
.syment
.n_scnum
= N_ABS
;
1463 native
->u
.syment
.n_value
= symbol
->value
;
1465 else if (symbol
->flags
& (BSF_UNDEFINED
| BSF_FORT_COMM
)) {
1466 native
->u
.syment
.n_scnum
= N_UNDEF
;
1467 native
->u
.syment
.n_value
= symbol
->value
;
1469 else if (symbol
->flags
& BSF_DEBUGGING
) {
1471 remove name so it doesn't take up any space
1476 native
->u
.syment
.n_scnum
= symbol
->section
->output_section
->index
+
1478 native
->u
.syment
.n_value
= symbol
->value
+
1479 symbol
->section
->output_section
->vma
+
1480 symbol
->section
->output_offset
;
1482 /* Copy the any flags from the the file hdr into the symbol */
1484 coff_symbol_type
*c
= coff_symbol_from(abfd
, symbol
);
1485 if (c
!= (coff_symbol_type
*)NULL
) {
1486 native
->u
.syment
.n_flags
= c
->symbol
.the_bfd
->flags
;
1493 native
->u
.syment
.pad1
[0] = 0;
1494 native
->u
.syment
.pad1
[0] = 0;
1497 native
->u
.syment
.n_type
= 0;
1498 if (symbol
->flags
& BSF_LOCAL
)
1499 native
->u
.syment
.n_sclass
= C_STAT
;
1501 native
->u
.syment
.n_sclass
= C_EXT
;
1502 native
->u
.syment
.n_numaux
= 0;
1504 return coff_write_symbol(abfd
, symbol
, native
, written
);
1508 DEFUN(coff_write_native_symbol
,(abfd
, symbol
, written
),
1510 coff_symbol_type
*symbol AND
1511 unsigned int written
)
1514 Does this symbol have an ascociated line number - if so then
1515 make it remember this symbol index. Also tag the auxent of
1516 this symbol to point to the right place in the lineno table
1518 combined_entry_type
*native
= symbol
->native
;
1520 alent
*lineno
= symbol
->lineno
;
1523 unsigned int count
= 0;
1524 lineno
[count
].u
.offset
= written
;
1525 if (native
->u
.syment
.n_numaux
) {
1526 union internal_auxent
*a
= &((native
+1)->u
.auxent
);
1528 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1529 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1532 And count and relocate all other linenumbers
1535 while (lineno
[count
].line_number
) {
1536 lineno
[count
].u
.offset
+=
1537 symbol
->symbol
.section
->output_section
->vma
+
1538 symbol
->symbol
.section
->output_offset
;
1541 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1544 return coff_write_symbol(abfd
, &( symbol
->symbol
), native
,written
);
1548 DEFUN(coff_write_symbols
,(abfd
),
1552 unsigned int limit
= bfd_get_symcount(abfd
);
1553 unsigned int written
= 0;
1560 /* Seek to the right place */
1561 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
1563 /* Output all the symbols we have */
1566 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1568 asymbol
*symbol
= *p
;
1569 coff_symbol_type
*c_symbol
= coff_symbol_from(abfd
, symbol
);
1571 if (c_symbol
== (coff_symbol_type
*) NULL
||
1572 c_symbol
->native
== (combined_entry_type
*)NULL
)
1574 written
= coff_write_alien_symbol(abfd
, symbol
, written
);
1578 written
= coff_write_native_symbol(abfd
, c_symbol
, written
);
1583 bfd_get_symcount(abfd
) = written
;
1585 /* Now write out strings */
1587 if (string_size
!= 0)
1589 unsigned int size
= string_size
+ 4;
1592 bfd_h_put_32(abfd
, size
, buffer
);
1593 bfd_write((PTR
) buffer
, 1, sizeof(buffer
), abfd
);
1594 for (p
= abfd
->outsymbols
, i
= 0;
1599 size_t name_length
= strlen(q
->name
);
1601 coff_symbol_type
* c_symbol
= coff_symbol_from(abfd
, q
);
1602 maxlen
= ((c_symbol
!= NULL
&& c_symbol
->native
!= NULL
) &&
1603 (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
)) ?
1604 FILNMLEN
: SYMNMLEN
;
1606 if (name_length
> maxlen
) {
1607 bfd_write((PTR
) (q
->name
), 1, name_length
+ 1, abfd
);
1612 /* We would normally not write anything here, but we'll write
1613 out 4 so that any stupid coff reader which tries to read
1614 the string table even when there isn't one won't croak.
1617 uint32e_type size
= 4;
1619 bfd_write((PTR
)&size
, 1, sizeof(size
), abfd
);
1625 @subsubsection Writing Relocations
1626 To write a relocations, all the back end does is step though the
1627 canonical relocation table, and create an @code{internal_reloc}. The
1628 symbol index to use is removed from the @code{offset} field in the
1629 symbol table supplied, the address comes directly from the sum of the
1630 section base address and the relocation offset and the type is dug
1631 directly from the howto field.
1633 Then the @code{internal_reloc} is swapped into the shape of an
1634 @code{external_reloc} and written out to disk.
1638 DEFUN(coff_write_relocs
,(abfd
),
1642 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1644 struct external_reloc dst
;
1646 arelent
**p
= s
->orelocation
;
1647 bfd_seek(abfd
, s
->rel_filepos
, SEEK_SET
);
1648 for (i
= 0; i
< s
->reloc_count
; i
++) {
1649 struct internal_reloc n
;
1651 memset((PTR
)&n
, 0, sizeof(n
));
1652 n
.r_vaddr
= q
->address
+ s
->vma
;
1653 if (q
->sym_ptr_ptr
) {
1654 n
.r_symndx
= get_index((*(q
->sym_ptr_ptr
)));
1657 /* Work out reloc type from what is required */
1658 SELECT_RELOC(n
.r_type
, q
->howto
);
1660 n
.r_type
= q
->howto
->type
;
1662 coff_swap_reloc_out(abfd
, &n
, &dst
);
1663 bfd_write((PTR
) &n
, 1, RELSZ
, abfd
);
1667 #endif /* NO_COFF_SYMBOLS */
1669 #ifndef NO_COFF_LINENOS
1672 DEFUN(coff_write_linenumbers
,(abfd
),
1676 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1677 if (s
->lineno_count
) {
1678 asymbol
**q
= abfd
->outsymbols
;
1679 bfd_seek(abfd
, s
->line_filepos
, SEEK_SET
);
1680 /* Find all the linenumbers in this section */
1683 alent
*l
= BFD_SEND(p
->the_bfd
, _get_lineno
, (p
->the_bfd
, p
));
1685 /* Found a linenumber entry, output */
1686 struct internal_lineno out
;
1688 memset( (PTR
)&out
, 0, sizeof(out
));
1690 out
.l_addr
.l_symndx
= l
->u
.offset
;
1691 coff_swap_lineno_out(abfd
, &out
, &buff
);
1692 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1694 while (l
->line_number
) {
1695 out
.l_lnno
= l
->line_number
;
1696 out
.l_addr
.l_symndx
= l
->u
.offset
;
1697 coff_swap_lineno_out(abfd
, &out
, &buff
);
1698 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1709 DEFUN(coff_get_lineno
,(ignore_abfd
, symbol
),
1710 bfd
*ignore_abfd AND
1713 return coffsymbol(symbol
)->lineno
;
1716 #endif /* NO_COFF_LINENOS */
1719 coff_make_empty_symbol(abfd
)
1722 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc(abfd
, sizeof(coff_symbol_type
));
1724 bfd_error
= no_memory
;
1728 new->lineno
= (alent
*) NULL
;
1729 new->symbol
.the_bfd
= abfd
;
1730 return &new->symbol
;
1733 #ifndef NO_COFF_SYMBOLS
1736 DEFUN(coff_print_symbol
,(ignore_abfd
, filep
, symbol
, how
),
1737 bfd
*ignore_abfd AND
1740 bfd_print_symbol_type how
)
1742 FILE *file
= (FILE *)filep
;
1744 case bfd_print_symbol_name
:
1745 fprintf(file
, "%s", symbol
->name
);
1747 case bfd_print_symbol_more
:
1748 fprintf(file
, "coff %lx %lx", (unsigned long) coffsymbol(symbol
)->native
,
1749 (unsigned long) coffsymbol(symbol
)->lineno
);
1751 case bfd_print_symbol_nm
:
1752 case bfd_print_symbol_all
:
1754 CONST
char *section_name
= symbol
->section
== (asection
*) NULL
?
1755 (CONST
char *)"*abs" : symbol
->section
->name
;
1756 bfd_print_symbol_vandf((PTR
) file
, symbol
);
1758 fprintf(file
, " %-5s %s %s %s",
1760 coffsymbol(symbol
)->native
? "n" : "g",
1761 coffsymbol(symbol
)->lineno
? "l" : " ",
1770 #endif /* NO_COFF_SYMBOLS */
1772 /* Set flags and magic number of a coff file from architecture and machine
1773 type. Result is true if we can represent the arch&type, false if not. */
1776 DEFUN(coff_set_flags
,(abfd
, magicp
, flagsp
),
1778 unsigned *magicp AND
1779 unsigned short *flagsp
)
1781 switch (bfd_get_arch(abfd
)) {
1789 *magicp
= I960ROMAGIC
;
1791 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1792 I960RWMAGIC); FIXME???
1794 switch (bfd_get_mach(abfd
)) {
1795 case bfd_mach_i960_core
:
1798 case bfd_mach_i960_kb_sb
:
1801 case bfd_mach_i960_mc
:
1804 case bfd_mach_i960_xa
:
1807 case bfd_mach_i960_ca
:
1810 case bfd_mach_i960_ka_sa
:
1823 *magicp
= MIPS_MAGIC_2
;
1829 *magicp
= I386MAGIC
;
1834 *magicp
= MC68MAGIC
;
1840 *magicp
= MC88OMAGIC
;
1845 #ifdef A29K_MAGIC_BIG
1847 if (abfd
->xvec
->byteorder_big_p
)
1848 *magicp
= A29K_MAGIC_BIG
;
1850 *magicp
= A29K_MAGIC_LITTLE
;
1856 case bfd_arch_rs6000
:
1857 *magicp
= U802TOCMAGIC
;
1861 default: /* Unknown architecture */
1862 /* return false; -- fall through to "return false" below, to avoid
1863 "statement never reached" errors on the one below. */
1872 DEFUN(coff_set_arch_mach
,(abfd
, arch
, machine
),
1874 enum bfd_architecture arch AND
1875 unsigned long machine
)
1878 unsigned short dummy2
;
1879 bfd_default_set_arch_mach(abfd
, arch
, machine
);
1881 if (arch
!= bfd_arch_unknown
&&
1882 coff_set_flags(abfd
, &dummy1
, &dummy2
) != true)
1883 return false; /* We can't represent this type */
1884 return true; /* We're easy ... */
1888 /* Calculate the file position for each section. */
1891 DEFUN(coff_compute_section_file_positions
,(abfd
),
1895 asection
*previous
= (asection
*)NULL
;
1896 file_ptr sofar
= FILHSZ
;
1898 if (bfd_get_start_address(abfd
))
1900 /* A start address may have been added to the original file. In this
1901 case it will need an optional header to record it. */
1902 abfd
->flags
|= EXEC_P
;
1905 if (abfd
->flags
& EXEC_P
)
1908 sofar
+= abfd
->section_count
* SCNHSZ
;
1909 for (current
= abfd
->sections
;
1910 current
!= (asection
*)NULL
;
1911 current
= current
->next
) {
1913 /* Only deal with sections which have contents */
1914 if (!(current
->flags
& SEC_HAS_CONTENTS
))
1917 /* Align the sections in the file to the same boundary on
1918 which they are aligned in virtual memory. I960 doesn't
1919 do this (FIXME) so we can stay in sync with Intel. 960
1920 doesn't yet page from files... */
1923 /* make sure this section is aligned on the right boundary - by
1924 padding the previous section up if necessary */
1927 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
1928 if (previous
!= (asection
*)NULL
) {
1929 previous
->size
+= sofar
- old_sofar
;
1934 /* FIXME, in demand paged files, the low order bits of the file
1935 offset must match the low order bits of the virtual address.
1936 "Low order" is apparently implementation defined. Add code
1937 here to round sofar up to match the virtual address. */
1939 current
->filepos
= sofar
;
1941 /* make sure that this section is of the right size too */
1942 old_sofar
= sofar
+= current
->size
;
1943 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
1944 current
->size
+= sofar
- old_sofar
;
1948 obj_relocbase(abfd
) = sofar
;
1957 DEFUN(coff_write_object_contents
,(abfd
),
1961 boolean hasrelocs
= false;
1962 boolean haslinno
= false;
1963 file_ptr reloc_base
;
1964 file_ptr lineno_base
;
1968 unsigned long reloc_size
= 0;
1969 unsigned long lnno_size
= 0;
1970 asection
*text_sec
= NULL
;
1971 asection
*data_sec
= NULL
;
1972 asection
*bss_sec
= NULL
;
1974 struct internal_filehdr internal_f
;
1975 struct internal_aouthdr internal_a
;
1978 bfd_error
= system_call_error
;
1981 if(abfd
->output_has_begun
== false) {
1982 coff_compute_section_file_positions(abfd
);
1985 if (abfd
->sections
!= (asection
*)NULL
) {
1986 scn_base
= abfd
->sections
->filepos
;
1991 if (bfd_seek(abfd
, scn_base
, SEEK_SET
) != 0)
1993 reloc_base
= obj_relocbase(abfd
);
1995 /* Make a pass through the symbol table to count line number entries and
1996 put them into the correct asections */
1998 #ifndef NO_COFF_LINENOS
1999 coff_count_linenumbers(abfd
);
2001 data_base
= scn_base
;
2003 /* Work out the size of the reloc and linno areas */
2005 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
) {
2006 reloc_size
+= current
->reloc_count
* RELSZ
;
2007 #ifndef NO_COFF_LINENOS
2008 lnno_size
+= current
->lineno_count
* LINESZ
;
2010 data_base
+= SCNHSZ
;
2013 lineno_base
= reloc_base
+ reloc_size
;
2014 sym_base
= lineno_base
+ lnno_size
;
2016 /* Indicate in each section->line_filepos its actual file address */
2017 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
) {
2018 if (current
->lineno_count
) {
2019 current
->line_filepos
= lineno_base
;
2020 current
->moving_line_filepos
= lineno_base
;
2021 #ifndef NO_COFF_LINENOS
2022 lineno_base
+= current
->lineno_count
* LINESZ
;
2026 current
->line_filepos
= 0;
2028 if (current
->reloc_count
) {
2029 current
->rel_filepos
= reloc_base
;
2030 reloc_base
+= current
->reloc_count
* sizeof(struct internal_reloc
);
2033 current
->rel_filepos
= 0;
2037 /* Write section headers to the file. */
2040 (file_ptr
) ((abfd
->flags
& EXEC_P
) ?
2041 (FILHSZ
+ AOUTSZ
) : FILHSZ
),
2046 unsigned int pad
= abfd
->flags
& D_PAGED
? data_base
: 0;
2048 unsigned int pad
= 0;
2050 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
) {
2051 struct internal_scnhdr section
;
2052 strncpy(&(section
.s_name
[0]), current
->name
, 8);
2053 section
.s_vaddr
= current
->vma
+ pad
;
2054 section
.s_paddr
= current
->vma
+ pad
;
2055 section
.s_size
= current
->size
- pad
;
2057 If this section has no size or is unloadable then the scnptr
2060 if (current
->size
- pad
== 0 ||
2061 (current
->flags
& SEC_LOAD
) == 0) {
2062 section
.s_scnptr
= 0;
2065 section
.s_scnptr
= current
->filepos
;
2067 section
.s_relptr
= current
->rel_filepos
;
2068 section
.s_lnnoptr
= current
->line_filepos
;
2069 section
.s_nreloc
= current
->reloc_count
;
2070 section
.s_nlnno
= current
->lineno_count
;
2071 if (current
->reloc_count
!= 0)
2073 if (current
->lineno_count
!= 0)
2076 section
.s_flags
= sec_to_styp_flags(current
->name
,current
->flags
);
2078 if (!strcmp(current
->name
, _TEXT
)) {
2080 } else if (!strcmp(current
->name
, _DATA
)) {
2082 } else if (!strcmp(current
->name
, _BSS
)) {
2087 section
.s_align
= (current
->alignment_power
2088 ? 1 << current
->alignment_power
2095 coff_swap_scnhdr_out(abfd
, §ion
, &buff
);
2096 bfd_write((PTR
) (&buff
), 1, SCNHSZ
, abfd
);
2103 /* OK, now set up the filehdr... */
2104 internal_f
.f_nscns
= abfd
->section_count
;
2106 We will NOT put a fucking timestamp in the header here. Every time you
2107 put it back, I will come in and take it out again. I'm sorry. This
2108 field does not belong here. We fill it with a 0 so it compares the
2109 same but is not a reasonable time. -- gnu@cygnus.com
2112 Well, I like it, so I'm conditionally compiling it in.
2115 #ifdef COFF_TIMESTAMP
2116 internal_f
.f_timdat
= time(0);
2118 internal_f
.f_timdat
= 0;
2121 if (bfd_get_symcount(abfd
) != 0)
2122 internal_f
.f_symptr
= sym_base
;
2124 internal_f
.f_symptr
= 0;
2126 internal_f
.f_flags
= 0;
2128 if (abfd
->flags
& EXEC_P
)
2129 internal_f
.f_opthdr
= AOUTSZ
;
2131 internal_f
.f_opthdr
= 0;
2134 internal_f
.f_flags
|= F_RELFLG
;
2136 internal_f
.f_flags
|= F_LNNO
;
2137 if (0 == bfd_get_symcount(abfd
))
2138 internal_f
.f_flags
|= F_LSYMS
;
2139 if (abfd
->flags
& EXEC_P
)
2140 internal_f
.f_flags
|= F_EXEC
;
2142 internal_f
.f_flags
|= F_AR32W
;
2144 if (!abfd
->xvec
->byteorder_big_p
)
2145 internal_f
.f_flags
|= F_AR32WR
;
2148 FIXME, should do something about the other byte orders and
2152 /* Set up architecture-dependent stuff */
2154 { unsigned int magic
= 0;
2155 unsigned short flags
= 0;
2156 coff_set_flags(abfd
, &magic
, &flags
);
2157 internal_f
.f_magic
= magic
;
2158 internal_f
.f_flags
|= flags
;
2159 /* ...and the "opt"hdr... */
2162 # ifdef ULTRA3 /* NYU's machine */
2163 /* FIXME: This is a bogus check. I really want to see if there
2164 * is a .shbss or a .shdata section, if so then set the magic
2165 * number to indicate a shared data executable.
2167 if (internal_f
.f_nscns
>= 7)
2168 internal_a
.magic
= SHMAGIC
; /* Shared magic */
2170 # endif /* ULTRA3 */
2171 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
2172 #define __A_MAGIC_SET__
2175 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
2176 #define __A_MAGIC_SET__
2179 #define __A_MAGIC_SET__
2180 internal_a
.magic
= PAGEMAGICBCS
;
2183 #if M68 || I386 || MIPS
2184 #define __A_MAGIC_SET__
2185 /* Never was anything here for the 68k */
2189 #define __A_MAGIC_SET__
2190 internal_a
.magic
= (abfd
->flags
& D_PAGED
)? RS6K_AOUTHDR_ZMAGIC
:
2191 (abfd
->flags
& WP_TEXT
)? RS6K_AOUTHDR_NMAGIC
:
2192 RS6K_AOUTHDR_OMAGIC
;
2195 #ifndef __A_MAGIC_SET__
2196 # include "Your aouthdr magic number is not being set!"
2198 # undef __A_MAGIC_SET__
2201 /* Now should write relocs, strings, syms */
2202 obj_sym_filepos(abfd
) = sym_base
;
2204 #ifndef NO_COFF_SYMBOLS
2205 if (bfd_get_symcount(abfd
) != 0) {
2206 coff_renumber_symbols(abfd
);
2207 coff_mangle_symbols(abfd
);
2208 coff_write_symbols(abfd
);
2209 coff_write_linenumbers(abfd
);
2210 coff_write_relocs(abfd
);
2212 #endif /* NO_COFF_SYMBOLS */
2214 internal_a
.tsize
= text_sec
->size
;
2215 internal_a
.text_start
=text_sec
->size
? text_sec
->vma
: 0;
2218 internal_a
.dsize
= data_sec
->size
;
2219 internal_a
.data_start
= data_sec
->size
? data_sec
->vma
: 0;
2222 internal_a
.bsize
= bss_sec
->size
;
2225 internal_a
.entry
= bfd_get_start_address(abfd
);
2226 internal_f
.f_nsyms
= bfd_get_symcount(abfd
);
2228 /* now write them */
2229 if (bfd_seek(abfd
, 0L, SEEK_SET
) != 0)
2233 coff_swap_filehdr_out(abfd
, &internal_f
, &buff
);
2234 bfd_write((PTR
) &buff
, 1, FILHSZ
, abfd
);
2236 if (abfd
->flags
& EXEC_P
) {
2238 coff_swap_aouthdr_out(abfd
, &internal_a
, &buff
);
2239 bfd_write((PTR
) &buff
, 1, AOUTSZ
, abfd
);
2244 #ifndef NO_COFF_SYMBOLS
2247 this function transforms the offsets into the symbol table into
2248 pointers to syments.
2253 DEFUN(coff_pointerize_aux
,(ignore_abfd
, table_base
, type
, class, auxent
),
2254 bfd
*ignore_abfd AND
2255 combined_entry_type
*table_base AND
2258 combined_entry_type
*auxent
)
2260 /* Don't bother if this is a file or a section */
2261 if (class == C_STAT
&& type
== T_NULL
) return;
2262 if (class == C_FILE
) return;
2264 /* Otherwise patch up */
2265 if (ISFCN(type
) || ISTAG(class) || class == C_BLOCK
) {
2266 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
= table_base
+
2267 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2268 auxent
->fix_end
= 1;
2270 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
!= 0) {
2271 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
= table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
2272 auxent
->fix_tag
= 1;
2276 #endif /* NO_COFF_SYMBOLS */
2279 DEFUN(coff_set_section_contents
,(abfd
, section
, location
, offset
, count
),
2284 bfd_size_type count
)
2286 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
2287 coff_compute_section_file_positions(abfd
);
2289 bfd_seek(abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
);
2292 return (bfd_write(location
, 1, count
, abfd
) == count
) ? true : false;
2298 coff_close_and_cleanup(abfd
)
2301 if (!bfd_read_p(abfd
))
2302 switch (abfd
->format
) {
2304 if (!_bfd_write_archive_contents(abfd
))
2308 if (!coff_write_object_contents(abfd
))
2312 bfd_error
= invalid_operation
;
2316 /* We depend on bfd_close to free all the memory on the obstack. */
2317 /* FIXME if bfd_release is not using obstacks! */
2323 buy_and_read(abfd
, where
, seek_direction
, size
)
2329 PTR area
= (PTR
) bfd_alloc(abfd
, size
);
2331 bfd_error
= no_memory
;
2334 bfd_seek(abfd
, where
, seek_direction
);
2335 if (bfd_read(area
, 1, size
, abfd
) != size
) {
2336 bfd_error
= system_call_error
;
2340 } /* buy_and_read() */
2343 #ifndef NO_COFF_SYMBOLS
2346 DEFUN(build_string_table
,(abfd
),
2349 char string_table_size_buffer
[4];
2350 unsigned int string_table_size
;
2353 /* At this point we should be "seek"'d to the end of the
2354 symbols === the symbol table size. */
2355 if (bfd_read((char *) string_table_size_buffer
,
2356 sizeof(string_table_size_buffer
),
2357 1, abfd
) != sizeof(string_table_size
)) {
2358 bfd_error
= system_call_error
;
2362 string_table_size
= bfd_h_get_32(abfd
, (bfd_byte
*) string_table_size_buffer
);
2364 if ((string_table
= (PTR
) bfd_alloc(abfd
, string_table_size
-= 4)) == NULL
) {
2365 bfd_error
= no_memory
;
2367 } /* on mallocation error */
2368 if (bfd_read(string_table
, string_table_size
, 1, abfd
) != string_table_size
) {
2369 bfd_error
= system_call_error
;
2372 return string_table
;
2375 /* Allocate space for the ".debug" section, and read it.
2376 We did not read the debug section until now, because
2377 we didn't want to go to the trouble until someone needed it. */
2380 DEFUN(build_debug_section
,(abfd
),
2383 char *debug_section
;
2386 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
2389 bfd_error
= no_debug_section
;
2393 debug_section
= (PTR
) bfd_alloc (abfd
, bfd_section_size (abfd
, sect
));
2394 if (debug_section
== NULL
) {
2395 bfd_error
= no_memory
;
2399 /* Seek to the beginning of the `.debug' section and read it.
2400 Save the current position first; it is needed by our caller.
2401 Then read debug section and reset the file pointer. */
2403 position
= bfd_tell (abfd
);
2404 bfd_seek (abfd
, sect
->filepos
, SEEK_SET
);
2405 if (bfd_read (debug_section
, bfd_section_size (abfd
, sect
), 1, abfd
)
2406 != bfd_section_size (abfd
, sect
)) {
2407 bfd_error
= system_call_error
;
2410 bfd_seek (abfd
, position
, SEEK_SET
);
2411 return debug_section
;
2415 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
2416 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
2417 be \0-terminated. */
2419 DEFUN(copy_name
,(abfd
, name
, maxlen
),
2427 for (len
= 0; len
< maxlen
; ++len
) {
2428 if (name
[len
] == '\0') {
2433 if ((newname
= (PTR
) bfd_alloc(abfd
, len
+1)) == NULL
) {
2434 bfd_error
= no_memory
;
2437 strncpy(newname
, name
, len
);
2438 newname
[len
] = '\0';
2443 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
2444 knit the symbol names into a normalized form. By normalized here I
2445 mean that all symbols have an n_offset pointer that points to a null-
2446 terminated string. */
2448 #ifndef SYMNAME_IN_DEBUG
2449 #define SYMNAME_IN_DEBUG(x) 0
2452 static combined_entry_type
*
2453 DEFUN(get_normalized_symtab
,(abfd
),
2456 combined_entry_type
*internal
;
2457 combined_entry_type
*internal_ptr
;
2458 combined_entry_type
*internal_end
;
2462 char *string_table
= NULL
;
2463 char *debug_section
= NULL
;
2466 unsigned int raw_size
;
2467 if (obj_raw_syments(abfd
) != (combined_entry_type
*)NULL
) {
2468 return obj_raw_syments(abfd
);
2470 if ((size
= bfd_get_symcount(abfd
) * sizeof(combined_entry_type
)) == 0) {
2471 bfd_error
= no_symbols
;
2475 internal
= (combined_entry_type
*)bfd_alloc(abfd
, size
);
2476 internal_end
= internal
+ bfd_get_symcount(abfd
);
2478 raw_size
= bfd_get_symcount(abfd
) * SYMESZ
;
2479 raw
= (SYMENT
*)bfd_alloc(abfd
,raw_size
);
2481 if (bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
) == -1
2482 || bfd_read((PTR
)raw
, raw_size
, 1, abfd
) != raw_size
) {
2483 bfd_error
= system_call_error
;
2486 /* mark the end of the symbols */
2487 raw_end
= raw
+ bfd_get_symcount(abfd
);
2489 FIXME SOMEDAY. A string table size of zero is very weird, but
2490 probably possible. If one shows up, it will probably kill us.
2493 /* Swap all the raw entries */
2494 for (raw_src
= raw
, internal_ptr
= internal
;
2496 raw_src
++, internal_ptr
++) {
2499 coff_swap_sym_in(abfd
, (char *)raw_src
, (char *)&internal_ptr
->u
.syment
);
2500 internal_ptr
->fix_tag
= 0;
2501 internal_ptr
->fix_end
= 0;
2503 for (i
= internal_ptr
->u
.syment
.n_numaux
;
2505 --i
, raw_src
++, internal_ptr
++) {
2507 (internal_ptr
+1)->fix_tag
= 0;
2508 (internal_ptr
+1)->fix_end
= 0;
2510 coff_swap_aux_in(abfd
, (char *)(raw_src
+1),
2511 internal_ptr
->u
.syment
.n_type
,
2512 internal_ptr
->u
.syment
.n_sclass
,
2513 &(internal_ptr
+1)->u
.auxent
);
2515 coff_pointerize_aux(abfd
,
2517 internal_ptr
->u
.syment
.n_type
,
2518 internal_ptr
->u
.syment
.n_sclass
,
2523 /* Free all the raw stuff */
2524 bfd_release(abfd
, raw
);
2526 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
2529 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
) {
2530 /* make a file symbol point to the name in the auxent, since
2531 the text ".file" is redundant */
2532 if ((internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_zeroes
== 0) {
2533 /* the filename is a long one, point into the string table */
2534 if (string_table
== NULL
) {
2535 string_table
= build_string_table(abfd
);
2538 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
2539 (int) (string_table
- 4 +
2540 (internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_offset
);
2543 /* ordinary short filename, put into memory anyway */
2544 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2545 copy_name(abfd
, (internal_ptr
+1)->u
.auxent
.x_file
.x_fname
,
2550 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0) {
2551 /* This is a "short" name. Make it long. */
2552 unsigned long i
= 0;
2553 char *newstring
= NULL
;
2555 /* find the length of this string without walking into memory
2557 for (i
= 0; i
< 8; ++i
) {
2558 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0') {
2560 } /* if end of string */
2561 } /* possible lengths of this string. */
2563 if ((newstring
= (PTR
) bfd_alloc(abfd
, ++i
)) == NULL
) {
2564 bfd_error
= no_memory
;
2567 bzero(newstring
, i
);
2568 strncpy(newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
-1);
2569 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int) newstring
;
2570 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
2572 else if (!SYMNAME_IN_DEBUG(&internal_ptr
->u
.syment
)) {
2573 /* Long name already. Point symbol at the string in the table. */
2574 if (string_table
== NULL
) {
2575 string_table
= build_string_table(abfd
);
2577 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2578 (string_table
- 4 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
2581 /* Long name in debug section. Very similar. */
2582 if (debug_section
== NULL
) {
2583 debug_section
= build_debug_section(abfd
);
2585 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2586 (debug_section
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
2589 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
2592 obj_raw_syments(abfd
) = internal
;
2595 } /* get_normalized_symtab() */
2597 #endif /* NO_COFF_SYMBOLS */
2601 DEFUN(section_from_bfd_index
,(abfd
, index
),
2606 struct sec
*answer
= abfd
->sections
;
2608 answer
= answer
->next
;
2615 #ifndef NO_COFF_LINENOS
2618 @subsubsection Reading Linenumbers
2619 Createing the linenumber table is done by reading in the entire coff
2620 linenumber table, and creating another table for internal use.
2622 A coff line number table is structured so that each
2623 function is marked as having a line number of 0. Each line within the
2624 function is an offset from the first line in the function. The base of
2625 the line number information for the table is stored in the symbol
2626 associated with the function.
2628 The information is copied from the external to the internal table, and
2629 each symbol which marks a function is marked by pointing its...
2631 **How does this work ?**
2636 coff_slurp_line_table(abfd
, asect
)
2640 LINENO
*native_lineno
;
2641 alent
*lineno_cache
;
2643 BFD_ASSERT(asect
->lineno
== (alent
*) NULL
);
2645 native_lineno
= (LINENO
*) buy_and_read(abfd
,
2646 asect
->line_filepos
,
2649 asect
->lineno_count
));
2651 (alent
*) bfd_alloc(abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof(alent
)));
2652 if (lineno_cache
== NULL
) {
2653 bfd_error
= no_memory
;
2656 unsigned int counter
= 0;
2657 alent
*cache_ptr
= lineno_cache
;
2658 LINENO
*src
= native_lineno
;
2660 while (counter
< asect
->lineno_count
) {
2661 struct internal_lineno dst
;
2662 coff_swap_lineno_in(abfd
, src
, &dst
);
2663 cache_ptr
->line_number
= dst
.l_lnno
;
2665 if (cache_ptr
->line_number
== 0) {
2666 coff_symbol_type
*sym
=
2667 (coff_symbol_type
*) (dst
.l_addr
.l_symndx
2668 + obj_symbol_slew(abfd
)
2669 + obj_raw_syments(abfd
))->u
.syment
._n
._n_n
._n_zeroes
;
2670 cache_ptr
->u
.sym
= (asymbol
*) sym
;
2671 sym
->lineno
= cache_ptr
;
2674 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
2675 - bfd_section_vma(abfd
, asect
);
2676 } /* If no linenumber expect a symbol index */
2682 cache_ptr
->line_number
= 0;
2685 asect
->lineno
= lineno_cache
;
2686 /* FIXME, free native_lineno here, or use alloca or something. */
2688 } /* coff_slurp_line_table() */
2690 #endif /* NO_COFF_LINENOS */
2692 #ifndef NO_COFF_LINENOS
2695 DEFUN(coff_slurp_symbol_table
,(abfd
),
2698 combined_entry_type
*native_symbols
;
2699 coff_symbol_type
*cached_area
;
2700 unsigned int *table_ptr
;
2702 unsigned int number_of_symbols
= 0;
2703 if (obj_symbols(abfd
))
2705 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
2707 /* Read in the symbol table */
2708 if ((native_symbols
= get_normalized_symtab(abfd
)) == NULL
) {
2712 /* Allocate enough room for all the symbols in cached form */
2714 (coff_symbol_type
*)
2715 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(coff_symbol_type
)));
2717 if (cached_area
== NULL
) {
2718 bfd_error
= no_memory
;
2723 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(unsigned int)));
2725 if (table_ptr
== NULL
) {
2726 bfd_error
= no_memory
;
2731 coff_symbol_type
*dst
= cached_area
;
2732 unsigned int last_native_index
= bfd_get_symcount(abfd
);
2733 unsigned int this_index
= 0;
2734 while (this_index
< last_native_index
) {
2735 combined_entry_type
*src
= native_symbols
+ this_index
;
2736 table_ptr
[this_index
] = number_of_symbols
;
2737 dst
->symbol
.the_bfd
= abfd
;
2739 dst
->symbol
.name
= (char *)(src
->u
.syment
._n
._n_n
._n_offset
);
2741 We use the native name field to point to the cached field
2743 src
->u
.syment
._n
._n_n
._n_zeroes
= (int) dst
;
2744 dst
->symbol
.section
= section_from_bfd_index(abfd
,
2745 src
->u
.syment
.n_scnum
);
2746 switch (src
->u
.syment
.n_sclass
) {
2750 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
2751 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2752 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
2754 /* Fall through to next case */
2762 if ((src
->u
.syment
.n_scnum
) == 0) {
2763 if ((src
->u
.syment
.n_value
) == 0) {
2764 dst
->symbol
.flags
= BSF_UNDEFINED
;
2765 dst
->symbol
.value
= 0;
2768 dst
->symbol
.flags
= BSF_FORT_COMM
;
2769 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2774 Base the value as an index from the base of the
2777 if (dst
->symbol
.section
== (asection
*) NULL
) {
2778 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
| BSF_ABSOLUTE
;
2779 dst
->symbol
.value
= src
->u
.syment
.n_value
;
2782 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2783 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
2785 if (ISFCN((src
->u
.syment
.n_type
))) {
2787 A function ext does not go at the end of a file
2789 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
2796 case C_STAT
: /* static */
2798 case C_LEAFSTAT
: /* static leaf procedure */
2800 case C_LABEL
: /* label */
2801 if (src
->u
.syment
.n_scnum
== -2)
2802 dst
->symbol
.flags
= BSF_DEBUGGING
;
2804 dst
->symbol
.flags
= BSF_LOCAL
;
2806 Base the value as an index from the base of the section, if
2809 if (dst
->symbol
.section
)
2810 dst
->symbol
.value
= (src
->u
.syment
.n_value
) -
2811 dst
->symbol
.section
->vma
;
2813 dst
->symbol
.value
= (src
->u
.syment
.n_value
) ;
2816 case C_MOS
: /* member of structure */
2817 case C_EOS
: /* end of structure */
2818 #ifdef NOTDEF /* C_AUTOARG has the same value */
2820 case C_GLBLREG
: /* A29k-specific storage class */
2823 case C_REGPARM
: /* register parameter */
2824 case C_REG
: /* register variable */
2826 case C_AUTOARG
: /* 960-specific storage class */
2828 case C_TPDEF
: /* type definition */
2830 case C_AUTO
: /* automatic variable */
2831 case C_FIELD
: /* bit field */
2832 case C_ENTAG
: /* enumeration tag */
2833 case C_MOE
: /* member of enumeration */
2834 case C_MOU
: /* member of union */
2835 case C_UNTAG
: /* union tag */
2836 dst
->symbol
.flags
= BSF_DEBUGGING
;
2837 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2840 case C_FILE
: /* file name */
2841 case C_STRTAG
: /* structure tag */
2843 case C_BINCL
: /* beginning of include file */
2844 case C_EINCL
: /* ending of include file */
2857 dst
->symbol
.flags
= BSF_DEBUGGING
;
2858 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2861 case C_BLOCK
: /* ".bb" or ".eb" */
2862 case C_FCN
: /* ".bf" or ".ef" */
2863 case C_EFCN
: /* physical end of function */
2864 dst
->symbol
.flags
= BSF_LOCAL
;
2866 Base the value as an index from the base of the section
2868 dst
->symbol
.value
= (src
->u
.syment
.n_value
) - dst
->symbol
.section
->vma
;
2872 case C_EXTDEF
: /* external definition */
2873 case C_ULABEL
: /* undefined label */
2874 case C_USTATIC
: /* undefined static */
2875 case C_LINE
: /* line # reformatted as symbol table entry */
2876 case C_ALIAS
: /* duplicate tag */
2877 case C_HIDDEN
: /* ext symbol in dmert public lib */
2880 fprintf(stderr
,"Unrecognized storage class %d\n",
2881 src
->u
.syment
.n_sclass
);
2883 dst
->symbol
.flags
= BSF_DEBUGGING
;
2884 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2888 BFD_ASSERT(dst
->symbol
.flags
!= 0);
2892 dst
->symbol
.udata
= 0;
2893 dst
->lineno
= (alent
*) NULL
;
2894 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
2896 number_of_symbols
++;
2897 } /* walk the native symtab */
2898 } /* bfdize the native symtab */
2900 obj_symbols(abfd
) = cached_area
;
2901 obj_raw_syments(abfd
) = native_symbols
;
2903 bfd_get_symcount(abfd
) = number_of_symbols
;
2904 obj_convert(abfd
) = table_ptr
;
2905 /* Slurp the line tables for each section too */
2910 coff_slurp_line_table(abfd
, p
);
2915 } /* coff_slurp_symbol_table() */
2918 coff_get_symtab_upper_bound(abfd
)
2921 if (!coff_slurp_symbol_table(abfd
))
2924 return (bfd_get_symcount(abfd
) + 1) * (sizeof(coff_symbol_type
*));
2929 DEFUN(coff_get_symtab
, (abfd
, alocation
),
2931 asymbol
**alocation
)
2933 unsigned int counter
= 0;
2934 coff_symbol_type
*symbase
;
2935 coff_symbol_type
**location
= (coff_symbol_type
**) (alocation
);
2936 if (!coff_slurp_symbol_table(abfd
))
2939 symbase
= obj_symbols(abfd
);
2940 while (counter
< bfd_get_symcount(abfd
))
2942 /* This nasty code looks at the symbol to decide whether or
2943 not it is descibes a constructor/destructor entry point. It
2944 is structured this way to (hopefully) speed non matches */
2946 if (symbase
->symbol
.name
[9] == '$')
2948 bfd_constructor_entry(abfd
,
2949 (asymbol
**)location
,
2950 symbase
->symbol
.name
[10] == 'I' ?
2954 *(location
++) = symbase
++;
2958 return bfd_get_symcount(abfd
);
2961 #endif /* NO_COFF_SYMBOLS */
2964 coff_get_reloc_upper_bound(abfd
, asect
)
2968 if (bfd_get_format(abfd
) != bfd_object
) {
2969 bfd_error
= invalid_operation
;
2972 return (asect
->reloc_count
+ 1) * sizeof(arelent
*);
2976 @subsubsection Reading Relocations
2977 Coff relocations are easily transformed into the internal BFD form
2980 Reading a coff relocation table is done in the following stages:
2983 The entire coff relocation table is read into memory.
2985 Each relocation is processed in turn, first it is swapped from the
2986 external to the internal form.
2988 The symbol referenced in the relocation's symbol index is turned into
2989 a pointer into the canonical symbol table. Note that this table is the
2990 same as the one returned by a call to @code{bfd_canonicalize_symtab}.
2991 The back end will call the routine and save the result if a
2992 canonicalization hasn't been done.
2994 The reloc index is turned into a pointer to a howto structure, in a
2995 back end specific way. For instance, the 386 and 960 use the
2996 @code{r_type} to directly produce an index into a howto table vector;
2997 the 88k subtracts a number from the @code{r_type} field and creates an
3003 DEFUN(coff_slurp_reloc_table
,(abfd
, asect
, symbols
),
3008 RELOC
*native_relocs
;
3009 arelent
*reloc_cache
;
3010 if (asect
->relocation
)
3012 if (asect
->reloc_count
== 0)
3014 if (asect
->flags
& SEC_CONSTRUCTOR
)
3016 #ifndef NO_COFF_SYMBOLS
3017 if (!coff_slurp_symbol_table(abfd
))
3021 (RELOC
*) buy_and_read(abfd
,
3025 asect
->reloc_count
));
3026 reloc_cache
= (arelent
*)
3027 bfd_alloc(abfd
, (size_t) (asect
->reloc_count
* sizeof(arelent
)));
3029 if (reloc_cache
== NULL
) {
3030 bfd_error
= no_memory
;
3035 for (cache_ptr
= reloc_cache
,
3036 src
= native_relocs
;
3037 cache_ptr
< reloc_cache
+ asect
->reloc_count
;
3040 struct internal_reloc dst
;
3042 bfd_swap_reloc_in(abfd
, src
, &dst
);
3044 dst
.r_symndx
+= obj_symbol_slew(abfd
);
3045 cache_ptr
->sym_ptr_ptr
= symbols
+ obj_convert(abfd
)[dst
.r_symndx
];
3047 /* AMD has two relocation entries for the 'consth' instruction.
3048 * The first is R_IHIHALF (part 1), the second is R_IHCONST
3049 * (part 2). The second entry's r_symndx does not contain
3050 * an index to a symbol but rather a value (apparently).
3051 * Also, see the ifdef below for saving the r_symndx value in addend.
3053 if (dst
.r_type
== R_IHCONST
) {
3057 ptr
= *(cache_ptr
->sym_ptr_ptr
);
3058 cache_ptr
->address
= dst
.r_vaddr
;
3060 The symbols definitions that we have read in have been
3061 relocated as if their sections started at 0. But the offsets
3062 refering to the symbols in the raw data have not been
3063 modified, so we have to have a negative addend to compensate.
3065 Note that symbols which used to be common must be left alone */
3067 if (ptr
&& ptr
->the_bfd
== abfd
3068 && ptr
->section
!= (asection
*) NULL
3069 && ((ptr
->flags
& BSF_OLD_COMMON
)== 0))
3072 cache_ptr
->addend
= -(ptr
->section
->vma
+ ptr
->value
);
3074 cache_ptr
->addend
= 0;
3079 cache_ptr
->addend
= 0;
3082 cache_ptr
->address
-= asect
->vma
;
3084 cache_ptr
->section
= (asection
*) NULL
;
3087 if (dst
.r_type
== R_IHCONST
) {
3088 /* Add in the value which was stored in the symbol index */
3089 /* See above comment */
3090 cache_ptr
->addend
+= dst
.r_symndx
;
3091 /* Throw away the bogus symbol pointer */
3092 cache_ptr
->sym_ptr_ptr
= 0;
3094 cache_ptr
->howto
= howto_table
+ dst
.r_type
;
3097 cache_ptr
->howto
= howto_table
+ dst
.r_type
;
3100 cache_ptr
->howto
= howto_table
+ dst
.r_type
;
3103 cache_ptr
->howto
= howto_table
+ dst
.r_type
- R_RELBYTE
;
3106 if (dst
.r_type
>= R_PCR16L
&& dst
.r_type
<= R_VRT32
) {
3107 cache_ptr
->howto
= howto_table
+ dst
.r_type
- R_PCR16L
;
3108 cache_ptr
->addend
+= dst
.r_offset
<< 16;
3117 asect
->relocation
= reloc_cache
;
3122 /* This is stupid. This function should be a boolean predicate */
3124 DEFUN(coff_canonicalize_reloc
, (abfd
, section
, relptr
, symbols
),
3127 arelent
**relptr AND
3130 arelent
*tblptr
= section
->relocation
;
3131 unsigned int count
= 0;
3134 if (section
->flags
& SEC_CONSTRUCTOR
)
3136 /* this section has relocs made up by us, they are not in the
3137 file, so take them out of their chain and place them into
3138 the data area provided */
3139 arelent_chain
*chain
= section
->constructor_chain
;
3140 for (count
= 0; count
< section
->reloc_count
; count
++)
3142 *relptr
++ = &chain
->relent
;
3143 chain
= chain
->next
;
3149 coff_slurp_reloc_table(abfd
, section
, symbols
);
3152 tblptr
= section
->relocation
;
3156 for (; count
++ < section
->reloc_count
;)
3157 *relptr
++ = tblptr
++;
3162 return section
->reloc_count
;
3165 #ifndef NO_COFF_SYMBOLS
3168 provided a BFD, a section and an offset into the section, calculate and
3169 return the name of the source file and the line nearest to the wanted
3174 DEFUN(coff_find_nearest_line
,(abfd
,
3182 asection
*section AND
3183 asymbol
**ignore_symbols AND
3185 CONST
char **filename_ptr AND
3186 CONST
char **functionname_ptr AND
3187 unsigned int *line_ptr
)
3189 static bfd
*cache_abfd
;
3190 static asection
*cache_section
;
3191 static bfd_vma cache_offset
;
3192 static unsigned int cache_i
;
3193 static alent
*cache_l
;
3196 coff_data_type
*cof
= coff_data(abfd
);
3197 /* Run through the raw syments if available */
3198 combined_entry_type
*p
;
3200 unsigned int line_base
= 0;
3204 *functionname_ptr
= 0;
3207 /* Don't try and find line numbers in a non coff file */
3208 if (abfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
3214 p
= cof
->raw_syments
;
3216 for (i
= 0; i
< cof
->raw_syment_count
; i
++) {
3217 if (p
->u
.syment
.n_sclass
== C_FILE
) {
3218 /* File name has been moved into symbol */
3219 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
3222 p
+= 1 + p
->u
.syment
.n_numaux
;
3224 /* Now wander though the raw linenumbers of the section */
3226 If this is the same BFD as we were previously called with and this is
3227 the same section, and the offset we want is further down then we can
3228 prime the lookup loop
3230 if (abfd
== cache_abfd
&&
3231 section
== cache_section
&&
3232 offset
>= cache_offset
) {
3238 l
= section
->lineno
;
3241 for (; i
< section
->lineno_count
; i
++) {
3242 if (l
->line_number
== 0) {
3243 /* Get the symbol this line number points at */
3244 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
3245 *functionname_ptr
= coff
->symbol
.name
;
3247 combined_entry_type
*s
= coff
->native
;
3248 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
3250 S should now point to the .bf of the function
3252 if (s
->u
.syment
.n_numaux
) {
3254 The linenumber is stored in the auxent
3256 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
3257 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
3262 if (l
->u
.offset
> offset
)
3264 *line_ptr
= l
->line_number
+ line_base
+ 1;
3270 cache_section
= section
;
3271 cache_offset
= offset
;
3280 coff_sym_filepos(abfd
)
3283 return obj_sym_filepos(abfd
);
3287 #endif /* NO_COFF_SYMBOLS */
3291 DEFUN(coff_sizeof_headers
,(abfd
, reloc
),
3297 if (reloc
== false) {
3298 size
= FILHSZ
+ AOUTSZ
;
3304 size
+= abfd
->section_count
* SCNHSZ
;
3309 #define coff_core_file_failing_command _bfd_dummy_core_file_failing_command
3310 #define coff_core_file_failing_signal _bfd_dummy_core_file_failing_signal
3311 #define coff_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
3312 #define coff_slurp_armap bfd_slurp_coff_armap
3313 #define coff_slurp_extended_name_table _bfd_slurp_extended_name_table
3314 #define coff_truncate_arname bfd_dont_truncate_arname
3315 #define coff_openr_next_archived_file bfd_generic_openr_next_archived_file
3316 #define coff_generic_stat_arch_elt bfd_generic_stat_arch_elt
3317 #define coff_get_section_contents bfd_generic_get_section_contents
3318 #define coff_close_and_cleanup bfd_generic_close_and_cleanup
3320 #define coff_bfd_debug_info_start bfd_void
3321 #define coff_bfd_debug_info_end bfd_void
3322 #define coff_bfd_debug_info_accumulate (PROTO(void,(*),(bfd*, struct sec *))) bfd_void