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. */
26 BFD supports a number of different flavours of coff format.
27 The major difference between formats are the sizes and
28 alignments of fields in structures on disk, and the occasional
31 Coff in all its varieties is implimented with a few common
32 files and a number of implementation specific files. For
33 example, The 88k bcs coff format is implemented in the file
34 @code{coff-m88k.c}. This file @code{#include}s
35 @code{coff-m88k.h} which defines the external structure of the
36 coff format for the 88k, and @code{internalcoff.h} which
37 defines the internal structure. @code{coff-m88k.c} also
38 defines pthe relocations used by the 88k format
39 @xref{Relocations}. Then the major portion of coff code is
40 included (@code{coffcode.h}) which defines the methods used to
41 act upon the types defined in @code{coff-m88k.h} and
42 @code{internalcoff.h}.
45 The Intel i960 processor version of coff is implemented in
46 @code{coff-i960.c}. This file has the same structure as
47 @code{coff-m88k.c}, except that it includes @code{coff-i960.h}
48 rather than @code{coff-m88k.h}.
51 Porting To A New Version of Coff
53 The recommended method is to select from the existing
54 implimentations the version of coff which is most like the one
55 you want to use, for our purposes, we'll say that i386 coff is
56 the one you select, and that your coff flavour is called foo.
57 Copy the @code{i386coff.c} to @code{foocoff.c}, copy
58 @code{../include/i386coff.h} to @code{../include/foocoff.h}
59 and add the lines to @code{targets.c} and @code{Makefile.in}
60 so that your new back end is used. Alter the shapes of the
61 structures in @code{../include/foocoff.h} so that they match
62 what you need. You will probably also have to add
63 @code{#ifdef}s to the code in @code{internalcoff.h} and
64 @code{coffcode.h} if your version of coff is too wild.
66 You can verify that your new BFD backend works quite simply by
67 building @code{objdump} from the @code{binutils} directory,
68 and making sure that its version of what's going on at your
69 host systems idea (assuming it has the pretty standard coff
70 dump utility (usually called @code{att-dump} or just
71 @code{dump})) are the same. Then clean up your code, and send
72 what you've done to Cygnus. Then your stuff will be in the
73 next release, and you won't have to keep integrating it.
76 How The Coff Backend Works
81 Each flavour of coff supported in BFD has its own header file
82 descibing the external layout of the structures. There is also
83 an internal description of the coff layout (in
84 @code{internalcoff.h}) file (@code{}). A major function of the
85 coff backend is swapping the bytes and twiddling the bits to
86 translate the external form of the structures into the normal
87 internal form. This is all performed in the
88 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
89 elements are different sizes between different versions of
90 coff, it is the duty of the coff version specific include file
91 to override the definitions of various packing routines in
92 @code{coffcode.h}. Eg the size of line number entry in coff is
93 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
94 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
95 correct one. No doubt, some day someone will find a version of
96 coff which has a varying field size not catered for at the
97 moment. To port BFD, that person will have to add more @code{#defines}.
98 Three of the bit twiddling routines are exported to
99 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
100 and @code{coff_swap_linno_in}. @code{GDB} reads the symbol
101 table on its own, but uses BFD to fix things up. More of the
102 bit twiddlers are exported for @code{gas};
103 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
104 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
105 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
106 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
107 of all the symbol table and reloc drudgery itself, thereby
108 saving the internal BFD overhead, but uses BFD to swap things
109 on the way out, making cross ports much safer. This also
110 allows BFD (and thus the linker) to use the same header files
111 as @code{gas}, which makes one avenue to disaster disappear.
116 The simple canonical form for symbols used by BFD is not rich
117 enough to keep all the information available in a coff symbol
118 table. The back end gets around this by keeping the original
119 symbol table around, "behind the scenes".
121 When a symbol table is requested (through a call to
122 @code{bfd_canonicalize_symtab}, a request gets through to
123 @code{get_normalized_symtab}. This reads the symbol table from
124 the coff file and swaps all the structures inside into the
125 internal form. It also fixes up all the pointers in the table
126 (represented in the file by offsets from the first symbol in
127 the table) into physical pointers to elements in the new
128 internal table. This involves some work since the meanings of
129 fields changes depending upon context; a field that is a
130 pointer to another structure in the symbol table at one moment
131 may be the size in bytes of a structure in the next. Another
132 pass is made over the table. All symbols which mark file names
133 (<<C_FILE>> symbols) are modified so that the internal
134 string points to the value in the auxent (the real filename)
135 rather than the normal text associated with the symbol
138 At this time the symbol names are moved around. Coff stores
139 all symbols less than nine characters long physically
140 within the symbol table, longer strings are kept at the end of
141 the file in the string table. This pass moves all strings
142 into memory, and replaces them with pointers to the strings.
145 The symbol table is massaged once again, this time to create
146 the canonical table used by the BFD application. Each symbol
147 is inspected in turn, and a decision made (using the
148 @code{sclass} field) about the various flags to set in the
149 @code{asymbol} @xref{Symbols}. The generated canonical table
150 shares strings with the hidden internal symbol table.
152 Any linenumbers are read from the coff file too, and attached
153 to the symbols which own the functions the linenumbers belong to.
158 Writing a symbol to a coff file which didn't come from a coff
159 file will lose any debugging information. The @code{asymbol}
160 structure remembers the BFD from which was born, and on output
161 the back end makes sure that the same destination target as
162 source target is present.
164 When the symbols have come from a coff file then all the
165 debugging information is preserved.
167 Symbol tables are provided for writing to the back end in a
168 vector of pointers to pointers. This allows applications like
169 the linker to accumulate and output large symbol tables
170 without having to do too much byte copying.
172 This function runs through the provided symbol table and
173 patches each symbol marked as a file place holder
174 (@code{C_FILE}) to point to the next file place holder in the
175 list. It also marks each @code{offset} field in the list with
176 the offset from the first symbol of the current symbol.
178 Another function of this procedure is to turn the canonical
179 value form of BFD into the form used by coff. Internally, BFD
180 expects symbol values to be offsets from a section base; so a
181 symbol physically at 0x120, but in a section starting at
182 0x100, would have the value 0x20. Coff expects symbols to
183 contain their final value, so symbols have their values
184 changed at this point to reflect their sum with their owning
185 section. Note that this transformation uses the
186 <<output_section>> field of the @code{asymbol}'s
187 @code{asection} @xref{Sections}.
189 o coff_mangle_symbols
191 This routine runs though the provided symbol table and uses
192 the offsets generated by the previous pass and the pointers
193 generated when the symbol table was read in to create the
194 structured hierachy required by coff. It changes each pointer
195 to a symbol to an index into the symbol table of the symbol
200 This routine runs through the symbol table and patches up the
201 symbols from their internal form into the coff way, calls the
202 bit twiddlers and writes out the tabel to the file.
211 The hidden information for an asymbol is described in a
212 coff_ptr_struct, which is typedefed to a combined_entry_type
215 .typedef struct coff_ptr_struct
218 . {* Remembers the offset from the first symbol in the file for
219 . this symbol. Generated by coff_renumber_symbols. *}
220 .unsigned int offset;
222 . {* Should the tag field of this symbol be renumbered.
223 . Created by coff_pointerize_aux. *}
226 . {* Should the endidx field of this symbol be renumbered.
227 . Created by coff_pointerize_aux. *}
230 . {* The container for the symbol structure as read and translated
234 . union internal_auxent auxent;
235 . struct internal_syment syment;
237 .} combined_entry_type;
240 .{* Each canonical asymbol really looks like this: *}
242 .typedef struct coff_symbol_struct
244 . {* The actual symbol which the rest of BFD works with *}
247 . {* A pointer to the hidden information for this symbol *}
248 .combined_entry_type *native;
250 . {* A pointer to the linenumber information for this symbol *}
251 .struct lineno_cache_entry *lineno;
258 /* Most of this hacked by Steve Chamberlain, steve@cygnus.com */
261 #define PUTWORD bfd_h_put_32
262 #define PUTHALF bfd_h_put_16
263 #define PUTBYTE bfd_h_put_8
265 #ifndef GET_FCN_LNNOPTR
266 #define GET_FCN_LNNOPTR(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
269 #ifndef GET_FCN_ENDNDX
270 #define GET_FCN_ENDNDX(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
273 #ifndef PUT_FCN_LNNOPTR
274 #define PUT_FCN_LNNOPTR(abfd, in, ext) PUTWORD(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
276 #ifndef PUT_FCN_ENDNDX
277 #define PUT_FCN_ENDNDX(abfd, in, ext) PUTWORD(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
279 #ifndef GET_LNSZ_LNNO
280 #define GET_LNSZ_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_lnno)
282 #ifndef GET_LNSZ_SIZE
283 #define GET_LNSZ_SIZE(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_size)
285 #ifndef PUT_LNSZ_LNNO
286 #define PUT_LNSZ_LNNO(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_sym.x_misc.x_lnsz.x_lnno)
288 #ifndef PUT_LNSZ_SIZE
289 #define PUT_LNSZ_SIZE(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte*) ext->x_sym.x_misc.x_lnsz.x_size)
291 #ifndef GET_SCN_SCNLEN
292 #define GET_SCN_SCNLEN(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_scn.x_scnlen)
294 #ifndef GET_SCN_NRELOC
295 #define GET_SCN_NRELOC(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nreloc)
297 #ifndef GET_SCN_NLINNO
298 #define GET_SCN_NLINNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nlinno)
300 #ifndef PUT_SCN_SCNLEN
301 #define PUT_SCN_SCNLEN(abfd,in, ext) bfd_h_put_32(abfd, in, (bfd_byte *) ext->x_scn.x_scnlen)
303 #ifndef PUT_SCN_NRELOC
304 #define PUT_SCN_NRELOC(abfd,in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_scn.x_nreloc)
306 #ifndef PUT_SCN_NLINNO
307 #define PUT_SCN_NLINNO(abfd,in, ext) bfd_h_put_16(abfd,in, (bfd_byte *) ext->x_scn.x_nlinno)
309 #ifndef GET_LINENO_LNNO
310 #define GET_LINENO_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) (ext->l_lnno));
312 #ifndef PUT_LINENO_LNNO
313 #define PUT_LINENO_LNNO(abfd,val, ext) bfd_h_put_16(abfd,val, (bfd_byte *) (ext->l_lnno));
317 /* void warning(); */
320 * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the
321 * incoming SEC_* flags. The inverse of this function is styp_to_sec_flags().
322 * NOTE: If you add to/change this routine, you should mirror the changes
323 * in styp_to_sec_flags().
326 DEFUN(sec_to_styp_flags
, (sec_name
, sec_flags
),
327 CONST
char * sec_name AND
332 if (!strcmp(sec_name
, _TEXT
)) {
333 return((long)STYP_TEXT
);
334 } else if (!strcmp(sec_name
, _DATA
)) {
335 return((long)STYP_DATA
);
336 } else if (!strcmp(sec_name
, _BSS
)) {
337 return((long)STYP_BSS
);
339 } else if (!strcmp(sec_name
, _COMMENT
)) {
340 return((long)STYP_INFO
);
341 #endif /* _COMMENT */
344 /* Try and figure out what it should be */
345 if (sec_flags
& SEC_CODE
) styp_flags
= STYP_TEXT
;
346 if (sec_flags
& SEC_DATA
) styp_flags
= STYP_DATA
;
347 else if (sec_flags
& SEC_READONLY
)
348 #ifdef STYP_LIT /* 29k readonly text/data section */
349 styp_flags
= STYP_LIT
;
351 styp_flags
= STYP_TEXT
;
352 #endif /* STYP_LIT */
353 else if (sec_flags
& SEC_LOAD
) styp_flags
= STYP_TEXT
;
355 if (styp_flags
== 0) styp_flags
= STYP_BSS
;
360 * Return a word with SEC_* flags set to represent the incoming
361 * STYP_* flags (from scnhdr.s_flags). The inverse of this
362 * function is sec_to_styp_flags().
363 * NOTE: If you add to/change this routine, you should mirror the changes
364 * in sec_to_styp_flags().
367 DEFUN(styp_to_sec_flags
, (styp_flags
),
370 flagword sec_flags
=0;
372 if ((styp_flags
& STYP_TEXT
) || (styp_flags
& STYP_DATA
))
373 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
374 else if (styp_flags
& STYP_BSS
)
375 sec_flags
= SEC_ALLOC
;
377 #ifdef STYP_LIT /* A29k readonly text/data section type */
378 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
379 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
380 #endif /* STYP_LIT */
381 #ifdef STYP_OTHER_LOAD /* Other loaded sections */
382 if (styp_flags
& STYP_OTHER_LOAD
)
383 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
384 #endif /* STYP_SDATA */
389 #define get_index(symbol) ((int) (symbol)->value)
390 #define set_index(symbol, idx) ((symbol)->value = (idx))
392 /* **********************************************************************
393 Here are all the routines for swapping the structures seen in the
394 outside world into the internal forms.
399 DEFUN(bfd_swap_reloc_in
,(abfd
, reloc_src
, reloc_dst
),
402 struct internal_reloc
*reloc_dst
)
404 reloc_dst
->r_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*)reloc_src
->r_vaddr
);
405 reloc_dst
->r_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) reloc_src
->r_symndx
);
408 reloc_dst
->r_type
= bfd_h_get_8(abfd
, reloc_src
->r_type
);
409 reloc_dst
->r_size
= bfd_h_get_8(abfd
, reloc_src
->r_size
);
411 reloc_dst
->r_type
= bfd_h_get_16(abfd
, (bfd_byte
*) reloc_src
->r_type
);
414 #ifdef SWAP_IN_RELOC_OFFSET
415 reloc_dst
->r_offset
= SWAP_IN_RELOC_OFFSET(abfd
,
416 (bfd_byte
*) reloc_src
->r_offset
);
422 DEFUN(coff_swap_reloc_out
,(abfd
, src
, dst
),
427 struct internal_reloc
*reloc_src
= (struct internal_reloc
*)src
;
428 struct external_reloc
*reloc_dst
= (struct external_reloc
*)dst
;
429 bfd_h_put_32(abfd
, reloc_src
->r_vaddr
, (bfd_byte
*) reloc_dst
->r_vaddr
);
430 bfd_h_put_32(abfd
, reloc_src
->r_symndx
, (bfd_byte
*) reloc_dst
->r_symndx
);
431 bfd_h_put_16(abfd
, reloc_src
->r_type
, (bfd_byte
*)
434 #ifdef SWAP_OUT_RELOC_OFFSET
435 SWAP_OUT_RELOC_OFFSET(abfd
,
437 (bfd_byte
*) reloc_dst
->r_offset
);
439 #ifdef SWAP_OUT_RELOC_EXTRA
440 SWAP_OUT_RELOC_EXTRA(abfd
,reloc_src
, reloc_dst
);
443 return sizeof(struct external_reloc
);
447 DEFUN(bfd_swap_filehdr_in
,(abfd
, filehdr_src
, filehdr_dst
),
449 FILHDR
*filehdr_src AND
450 struct internal_filehdr
*filehdr_dst
)
452 filehdr_dst
->f_magic
= bfd_h_get_16(abfd
, (bfd_byte
*) filehdr_src
->f_magic
);
453 filehdr_dst
->f_nscns
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_nscns
);
454 filehdr_dst
->f_timdat
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_timdat
);
455 filehdr_dst
->f_symptr
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_symptr
);
456 filehdr_dst
->f_nsyms
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_nsyms
);
457 filehdr_dst
->f_opthdr
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_opthdr
);
458 filehdr_dst
->f_flags
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_flags
);
462 DEFUN(coff_swap_filehdr_out
,(abfd
, in
, out
),
467 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*)in
;
468 FILHDR
*filehdr_out
= (FILHDR
*)out
;
469 bfd_h_put_16(abfd
, filehdr_in
->f_magic
, (bfd_byte
*) filehdr_out
->f_magic
);
470 bfd_h_put_16(abfd
, filehdr_in
->f_nscns
, (bfd_byte
*) filehdr_out
->f_nscns
);
471 bfd_h_put_32(abfd
, filehdr_in
->f_timdat
, (bfd_byte
*) filehdr_out
->f_timdat
);
472 bfd_h_put_32(abfd
, filehdr_in
->f_symptr
, (bfd_byte
*) filehdr_out
->f_symptr
);
473 bfd_h_put_32(abfd
, filehdr_in
->f_nsyms
, (bfd_byte
*) filehdr_out
->f_nsyms
);
474 bfd_h_put_16(abfd
, filehdr_in
->f_opthdr
, (bfd_byte
*) filehdr_out
->f_opthdr
);
475 bfd_h_put_16(abfd
, filehdr_in
->f_flags
, (bfd_byte
*) filehdr_out
->f_flags
);
476 return sizeof(FILHDR
);
480 #ifndef NO_COFF_SYMBOLS
483 DEFUN(coff_swap_sym_in
,(abfd
, ext1
, in1
),
488 SYMENT
*ext
= (SYMENT
*)ext1
;
489 struct internal_syment
*in
= (struct internal_syment
*)in1
;
491 if( ext
->e
.e_name
[0] == 0) {
492 in
->_n
._n_n
._n_zeroes
= 0;
493 in
->_n
._n_n
._n_offset
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e
.e
.e_offset
);
496 #if SYMNMLEN != E_SYMNMLEN
497 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
499 memcpy(in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
502 in
->n_value
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_value
);
503 in
->n_scnum
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_scnum
);
504 if (sizeof(ext
->e_type
) == 2){
505 in
->n_type
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_type
);
508 in
->n_type
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_type
);
510 in
->n_sclass
= bfd_h_get_8(abfd
, ext
->e_sclass
);
511 in
->n_numaux
= bfd_h_get_8(abfd
, ext
->e_numaux
);
515 DEFUN(coff_swap_sym_out
,(abfd
, inp
, extp
),
520 struct internal_syment
*in
= (struct internal_syment
*)inp
;
521 SYMENT
*ext
=(SYMENT
*)extp
;
522 if(in
->_n
._n_name
[0] == 0) {
523 bfd_h_put_32(abfd
, 0, (bfd_byte
*) ext
->e
.e
.e_zeroes
);
524 bfd_h_put_32(abfd
, in
->_n
._n_n
._n_offset
, (bfd_byte
*) ext
->e
.e
.e_offset
);
527 #if SYMNMLEN != E_SYMNMLEN
528 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
530 memcpy(ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
533 bfd_h_put_32(abfd
, in
->n_value
, (bfd_byte
*) ext
->e_value
);
534 bfd_h_put_16(abfd
, in
->n_scnum
, (bfd_byte
*) ext
->e_scnum
);
535 if (sizeof(ext
->e_type
) == 2)
537 bfd_h_put_16(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
541 bfd_h_put_32(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
543 bfd_h_put_8(abfd
, in
->n_sclass
, ext
->e_sclass
);
544 bfd_h_put_8(abfd
, in
->n_numaux
, ext
->e_numaux
);
545 return sizeof(SYMENT
);
549 DEFUN(coff_swap_aux_in
,(abfd
, ext1
, type
, class, in1
),
556 AUXENT
*ext
= (AUXENT
*)ext1
;
557 union internal_auxent
*in
= (union internal_auxent
*)in1
;
560 if (ext
->x_file
.x_fname
[0] == 0) {
561 in
->x_file
.x_n
.x_zeroes
= 0;
562 in
->x_file
.x_n
.x_offset
=
563 bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
565 #if FILNMLEN != E_FILNMLEN
566 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
568 memcpy (in
->x_file
.x_fname
, ext
->x_file
.x_fname
, FILNMLEN
);
573 /* RS/6000 "csect" auxents */
577 in
->x_csect
.x_scnlen
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_scnlen
);
578 in
->x_csect
.x_parmhash
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_parmhash
);
579 in
->x_csect
.x_snhash
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snhash
);
580 /* We don't have to hack bitfields in x_smtyp because it's defined by
581 shifts-and-ands, which are equivalent on all byte orders. */
582 in
->x_csect
.x_smtyp
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smtyp
);
583 in
->x_csect
.x_smclas
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smclas
);
584 in
->x_csect
.x_stab
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_stab
);
585 in
->x_csect
.x_snstab
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snstab
);
594 if (type
== T_NULL
) {
595 in
->x_scn
.x_scnlen
= GET_SCN_SCNLEN(abfd
, ext
);
596 in
->x_scn
.x_nreloc
= GET_SCN_NRELOC(abfd
, ext
);
597 in
->x_scn
.x_nlinno
= GET_SCN_NLINNO(abfd
, ext
);
601 in
->x_sym
.x_tagndx
.l
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
603 in
->x_sym
.x_tvndx
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
606 if (ISARY(type
) || class == C_BLOCK
) {
607 #if DIMNUM != E_DIMNUM
608 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
610 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]);
611 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]);
612 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]);
613 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]);
616 in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= GET_FCN_LNNOPTR(abfd
, ext
);
617 in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= GET_FCN_ENDNDX(abfd
, ext
);
620 in
->x_sym
.x_misc
.x_fsize
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
623 in
->x_sym
.x_misc
.x_lnsz
.x_lnno
= GET_LNSZ_LNNO(abfd
, ext
);
624 in
->x_sym
.x_misc
.x_lnsz
.x_size
= GET_LNSZ_SIZE(abfd
, ext
);
630 DEFUN(coff_swap_aux_out
,(abfd
, inp
, type
, class, extp
),
637 union internal_auxent
*in
= (union internal_auxent
*)inp
;
638 AUXENT
*ext
= (AUXENT
*)extp
;
641 if (in
->x_file
.x_fname
[0] == 0) {
642 PUTWORD(abfd
, 0, (bfd_byte
*) ext
->x_file
.x_n
.x_zeroes
);
644 in
->x_file
.x_n
.x_offset
,
645 (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
648 #if FILNMLEN != E_FILNMLEN
649 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
651 memcpy (ext
->x_file
.x_fname
, in
->x_file
.x_fname
, FILNMLEN
);
657 /* RS/6000 "csect" auxents */
660 PUTWORD (abfd
, in
->x_csect
.x_scnlen
, ext
->x_csect
.x_scnlen
);
661 PUTWORD (abfd
, in
->x_csect
.x_parmhash
, ext
->x_csect
.x_parmhash
);
662 PUTHALF (abfd
, in
->x_csect
.x_snhash
, ext
->x_csect
.x_snhash
);
663 /* We don't have to hack bitfields in x_smtyp because it's defined by
664 shifts-and-ands, which are equivalent on all byte orders. */
665 PUTBYTE (abfd
, in
->x_csect
.x_smtyp
, ext
->x_csect
.x_smtyp
);
666 PUTBYTE (abfd
, in
->x_csect
.x_smclas
, ext
->x_csect
.x_smclas
);
667 PUTWORD (abfd
, in
->x_csect
.x_stab
, ext
->x_csect
.x_stab
);
668 PUTHALF (abfd
, in
->x_csect
.x_snstab
, ext
->x_csect
.x_snstab
);
677 if (type
== T_NULL
) {
678 PUT_SCN_SCNLEN(abfd
, in
->x_scn
.x_scnlen
, ext
);
679 PUT_SCN_NRELOC(abfd
, in
->x_scn
.x_nreloc
, ext
);
680 PUT_SCN_NLINNO(abfd
, in
->x_scn
.x_nlinno
, ext
);
684 PUTWORD(abfd
, in
->x_sym
.x_tagndx
.l
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
686 PUTWORD(abfd
, in
->x_sym
.x_tvndx
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
690 PUTWORD(abfd
, in
->x_sym
.x_misc
.x_fsize
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
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
);
696 if (ISARY(type
) || class == C_BLOCK
) {
697 #if DIMNUM != E_DIMNUM
698 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
700 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]);
701 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]);
702 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]);
703 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]);
706 PUT_LNSZ_LNNO(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
707 PUT_LNSZ_SIZE(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
709 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
710 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
715 return sizeof(AUXENT
);
718 #endif /* NO_COFF_SYMBOLS */
720 #ifndef NO_COFF_LINENOS
723 DEFUN(coff_swap_lineno_in
,(abfd
, ext1
, in1
),
728 LINENO
*ext
= (LINENO
*)ext1
;
729 struct internal_lineno
*in
= (struct internal_lineno
*)in1
;
731 in
->l_addr
.l_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->l_addr
.l_symndx
);
732 in
->l_lnno
= GET_LINENO_LNNO(abfd
, ext
);
736 DEFUN(coff_swap_lineno_out
,(abfd
, inp
, outp
),
741 struct internal_lineno
*in
= (struct internal_lineno
*)inp
;
742 struct external_lineno
*ext
= (struct external_lineno
*)outp
;
743 PUTWORD(abfd
, in
->l_addr
.l_symndx
, (bfd_byte
*)
744 ext
->l_addr
.l_symndx
);
746 PUT_LINENO_LNNO (abfd
, in
->l_lnno
, ext
);
747 return sizeof(struct external_lineno
);
750 #endif /* NO_COFF_LINENOS */
754 DEFUN(bfd_swap_aouthdr_in
,(abfd
, aouthdr_ext1
, aouthdr_int1
),
759 AOUTHDR
*aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
760 struct internal_aouthdr
*aouthdr_int
= (struct internal_aouthdr
*)aouthdr_int1
;
762 aouthdr_int
->magic
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->magic
);
763 aouthdr_int
->vstamp
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->vstamp
);
764 aouthdr_int
->tsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tsize
);
765 aouthdr_int
->dsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->dsize
);
766 aouthdr_int
->bsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->bsize
);
767 aouthdr_int
->entry
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->entry
);
768 aouthdr_int
->text_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->text_start
);
769 aouthdr_int
->data_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->data_start
);
771 aouthdr_int
->tagentries
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tagentries
);
775 aouthdr_int
->o_toc
= bfd_h_get_32(abfd
, aouthdr_ext
->o_toc
);
776 aouthdr_int
->o_snentry
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snentry
);
777 aouthdr_int
->o_sntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntext
);
778 aouthdr_int
->o_sndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sndata
);
779 aouthdr_int
->o_sntoc
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntoc
);
780 aouthdr_int
->o_snloader
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snloader
);
781 aouthdr_int
->o_snbss
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snbss
);
782 aouthdr_int
->o_algntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algntext
);
783 aouthdr_int
->o_algndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algndata
);
784 aouthdr_int
->o_modtype
= bfd_h_get_16(abfd
, aouthdr_ext
->o_modtype
);
785 aouthdr_int
->o_maxstack
= bfd_h_get_32(abfd
, aouthdr_ext
->o_maxstack
);
790 DEFUN(coff_swap_aouthdr_out
,(abfd
, in
, out
),
795 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*)in
;
796 AOUTHDR
*aouthdr_out
= (AOUTHDR
*)out
;
797 bfd_h_put_16(abfd
, aouthdr_in
->magic
, (bfd_byte
*) aouthdr_out
->magic
);
798 bfd_h_put_16(abfd
, aouthdr_in
->vstamp
, (bfd_byte
*) aouthdr_out
->vstamp
);
799 bfd_h_put_32(abfd
, aouthdr_in
->tsize
, (bfd_byte
*) aouthdr_out
->tsize
);
800 bfd_h_put_32(abfd
, aouthdr_in
->dsize
, (bfd_byte
*) aouthdr_out
->dsize
);
801 bfd_h_put_32(abfd
, aouthdr_in
->bsize
, (bfd_byte
*) aouthdr_out
->bsize
);
802 bfd_h_put_32(abfd
, aouthdr_in
->entry
, (bfd_byte
*) aouthdr_out
->entry
);
803 bfd_h_put_32(abfd
, aouthdr_in
->text_start
,
804 (bfd_byte
*) aouthdr_out
->text_start
);
805 bfd_h_put_32(abfd
, aouthdr_in
->data_start
, (bfd_byte
*) aouthdr_out
->data_start
);
807 bfd_h_put_32(abfd
, aouthdr_in
->tagentries
, (bfd_byte
*) aouthdr_out
->tagentries
);
809 return sizeof(AOUTHDR
);
813 DEFUN(coff_swap_scnhdr_in
,(abfd
, scnhdr_ext
, scnhdr_int
),
815 SCNHDR
*scnhdr_ext AND
816 struct internal_scnhdr
*scnhdr_int
)
818 memcpy(scnhdr_int
->s_name
, scnhdr_ext
->s_name
, sizeof(scnhdr_int
->s_name
));
819 scnhdr_int
->s_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
820 scnhdr_int
->s_paddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
821 scnhdr_int
->s_size
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_size
);
822 scnhdr_int
->s_scnptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
823 scnhdr_int
->s_relptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
824 scnhdr_int
->s_lnnoptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
825 scnhdr_int
->s_flags
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_flags
);
827 scnhdr_int
->s_nreloc
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
828 scnhdr_int
->s_nlnno
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
830 scnhdr_int
->s_nreloc
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
831 scnhdr_int
->s_nlnno
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
834 scnhdr_int
->s_align
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_align
);
839 DEFUN(coff_swap_scnhdr_out
,(abfd
, in
, out
),
844 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*)in
;
845 SCNHDR
*scnhdr_ext
= (SCNHDR
*)out
;
846 memcpy(scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof(scnhdr_int
->s_name
));
847 PUTWORD(abfd
, scnhdr_int
->s_vaddr
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
848 PUTWORD(abfd
, scnhdr_int
->s_paddr
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
849 PUTWORD(abfd
, scnhdr_int
->s_size
, (bfd_byte
*) scnhdr_ext
->s_size
);
850 PUTWORD(abfd
, scnhdr_int
->s_scnptr
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
851 PUTWORD(abfd
, scnhdr_int
->s_relptr
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
852 PUTWORD(abfd
, scnhdr_int
->s_lnnoptr
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
853 PUTWORD(abfd
, scnhdr_int
->s_flags
, (bfd_byte
*) scnhdr_ext
->s_flags
);
855 PUTWORD(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
856 PUTWORD(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
858 PUTHALF(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
859 PUTHALF(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
863 PUTWORD(abfd
, scnhdr_int
->s_align
, (bfd_byte
*) scnhdr_ext
->s_align
);
865 return sizeof(SCNHDR
);
870 initialize a section structure with information peculiar to this
871 particular implementation of coff
875 DEFUN(coff_new_section_hook
,(abfd_ignore
, section_ignore
),
877 asection
*section_ignore
)
879 section_ignore
->alignment_power
= abfd_ignore
->xvec
->align_power_min
;
883 /* Take a section header read from a coff file (in HOST byte order),
884 and make a BFD "section" out of it. */
886 DEFUN(make_a_section_from_file
,(abfd
, hdr
),
888 struct internal_scnhdr
*hdr
)
890 asection
*return_section
;
893 /* Assorted wastage to null-terminate the name, thanks AT&T! */
894 char *name
= bfd_alloc(abfd
, sizeof (hdr
->s_name
)+1);
896 bfd_error
= no_memory
;
899 strncpy(name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
900 name
[sizeof (hdr
->s_name
)] = 0;
902 return_section
= bfd_make_section(abfd
, name
);
903 if (return_section
== NULL
)
907 /* s_paddr is presumed to be = to s_vaddr */
908 #define assign(to, from) return_section->to = hdr->from
909 assign(vma
, s_vaddr
);
910 /* assign (vma, s_vaddr); */
911 assign(size
, s_size
);
912 assign(filepos
, s_scnptr
);
913 assign(rel_filepos
, s_relptr
);
914 assign(reloc_count
, s_nreloc
);
917 /* FIXME, use a temp var rather than alignment_power */
918 assign(alignment_power
, s_align
);
921 for (i
= 0; i
< 32; i
++) {
922 if ((1 << i
) >= (int) (return_section
->alignment_power
)) {
923 return_section
->alignment_power
= i
;
930 assign(line_filepos
, s_lnnoptr
);
932 return_section->linesize = hdr->s_nlnno * sizeof (struct lineno);
935 return_section
->lineno_count
= hdr
->s_nlnno
;
936 return_section
->userdata
= NULL
;
937 return_section
->next
= (asection
*) NULL
;
938 return_section
->flags
= styp_to_sec_flags(hdr
->s_flags
);
941 if (hdr
->s_nreloc
!= 0)
942 return_section
->flags
|= SEC_RELOC
;
943 /* FIXME: should this check 'hdr->s_size > 0' */
944 if (hdr
->s_scnptr
!= 0)
945 return_section
->flags
|= SEC_HAS_CONTENTS
;
949 DEFUN(coff_mkobject
,(abfd
),
952 set_tdata (abfd
, bfd_zalloc (abfd
,sizeof(coff_data_type
)));
953 if (coff_data(abfd
) == 0) {
954 bfd_error
= no_memory
;
957 coff_data(abfd
)->relocbase
= 0;
963 DEFUN(coff_real_object_p
,(abfd
, nscns
, internal_f
, internal_a
),
966 struct internal_filehdr
*internal_f AND
967 struct internal_aouthdr
*internal_a
)
969 coff_data_type
*coff
;
970 enum bfd_architecture arch
;
972 size_t readsize
; /* length of file_info */
973 SCNHDR
*external_sections
;
975 /* Build a play area */
976 if (coff_mkobject(abfd
) != true)
978 coff
= coff_data(abfd
);
981 external_sections
= (SCNHDR
*)bfd_alloc(abfd
, readsize
= (nscns
* SCNHSZ
));
983 if (bfd_read((PTR
)external_sections
, 1, readsize
, abfd
) != readsize
) {
988 /* Now copy data as required; construct all asections etc */
989 coff
->symbol_index_slew
= 0;
991 coff
->raw_syment_count
= 0;
992 coff
->raw_linenos
= 0;
993 coff
->raw_syments
= 0;
994 coff
->sym_filepos
=0;
995 coff
->flags
= internal_f
->f_flags
;
998 for (i
= 0; i
< nscns
; i
++) {
999 struct internal_scnhdr tmp
;
1000 coff_swap_scnhdr_in(abfd
, external_sections
+ i
, &tmp
);
1001 make_a_section_from_file(abfd
,&tmp
);
1004 /* Determine the machine architecture and type. */
1006 switch (internal_f
->f_magic
) {
1009 arch
= bfd_arch_i386
;
1014 #ifdef A29K_MAGIC_BIG
1015 case A29K_MAGIC_BIG
:
1016 case A29K_MAGIC_LITTLE
:
1017 arch
= bfd_arch_a29k
;
1026 arch
= bfd_arch_mips
;
1034 arch
= bfd_arch_m68k
;
1042 arch
= bfd_arch_m88k
;
1050 arch
= bfd_arch_i960
;
1051 switch (F_I960TYPE
& internal_f
->f_flags
)
1055 machine
= bfd_mach_i960_core
;
1058 machine
= bfd_mach_i960_kb_sb
;
1061 machine
= bfd_mach_i960_mc
;
1064 machine
= bfd_mach_i960_xa
;
1067 machine
= bfd_mach_i960_ca
;
1070 machine
= bfd_mach_i960_ka_sa
;
1081 arch
= bfd_arch_rs6000
;
1088 arch
= bfd_arch_h8300
;
1093 default: /* Unreadable input file type */
1094 arch
= bfd_arch_obscure
;
1098 bfd_default_set_arch_mach(abfd
, arch
, machine
);
1099 if (!(internal_f
->f_flags
& F_RELFLG
))
1100 abfd
->flags
|= HAS_RELOC
;
1101 if ((internal_f
->f_flags
& F_EXEC
))
1102 abfd
->flags
|= EXEC_P
;
1103 if (!(internal_f
->f_flags
& F_LNNO
))
1104 abfd
->flags
|= HAS_LINENO
;
1105 if (!(internal_f
->f_flags
& F_LSYMS
))
1106 abfd
->flags
|= HAS_LOCALS
;
1109 bfd_get_symcount(abfd
) = internal_f
->f_nsyms
;
1110 if (internal_f
->f_nsyms
)
1111 abfd
->flags
|= HAS_SYMS
;
1113 coff
->sym_filepos
= internal_f
->f_symptr
;
1115 /* These members communicate important constants about the symbol table
1116 to GDB's symbol-reading code. These `constants' unfortunately vary
1117 from coff implementation to implementation... */
1118 #ifndef NO_COFF_SYMBOLS
1119 coff
->local_n_btmask
= N_BTMASK
;
1120 coff
->local_n_btshft
= N_BTSHFT
;
1121 coff
->local_n_tmask
= N_TMASK
;
1122 coff
->local_n_tshift
= N_TSHIFT
;
1123 coff
->local_symesz
= SYMESZ
;
1124 coff
->local_auxesz
= AUXESZ
;
1125 coff
->local_linesz
= LINESZ
;
1128 coff
->symbols
= (coff_symbol_type
*) NULL
;
1129 bfd_get_start_address(abfd
) = internal_f
->f_opthdr
? internal_a
->entry
: 0;
1133 bfd_release(abfd
, coff
);
1134 return (bfd_target
*)NULL
;
1138 DEFUN(coff_object_p
,(abfd
),
1144 struct internal_filehdr internal_f
;
1145 struct internal_aouthdr internal_a
;
1147 bfd_error
= system_call_error
;
1149 /* figure out how much to read */
1150 if (bfd_read((PTR
) &filehdr
, 1, FILHSZ
, abfd
) != FILHSZ
)
1153 bfd_swap_filehdr_in(abfd
, &filehdr
, &internal_f
);
1155 if (BADMAG(internal_f
)) {
1156 bfd_error
= wrong_format
;
1159 nscns
=internal_f
.f_nscns
;
1161 if (internal_f
.f_opthdr
) {
1162 if (bfd_read((PTR
) &opthdr
, 1,AOUTSZ
, abfd
) != AOUTSZ
) {
1165 bfd_swap_aouthdr_in(abfd
, (char *)&opthdr
, (char *)&internal_a
);
1168 /* Seek past the opt hdr stuff */
1169 bfd_seek(abfd
, internal_f
.f_opthdr
+ FILHSZ
, SEEK_SET
);
1171 /* if the optional header is NULL or not the correct size then
1172 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1173 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1174 optional header is of a different size.
1176 But the mips keeps extra stuff in it's opthdr, so dont check
1180 #if defined(M88) || defined(I960)
1181 if (internal_f
.f_opthdr
!= 0 && AOUTSZ
!= internal_f
.f_opthdr
)
1182 return (bfd_target
*)NULL
;
1185 return coff_real_object_p(abfd
, nscns
, &internal_f
, &internal_a
);
1190 #ifndef NO_COFF_LINENOS
1193 DEFUN(coff_count_linenumbers
,(abfd
),
1196 unsigned int limit
= bfd_get_symcount(abfd
);
1200 asection
*s
= abfd
->sections
->output_section
;
1202 BFD_ASSERT(s
->lineno_count
== 0);
1208 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++) {
1209 asymbol
*q_maybe
= *p
;
1210 if (q_maybe
->the_bfd
->xvec
->flavour
== bfd_target_coff_flavour
) {
1211 coff_symbol_type
*q
= coffsymbol(q_maybe
);
1214 This symbol has a linenumber, increment the owning
1215 section's linenumber count
1217 alent
*l
= q
->lineno
;
1218 q
->symbol
.section
->output_section
->lineno_count
++;
1220 while (l
->line_number
) {
1221 q
->symbol
.section
->output_section
->lineno_count
++;
1229 #endif /* NO_COFF_LINENOS */
1231 #ifndef NO_COFF_SYMBOLS
1234 Takes a bfd and a symbol, returns a pointer to the coff specific area
1235 of the symbol if there is one.
1237 static coff_symbol_type
*
1238 DEFUN(coff_symbol_from
,(ignore_abfd
, symbol
),
1239 bfd
*ignore_abfd AND
1242 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
1243 return (coff_symbol_type
*)NULL
;
1245 if (symbol
->the_bfd
->tdata
== (PTR
)NULL
)
1246 return (coff_symbol_type
*)NULL
;
1248 return (coff_symbol_type
*) symbol
;
1254 DEFUN(fixup_symbol_value
,(coff_symbol_ptr
, syment
),
1255 coff_symbol_type
*coff_symbol_ptr AND
1256 struct internal_syment
*syment
)
1259 /* Normalize the symbol flags */
1260 if (coff_symbol_ptr
->symbol
.flags
& BSF_FORT_COMM
) {
1261 /* a common symbol is undefined with a value */
1262 syment
->n_scnum
= N_UNDEF
;
1263 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1265 else if (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) {
1266 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1268 else if (coff_symbol_ptr
->symbol
.flags
& BSF_UNDEFINED
) {
1269 syment
->n_scnum
= N_UNDEF
;
1270 syment
->n_value
= 0;
1272 else if (coff_symbol_ptr
->symbol
.flags
& BSF_ABSOLUTE
) {
1273 syment
->n_scnum
= N_ABS
;
1274 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1277 if (coff_symbol_ptr
->symbol
.section
) {
1279 coff_symbol_ptr
->symbol
.section
->output_section
->index
+1;
1282 coff_symbol_ptr
->symbol
.value
+
1283 coff_symbol_ptr
->symbol
.section
->output_offset
+
1284 coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
1287 /* This can happen, but I don't know why yet (steve@cygnus.com) */
1288 syment
->n_scnum
= N_ABS
;
1289 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1294 /* run through all the symbols in the symbol table and work out what
1295 their indexes into the symbol table will be when output
1297 Coff requires that each C_FILE symbol points to the next one in the
1298 chain, and that the last one points to the first external symbol. We
1303 DEFUN(coff_renumber_symbols
,(bfd_ptr
),
1306 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1307 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1308 unsigned int native_index
= 0;
1309 struct internal_syment
*last_file
= (struct internal_syment
*)NULL
;
1310 unsigned int symbol_index
;
1311 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1313 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1314 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1315 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1318 if (s
->u
.syment
.n_sclass
== C_FILE
)
1320 if (last_file
!= (struct internal_syment
*)NULL
) {
1321 last_file
->n_value
= native_index
;
1323 last_file
= &(s
->u
.syment
);
1327 /* Modify the symbol values according to their section and
1330 fixup_symbol_value(coff_symbol_ptr
, &(s
->u
.syment
));
1332 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++) {
1333 s
[i
].offset
= native_index
++;
1344 Run thorough the symbol table again, and fix it so that all pointers to
1345 entries are changed to the entries' index in the output symbol table.
1349 DEFUN(coff_mangle_symbols
,(bfd_ptr
),
1352 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1353 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1354 unsigned int symbol_index
;
1356 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1358 coff_symbol_type
*coff_symbol_ptr
=
1359 coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1361 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1363 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1365 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++) {
1366 combined_entry_type
*a
= s
+ i
+ 1;
1368 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
1369 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
1372 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
1373 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
1381 static int string_size
;
1383 DEFUN(coff_fix_symbol_name
,(ignore_abfd
, symbol
, native
),
1384 bfd
*ignore_abfd AND
1386 combined_entry_type
*native
)
1388 unsigned int name_length
;
1389 union internal_auxent
*auxent
;
1390 char * name
= ( char *)(symbol
->name
);
1392 if (name
== (char *) NULL
) {
1393 /* coff symbols always have names, so we'll make one up */
1394 symbol
->name
= "strange";
1395 name
= (char *)symbol
->name
;
1397 name_length
= strlen(name
);
1399 if (native
->u
.syment
.n_sclass
== C_FILE
) {
1400 strncpy(native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
1401 auxent
= &(native
+1)->u
.auxent
;
1403 #ifdef COFF_LONG_FILENAMES
1404 if (name_length
<= FILNMLEN
) {
1405 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1408 auxent
->x_file
.x_n
.x_offset
= string_size
+ 4;
1409 auxent
->x_file
.x_n
.x_zeroes
= 0;
1410 string_size
+= name_length
+ 1;
1413 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1414 if (name_length
> FILNMLEN
) {
1415 name
[FILNMLEN
] = '\0';
1420 { /* NOT A C_FILE SYMBOL */
1421 if (name_length
<= SYMNMLEN
) {
1422 /* This name will fit into the symbol neatly */
1423 strncpy(native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
1426 native
->u
.syment
._n
._n_n
._n_offset
= string_size
+ 4;
1427 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1428 string_size
+= name_length
+ 1;
1436 DEFUN(coff_write_symbol
,(abfd
, symbol
, native
, written
),
1439 combined_entry_type
*native AND
1440 unsigned int written
)
1442 unsigned int numaux
= native
->u
.syment
.n_numaux
;
1443 int type
= native
->u
.syment
.n_type
;
1444 int class = native
->u
.syment
.n_sclass
;
1448 coff_fix_symbol_name(abfd
, symbol
, native
);
1449 coff_swap_sym_out(abfd
, &native
->u
.syment
, &buf
);
1450 bfd_write((PTR
)& buf
, 1, SYMESZ
, abfd
);
1451 for (j
= 0; j
!= native
->u
.syment
.n_numaux
; j
++)
1454 bzero((PTR
)&buf
, AUXESZ
);
1455 coff_swap_aux_out(abfd
,
1456 &( (native
+ j
+ 1)->u
.auxent
), type
, class, &buf1
);
1457 bfd_write((PTR
) (&buf1
), 1, AUXESZ
, abfd
);
1460 Reuse somewhere in the symbol to keep the index
1462 set_index(symbol
, written
);
1463 return written
+ 1 + numaux
;
1468 DEFUN(coff_write_alien_symbol
,(abfd
, symbol
, written
),
1471 unsigned int written
)
1474 This symbol has been created by the loader, or come from a non
1475 coff format. It has no native element to inherit, make our
1478 combined_entry_type
*native
;
1479 combined_entry_type dummy
;
1481 native
->u
.syment
.n_type
= T_NULL
;
1483 native
->u
.syment
.n_flags
= 0;
1485 if (symbol
->flags
& BSF_ABSOLUTE
) {
1486 native
->u
.syment
.n_scnum
= N_ABS
;
1487 native
->u
.syment
.n_value
= symbol
->value
;
1489 else if (symbol
->flags
& (BSF_UNDEFINED
| BSF_FORT_COMM
)) {
1490 native
->u
.syment
.n_scnum
= N_UNDEF
;
1491 native
->u
.syment
.n_value
= symbol
->value
;
1493 else if (symbol
->flags
& BSF_DEBUGGING
) {
1495 remove name so it doesn't take up any space
1500 native
->u
.syment
.n_scnum
= symbol
->section
->output_section
->index
+
1502 native
->u
.syment
.n_value
= symbol
->value
+
1503 symbol
->section
->output_section
->vma
+
1504 symbol
->section
->output_offset
;
1506 /* Copy the any flags from the the file hdr into the symbol */
1508 coff_symbol_type
*c
= coff_symbol_from(abfd
, symbol
);
1509 if (c
!= (coff_symbol_type
*)NULL
) {
1510 native
->u
.syment
.n_flags
= c
->symbol
.the_bfd
->flags
;
1517 native
->u
.syment
.pad1
[0] = 0;
1518 native
->u
.syment
.pad1
[0] = 0;
1521 native
->u
.syment
.n_type
= 0;
1522 if (symbol
->flags
& BSF_LOCAL
)
1523 native
->u
.syment
.n_sclass
= C_STAT
;
1525 native
->u
.syment
.n_sclass
= C_EXT
;
1526 native
->u
.syment
.n_numaux
= 0;
1528 return coff_write_symbol(abfd
, symbol
, native
, written
);
1532 DEFUN(coff_write_native_symbol
,(abfd
, symbol
, written
),
1534 coff_symbol_type
*symbol AND
1535 unsigned int written
)
1538 Does this symbol have an ascociated line number - if so then
1539 make it remember this symbol index. Also tag the auxent of
1540 this symbol to point to the right place in the lineno table
1542 combined_entry_type
*native
= symbol
->native
;
1544 alent
*lineno
= symbol
->lineno
;
1547 unsigned int count
= 0;
1548 lineno
[count
].u
.offset
= written
;
1549 if (native
->u
.syment
.n_numaux
) {
1550 union internal_auxent
*a
= &((native
+1)->u
.auxent
);
1552 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1553 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1556 And count and relocate all other linenumbers
1559 while (lineno
[count
].line_number
) {
1560 lineno
[count
].u
.offset
+=
1561 symbol
->symbol
.section
->output_section
->vma
+
1562 symbol
->symbol
.section
->output_offset
;
1565 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1568 return coff_write_symbol(abfd
, &( symbol
->symbol
), native
,written
);
1572 DEFUN(coff_write_symbols
,(abfd
),
1576 unsigned int limit
= bfd_get_symcount(abfd
);
1577 unsigned int written
= 0;
1584 /* Seek to the right place */
1585 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
1587 /* Output all the symbols we have */
1590 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1592 asymbol
*symbol
= *p
;
1593 coff_symbol_type
*c_symbol
= coff_symbol_from(abfd
, symbol
);
1595 if (c_symbol
== (coff_symbol_type
*) NULL
||
1596 c_symbol
->native
== (combined_entry_type
*)NULL
)
1598 written
= coff_write_alien_symbol(abfd
, symbol
, written
);
1602 written
= coff_write_native_symbol(abfd
, c_symbol
, written
);
1607 bfd_get_symcount(abfd
) = written
;
1609 /* Now write out strings */
1611 if (string_size
!= 0)
1613 unsigned int size
= string_size
+ 4;
1616 bfd_h_put_32(abfd
, size
, buffer
);
1617 bfd_write((PTR
) buffer
, 1, sizeof(buffer
), abfd
);
1618 for (p
= abfd
->outsymbols
, i
= 0;
1623 size_t name_length
= strlen(q
->name
);
1625 coff_symbol_type
* c_symbol
= coff_symbol_from(abfd
, q
);
1626 maxlen
= ((c_symbol
!= NULL
&& c_symbol
->native
!= NULL
) &&
1627 (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
)) ?
1628 FILNMLEN
: SYMNMLEN
;
1630 if (name_length
> maxlen
) {
1631 bfd_write((PTR
) (q
->name
), 1, name_length
+ 1, abfd
);
1636 /* We would normally not write anything here, but we'll write
1637 out 4 so that any stupid coff reader which tries to read
1638 the string table even when there isn't one won't croak.
1641 uint32e_type size
= 4;
1643 bfd_write((PTR
)&size
, 1, sizeof(size
), abfd
);
1652 To write relocations, all the back end does is step though the
1653 canonical relocation table, and create an
1654 @code{internal_reloc}. The symbol index to use is removed from
1655 the @code{offset} field in the symbol table supplied, the
1656 address comes directly from the sum of the section base
1657 address and the relocation offset and the type is dug directly
1658 from the howto field. Then the @code{internal_reloc} is
1659 swapped into the shape of an @code{external_reloc} and written
1665 DEFUN(coff_write_relocs
,(abfd
),
1669 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1671 struct external_reloc dst
;
1673 arelent
**p
= s
->orelocation
;
1674 bfd_seek(abfd
, s
->rel_filepos
, SEEK_SET
);
1675 for (i
= 0; i
< s
->reloc_count
; i
++) {
1676 struct internal_reloc n
;
1678 memset((PTR
)&n
, 0, sizeof(n
));
1679 n
.r_vaddr
= q
->address
+ s
->vma
;
1680 if (q
->sym_ptr_ptr
) {
1681 n
.r_symndx
= get_index((*(q
->sym_ptr_ptr
)));
1684 /* Work out reloc type from what is required */
1685 SELECT_RELOC(n
.r_type
, q
->howto
);
1687 n
.r_type
= q
->howto
->type
;
1689 coff_swap_reloc_out(abfd
, &n
, &dst
);
1690 bfd_write((PTR
) &n
, 1, RELSZ
, abfd
);
1694 #endif /* NO_COFF_SYMBOLS */
1696 #ifndef NO_COFF_LINENOS
1699 DEFUN(coff_write_linenumbers
,(abfd
),
1703 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1704 if (s
->lineno_count
) {
1705 asymbol
**q
= abfd
->outsymbols
;
1706 bfd_seek(abfd
, s
->line_filepos
, SEEK_SET
);
1707 /* Find all the linenumbers in this section */
1710 alent
*l
= BFD_SEND(p
->the_bfd
, _get_lineno
, (p
->the_bfd
, p
));
1712 /* Found a linenumber entry, output */
1713 struct internal_lineno out
;
1715 memset( (PTR
)&out
, 0, sizeof(out
));
1717 out
.l_addr
.l_symndx
= l
->u
.offset
;
1718 coff_swap_lineno_out(abfd
, &out
, &buff
);
1719 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1721 while (l
->line_number
) {
1722 out
.l_lnno
= l
->line_number
;
1723 out
.l_addr
.l_symndx
= l
->u
.offset
;
1724 coff_swap_lineno_out(abfd
, &out
, &buff
);
1725 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1736 DEFUN(coff_get_lineno
,(ignore_abfd
, symbol
),
1737 bfd
*ignore_abfd AND
1740 return coffsymbol(symbol
)->lineno
;
1743 #endif /* NO_COFF_LINENOS */
1746 coff_make_empty_symbol(abfd
)
1749 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc(abfd
, sizeof(coff_symbol_type
));
1751 bfd_error
= no_memory
;
1755 new->lineno
= (alent
*) NULL
;
1756 new->symbol
.the_bfd
= abfd
;
1757 return &new->symbol
;
1760 #ifndef NO_COFF_SYMBOLS
1763 DEFUN(coff_print_symbol
,(ignore_abfd
, filep
, symbol
, how
),
1764 bfd
*ignore_abfd AND
1767 bfd_print_symbol_type how
)
1769 FILE *file
= (FILE *)filep
;
1771 case bfd_print_symbol_name
:
1772 fprintf(file
, "%s", symbol
->name
);
1774 case bfd_print_symbol_more
:
1775 fprintf(file
, "coff %lx %lx", (unsigned long) coffsymbol(symbol
)->native
,
1776 (unsigned long) coffsymbol(symbol
)->lineno
);
1778 case bfd_print_symbol_nm
:
1781 CONST
char *section_name
= symbol
->section
== (asection
*) NULL
?
1782 "*abs" : symbol
->section
->name
;
1783 bfd_print_symbol_vandf((PTR
) file
, symbol
);
1786 fprintf(file
, " %-5s %s %s %s",
1788 coffsymbol(symbol
)->native
? "n" : "g",
1789 coffsymbol(symbol
)->lineno
? "l" : " ",
1795 case bfd_print_symbol_all
:
1796 /* Print out the symbols in a reasonable way */
1798 CONST
char *section_name
= symbol
->section
== (asection
*) NULL
?
1799 "*abs" : symbol
->section
->name
;
1802 if (coffsymbol(symbol
)->native
)
1805 combined_entry_type
*combined
= coffsymbol(symbol
)->native
;
1806 combined_entry_type
*root
= obj_raw_syments(ignore_abfd
);
1808 fprintf(file
,"[%3d]",
1812 fprintf(file
, "(sc %2d)(fl%4x)(ty%3x)(sc%3d) nx(%d) %08x %s",
1813 combined
->u
.syment
.n_scnum
,
1814 combined
->u
.syment
.n_flags
,
1815 combined
->u
.syment
.n_type
,
1816 combined
->u
.syment
.n_sclass
,
1817 combined
->u
.syment
.n_numaux
,
1818 combined
->u
.syment
.n_value
,
1821 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
1824 switch (combined
->u
.syment
.n_sclass
) {
1826 fprintf(file
, "File ");
1829 fprintf(file
, "AUX lnno %x size %x",
1830 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
1831 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
);
1844 bfd_print_symbol_vandf((PTR
) file
, symbol
);
1845 fprintf(file
, " %-5s %s %s %s",
1847 coffsymbol(symbol
)->native
? "n" : "g",
1848 coffsymbol(symbol
)->lineno
? "l" : " ",
1857 #endif /* NO_COFF_SYMBOLS */
1859 /* Set flags and magic number of a coff file from architecture and machine
1860 type. Result is true if we can represent the arch&type, false if not. */
1863 DEFUN(coff_set_flags
,(abfd
, magicp
, flagsp
),
1865 unsigned *magicp AND
1866 unsigned short *flagsp
)
1868 switch (bfd_get_arch(abfd
)) {
1876 *magicp
= I960ROMAGIC
;
1878 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1879 I960RWMAGIC); FIXME???
1881 switch (bfd_get_mach(abfd
)) {
1882 case bfd_mach_i960_core
:
1885 case bfd_mach_i960_kb_sb
:
1888 case bfd_mach_i960_mc
:
1891 case bfd_mach_i960_xa
:
1894 case bfd_mach_i960_ca
:
1897 case bfd_mach_i960_ka_sa
:
1910 *magicp
= MIPS_MAGIC_2
;
1916 *magicp
= I386MAGIC
;
1921 *magicp
= MC68MAGIC
;
1927 *magicp
= MC88OMAGIC
;
1932 case bfd_arch_h8300
:
1933 *magicp
= H8300MAGIC
;
1937 #ifdef A29K_MAGIC_BIG
1939 if (abfd
->xvec
->byteorder_big_p
)
1940 *magicp
= A29K_MAGIC_BIG
;
1942 *magicp
= A29K_MAGIC_LITTLE
;
1948 case bfd_arch_rs6000
:
1949 *magicp
= U802TOCMAGIC
;
1953 default: /* Unknown architecture */
1954 /* return false; -- fall through to "return false" below, to avoid
1955 "statement never reached" errors on the one below. */
1964 DEFUN(coff_set_arch_mach
,(abfd
, arch
, machine
),
1966 enum bfd_architecture arch AND
1967 unsigned long machine
)
1970 unsigned short dummy2
;
1971 bfd_default_set_arch_mach(abfd
, arch
, machine
);
1973 if (arch
!= bfd_arch_unknown
&&
1974 coff_set_flags(abfd
, &dummy1
, &dummy2
) != true)
1975 return false; /* We can't represent this type */
1976 return true; /* We're easy ... */
1980 /* Calculate the file position for each section. */
1983 DEFUN(coff_compute_section_file_positions
,(abfd
),
1987 asection
*previous
= (asection
*)NULL
;
1988 file_ptr sofar
= FILHSZ
;
1990 if (bfd_get_start_address(abfd
))
1992 /* A start address may have been added to the original file. In this
1993 case it will need an optional header to record it. */
1994 abfd
->flags
|= EXEC_P
;
1997 if (abfd
->flags
& EXEC_P
)
2000 sofar
+= abfd
->section_count
* SCNHSZ
;
2001 for (current
= abfd
->sections
;
2002 current
!= (asection
*)NULL
;
2003 current
= current
->next
) {
2005 /* Only deal with sections which have contents */
2006 if (!(current
->flags
& SEC_HAS_CONTENTS
))
2009 /* Align the sections in the file to the same boundary on
2010 which they are aligned in virtual memory. I960 doesn't
2011 do this (FIXME) so we can stay in sync with Intel. 960
2012 doesn't yet page from files... */
2015 /* make sure this section is aligned on the right boundary - by
2016 padding the previous section up if necessary */
2019 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2020 if (previous
!= (asection
*)NULL
) {
2021 previous
->size
+= sofar
- old_sofar
;
2026 /* FIXME, in demand paged files, the low order bits of the file
2027 offset must match the low order bits of the virtual address.
2028 "Low order" is apparently implementation defined. Add code
2029 here to round sofar up to match the virtual address. */
2031 current
->filepos
= sofar
;
2033 /* make sure that this section is of the right size too */
2034 old_sofar
= sofar
+= current
->size
;
2035 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2036 current
->size
+= sofar
- old_sofar
;
2040 obj_relocbase(abfd
) = sofar
;
2049 DEFUN(coff_write_object_contents
,(abfd
),
2053 boolean hasrelocs
= false;
2054 boolean haslinno
= false;
2055 file_ptr reloc_base
;
2056 file_ptr lineno_base
;
2060 unsigned long reloc_size
= 0;
2061 unsigned long lnno_size
= 0;
2062 asection
*text_sec
= NULL
;
2063 asection
*data_sec
= NULL
;
2064 asection
*bss_sec
= NULL
;
2066 struct internal_filehdr internal_f
;
2067 struct internal_aouthdr internal_a
;
2070 bfd_error
= system_call_error
;
2073 if(abfd
->output_has_begun
== false) {
2074 coff_compute_section_file_positions(abfd
);
2077 if (abfd
->sections
!= (asection
*)NULL
) {
2078 scn_base
= abfd
->sections
->filepos
;
2083 if (bfd_seek(abfd
, scn_base
, SEEK_SET
) != 0)
2085 reloc_base
= obj_relocbase(abfd
);
2087 /* Make a pass through the symbol table to count line number entries and
2088 put them into the correct asections */
2090 #ifndef NO_COFF_LINENOS
2091 coff_count_linenumbers(abfd
);
2093 data_base
= scn_base
;
2095 /* Work out the size of the reloc and linno areas */
2097 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
) {
2098 reloc_size
+= current
->reloc_count
* RELSZ
;
2099 #ifndef NO_COFF_LINENOS
2100 lnno_size
+= current
->lineno_count
* LINESZ
;
2102 data_base
+= SCNHSZ
;
2105 lineno_base
= reloc_base
+ reloc_size
;
2106 sym_base
= lineno_base
+ lnno_size
;
2108 /* Indicate in each section->line_filepos its actual file address */
2109 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
) {
2110 if (current
->lineno_count
) {
2111 current
->line_filepos
= lineno_base
;
2112 current
->moving_line_filepos
= lineno_base
;
2113 #ifndef NO_COFF_LINENOS
2114 lineno_base
+= current
->lineno_count
* LINESZ
;
2118 current
->line_filepos
= 0;
2120 if (current
->reloc_count
) {
2121 current
->rel_filepos
= reloc_base
;
2122 reloc_base
+= current
->reloc_count
* sizeof(struct internal_reloc
);
2125 current
->rel_filepos
= 0;
2129 /* Write section headers to the file. */
2132 (file_ptr
) ((abfd
->flags
& EXEC_P
) ?
2133 (FILHSZ
+ AOUTSZ
) : FILHSZ
),
2138 unsigned int pad
= abfd
->flags
& D_PAGED
? data_base
: 0;
2140 unsigned int pad
= 0;
2142 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
) {
2143 struct internal_scnhdr section
;
2144 strncpy(&(section
.s_name
[0]), current
->name
, 8);
2145 section
.s_vaddr
= current
->vma
+ pad
;
2146 section
.s_paddr
= current
->vma
+ pad
;
2147 section
.s_size
= current
->size
- pad
;
2149 If this section has no size or is unloadable then the scnptr
2152 if (current
->size
- pad
== 0 ||
2153 (current
->flags
& SEC_LOAD
) == 0) {
2154 section
.s_scnptr
= 0;
2157 section
.s_scnptr
= current
->filepos
;
2159 section
.s_relptr
= current
->rel_filepos
;
2160 section
.s_lnnoptr
= current
->line_filepos
;
2161 section
.s_nreloc
= current
->reloc_count
;
2162 section
.s_nlnno
= current
->lineno_count
;
2163 if (current
->reloc_count
!= 0)
2165 if (current
->lineno_count
!= 0)
2168 section
.s_flags
= sec_to_styp_flags(current
->name
,current
->flags
);
2170 if (!strcmp(current
->name
, _TEXT
)) {
2172 } else if (!strcmp(current
->name
, _DATA
)) {
2174 } else if (!strcmp(current
->name
, _BSS
)) {
2179 section
.s_align
= (current
->alignment_power
2180 ? 1 << current
->alignment_power
2187 coff_swap_scnhdr_out(abfd
, §ion
, &buff
);
2188 bfd_write((PTR
) (&buff
), 1, SCNHSZ
, abfd
);
2195 /* OK, now set up the filehdr... */
2196 internal_f
.f_nscns
= abfd
->section_count
;
2198 We will NOT put a fucking timestamp in the header here. Every time you
2199 put it back, I will come in and take it out again. I'm sorry. This
2200 field does not belong here. We fill it with a 0 so it compares the
2201 same but is not a reasonable time. -- gnu@cygnus.com
2204 Well, I like it, so I'm conditionally compiling it in.
2207 #ifdef COFF_TIMESTAMP
2208 internal_f
.f_timdat
= time(0);
2210 internal_f
.f_timdat
= 0;
2213 if (bfd_get_symcount(abfd
) != 0)
2214 internal_f
.f_symptr
= sym_base
;
2216 internal_f
.f_symptr
= 0;
2218 internal_f
.f_flags
= 0;
2220 if (abfd
->flags
& EXEC_P
)
2221 internal_f
.f_opthdr
= AOUTSZ
;
2223 internal_f
.f_opthdr
= 0;
2226 internal_f
.f_flags
|= F_RELFLG
;
2228 internal_f
.f_flags
|= F_LNNO
;
2229 if (0 == bfd_get_symcount(abfd
))
2230 internal_f
.f_flags
|= F_LSYMS
;
2231 if (abfd
->flags
& EXEC_P
)
2232 internal_f
.f_flags
|= F_EXEC
;
2234 internal_f
.f_flags
|= F_AR32W
;
2236 if (!abfd
->xvec
->byteorder_big_p
)
2237 internal_f
.f_flags
|= F_AR32WR
;
2240 FIXME, should do something about the other byte orders and
2244 /* Set up architecture-dependent stuff */
2246 { unsigned int magic
= 0;
2247 unsigned short flags
= 0;
2248 coff_set_flags(abfd
, &magic
, &flags
);
2249 internal_f
.f_magic
= magic
;
2250 internal_f
.f_flags
|= flags
;
2251 /* ...and the "opt"hdr... */
2254 # ifdef ULTRA3 /* NYU's machine */
2255 /* FIXME: This is a bogus check. I really want to see if there
2256 * is a .shbss or a .shdata section, if so then set the magic
2257 * number to indicate a shared data executable.
2259 if (internal_f
.f_nscns
>= 7)
2260 internal_a
.magic
= SHMAGIC
; /* Shared magic */
2262 # endif /* ULTRA3 */
2263 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
2264 #define __A_MAGIC_SET__
2267 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
2268 #define __A_MAGIC_SET__
2271 #define __A_MAGIC_SET__
2272 internal_a
.magic
= PAGEMAGICBCS
;
2275 #if M68 || I386 || MIPS
2276 #define __A_MAGIC_SET__
2277 /* Never was anything here for the 68k */
2281 #define __A_MAGIC_SET__
2282 internal_a
.magic
= (abfd
->flags
& D_PAGED
)? RS6K_AOUTHDR_ZMAGIC
:
2283 (abfd
->flags
& WP_TEXT
)? RS6K_AOUTHDR_NMAGIC
:
2284 RS6K_AOUTHDR_OMAGIC
;
2287 #ifndef __A_MAGIC_SET__
2288 # include "Your aouthdr magic number is not being set!"
2290 # undef __A_MAGIC_SET__
2293 /* Now should write relocs, strings, syms */
2294 obj_sym_filepos(abfd
) = sym_base
;
2296 #ifndef NO_COFF_SYMBOLS
2297 if (bfd_get_symcount(abfd
) != 0) {
2298 coff_renumber_symbols(abfd
);
2299 coff_mangle_symbols(abfd
);
2300 coff_write_symbols(abfd
);
2301 coff_write_linenumbers(abfd
);
2302 coff_write_relocs(abfd
);
2304 #endif /* NO_COFF_SYMBOLS */
2306 internal_a
.tsize
= text_sec
->size
;
2307 internal_a
.text_start
=text_sec
->size
? text_sec
->vma
: 0;
2310 internal_a
.dsize
= data_sec
->size
;
2311 internal_a
.data_start
= data_sec
->size
? data_sec
->vma
: 0;
2314 internal_a
.bsize
= bss_sec
->size
;
2317 internal_a
.entry
= bfd_get_start_address(abfd
);
2318 internal_f
.f_nsyms
= bfd_get_symcount(abfd
);
2320 /* now write them */
2321 if (bfd_seek(abfd
, 0L, SEEK_SET
) != 0)
2325 coff_swap_filehdr_out(abfd
, &internal_f
, &buff
);
2326 bfd_write((PTR
) &buff
, 1, FILHSZ
, abfd
);
2328 if (abfd
->flags
& EXEC_P
) {
2330 coff_swap_aouthdr_out(abfd
, &internal_a
, &buff
);
2331 bfd_write((PTR
) &buff
, 1, AOUTSZ
, abfd
);
2336 #ifndef NO_COFF_SYMBOLS
2339 this function transforms the offsets into the symbol table into
2340 pointers to syments.
2345 DEFUN(coff_pointerize_aux
,(ignore_abfd
, table_base
, type
, class, auxent
),
2346 bfd
*ignore_abfd AND
2347 combined_entry_type
*table_base AND
2350 combined_entry_type
*auxent
)
2352 /* Don't bother if this is a file or a section */
2353 if (class == C_STAT
&& type
== T_NULL
) return;
2354 if (class == C_FILE
) return;
2356 /* Otherwise patch up */
2357 if (ISFCN(type
) || ISTAG(class) || class == C_BLOCK
) {
2358 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
= table_base
+
2359 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2360 auxent
->fix_end
= 1;
2362 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
!= 0) {
2363 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
= table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
2364 auxent
->fix_tag
= 1;
2368 #endif /* NO_COFF_SYMBOLS */
2371 DEFUN(coff_set_section_contents
,(abfd
, section
, location
, offset
, count
),
2376 bfd_size_type count
)
2378 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
2379 coff_compute_section_file_positions(abfd
);
2381 bfd_seek(abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
);
2384 return (bfd_write(location
, 1, count
, abfd
) == count
) ? true : false;
2390 coff_close_and_cleanup(abfd
)
2393 if (!bfd_read_p(abfd
))
2394 switch (abfd
->format
) {
2396 if (!_bfd_write_archive_contents(abfd
))
2400 if (!coff_write_object_contents(abfd
))
2404 bfd_error
= invalid_operation
;
2408 /* We depend on bfd_close to free all the memory on the obstack. */
2409 /* FIXME if bfd_release is not using obstacks! */
2415 buy_and_read(abfd
, where
, seek_direction
, size
)
2421 PTR area
= (PTR
) bfd_alloc(abfd
, size
);
2423 bfd_error
= no_memory
;
2426 bfd_seek(abfd
, where
, seek_direction
);
2427 if (bfd_read(area
, 1, size
, abfd
) != size
) {
2428 bfd_error
= system_call_error
;
2432 } /* buy_and_read() */
2435 #ifndef NO_COFF_SYMBOLS
2438 DEFUN(build_string_table
,(abfd
),
2441 char string_table_size_buffer
[4];
2442 unsigned int string_table_size
;
2445 /* At this point we should be "seek"'d to the end of the
2446 symbols === the symbol table size. */
2447 if (bfd_read((char *) string_table_size_buffer
,
2448 sizeof(string_table_size_buffer
),
2449 1, abfd
) != sizeof(string_table_size
)) {
2450 bfd_error
= system_call_error
;
2454 string_table_size
= bfd_h_get_32(abfd
, (bfd_byte
*) string_table_size_buffer
);
2456 if ((string_table
= (PTR
) bfd_alloc(abfd
, string_table_size
-= 4)) == NULL
) {
2457 bfd_error
= no_memory
;
2459 } /* on mallocation error */
2460 if (bfd_read(string_table
, string_table_size
, 1, abfd
) != string_table_size
) {
2461 bfd_error
= system_call_error
;
2464 return string_table
;
2467 /* Allocate space for the ".debug" section, and read it.
2468 We did not read the debug section until now, because
2469 we didn't want to go to the trouble until someone needed it. */
2472 DEFUN(build_debug_section
,(abfd
),
2475 char *debug_section
;
2478 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
2481 bfd_error
= no_debug_section
;
2485 debug_section
= (PTR
) bfd_alloc (abfd
, bfd_section_size (abfd
, sect
));
2486 if (debug_section
== NULL
) {
2487 bfd_error
= no_memory
;
2491 /* Seek to the beginning of the `.debug' section and read it.
2492 Save the current position first; it is needed by our caller.
2493 Then read debug section and reset the file pointer. */
2495 position
= bfd_tell (abfd
);
2496 bfd_seek (abfd
, sect
->filepos
, SEEK_SET
);
2497 if (bfd_read (debug_section
, bfd_section_size (abfd
, sect
), 1, abfd
)
2498 != bfd_section_size (abfd
, sect
)) {
2499 bfd_error
= system_call_error
;
2502 bfd_seek (abfd
, position
, SEEK_SET
);
2503 return debug_section
;
2507 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
2508 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
2509 be \0-terminated. */
2511 DEFUN(copy_name
,(abfd
, name
, maxlen
),
2519 for (len
= 0; len
< maxlen
; ++len
) {
2520 if (name
[len
] == '\0') {
2525 if ((newname
= (PTR
) bfd_alloc(abfd
, len
+1)) == NULL
) {
2526 bfd_error
= no_memory
;
2529 strncpy(newname
, name
, len
);
2530 newname
[len
] = '\0';
2535 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
2536 knit the symbol names into a normalized form. By normalized here I
2537 mean that all symbols have an n_offset pointer that points to a null-
2538 terminated string. */
2540 #ifndef SYMNAME_IN_DEBUG
2541 #define SYMNAME_IN_DEBUG(x) 0
2544 static combined_entry_type
*
2545 DEFUN(get_normalized_symtab
,(abfd
),
2548 combined_entry_type
*internal
;
2549 combined_entry_type
*internal_ptr
;
2550 combined_entry_type
*internal_end
;
2554 char *string_table
= NULL
;
2555 char *debug_section
= NULL
;
2558 unsigned int raw_size
;
2559 if (obj_raw_syments(abfd
) != (combined_entry_type
*)NULL
) {
2560 return obj_raw_syments(abfd
);
2562 if ((size
= bfd_get_symcount(abfd
) * sizeof(combined_entry_type
)) == 0) {
2563 bfd_error
= no_symbols
;
2567 internal
= (combined_entry_type
*)bfd_alloc(abfd
, size
);
2568 internal_end
= internal
+ bfd_get_symcount(abfd
);
2570 raw_size
= bfd_get_symcount(abfd
) * SYMESZ
;
2571 raw
= (SYMENT
*)bfd_alloc(abfd
,raw_size
);
2573 if (bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
) == -1
2574 || bfd_read((PTR
)raw
, raw_size
, 1, abfd
) != raw_size
) {
2575 bfd_error
= system_call_error
;
2578 /* mark the end of the symbols */
2579 raw_end
= raw
+ bfd_get_symcount(abfd
);
2581 FIXME SOMEDAY. A string table size of zero is very weird, but
2582 probably possible. If one shows up, it will probably kill us.
2585 /* Swap all the raw entries */
2586 for (raw_src
= raw
, internal_ptr
= internal
;
2588 raw_src
++, internal_ptr
++) {
2591 coff_swap_sym_in(abfd
, (char *)raw_src
, (char *)&internal_ptr
->u
.syment
);
2592 internal_ptr
->fix_tag
= 0;
2593 internal_ptr
->fix_end
= 0;
2595 for (i
= internal_ptr
->u
.syment
.n_numaux
;
2597 --i
, raw_src
++, internal_ptr
++) {
2599 (internal_ptr
+1)->fix_tag
= 0;
2600 (internal_ptr
+1)->fix_end
= 0;
2602 coff_swap_aux_in(abfd
, (char *)(raw_src
+1),
2603 internal_ptr
->u
.syment
.n_type
,
2604 internal_ptr
->u
.syment
.n_sclass
,
2605 &(internal_ptr
+1)->u
.auxent
);
2607 coff_pointerize_aux(abfd
,
2609 internal_ptr
->u
.syment
.n_type
,
2610 internal_ptr
->u
.syment
.n_sclass
,
2615 /* Free all the raw stuff */
2616 bfd_release(abfd
, raw
);
2618 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
2621 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
) {
2622 /* make a file symbol point to the name in the auxent, since
2623 the text ".file" is redundant */
2624 if ((internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_zeroes
== 0) {
2625 /* the filename is a long one, point into the string table */
2626 if (string_table
== NULL
) {
2627 string_table
= build_string_table(abfd
);
2630 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
2631 (int) (string_table
- 4 +
2632 (internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_offset
);
2635 /* ordinary short filename, put into memory anyway */
2636 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2637 copy_name(abfd
, (internal_ptr
+1)->u
.auxent
.x_file
.x_fname
,
2642 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0) {
2643 /* This is a "short" name. Make it long. */
2644 unsigned long i
= 0;
2645 char *newstring
= NULL
;
2647 /* find the length of this string without walking into memory
2649 for (i
= 0; i
< 8; ++i
) {
2650 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0') {
2652 } /* if end of string */
2653 } /* possible lengths of this string. */
2655 if ((newstring
= (PTR
) bfd_alloc(abfd
, ++i
)) == NULL
) {
2656 bfd_error
= no_memory
;
2659 bzero(newstring
, i
);
2660 strncpy(newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
-1);
2661 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int) newstring
;
2662 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
2664 else if (!SYMNAME_IN_DEBUG(&internal_ptr
->u
.syment
)) {
2665 /* Long name already. Point symbol at the string in the table. */
2666 if (string_table
== NULL
) {
2667 string_table
= build_string_table(abfd
);
2669 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2670 (string_table
- 4 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
2673 /* Long name in debug section. Very similar. */
2674 if (debug_section
== NULL
) {
2675 debug_section
= build_debug_section(abfd
);
2677 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2678 (debug_section
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
2681 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
2684 obj_raw_syments(abfd
) = internal
;
2687 } /* get_normalized_symtab() */
2689 #endif /* NO_COFF_SYMBOLS */
2693 DEFUN(section_from_bfd_index
,(abfd
, index
),
2698 struct sec
*answer
= abfd
->sections
;
2700 answer
= answer
->next
;
2707 #ifndef NO_COFF_LINENOS
2713 Creating the linenumber table is done by reading in the entire
2714 coff linenumber table, and creating another table for internal use.
2716 A coff line number table is structured so that each function
2717 is marked as having a line number of 0. Each line within the
2718 function is an offset from the first line in the function. The
2719 base of the line number information for the table is stored in
2720 the symbol associated with the function.
2722 The information is copied from the external to the internal
2723 table, and each symbol which marks a function is marked by
2726 How does this work ?
2731 coff_slurp_line_table(abfd
, asect
)
2735 LINENO
*native_lineno
;
2736 alent
*lineno_cache
;
2738 BFD_ASSERT(asect
->lineno
== (alent
*) NULL
);
2740 native_lineno
= (LINENO
*) buy_and_read(abfd
,
2741 asect
->line_filepos
,
2744 asect
->lineno_count
));
2746 (alent
*) bfd_alloc(abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof(alent
)));
2747 if (lineno_cache
== NULL
) {
2748 bfd_error
= no_memory
;
2751 unsigned int counter
= 0;
2752 alent
*cache_ptr
= lineno_cache
;
2753 LINENO
*src
= native_lineno
;
2755 while (counter
< asect
->lineno_count
) {
2756 struct internal_lineno dst
;
2757 coff_swap_lineno_in(abfd
, src
, &dst
);
2758 cache_ptr
->line_number
= dst
.l_lnno
;
2760 if (cache_ptr
->line_number
== 0) {
2761 coff_symbol_type
*sym
=
2762 (coff_symbol_type
*) (dst
.l_addr
.l_symndx
2763 + obj_raw_syments(abfd
))->u
.syment
._n
._n_n
._n_zeroes
;
2764 cache_ptr
->u
.sym
= (asymbol
*) sym
;
2765 sym
->lineno
= cache_ptr
;
2768 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
2769 - bfd_section_vma(abfd
, asect
);
2770 } /* If no linenumber expect a symbol index */
2776 cache_ptr
->line_number
= 0;
2779 asect
->lineno
= lineno_cache
;
2780 /* FIXME, free native_lineno here, or use alloca or something. */
2782 } /* coff_slurp_line_table() */
2784 #endif /* NO_COFF_LINENOS */
2786 #ifndef NO_COFF_LINENOS
2789 DEFUN(coff_slurp_symbol_table
,(abfd
),
2792 combined_entry_type
*native_symbols
;
2793 coff_symbol_type
*cached_area
;
2794 unsigned int *table_ptr
;
2796 unsigned int number_of_symbols
= 0;
2797 if (obj_symbols(abfd
))
2799 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
2801 /* Read in the symbol table */
2802 if ((native_symbols
= get_normalized_symtab(abfd
)) == NULL
) {
2806 /* Allocate enough room for all the symbols in cached form */
2808 (coff_symbol_type
*)
2809 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(coff_symbol_type
)));
2811 if (cached_area
== NULL
) {
2812 bfd_error
= no_memory
;
2817 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(unsigned int)));
2819 if (table_ptr
== NULL
) {
2820 bfd_error
= no_memory
;
2825 coff_symbol_type
*dst
= cached_area
;
2826 unsigned int last_native_index
= bfd_get_symcount(abfd
);
2827 unsigned int this_index
= 0;
2828 while (this_index
< last_native_index
) {
2829 combined_entry_type
*src
= native_symbols
+ this_index
;
2830 table_ptr
[this_index
] = number_of_symbols
;
2831 dst
->symbol
.the_bfd
= abfd
;
2833 dst
->symbol
.name
= (char *)(src
->u
.syment
._n
._n_n
._n_offset
);
2835 We use the native name field to point to the cached field
2837 src
->u
.syment
._n
._n_n
._n_zeroes
= (int) dst
;
2838 dst
->symbol
.section
= section_from_bfd_index(abfd
,
2839 src
->u
.syment
.n_scnum
);
2840 switch (src
->u
.syment
.n_sclass
) {
2844 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
2845 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2846 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
2848 /* Fall through to next case */
2856 if ((src
->u
.syment
.n_scnum
) == 0) {
2857 if ((src
->u
.syment
.n_value
) == 0) {
2858 dst
->symbol
.flags
= BSF_UNDEFINED
;
2859 dst
->symbol
.value
= 0;
2862 dst
->symbol
.flags
= BSF_FORT_COMM
;
2863 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2868 Base the value as an index from the base of the
2871 if (dst
->symbol
.section
== (asection
*) NULL
) {
2872 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
| BSF_ABSOLUTE
;
2873 dst
->symbol
.value
= src
->u
.syment
.n_value
;
2876 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2877 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
2879 if (ISFCN((src
->u
.syment
.n_type
))) {
2881 A function ext does not go at the end of a file
2883 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
2890 case C_STAT
: /* static */
2892 case C_LEAFSTAT
: /* static leaf procedure */
2894 case C_LABEL
: /* label */
2895 if (src
->u
.syment
.n_scnum
== -2)
2896 dst
->symbol
.flags
= BSF_DEBUGGING
;
2898 dst
->symbol
.flags
= BSF_LOCAL
;
2900 Base the value as an index from the base of the section, if
2903 if (dst
->symbol
.section
)
2904 dst
->symbol
.value
= (src
->u
.syment
.n_value
) -
2905 dst
->symbol
.section
->vma
;
2907 dst
->symbol
.value
= (src
->u
.syment
.n_value
) ;
2910 case C_MOS
: /* member of structure */
2911 case C_EOS
: /* end of structure */
2912 #ifdef NOTDEF /* C_AUTOARG has the same value */
2914 case C_GLBLREG
: /* A29k-specific storage class */
2917 case C_REGPARM
: /* register parameter */
2918 case C_REG
: /* register variable */
2920 case C_AUTOARG
: /* 960-specific storage class */
2922 case C_TPDEF
: /* type definition */
2924 case C_AUTO
: /* automatic variable */
2925 case C_FIELD
: /* bit field */
2926 case C_ENTAG
: /* enumeration tag */
2927 case C_MOE
: /* member of enumeration */
2928 case C_MOU
: /* member of union */
2929 case C_UNTAG
: /* union tag */
2930 dst
->symbol
.flags
= BSF_DEBUGGING
;
2931 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2934 case C_FILE
: /* file name */
2935 case C_STRTAG
: /* structure tag */
2937 case C_BINCL
: /* beginning of include file */
2938 case C_EINCL
: /* ending of include file */
2951 dst
->symbol
.flags
= BSF_DEBUGGING
;
2952 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2955 case C_BLOCK
: /* ".bb" or ".eb" */
2956 case C_FCN
: /* ".bf" or ".ef" */
2957 case C_EFCN
: /* physical end of function */
2958 dst
->symbol
.flags
= BSF_LOCAL
;
2960 Base the value as an index from the base of the section
2962 dst
->symbol
.value
= (src
->u
.syment
.n_value
) - dst
->symbol
.section
->vma
;
2966 case C_EXTDEF
: /* external definition */
2967 case C_ULABEL
: /* undefined label */
2968 case C_USTATIC
: /* undefined static */
2969 case C_LINE
: /* line # reformatted as symbol table entry */
2970 case C_ALIAS
: /* duplicate tag */
2971 case C_HIDDEN
: /* ext symbol in dmert public lib */
2974 fprintf(stderr
,"Unrecognized storage class %d\n",
2975 src
->u
.syment
.n_sclass
);
2977 dst
->symbol
.flags
= BSF_DEBUGGING
;
2978 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2982 BFD_ASSERT(dst
->symbol
.flags
!= 0);
2986 dst
->symbol
.udata
= 0;
2987 dst
->lineno
= (alent
*) NULL
;
2988 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
2990 number_of_symbols
++;
2991 } /* walk the native symtab */
2992 } /* bfdize the native symtab */
2994 obj_symbols(abfd
) = cached_area
;
2995 obj_raw_syments(abfd
) = native_symbols
;
2997 bfd_get_symcount(abfd
) = number_of_symbols
;
2998 obj_convert(abfd
) = table_ptr
;
2999 /* Slurp the line tables for each section too */
3004 coff_slurp_line_table(abfd
, p
);
3009 } /* coff_slurp_symbol_table() */
3012 coff_get_symtab_upper_bound(abfd
)
3015 if (!coff_slurp_symbol_table(abfd
))
3018 return (bfd_get_symcount(abfd
) + 1) * (sizeof(coff_symbol_type
*));
3023 DEFUN(coff_get_symtab
, (abfd
, alocation
),
3025 asymbol
**alocation
)
3027 unsigned int counter
= 0;
3028 coff_symbol_type
*symbase
;
3029 coff_symbol_type
**location
= (coff_symbol_type
**) (alocation
);
3030 if (!coff_slurp_symbol_table(abfd
))
3033 symbase
= obj_symbols(abfd
);
3034 while (counter
< bfd_get_symcount(abfd
))
3036 /* This nasty code looks at the symbol to decide whether or
3037 not it is descibes a constructor/destructor entry point. It
3038 is structured this way to (hopefully) speed non matches */
3040 if (0 && symbase
->symbol
.name
[9] == '$')
3042 bfd_constructor_entry(abfd
,
3043 (asymbol
**)location
,
3044 symbase
->symbol
.name
[10] == 'I' ?
3048 *(location
++) = symbase
++;
3052 return bfd_get_symcount(abfd
);
3055 #endif /* NO_COFF_SYMBOLS */
3058 coff_get_reloc_upper_bound(abfd
, asect
)
3062 if (bfd_get_format(abfd
) != bfd_object
) {
3063 bfd_error
= invalid_operation
;
3066 return (asect
->reloc_count
+ 1) * sizeof(arelent
*);
3073 Coff relocations are easily transformed into the internal BFD form
3076 Reading a coff relocation table is done in the following stages:
3078 o The entire coff relocation table is read into memory.
3080 o Each relocation is processed in turn, first it is swapped from the
3081 external to the internal form.
3083 o The symbol referenced in the relocation's symbol index is
3084 turned intoa pointer into the canonical symbol table. Note
3085 that this table is the same as the one returned by a call to
3086 @code{bfd_canonicalize_symtab}. The back end will call the
3087 routine and save the result if a canonicalization hasn't been done.
3089 o The reloc index is turned into a pointer to a howto
3090 structure, in a back end specific way. For instance, the 386
3091 and 960 use the @code{r_type} to directly produce an index
3092 into a howto table vector; the 88k subtracts a number from the
3093 @code{r_type} field and creates an addend field.
3099 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
3100 if (ptr && ptr->the_bfd == abfd \
3101 && ptr->section != (asection *) NULL \
3102 && ((ptr->flags & BSF_OLD_COMMON)== 0)) \
3104 cache_ptr->addend = -(ptr->section->vma + ptr->value); \
3107 cache_ptr->addend = 0; \
3112 DEFUN(coff_slurp_reloc_table
,(abfd
, asect
, symbols
),
3117 RELOC
*native_relocs
;
3118 arelent
*reloc_cache
;
3123 if (asect
->relocation
)
3125 if (asect
->reloc_count
== 0)
3127 if (asect
->flags
& SEC_CONSTRUCTOR
)
3129 #ifndef NO_COFF_SYMBOLS
3130 if (!coff_slurp_symbol_table(abfd
))
3134 (RELOC
*) buy_and_read(abfd
,
3138 asect
->reloc_count
));
3139 reloc_cache
= (arelent
*)
3140 bfd_alloc(abfd
, (size_t) (asect
->reloc_count
* sizeof(arelent
)));
3142 if (reloc_cache
== NULL
) {
3143 bfd_error
= no_memory
;
3148 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
3150 #ifdef RELOC_PROCESSING
3151 struct internal_reloc dst
;
3152 struct external_reloc
*src
;
3154 cache_ptr
= reloc_cache
+ idx
;
3155 src
= native_relocs
+ idx
;
3156 bfd_swap_reloc_in(abfd
, src
, &dst
);
3158 RELOC_PROCESSING(cache_ptr
, &dst
, symbols
, abfd
, asect
);
3160 struct internal_reloc dst
;
3162 struct external_reloc
*src
;
3164 cache_ptr
= reloc_cache
+ idx
;
3165 src
= native_relocs
+ idx
;
3167 bfd_swap_reloc_in(abfd
, src
, &dst
);
3170 cache_ptr
->address
= dst
.r_vaddr
;
3172 if (dst
.r_symndx
!= -1)
3174 cache_ptr
->sym_ptr_ptr
= symbols
+ obj_convert(abfd
)[dst
.r_symndx
];
3175 ptr
= *(cache_ptr
->sym_ptr_ptr
);
3179 cache_ptr
->sym_ptr_ptr
= 0;
3185 The symbols definitions that we have read in have been
3186 relocated as if their sections started at 0. But the offsets
3187 refering to the symbols in the raw data have not been
3188 modified, so we have to have a negative addend to compensate.
3190 Note that symbols which used to be common must be left alone */
3192 /* Calculate any reloc addend by looking at the symbol */
3193 CALC_ADDEND(abfd
, ptr
, dst
, cache_ptr
);
3195 cache_ptr
->address
-= asect
->vma
;
3196 cache_ptr
->section
= (asection
*) NULL
;
3198 /* Fill in the cache_ptr->howto field from dst.r_type */
3199 RTYPE2HOWTO(cache_ptr
, dst
);
3204 asect
->relocation
= reloc_cache
;
3209 /* This is stupid. This function should be a boolean predicate */
3211 DEFUN(coff_canonicalize_reloc
, (abfd
, section
, relptr
, symbols
),
3214 arelent
**relptr AND
3217 arelent
*tblptr
= section
->relocation
;
3218 unsigned int count
= 0;
3221 if (section
->flags
& SEC_CONSTRUCTOR
)
3223 /* this section has relocs made up by us, they are not in the
3224 file, so take them out of their chain and place them into
3225 the data area provided */
3226 arelent_chain
*chain
= section
->constructor_chain
;
3227 for (count
= 0; count
< section
->reloc_count
; count
++)
3229 *relptr
++ = &chain
->relent
;
3230 chain
= chain
->next
;
3236 coff_slurp_reloc_table(abfd
, section
, symbols
);
3239 tblptr
= section
->relocation
;
3243 for (; count
++ < section
->reloc_count
;)
3244 *relptr
++ = tblptr
++;
3249 return section
->reloc_count
;
3252 #ifndef NO_COFF_SYMBOLS
3255 provided a BFD, a section and an offset into the section, calculate and
3256 return the name of the source file and the line nearest to the wanted
3261 DEFUN(coff_find_nearest_line
,(abfd
,
3269 asection
*section AND
3270 asymbol
**ignore_symbols AND
3272 CONST
char **filename_ptr AND
3273 CONST
char **functionname_ptr AND
3274 unsigned int *line_ptr
)
3276 static bfd
*cache_abfd
;
3277 static asection
*cache_section
;
3278 static bfd_vma cache_offset
;
3279 static unsigned int cache_i
;
3280 static alent
*cache_l
;
3283 coff_data_type
*cof
= coff_data(abfd
);
3284 /* Run through the raw syments if available */
3285 combined_entry_type
*p
;
3287 unsigned int line_base
= 0;
3291 *functionname_ptr
= 0;
3294 /* Don't try and find line numbers in a non coff file */
3295 if (abfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
3301 p
= cof
->raw_syments
;
3303 for (i
= 0; i
< cof
->raw_syment_count
; i
++) {
3304 if (p
->u
.syment
.n_sclass
== C_FILE
) {
3305 /* File name has been moved into symbol */
3306 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
3309 p
+= 1 + p
->u
.syment
.n_numaux
;
3311 /* Now wander though the raw linenumbers of the section */
3313 If this is the same BFD as we were previously called with and this is
3314 the same section, and the offset we want is further down then we can
3315 prime the lookup loop
3317 if (abfd
== cache_abfd
&&
3318 section
== cache_section
&&
3319 offset
>= cache_offset
) {
3325 l
= section
->lineno
;
3328 for (; i
< section
->lineno_count
; i
++) {
3329 if (l
->line_number
== 0) {
3330 /* Get the symbol this line number points at */
3331 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
3332 *functionname_ptr
= coff
->symbol
.name
;
3334 combined_entry_type
*s
= coff
->native
;
3335 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
3337 S should now point to the .bf of the function
3339 if (s
->u
.syment
.n_numaux
) {
3341 The linenumber is stored in the auxent
3343 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
3344 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
3349 if (l
->u
.offset
> offset
)
3351 *line_ptr
= l
->line_number
+ line_base
+ 1;
3357 cache_section
= section
;
3358 cache_offset
= offset
;
3367 coff_sym_filepos(abfd
)
3370 return obj_sym_filepos(abfd
);
3374 #endif /* NO_COFF_SYMBOLS */
3378 DEFUN(coff_sizeof_headers
,(abfd
, reloc
),
3384 if (reloc
== false) {
3385 size
= FILHSZ
+ AOUTSZ
;
3391 size
+= abfd
->section_count
* SCNHSZ
;
3396 #define coff_core_file_failing_command _bfd_dummy_core_file_failing_command
3397 #define coff_core_file_failing_signal _bfd_dummy_core_file_failing_signal
3398 #define coff_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
3399 #define coff_slurp_armap bfd_slurp_coff_armap
3400 #define coff_slurp_extended_name_table _bfd_slurp_extended_name_table
3401 #define coff_truncate_arname bfd_dont_truncate_arname
3402 #define coff_openr_next_archived_file bfd_generic_openr_next_archived_file
3403 #define coff_generic_stat_arch_elt bfd_generic_stat_arch_elt
3404 #define coff_get_section_contents bfd_generic_get_section_contents
3405 #define coff_close_and_cleanup bfd_generic_close_and_cleanup
3407 #define coff_bfd_debug_info_start bfd_void
3408 #define coff_bfd_debug_info_end bfd_void
3409 #define coff_bfd_debug_info_accumulate (PROTO(void,(*),(bfd*, struct sec *))) bfd_void