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. */
27 BFD supports a number of different flavours of coff format.
28 The major difference between formats are the sizes and
29 alignments of fields in structures on disk, and the occasional
32 Coff in all its varieties is implimented with a few common
33 files and a number of implementation specific files. For
34 example, The 88k bcs coff format is implemented in the file
35 @code{coff-m88k.c}. This file @code{#include}s
36 @code{coff-m88k.h} which defines the external structure of the
37 coff format for the 88k, and @code{internalcoff.h} which
38 defines the internal structure. @code{coff-m88k.c} also
39 defines pthe relocations used by the 88k format
40 @xref{Relocations}. Then the major portion of coff code is
41 included (@code{coffcode.h}) which defines the methods used to
42 act upon the types defined in @code{coff-m88k.h} and
43 @code{internalcoff.h}.
46 The Intel i960 processor version of coff is implemented in
47 @code{coff-i960.c}. This file has the same structure as
48 @code{coff-m88k.c}, except that it includes @code{coff-i960.h}
49 rather than @code{coff-m88k.h}.
52 Porting To A New Version of Coff
55 The recommended method is to select from the existing
56 implimentations the version of coff which is most like the one
57 you want to use, for our purposes, we'll say that i386 coff is
58 the one you select, and that your coff flavour is called foo.
59 Copy the @code{i386coff.c} to @code{foocoff.c}, copy
60 @code{../include/i386coff.h} to @code{../include/foocoff.h}
61 and add the lines to @code{targets.c} and @code{Makefile.in}
62 so that your new back end is used. Alter the shapes of the
63 structures in @code{../include/foocoff.h} so that they match
64 what you need. You will probably also have to add
65 @code{#ifdef}s to the code in @code{internalcoff.h} and
66 @code{coffcode.h} if your version of coff is too wild.
68 You can verify that your new BFD backend works quite simply by
69 building @code{objdump} from the @code{binutils} directory,
70 and making sure that its version of what's going on at your
71 host systems idea (assuming it has the pretty standard coff
72 dump utility (usually called @code{att-dump} or just
73 @code{dump})) are the same. Then clean up your code, and send
74 what you've done to Cygnus. Then your stuff will be in the
75 next release, and you won't have to keep integrating it.
78 How The Coff Backend Works
84 Each flavour of coff supported in BFD has its own header file
85 descibing the external layout of the structures. There is also
86 an internal description of the coff layout (in
87 @code{internalcoff.h}) file (@code{}). A major function of the
88 coff backend is swapping the bytes and twiddling the bits to
89 translate the external form of the structures into the normal
90 internal form. This is all performed in the
91 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
92 elements are different sizes between different versions of
93 coff, it is the duty of the coff version specific include file
94 to override the definitions of various packing routines in
95 @code{coffcode.h}. Eg the size of line number entry in coff is
96 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
97 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
98 correct one. No doubt, some day someone will find a version of
99 coff which has a varying field size not catered for at the
100 moment. To port BFD, that person will have to add more @code{#defines}.
101 Three of the bit twiddling routines are exported to
102 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
103 and @code{coff_swap_linno_in}. @code{GDB} reads the symbol
104 table on its own, but uses BFD to fix things up. More of the
105 bit twiddlers are exported for @code{gas};
106 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
107 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
108 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
109 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
110 of all the symbol table and reloc drudgery itself, thereby
111 saving the internal BFD overhead, but uses BFD to swap things
112 on the way out, making cross ports much safer. This also
113 allows BFD (and thus the linker) to use the same header files
114 as @code{gas}, which makes one avenue to disaster disappear.
120 The simple canonical form for symbols used by BFD is not rich
121 enough to keep all the information available in a coff symbol
122 table. The back end gets around this by keeping the original
123 symbol table around, "behind the scenes".
125 When a symbol table is requested (through a call to
126 @code{bfd_canonicalize_symtab}, a request gets through to
127 @code{get_normalized_symtab}. This reads the symbol table from
128 the coff file and swaps all the structures inside into the
129 internal form. It also fixes up all the pointers in the table
130 (represented in the file by offsets from the first symbol in
131 the table) into physical pointers to elements in the new
132 internal table. This involves some work since the meanings of
133 fields changes depending upon context; a field that is a
134 pointer to another structure in the symbol table at one moment
135 may be the size in bytes of a structure in the next. Another
136 pass is made over the table. All symbols which mark file names
137 (@code{C_FILE} symbols) are modified so that the internal
138 string points to the value in the auxent (the real filename)
139 rather than the normal text associated with the symbol
142 At this time the symbol names are moved around. Coff stores
143 all symbols less than nine characters long physically
144 within the symbol table, longer strings are kept at the end of
145 the file in the string table. This pass moves all strings
146 into memory, and replaces them with pointers to the strings.
149 The symbol table is massaged once again, this time to create
150 the canonical table used by the BFD application. Each symbol
151 is inspected in turn, and a decision made (using the
152 @code{sclass} field) about the various flags to set in the
153 @code{asymbol} @xref{Symbols}. The generated canonical table
154 shares strings with the hidden internal symbol table.
156 Any linenumbers are read from the coff file too, and attached
157 to the symbols which own the functions the linenumbers belong to.
164 Writing a symbol to a coff file which didn't come from a coff
165 file will lose any debugging information. The @code{asymbol}
166 structure remembers the BFD from which was born, and on output
167 the back end makes sure that the same destination target as
168 source target is present.
170 When the symbols have come from a coff file then all the
171 debugging information is preserved.
173 Symbol tables are provided for writing to the back end in a
174 vector of pointers to pointers. This allows applications like
175 the linker to accumulate and output large symbol tables
176 without having to do too much byte copying.
180 This function runs through the provided symbol table and
181 patches each symbol marked as a file place holder
182 (@code{C_FILE}) to point to the next file place holder in the
183 list. It also marks each @code{offset} field in the list with
184 the offset from the first symbol of the current symbol.
186 Another function of this procedure is to turn the canonical
187 value form of BFD into the form used by coff. Internally, BFD
188 expects symbol values to be offsets from a section base; so a
189 symbol physically at 0x120, but in a section starting at
190 0x100, would have the value 0x20. Coff expects symbols to
191 contain their final value, so symbols have their values
192 changed at this point to reflect their sum with their owning
193 section. Note that this transformation uses the
194 <<output_section>> field of the @code{asymbol}'s
195 @code{asection} @xref{Sections}.
197 o coff_mangle_symbols
198 This routine runs though the provided symbol table and uses
199 the offsets generated by the previous pass and the pointers
200 generated when the symbol table was read in to create the
201 structured hierachy required by coff. It changes each pointer
202 to a symbol to an index into the symbol table of the symbol
206 This routine runs through the symbol table and patches up the
207 symbols from their internal form into the coff way, calls the
208 bit twiddlers and writes out the tabel to the file.
216 The hidden information for an asymbol is described in a
217 coff_ptr_struct, which is typedefed to a combined_entry_type
219 .typedef struct coff_ptr_struct
222 Remembers the offset from the first symbol in the file for
223 this symbol. Generated by @code{coff_renumber_symbols}.
225 .unsigned int offset;
227 Should the tag field of this symbol be renumbered.
228 Created by @code{coff_pointerize_aux}.
232 Should the endidx field of this symbol be renumbered.
233 Created by @code{coff_pointerize_aux}.
237 The container for the symbol structure as read and translated
241 . union internal_auxent auxent;
242 . struct internal_syment syment;
244 .} combined_entry_type;
246 Each canonical asymbol really looks like this:
248 .typedef struct coff_symbol_struct
251 The actual symbol which the rest of BFD works with
255 A pointer to the hidden information for this symbol
257 .combined_entry_type *native;
259 A pointer to the linenumber information for this symbol
261 .struct lineno_cache_entry *lineno;
267 /* Most of this hacked by Steve Chamberlain, steve@cygnus.com */
270 #define PUTWORD bfd_h_put_32
271 #define PUTHALF bfd_h_put_16
272 #define PUTBYTE bfd_h_put_8
274 #ifndef GET_FCN_LNNOPTR
275 #define GET_FCN_LNNOPTR(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
278 #ifndef GET_FCN_ENDNDX
279 #define GET_FCN_ENDNDX(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
282 #ifndef PUT_FCN_LNNOPTR
283 #define PUT_FCN_LNNOPTR(abfd, in, ext) PUTWORD(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
285 #ifndef PUT_FCN_ENDNDX
286 #define PUT_FCN_ENDNDX(abfd, in, ext) PUTWORD(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
288 #ifndef GET_LNSZ_LNNO
289 #define GET_LNSZ_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_lnno)
291 #ifndef GET_LNSZ_SIZE
292 #define GET_LNSZ_SIZE(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_size)
294 #ifndef PUT_LNSZ_LNNO
295 #define PUT_LNSZ_LNNO(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_sym.x_misc.x_lnsz.x_lnno)
297 #ifndef PUT_LNSZ_SIZE
298 #define PUT_LNSZ_SIZE(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte*) ext->x_sym.x_misc.x_lnsz.x_size)
300 #ifndef GET_SCN_SCNLEN
301 #define GET_SCN_SCNLEN(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_scn.x_scnlen)
303 #ifndef GET_SCN_NRELOC
304 #define GET_SCN_NRELOC(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nreloc)
306 #ifndef GET_SCN_NLINNO
307 #define GET_SCN_NLINNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nlinno)
309 #ifndef PUT_SCN_SCNLEN
310 #define PUT_SCN_SCNLEN(abfd,in, ext) bfd_h_put_32(abfd, in, (bfd_byte *) ext->x_scn.x_scnlen)
312 #ifndef PUT_SCN_NRELOC
313 #define PUT_SCN_NRELOC(abfd,in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_scn.x_nreloc)
315 #ifndef PUT_SCN_NLINNO
316 #define PUT_SCN_NLINNO(abfd,in, ext) bfd_h_put_16(abfd,in, (bfd_byte *) ext->x_scn.x_nlinno)
318 #ifndef GET_LINENO_LNNO
319 #define GET_LINENO_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) (ext->l_lnno));
321 #ifndef PUT_LINENO_LNNO
322 #define PUT_LINENO_LNNO(abfd,val, ext) bfd_h_put_16(abfd,val, (bfd_byte *) (ext->l_lnno));
326 /* void warning(); */
329 * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the
330 * incoming SEC_* flags. The inverse of this function is styp_to_sec_flags().
331 * NOTE: If you add to/change this routine, you should mirror the changes
332 * in styp_to_sec_flags().
335 DEFUN(sec_to_styp_flags
, (sec_name
, sec_flags
),
336 CONST
char * sec_name AND
341 if (!strcmp(sec_name
, _TEXT
)) {
342 return((long)STYP_TEXT
);
343 } else if (!strcmp(sec_name
, _DATA
)) {
344 return((long)STYP_DATA
);
345 } else if (!strcmp(sec_name
, _BSS
)) {
346 return((long)STYP_BSS
);
348 } else if (!strcmp(sec_name
, _COMMENT
)) {
349 return((long)STYP_INFO
);
350 #endif /* _COMMENT */
353 /* Try and figure out what it should be */
354 if (sec_flags
& SEC_CODE
) styp_flags
= STYP_TEXT
;
355 if (sec_flags
& SEC_DATA
) styp_flags
= STYP_DATA
;
356 else if (sec_flags
& SEC_READONLY
)
357 #ifdef STYP_LIT /* 29k readonly text/data section */
358 styp_flags
= STYP_LIT
;
360 styp_flags
= STYP_TEXT
;
361 #endif /* STYP_LIT */
362 else if (sec_flags
& SEC_LOAD
) styp_flags
= STYP_TEXT
;
364 if (styp_flags
== 0) styp_flags
= STYP_BSS
;
369 * Return a word with SEC_* flags set to represent the incoming
370 * STYP_* flags (from scnhdr.s_flags). The inverse of this
371 * function is sec_to_styp_flags().
372 * NOTE: If you add to/change this routine, you should mirror the changes
373 * in sec_to_styp_flags().
376 DEFUN(styp_to_sec_flags
, (styp_flags
),
379 flagword sec_flags
=0;
381 if ((styp_flags
& STYP_TEXT
) || (styp_flags
& STYP_DATA
))
382 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
383 else if (styp_flags
& STYP_BSS
)
384 sec_flags
= SEC_ALLOC
;
386 #ifdef STYP_LIT /* A29k readonly text/data section type */
387 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
388 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
389 #endif /* STYP_LIT */
390 #ifdef STYP_OTHER_LOAD /* Other loaded sections */
391 if (styp_flags
& STYP_OTHER_LOAD
)
392 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
393 #endif /* STYP_SDATA */
398 #define get_index(symbol) ((int) (symbol)->value)
399 #define set_index(symbol, idx) ((symbol)->value = (idx))
401 /* **********************************************************************
402 Here are all the routines for swapping the structures seen in the
403 outside world into the internal forms.
408 DEFUN(bfd_swap_reloc_in
,(abfd
, reloc_src
, reloc_dst
),
411 struct internal_reloc
*reloc_dst
)
413 reloc_dst
->r_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*)reloc_src
->r_vaddr
);
414 reloc_dst
->r_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) reloc_src
->r_symndx
);
417 reloc_dst
->r_type
= bfd_h_get_8(abfd
, reloc_src
->r_type
);
418 reloc_dst
->r_size
= bfd_h_get_8(abfd
, reloc_src
->r_size
);
420 reloc_dst
->r_type
= bfd_h_get_16(abfd
, (bfd_byte
*) reloc_src
->r_type
);
423 #ifdef SWAP_IN_RELOC_OFFSET
424 reloc_dst
->r_offset
= SWAP_IN_RELOC_OFFSET(abfd
,
425 (bfd_byte
*) reloc_src
->r_offset
);
431 DEFUN(coff_swap_reloc_out
,(abfd
, src
, dst
),
436 struct internal_reloc
*reloc_src
= (struct internal_reloc
*)src
;
437 struct external_reloc
*reloc_dst
= (struct external_reloc
*)dst
;
438 bfd_h_put_32(abfd
, reloc_src
->r_vaddr
, (bfd_byte
*) reloc_dst
->r_vaddr
);
439 bfd_h_put_32(abfd
, reloc_src
->r_symndx
, (bfd_byte
*) reloc_dst
->r_symndx
);
440 bfd_h_put_16(abfd
, reloc_src
->r_type
, (bfd_byte
*)
443 #ifdef SWAP_OUT_RELOC_OFFSET
444 SWAP_OUT_RELOC_OFFSET(abfd
,
446 (bfd_byte
*) reloc_dst
->r_offset
);
448 #ifdef SWAP_OUT_RELOC_EXTRA
449 SWAP_OUT_RELOC_EXTRA(abfd
,reloc_src
, reloc_dst
);
452 return sizeof(struct external_reloc
);
456 DEFUN(bfd_swap_filehdr_in
,(abfd
, filehdr_src
, filehdr_dst
),
458 FILHDR
*filehdr_src AND
459 struct internal_filehdr
*filehdr_dst
)
461 filehdr_dst
->f_magic
= bfd_h_get_16(abfd
, (bfd_byte
*) filehdr_src
->f_magic
);
462 filehdr_dst
->f_nscns
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_nscns
);
463 filehdr_dst
->f_timdat
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_timdat
);
464 filehdr_dst
->f_symptr
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_symptr
);
465 filehdr_dst
->f_nsyms
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_nsyms
);
466 filehdr_dst
->f_opthdr
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_opthdr
);
467 filehdr_dst
->f_flags
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_flags
);
471 DEFUN(coff_swap_filehdr_out
,(abfd
, in
, out
),
476 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*)in
;
477 FILHDR
*filehdr_out
= (FILHDR
*)out
;
478 bfd_h_put_16(abfd
, filehdr_in
->f_magic
, (bfd_byte
*) filehdr_out
->f_magic
);
479 bfd_h_put_16(abfd
, filehdr_in
->f_nscns
, (bfd_byte
*) filehdr_out
->f_nscns
);
480 bfd_h_put_32(abfd
, filehdr_in
->f_timdat
, (bfd_byte
*) filehdr_out
->f_timdat
);
481 bfd_h_put_32(abfd
, filehdr_in
->f_symptr
, (bfd_byte
*) filehdr_out
->f_symptr
);
482 bfd_h_put_32(abfd
, filehdr_in
->f_nsyms
, (bfd_byte
*) filehdr_out
->f_nsyms
);
483 bfd_h_put_16(abfd
, filehdr_in
->f_opthdr
, (bfd_byte
*) filehdr_out
->f_opthdr
);
484 bfd_h_put_16(abfd
, filehdr_in
->f_flags
, (bfd_byte
*) filehdr_out
->f_flags
);
485 return sizeof(FILHDR
);
489 #ifndef NO_COFF_SYMBOLS
492 DEFUN(coff_swap_sym_in
,(abfd
, ext1
, in1
),
497 SYMENT
*ext
= (SYMENT
*)ext1
;
498 struct internal_syment
*in
= (struct internal_syment
*)in1
;
500 if( ext
->e
.e_name
[0] == 0) {
501 in
->_n
._n_n
._n_zeroes
= 0;
502 in
->_n
._n_n
._n_offset
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e
.e
.e_offset
);
505 #if SYMNMLEN != E_SYMNMLEN
506 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
508 memcpy(in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
511 in
->n_value
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_value
);
512 in
->n_scnum
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_scnum
);
513 if (sizeof(ext
->e_type
) == 2){
514 in
->n_type
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_type
);
517 in
->n_type
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_type
);
519 in
->n_sclass
= bfd_h_get_8(abfd
, ext
->e_sclass
);
520 in
->n_numaux
= bfd_h_get_8(abfd
, ext
->e_numaux
);
524 DEFUN(coff_swap_sym_out
,(abfd
, inp
, extp
),
529 struct internal_syment
*in
= (struct internal_syment
*)inp
;
530 SYMENT
*ext
=(SYMENT
*)extp
;
531 if(in
->_n
._n_name
[0] == 0) {
532 bfd_h_put_32(abfd
, 0, (bfd_byte
*) ext
->e
.e
.e_zeroes
);
533 bfd_h_put_32(abfd
, in
->_n
._n_n
._n_offset
, (bfd_byte
*) ext
->e
.e
.e_offset
);
536 #if SYMNMLEN != E_SYMNMLEN
537 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
539 memcpy(ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
542 bfd_h_put_32(abfd
, in
->n_value
, (bfd_byte
*) ext
->e_value
);
543 bfd_h_put_16(abfd
, in
->n_scnum
, (bfd_byte
*) ext
->e_scnum
);
544 if (sizeof(ext
->e_type
) == 2)
546 bfd_h_put_16(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
550 bfd_h_put_32(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
552 bfd_h_put_8(abfd
, in
->n_sclass
, ext
->e_sclass
);
553 bfd_h_put_8(abfd
, in
->n_numaux
, ext
->e_numaux
);
554 return sizeof(SYMENT
);
558 DEFUN(coff_swap_aux_in
,(abfd
, ext1
, type
, class, in1
),
565 AUXENT
*ext
= (AUXENT
*)ext1
;
566 union internal_auxent
*in
= (union internal_auxent
*)in1
;
569 if (ext
->x_file
.x_fname
[0] == 0) {
570 in
->x_file
.x_n
.x_zeroes
= 0;
571 in
->x_file
.x_n
.x_offset
=
572 bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
574 #if FILNMLEN != E_FILNMLEN
575 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
577 memcpy (in
->x_file
.x_fname
, ext
->x_file
.x_fname
, FILNMLEN
);
582 /* RS/6000 "csect" auxents */
586 in
->x_csect
.x_scnlen
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_scnlen
);
587 in
->x_csect
.x_parmhash
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_parmhash
);
588 in
->x_csect
.x_snhash
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snhash
);
589 /* We don't have to hack bitfields in x_smtyp because it's defined by
590 shifts-and-ands, which are equivalent on all byte orders. */
591 in
->x_csect
.x_smtyp
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smtyp
);
592 in
->x_csect
.x_smclas
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smclas
);
593 in
->x_csect
.x_stab
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_stab
);
594 in
->x_csect
.x_snstab
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snstab
);
603 if (type
== T_NULL
) {
604 in
->x_scn
.x_scnlen
= GET_SCN_SCNLEN(abfd
, ext
);
605 in
->x_scn
.x_nreloc
= GET_SCN_NRELOC(abfd
, ext
);
606 in
->x_scn
.x_nlinno
= GET_SCN_NLINNO(abfd
, ext
);
610 in
->x_sym
.x_tagndx
.l
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
612 in
->x_sym
.x_tvndx
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
615 if (ISARY(type
) || class == C_BLOCK
) {
616 #if DIMNUM != E_DIMNUM
617 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
619 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]);
620 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]);
621 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]);
622 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]);
625 in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= GET_FCN_LNNOPTR(abfd
, ext
);
626 in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= GET_FCN_ENDNDX(abfd
, ext
);
629 in
->x_sym
.x_misc
.x_fsize
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
632 in
->x_sym
.x_misc
.x_lnsz
.x_lnno
= GET_LNSZ_LNNO(abfd
, ext
);
633 in
->x_sym
.x_misc
.x_lnsz
.x_size
= GET_LNSZ_SIZE(abfd
, ext
);
639 DEFUN(coff_swap_aux_out
,(abfd
, inp
, type
, class, extp
),
646 union internal_auxent
*in
= (union internal_auxent
*)inp
;
647 AUXENT
*ext
= (AUXENT
*)extp
;
650 if (in
->x_file
.x_fname
[0] == 0) {
651 PUTWORD(abfd
, 0, (bfd_byte
*) ext
->x_file
.x_n
.x_zeroes
);
653 in
->x_file
.x_n
.x_offset
,
654 (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
657 #if FILNMLEN != E_FILNMLEN
658 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
660 memcpy (ext
->x_file
.x_fname
, in
->x_file
.x_fname
, FILNMLEN
);
666 /* RS/6000 "csect" auxents */
669 PUTWORD (abfd
, in
->x_csect
.x_scnlen
, ext
->x_csect
.x_scnlen
);
670 PUTWORD (abfd
, in
->x_csect
.x_parmhash
, ext
->x_csect
.x_parmhash
);
671 PUTHALF (abfd
, in
->x_csect
.x_snhash
, ext
->x_csect
.x_snhash
);
672 /* We don't have to hack bitfields in x_smtyp because it's defined by
673 shifts-and-ands, which are equivalent on all byte orders. */
674 PUTBYTE (abfd
, in
->x_csect
.x_smtyp
, ext
->x_csect
.x_smtyp
);
675 PUTBYTE (abfd
, in
->x_csect
.x_smclas
, ext
->x_csect
.x_smclas
);
676 PUTWORD (abfd
, in
->x_csect
.x_stab
, ext
->x_csect
.x_stab
);
677 PUTHALF (abfd
, in
->x_csect
.x_snstab
, ext
->x_csect
.x_snstab
);
686 if (type
== T_NULL
) {
687 PUT_SCN_SCNLEN(abfd
, in
->x_scn
.x_scnlen
, ext
);
688 PUT_SCN_NRELOC(abfd
, in
->x_scn
.x_nreloc
, ext
);
689 PUT_SCN_NLINNO(abfd
, in
->x_scn
.x_nlinno
, ext
);
693 PUTWORD(abfd
, in
->x_sym
.x_tagndx
.l
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
695 PUTWORD(abfd
, in
->x_sym
.x_tvndx
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
699 PUTWORD(abfd
, in
->x_sym
.x_misc
.x_fsize
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
700 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
701 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
705 if (ISARY(type
) || class == C_BLOCK
) {
706 #if DIMNUM != E_DIMNUM
707 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
709 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]);
710 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]);
711 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]);
712 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]);
715 PUT_LNSZ_LNNO(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
716 PUT_LNSZ_SIZE(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
718 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
719 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
724 return sizeof(AUXENT
);
727 #endif /* NO_COFF_SYMBOLS */
729 #ifndef NO_COFF_LINENOS
732 DEFUN(coff_swap_lineno_in
,(abfd
, ext1
, in1
),
737 LINENO
*ext
= (LINENO
*)ext1
;
738 struct internal_lineno
*in
= (struct internal_lineno
*)in1
;
740 in
->l_addr
.l_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->l_addr
.l_symndx
);
741 in
->l_lnno
= GET_LINENO_LNNO(abfd
, ext
);
745 DEFUN(coff_swap_lineno_out
,(abfd
, inp
, outp
),
750 struct internal_lineno
*in
= (struct internal_lineno
*)inp
;
751 struct external_lineno
*ext
= (struct external_lineno
*)outp
;
752 PUTWORD(abfd
, in
->l_addr
.l_symndx
, (bfd_byte
*)
753 ext
->l_addr
.l_symndx
);
755 PUT_LINENO_LNNO (abfd
, in
->l_lnno
, ext
);
756 return sizeof(struct external_lineno
);
759 #endif /* NO_COFF_LINENOS */
763 DEFUN(bfd_swap_aouthdr_in
,(abfd
, aouthdr_ext1
, aouthdr_int1
),
768 AOUTHDR
*aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
769 struct internal_aouthdr
*aouthdr_int
= (struct internal_aouthdr
*)aouthdr_int1
;
771 aouthdr_int
->magic
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->magic
);
772 aouthdr_int
->vstamp
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->vstamp
);
773 aouthdr_int
->tsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tsize
);
774 aouthdr_int
->dsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->dsize
);
775 aouthdr_int
->bsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->bsize
);
776 aouthdr_int
->entry
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->entry
);
777 aouthdr_int
->text_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->text_start
);
778 aouthdr_int
->data_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->data_start
);
780 aouthdr_int
->tagentries
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tagentries
);
784 aouthdr_int
->o_toc
= bfd_h_get_32(abfd
, aouthdr_ext
->o_toc
);
785 aouthdr_int
->o_snentry
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snentry
);
786 aouthdr_int
->o_sntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntext
);
787 aouthdr_int
->o_sndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sndata
);
788 aouthdr_int
->o_sntoc
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntoc
);
789 aouthdr_int
->o_snloader
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snloader
);
790 aouthdr_int
->o_snbss
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snbss
);
791 aouthdr_int
->o_algntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algntext
);
792 aouthdr_int
->o_algndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algndata
);
793 aouthdr_int
->o_modtype
= bfd_h_get_16(abfd
, aouthdr_ext
->o_modtype
);
794 aouthdr_int
->o_maxstack
= bfd_h_get_32(abfd
, aouthdr_ext
->o_maxstack
);
799 DEFUN(coff_swap_aouthdr_out
,(abfd
, in
, out
),
804 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*)in
;
805 AOUTHDR
*aouthdr_out
= (AOUTHDR
*)out
;
806 bfd_h_put_16(abfd
, aouthdr_in
->magic
, (bfd_byte
*) aouthdr_out
->magic
);
807 bfd_h_put_16(abfd
, aouthdr_in
->vstamp
, (bfd_byte
*) aouthdr_out
->vstamp
);
808 bfd_h_put_32(abfd
, aouthdr_in
->tsize
, (bfd_byte
*) aouthdr_out
->tsize
);
809 bfd_h_put_32(abfd
, aouthdr_in
->dsize
, (bfd_byte
*) aouthdr_out
->dsize
);
810 bfd_h_put_32(abfd
, aouthdr_in
->bsize
, (bfd_byte
*) aouthdr_out
->bsize
);
811 bfd_h_put_32(abfd
, aouthdr_in
->entry
, (bfd_byte
*) aouthdr_out
->entry
);
812 bfd_h_put_32(abfd
, aouthdr_in
->text_start
,
813 (bfd_byte
*) aouthdr_out
->text_start
);
814 bfd_h_put_32(abfd
, aouthdr_in
->data_start
, (bfd_byte
*) aouthdr_out
->data_start
);
816 bfd_h_put_32(abfd
, aouthdr_in
->tagentries
, (bfd_byte
*) aouthdr_out
->tagentries
);
818 return sizeof(AOUTHDR
);
822 DEFUN(coff_swap_scnhdr_in
,(abfd
, scnhdr_ext
, scnhdr_int
),
824 SCNHDR
*scnhdr_ext AND
825 struct internal_scnhdr
*scnhdr_int
)
827 memcpy(scnhdr_int
->s_name
, scnhdr_ext
->s_name
, sizeof(scnhdr_int
->s_name
));
828 scnhdr_int
->s_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
829 scnhdr_int
->s_paddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
830 scnhdr_int
->s_size
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_size
);
831 scnhdr_int
->s_scnptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
832 scnhdr_int
->s_relptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
833 scnhdr_int
->s_lnnoptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
834 scnhdr_int
->s_flags
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_flags
);
836 scnhdr_int
->s_nreloc
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
837 scnhdr_int
->s_nlnno
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
839 scnhdr_int
->s_nreloc
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
840 scnhdr_int
->s_nlnno
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
843 scnhdr_int
->s_align
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_align
);
848 DEFUN(coff_swap_scnhdr_out
,(abfd
, in
, out
),
853 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*)in
;
854 SCNHDR
*scnhdr_ext
= (SCNHDR
*)out
;
855 memcpy(scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof(scnhdr_int
->s_name
));
856 PUTWORD(abfd
, scnhdr_int
->s_vaddr
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
857 PUTWORD(abfd
, scnhdr_int
->s_paddr
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
858 PUTWORD(abfd
, scnhdr_int
->s_size
, (bfd_byte
*) scnhdr_ext
->s_size
);
859 PUTWORD(abfd
, scnhdr_int
->s_scnptr
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
860 PUTWORD(abfd
, scnhdr_int
->s_relptr
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
861 PUTWORD(abfd
, scnhdr_int
->s_lnnoptr
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
862 PUTWORD(abfd
, scnhdr_int
->s_flags
, (bfd_byte
*) scnhdr_ext
->s_flags
);
864 PUTWORD(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
865 PUTWORD(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
867 PUTHALF(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
868 PUTHALF(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
872 PUTWORD(abfd
, scnhdr_int
->s_align
, (bfd_byte
*) scnhdr_ext
->s_align
);
874 return sizeof(SCNHDR
);
879 initialize a section structure with information peculiar to this
880 particular implementation of coff
884 DEFUN(coff_new_section_hook
,(abfd_ignore
, section_ignore
),
886 asection
*section_ignore
)
888 section_ignore
->alignment_power
= abfd_ignore
->xvec
->align_power_min
;
892 /* Take a section header read from a coff file (in HOST byte order),
893 and make a BFD "section" out of it. */
895 DEFUN(make_a_section_from_file
,(abfd
, hdr
),
897 struct internal_scnhdr
*hdr
)
899 asection
*return_section
;
902 /* Assorted wastage to null-terminate the name, thanks AT&T! */
903 char *name
= bfd_alloc(abfd
, sizeof (hdr
->s_name
)+1);
905 bfd_error
= no_memory
;
908 strncpy(name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
909 name
[sizeof (hdr
->s_name
)] = 0;
911 return_section
= bfd_make_section(abfd
, name
);
912 if (return_section
== NULL
)
916 /* s_paddr is presumed to be = to s_vaddr */
917 #define assign(to, from) return_section->to = hdr->from
918 assign(vma
, s_vaddr
);
919 /* assign (vma, s_vaddr); */
920 assign(size
, s_size
);
921 assign(filepos
, s_scnptr
);
922 assign(rel_filepos
, s_relptr
);
923 assign(reloc_count
, s_nreloc
);
926 /* FIXME, use a temp var rather than alignment_power */
927 assign(alignment_power
, s_align
);
930 for (i
= 0; i
< 32; i
++) {
931 if ((1 << i
) >= (int) (return_section
->alignment_power
)) {
932 return_section
->alignment_power
= i
;
939 assign(line_filepos
, s_lnnoptr
);
941 return_section->linesize = hdr->s_nlnno * sizeof (struct lineno);
944 return_section
->lineno_count
= hdr
->s_nlnno
;
945 return_section
->userdata
= NULL
;
946 return_section
->next
= (asection
*) NULL
;
947 return_section
->flags
= styp_to_sec_flags(hdr
->s_flags
);
950 if (hdr
->s_nreloc
!= 0)
951 return_section
->flags
|= SEC_RELOC
;
952 /* FIXME: should this check 'hdr->s_size > 0' */
953 if (hdr
->s_scnptr
!= 0)
954 return_section
->flags
|= SEC_HAS_CONTENTS
;
958 DEFUN(coff_mkobject
,(abfd
),
961 set_tdata (abfd
, bfd_zalloc (abfd
,sizeof(coff_data_type
)));
962 if (coff_data(abfd
) == 0) {
963 bfd_error
= no_memory
;
966 coff_data(abfd
)->relocbase
= 0;
972 DEFUN(coff_real_object_p
,(abfd
, nscns
, internal_f
, internal_a
),
975 struct internal_filehdr
*internal_f AND
976 struct internal_aouthdr
*internal_a
)
978 coff_data_type
*coff
;
979 enum bfd_architecture arch
;
981 size_t readsize
; /* length of file_info */
982 SCNHDR
*external_sections
;
984 /* Build a play area */
985 if (coff_mkobject(abfd
) != true)
987 coff
= coff_data(abfd
);
990 external_sections
= (SCNHDR
*)bfd_alloc(abfd
, readsize
= (nscns
* SCNHSZ
));
992 if (bfd_read((PTR
)external_sections
, 1, readsize
, abfd
) != readsize
) {
997 /* Now copy data as required; construct all asections etc */
998 coff
->symbol_index_slew
= 0;
1000 coff
->raw_syment_count
= 0;
1001 coff
->raw_linenos
= 0;
1002 coff
->raw_syments
= 0;
1003 coff
->sym_filepos
=0;
1004 coff
->flags
= internal_f
->f_flags
;
1007 for (i
= 0; i
< nscns
; i
++) {
1008 struct internal_scnhdr tmp
;
1009 coff_swap_scnhdr_in(abfd
, external_sections
+ i
, &tmp
);
1010 make_a_section_from_file(abfd
,&tmp
);
1013 /* Determine the machine architecture and type. */
1015 switch (internal_f
->f_magic
) {
1018 arch
= bfd_arch_i386
;
1023 #ifdef A29K_MAGIC_BIG
1024 case A29K_MAGIC_BIG
:
1025 case A29K_MAGIC_LITTLE
:
1026 arch
= bfd_arch_a29k
;
1035 arch
= bfd_arch_mips
;
1043 arch
= bfd_arch_m68k
;
1051 arch
= bfd_arch_m88k
;
1059 arch
= bfd_arch_i960
;
1060 switch (F_I960TYPE
& internal_f
->f_flags
)
1064 machine
= bfd_mach_i960_core
;
1067 machine
= bfd_mach_i960_kb_sb
;
1070 machine
= bfd_mach_i960_mc
;
1073 machine
= bfd_mach_i960_xa
;
1076 machine
= bfd_mach_i960_ca
;
1079 machine
= bfd_mach_i960_ka_sa
;
1090 arch
= bfd_arch_rs6000
;
1097 arch
= bfd_arch_h8300
;
1102 default: /* Unreadable input file type */
1103 arch
= bfd_arch_obscure
;
1107 bfd_default_set_arch_mach(abfd
, arch
, machine
);
1108 if (!(internal_f
->f_flags
& F_RELFLG
))
1109 abfd
->flags
|= HAS_RELOC
;
1110 if ((internal_f
->f_flags
& F_EXEC
))
1111 abfd
->flags
|= EXEC_P
;
1112 if (!(internal_f
->f_flags
& F_LNNO
))
1113 abfd
->flags
|= HAS_LINENO
;
1114 if (!(internal_f
->f_flags
& F_LSYMS
))
1115 abfd
->flags
|= HAS_LOCALS
;
1118 bfd_get_symcount(abfd
) = internal_f
->f_nsyms
;
1119 if (internal_f
->f_nsyms
)
1120 abfd
->flags
|= HAS_SYMS
;
1122 coff
->sym_filepos
= internal_f
->f_symptr
;
1124 /* These members communicate important constants about the symbol table
1125 to GDB's symbol-reading code. These `constants' unfortunately vary
1126 from coff implementation to implementation... */
1127 #ifndef NO_COFF_SYMBOLS
1128 coff
->local_n_btmask
= N_BTMASK
;
1129 coff
->local_n_btshft
= N_BTSHFT
;
1130 coff
->local_n_tmask
= N_TMASK
;
1131 coff
->local_n_tshift
= N_TSHIFT
;
1132 coff
->local_symesz
= SYMESZ
;
1133 coff
->local_auxesz
= AUXESZ
;
1134 coff
->local_linesz
= LINESZ
;
1137 coff
->symbols
= (coff_symbol_type
*) NULL
;
1138 bfd_get_start_address(abfd
) = internal_f
->f_opthdr
? internal_a
->entry
: 0;
1142 bfd_release(abfd
, coff
);
1143 return (bfd_target
*)NULL
;
1147 DEFUN(coff_object_p
,(abfd
),
1153 struct internal_filehdr internal_f
;
1154 struct internal_aouthdr internal_a
;
1156 bfd_error
= system_call_error
;
1158 /* figure out how much to read */
1159 if (bfd_read((PTR
) &filehdr
, 1, FILHSZ
, abfd
) != FILHSZ
)
1162 bfd_swap_filehdr_in(abfd
, &filehdr
, &internal_f
);
1164 if (BADMAG(internal_f
)) {
1165 bfd_error
= wrong_format
;
1168 nscns
=internal_f
.f_nscns
;
1170 if (internal_f
.f_opthdr
) {
1171 if (bfd_read((PTR
) &opthdr
, 1,AOUTSZ
, abfd
) != AOUTSZ
) {
1174 bfd_swap_aouthdr_in(abfd
, (char *)&opthdr
, (char *)&internal_a
);
1177 /* Seek past the opt hdr stuff */
1178 bfd_seek(abfd
, internal_f
.f_opthdr
+ FILHSZ
, SEEK_SET
);
1180 /* if the optional header is NULL or not the correct size then
1181 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1182 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1183 optional header is of a different size.
1185 But the mips keeps extra stuff in it's opthdr, so dont check
1189 #if defined(M88) || defined(I960)
1190 if (internal_f
.f_opthdr
!= 0 && AOUTSZ
!= internal_f
.f_opthdr
)
1191 return (bfd_target
*)NULL
;
1194 return coff_real_object_p(abfd
, nscns
, &internal_f
, &internal_a
);
1199 #ifndef NO_COFF_LINENOS
1202 DEFUN(coff_count_linenumbers
,(abfd
),
1205 unsigned int limit
= bfd_get_symcount(abfd
);
1209 asection
*s
= abfd
->sections
->output_section
;
1211 BFD_ASSERT(s
->lineno_count
== 0);
1217 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++) {
1218 asymbol
*q_maybe
= *p
;
1219 if (q_maybe
->the_bfd
->xvec
->flavour
== bfd_target_coff_flavour
) {
1220 coff_symbol_type
*q
= coffsymbol(q_maybe
);
1223 This symbol has a linenumber, increment the owning
1224 section's linenumber count
1226 alent
*l
= q
->lineno
;
1227 q
->symbol
.section
->output_section
->lineno_count
++;
1229 while (l
->line_number
) {
1230 q
->symbol
.section
->output_section
->lineno_count
++;
1238 #endif /* NO_COFF_LINENOS */
1240 #ifndef NO_COFF_SYMBOLS
1243 Takes a bfd and a symbol, returns a pointer to the coff specific area
1244 of the symbol if there is one.
1246 static coff_symbol_type
*
1247 DEFUN(coff_symbol_from
,(ignore_abfd
, symbol
),
1248 bfd
*ignore_abfd AND
1251 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
1252 return (coff_symbol_type
*)NULL
;
1254 if (symbol
->the_bfd
->tdata
== (PTR
)NULL
)
1255 return (coff_symbol_type
*)NULL
;
1257 return (coff_symbol_type
*) symbol
;
1263 DEFUN(fixup_symbol_value
,(coff_symbol_ptr
, syment
),
1264 coff_symbol_type
*coff_symbol_ptr AND
1265 struct internal_syment
*syment
)
1268 /* Normalize the symbol flags */
1269 if (coff_symbol_ptr
->symbol
.flags
& BSF_FORT_COMM
) {
1270 /* a common symbol is undefined with a value */
1271 syment
->n_scnum
= N_UNDEF
;
1272 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1274 else if (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) {
1275 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1277 else if (coff_symbol_ptr
->symbol
.flags
& BSF_UNDEFINED
) {
1278 syment
->n_scnum
= N_UNDEF
;
1279 syment
->n_value
= 0;
1281 else if (coff_symbol_ptr
->symbol
.flags
& BSF_ABSOLUTE
) {
1282 syment
->n_scnum
= N_ABS
;
1283 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1286 if (coff_symbol_ptr
->symbol
.section
) {
1288 coff_symbol_ptr
->symbol
.section
->output_section
->index
+1;
1291 coff_symbol_ptr
->symbol
.value
+
1292 coff_symbol_ptr
->symbol
.section
->output_offset
+
1293 coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
1296 /* This can happen, but I don't know why yet (steve@cygnus.com) */
1297 syment
->n_scnum
= N_ABS
;
1298 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1303 /* run through all the symbols in the symbol table and work out what
1304 their indexes into the symbol table will be when output
1306 Coff requires that each C_FILE symbol points to the next one in the
1307 chain, and that the last one points to the first external symbol. We
1312 DEFUN(coff_renumber_symbols
,(bfd_ptr
),
1315 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1316 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1317 unsigned int native_index
= 0;
1318 struct internal_syment
*last_file
= (struct internal_syment
*)NULL
;
1319 unsigned int symbol_index
;
1320 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1322 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1323 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1324 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1327 if (s
->u
.syment
.n_sclass
== C_FILE
)
1329 if (last_file
!= (struct internal_syment
*)NULL
) {
1330 last_file
->n_value
= native_index
;
1332 last_file
= &(s
->u
.syment
);
1336 /* Modify the symbol values according to their section and
1339 fixup_symbol_value(coff_symbol_ptr
, &(s
->u
.syment
));
1341 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++) {
1342 s
[i
].offset
= native_index
++;
1353 Run thorough the symbol table again, and fix it so that all pointers to
1354 entries are changed to the entries' index in the output symbol table.
1358 DEFUN(coff_mangle_symbols
,(bfd_ptr
),
1361 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1362 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1363 unsigned int symbol_index
;
1365 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1367 coff_symbol_type
*coff_symbol_ptr
=
1368 coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1370 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1372 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1374 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++) {
1375 combined_entry_type
*a
= s
+ i
+ 1;
1377 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
1378 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
1381 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
1382 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
1390 static int string_size
;
1392 DEFUN(coff_fix_symbol_name
,(ignore_abfd
, symbol
, native
),
1393 bfd
*ignore_abfd AND
1395 combined_entry_type
*native
)
1397 unsigned int name_length
;
1398 union internal_auxent
*auxent
;
1399 char * name
= ( char *)(symbol
->name
);
1401 if (name
== (char *) NULL
) {
1402 /* coff symbols always have names, so we'll make one up */
1403 symbol
->name
= "strange";
1404 name
= (char *)symbol
->name
;
1406 name_length
= strlen(name
);
1408 if (native
->u
.syment
.n_sclass
== C_FILE
) {
1409 strncpy(native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
1410 auxent
= &(native
+1)->u
.auxent
;
1412 #ifdef COFF_LONG_FILENAMES
1413 if (name_length
<= FILNMLEN
) {
1414 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1417 auxent
->x_file
.x_n
.x_offset
= string_size
+ 4;
1418 auxent
->x_file
.x_n
.x_zeroes
= 0;
1419 string_size
+= name_length
+ 1;
1422 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1423 if (name_length
> FILNMLEN
) {
1424 name
[FILNMLEN
] = '\0';
1429 { /* NOT A C_FILE SYMBOL */
1430 if (name_length
<= SYMNMLEN
) {
1431 /* This name will fit into the symbol neatly */
1432 strncpy(native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
1435 native
->u
.syment
._n
._n_n
._n_offset
= string_size
+ 4;
1436 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1437 string_size
+= name_length
+ 1;
1445 DEFUN(coff_write_symbol
,(abfd
, symbol
, native
, written
),
1448 combined_entry_type
*native AND
1449 unsigned int written
)
1451 unsigned int numaux
= native
->u
.syment
.n_numaux
;
1452 int type
= native
->u
.syment
.n_type
;
1453 int class = native
->u
.syment
.n_sclass
;
1457 coff_fix_symbol_name(abfd
, symbol
, native
);
1458 coff_swap_sym_out(abfd
, &native
->u
.syment
, &buf
);
1459 bfd_write((PTR
)& buf
, 1, SYMESZ
, abfd
);
1460 for (j
= 0; j
!= native
->u
.syment
.n_numaux
; j
++)
1463 bzero((PTR
)&buf
, AUXESZ
);
1464 coff_swap_aux_out(abfd
,
1465 &( (native
+ j
+ 1)->u
.auxent
), type
, class, &buf1
);
1466 bfd_write((PTR
) (&buf1
), 1, AUXESZ
, abfd
);
1469 Reuse somewhere in the symbol to keep the index
1471 set_index(symbol
, written
);
1472 return written
+ 1 + numaux
;
1477 DEFUN(coff_write_alien_symbol
,(abfd
, symbol
, written
),
1480 unsigned int written
)
1483 This symbol has been created by the loader, or come from a non
1484 coff format. It has no native element to inherit, make our
1487 combined_entry_type
*native
;
1488 combined_entry_type dummy
;
1490 native
->u
.syment
.n_type
= T_NULL
;
1492 native
->u
.syment
.n_flags
= 0;
1494 if (symbol
->flags
& BSF_ABSOLUTE
) {
1495 native
->u
.syment
.n_scnum
= N_ABS
;
1496 native
->u
.syment
.n_value
= symbol
->value
;
1498 else if (symbol
->flags
& (BSF_UNDEFINED
| BSF_FORT_COMM
)) {
1499 native
->u
.syment
.n_scnum
= N_UNDEF
;
1500 native
->u
.syment
.n_value
= symbol
->value
;
1502 else if (symbol
->flags
& BSF_DEBUGGING
) {
1504 remove name so it doesn't take up any space
1509 native
->u
.syment
.n_scnum
= symbol
->section
->output_section
->index
+
1511 native
->u
.syment
.n_value
= symbol
->value
+
1512 symbol
->section
->output_section
->vma
+
1513 symbol
->section
->output_offset
;
1515 /* Copy the any flags from the the file hdr into the symbol */
1517 coff_symbol_type
*c
= coff_symbol_from(abfd
, symbol
);
1518 if (c
!= (coff_symbol_type
*)NULL
) {
1519 native
->u
.syment
.n_flags
= c
->symbol
.the_bfd
->flags
;
1526 native
->u
.syment
.pad1
[0] = 0;
1527 native
->u
.syment
.pad1
[0] = 0;
1530 native
->u
.syment
.n_type
= 0;
1531 if (symbol
->flags
& BSF_LOCAL
)
1532 native
->u
.syment
.n_sclass
= C_STAT
;
1534 native
->u
.syment
.n_sclass
= C_EXT
;
1535 native
->u
.syment
.n_numaux
= 0;
1537 return coff_write_symbol(abfd
, symbol
, native
, written
);
1541 DEFUN(coff_write_native_symbol
,(abfd
, symbol
, written
),
1543 coff_symbol_type
*symbol AND
1544 unsigned int written
)
1547 Does this symbol have an ascociated line number - if so then
1548 make it remember this symbol index. Also tag the auxent of
1549 this symbol to point to the right place in the lineno table
1551 combined_entry_type
*native
= symbol
->native
;
1553 alent
*lineno
= symbol
->lineno
;
1556 unsigned int count
= 0;
1557 lineno
[count
].u
.offset
= written
;
1558 if (native
->u
.syment
.n_numaux
) {
1559 union internal_auxent
*a
= &((native
+1)->u
.auxent
);
1561 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1562 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1565 And count and relocate all other linenumbers
1568 while (lineno
[count
].line_number
) {
1569 lineno
[count
].u
.offset
+=
1570 symbol
->symbol
.section
->output_section
->vma
+
1571 symbol
->symbol
.section
->output_offset
;
1574 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1577 return coff_write_symbol(abfd
, &( symbol
->symbol
), native
,written
);
1581 DEFUN(coff_write_symbols
,(abfd
),
1585 unsigned int limit
= bfd_get_symcount(abfd
);
1586 unsigned int written
= 0;
1593 /* Seek to the right place */
1594 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
1596 /* Output all the symbols we have */
1599 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1601 asymbol
*symbol
= *p
;
1602 coff_symbol_type
*c_symbol
= coff_symbol_from(abfd
, symbol
);
1604 if (c_symbol
== (coff_symbol_type
*) NULL
||
1605 c_symbol
->native
== (combined_entry_type
*)NULL
)
1607 written
= coff_write_alien_symbol(abfd
, symbol
, written
);
1611 written
= coff_write_native_symbol(abfd
, c_symbol
, written
);
1616 bfd_get_symcount(abfd
) = written
;
1618 /* Now write out strings */
1620 if (string_size
!= 0)
1622 unsigned int size
= string_size
+ 4;
1625 bfd_h_put_32(abfd
, size
, buffer
);
1626 bfd_write((PTR
) buffer
, 1, sizeof(buffer
), abfd
);
1627 for (p
= abfd
->outsymbols
, i
= 0;
1632 size_t name_length
= strlen(q
->name
);
1634 coff_symbol_type
* c_symbol
= coff_symbol_from(abfd
, q
);
1635 maxlen
= ((c_symbol
!= NULL
&& c_symbol
->native
!= NULL
) &&
1636 (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
)) ?
1637 FILNMLEN
: SYMNMLEN
;
1639 if (name_length
> maxlen
) {
1640 bfd_write((PTR
) (q
->name
), 1, name_length
+ 1, abfd
);
1645 /* We would normally not write anything here, but we'll write
1646 out 4 so that any stupid coff reader which tries to read
1647 the string table even when there isn't one won't croak.
1650 uint32e_type size
= 4;
1652 bfd_write((PTR
)&size
, 1, sizeof(size
), abfd
);
1662 To write relocations, all the back end does is step though the
1663 canonical relocation table, and create an
1664 @code{internal_reloc}. The symbol index to use is removed from
1665 the @code{offset} field in the symbol table supplied, the
1666 address comes directly from the sum of the section base
1667 address and the relocation offset and the type is dug directly
1668 from the howto field. Then the @code{internal_reloc} is
1669 swapped into the shape of an @code{external_reloc} and written
1675 DEFUN(coff_write_relocs
,(abfd
),
1679 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1681 struct external_reloc dst
;
1683 arelent
**p
= s
->orelocation
;
1684 bfd_seek(abfd
, s
->rel_filepos
, SEEK_SET
);
1685 for (i
= 0; i
< s
->reloc_count
; i
++) {
1686 struct internal_reloc n
;
1688 memset((PTR
)&n
, 0, sizeof(n
));
1689 n
.r_vaddr
= q
->address
+ s
->vma
;
1690 if (q
->sym_ptr_ptr
) {
1691 n
.r_symndx
= get_index((*(q
->sym_ptr_ptr
)));
1694 /* Work out reloc type from what is required */
1695 SELECT_RELOC(n
.r_type
, q
->howto
);
1697 n
.r_type
= q
->howto
->type
;
1699 coff_swap_reloc_out(abfd
, &n
, &dst
);
1700 bfd_write((PTR
) &n
, 1, RELSZ
, abfd
);
1704 #endif /* NO_COFF_SYMBOLS */
1706 #ifndef NO_COFF_LINENOS
1709 DEFUN(coff_write_linenumbers
,(abfd
),
1713 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1714 if (s
->lineno_count
) {
1715 asymbol
**q
= abfd
->outsymbols
;
1716 bfd_seek(abfd
, s
->line_filepos
, SEEK_SET
);
1717 /* Find all the linenumbers in this section */
1720 alent
*l
= BFD_SEND(p
->the_bfd
, _get_lineno
, (p
->the_bfd
, p
));
1722 /* Found a linenumber entry, output */
1723 struct internal_lineno out
;
1725 memset( (PTR
)&out
, 0, sizeof(out
));
1727 out
.l_addr
.l_symndx
= l
->u
.offset
;
1728 coff_swap_lineno_out(abfd
, &out
, &buff
);
1729 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1731 while (l
->line_number
) {
1732 out
.l_lnno
= l
->line_number
;
1733 out
.l_addr
.l_symndx
= l
->u
.offset
;
1734 coff_swap_lineno_out(abfd
, &out
, &buff
);
1735 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1746 DEFUN(coff_get_lineno
,(ignore_abfd
, symbol
),
1747 bfd
*ignore_abfd AND
1750 return coffsymbol(symbol
)->lineno
;
1753 #endif /* NO_COFF_LINENOS */
1756 coff_make_empty_symbol(abfd
)
1759 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc(abfd
, sizeof(coff_symbol_type
));
1761 bfd_error
= no_memory
;
1765 new->lineno
= (alent
*) NULL
;
1766 new->symbol
.the_bfd
= abfd
;
1767 return &new->symbol
;
1770 #ifndef NO_COFF_SYMBOLS
1773 DEFUN(coff_print_symbol
,(ignore_abfd
, filep
, symbol
, how
),
1774 bfd
*ignore_abfd AND
1777 bfd_print_symbol_type how
)
1779 FILE *file
= (FILE *)filep
;
1781 case bfd_print_symbol_name
:
1782 fprintf(file
, "%s", symbol
->name
);
1784 case bfd_print_symbol_more
:
1785 fprintf(file
, "coff %lx %lx", (unsigned long) coffsymbol(symbol
)->native
,
1786 (unsigned long) coffsymbol(symbol
)->lineno
);
1788 case bfd_print_symbol_nm
:
1791 CONST
char *section_name
= symbol
->section
== (asection
*) NULL
?
1792 "*abs" : symbol
->section
->name
;
1793 bfd_print_symbol_vandf((PTR
) file
, symbol
);
1796 fprintf(file
, " %-5s %s %s %s",
1798 coffsymbol(symbol
)->native
? "n" : "g",
1799 coffsymbol(symbol
)->lineno
? "l" : " ",
1805 case bfd_print_symbol_all
:
1806 /* Print out the symbols in a reasonable way */
1808 CONST
char *section_name
= symbol
->section
== (asection
*) NULL
?
1809 "*abs" : symbol
->section
->name
;
1812 if (coffsymbol(symbol
)->native
)
1815 combined_entry_type
*combined
= coffsymbol(symbol
)->native
;
1816 combined_entry_type
*root
= obj_raw_syments(ignore_abfd
);
1818 fprintf(file
,"[%3d]",
1822 fprintf(file
, "(sc %2d)(fl%4x)(ty%3x)(sc%3d) nx(%d) %08x %s",
1823 combined
->u
.syment
.n_scnum
,
1824 combined
->u
.syment
.n_flags
,
1825 combined
->u
.syment
.n_type
,
1826 combined
->u
.syment
.n_sclass
,
1827 combined
->u
.syment
.n_numaux
,
1828 combined
->u
.syment
.n_value
,
1831 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
1834 switch (combined
->u
.syment
.n_sclass
) {
1836 fprintf(file
, "File ");
1839 fprintf(file
, "AUX tv %x lnno %x size %x",
1840 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
1841 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
);
1854 bfd_print_symbol_vandf((PTR
) file
, symbol
);
1855 fprintf(file
, " %-5s %s %s %s",
1857 coffsymbol(symbol
)->native
? "n" : "g",
1858 coffsymbol(symbol
)->lineno
? "l" : " ",
1867 #endif /* NO_COFF_SYMBOLS */
1869 /* Set flags and magic number of a coff file from architecture and machine
1870 type. Result is true if we can represent the arch&type, false if not. */
1873 DEFUN(coff_set_flags
,(abfd
, magicp
, flagsp
),
1875 unsigned *magicp AND
1876 unsigned short *flagsp
)
1878 switch (bfd_get_arch(abfd
)) {
1886 *magicp
= I960ROMAGIC
;
1888 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1889 I960RWMAGIC); FIXME???
1891 switch (bfd_get_mach(abfd
)) {
1892 case bfd_mach_i960_core
:
1895 case bfd_mach_i960_kb_sb
:
1898 case bfd_mach_i960_mc
:
1901 case bfd_mach_i960_xa
:
1904 case bfd_mach_i960_ca
:
1907 case bfd_mach_i960_ka_sa
:
1920 *magicp
= MIPS_MAGIC_2
;
1926 *magicp
= I386MAGIC
;
1931 *magicp
= MC68MAGIC
;
1937 *magicp
= MC88OMAGIC
;
1942 case bfd_arch_h8300
:
1943 *magicp
= H8300MAGIC
;
1947 #ifdef A29K_MAGIC_BIG
1949 if (abfd
->xvec
->byteorder_big_p
)
1950 *magicp
= A29K_MAGIC_BIG
;
1952 *magicp
= A29K_MAGIC_LITTLE
;
1958 case bfd_arch_rs6000
:
1959 *magicp
= U802TOCMAGIC
;
1963 default: /* Unknown architecture */
1964 /* return false; -- fall through to "return false" below, to avoid
1965 "statement never reached" errors on the one below. */
1974 DEFUN(coff_set_arch_mach
,(abfd
, arch
, machine
),
1976 enum bfd_architecture arch AND
1977 unsigned long machine
)
1980 unsigned short dummy2
;
1981 bfd_default_set_arch_mach(abfd
, arch
, machine
);
1983 if (arch
!= bfd_arch_unknown
&&
1984 coff_set_flags(abfd
, &dummy1
, &dummy2
) != true)
1985 return false; /* We can't represent this type */
1986 return true; /* We're easy ... */
1990 /* Calculate the file position for each section. */
1993 DEFUN(coff_compute_section_file_positions
,(abfd
),
1997 asection
*previous
= (asection
*)NULL
;
1998 file_ptr sofar
= FILHSZ
;
2000 if (bfd_get_start_address(abfd
))
2002 /* A start address may have been added to the original file. In this
2003 case it will need an optional header to record it. */
2004 abfd
->flags
|= EXEC_P
;
2007 if (abfd
->flags
& EXEC_P
)
2010 sofar
+= abfd
->section_count
* SCNHSZ
;
2011 for (current
= abfd
->sections
;
2012 current
!= (asection
*)NULL
;
2013 current
= current
->next
) {
2015 /* Only deal with sections which have contents */
2016 if (!(current
->flags
& SEC_HAS_CONTENTS
))
2019 /* Align the sections in the file to the same boundary on
2020 which they are aligned in virtual memory. I960 doesn't
2021 do this (FIXME) so we can stay in sync with Intel. 960
2022 doesn't yet page from files... */
2025 /* make sure this section is aligned on the right boundary - by
2026 padding the previous section up if necessary */
2029 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2030 if (previous
!= (asection
*)NULL
) {
2031 previous
->size
+= sofar
- old_sofar
;
2036 /* FIXME, in demand paged files, the low order bits of the file
2037 offset must match the low order bits of the virtual address.
2038 "Low order" is apparently implementation defined. Add code
2039 here to round sofar up to match the virtual address. */
2041 current
->filepos
= sofar
;
2043 /* make sure that this section is of the right size too */
2044 old_sofar
= sofar
+= current
->size
;
2045 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2046 current
->size
+= sofar
- old_sofar
;
2050 obj_relocbase(abfd
) = sofar
;
2059 DEFUN(coff_write_object_contents
,(abfd
),
2063 boolean hasrelocs
= false;
2064 boolean haslinno
= false;
2065 file_ptr reloc_base
;
2066 file_ptr lineno_base
;
2070 unsigned long reloc_size
= 0;
2071 unsigned long lnno_size
= 0;
2072 asection
*text_sec
= NULL
;
2073 asection
*data_sec
= NULL
;
2074 asection
*bss_sec
= NULL
;
2076 struct internal_filehdr internal_f
;
2077 struct internal_aouthdr internal_a
;
2080 bfd_error
= system_call_error
;
2083 if(abfd
->output_has_begun
== false) {
2084 coff_compute_section_file_positions(abfd
);
2087 if (abfd
->sections
!= (asection
*)NULL
) {
2088 scn_base
= abfd
->sections
->filepos
;
2093 if (bfd_seek(abfd
, scn_base
, SEEK_SET
) != 0)
2095 reloc_base
= obj_relocbase(abfd
);
2097 /* Make a pass through the symbol table to count line number entries and
2098 put them into the correct asections */
2100 #ifndef NO_COFF_LINENOS
2101 coff_count_linenumbers(abfd
);
2103 data_base
= scn_base
;
2105 /* Work out the size of the reloc and linno areas */
2107 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
) {
2108 reloc_size
+= current
->reloc_count
* RELSZ
;
2109 #ifndef NO_COFF_LINENOS
2110 lnno_size
+= current
->lineno_count
* LINESZ
;
2112 data_base
+= SCNHSZ
;
2115 lineno_base
= reloc_base
+ reloc_size
;
2116 sym_base
= lineno_base
+ lnno_size
;
2118 /* Indicate in each section->line_filepos its actual file address */
2119 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
) {
2120 if (current
->lineno_count
) {
2121 current
->line_filepos
= lineno_base
;
2122 current
->moving_line_filepos
= lineno_base
;
2123 #ifndef NO_COFF_LINENOS
2124 lineno_base
+= current
->lineno_count
* LINESZ
;
2128 current
->line_filepos
= 0;
2130 if (current
->reloc_count
) {
2131 current
->rel_filepos
= reloc_base
;
2132 reloc_base
+= current
->reloc_count
* sizeof(struct internal_reloc
);
2135 current
->rel_filepos
= 0;
2139 /* Write section headers to the file. */
2142 (file_ptr
) ((abfd
->flags
& EXEC_P
) ?
2143 (FILHSZ
+ AOUTSZ
) : FILHSZ
),
2148 unsigned int pad
= abfd
->flags
& D_PAGED
? data_base
: 0;
2150 unsigned int pad
= 0;
2152 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
) {
2153 struct internal_scnhdr section
;
2154 strncpy(&(section
.s_name
[0]), current
->name
, 8);
2155 section
.s_vaddr
= current
->vma
+ pad
;
2156 section
.s_paddr
= current
->vma
+ pad
;
2157 section
.s_size
= current
->size
- pad
;
2159 If this section has no size or is unloadable then the scnptr
2162 if (current
->size
- pad
== 0 ||
2163 (current
->flags
& SEC_LOAD
) == 0) {
2164 section
.s_scnptr
= 0;
2167 section
.s_scnptr
= current
->filepos
;
2169 section
.s_relptr
= current
->rel_filepos
;
2170 section
.s_lnnoptr
= current
->line_filepos
;
2171 section
.s_nreloc
= current
->reloc_count
;
2172 section
.s_nlnno
= current
->lineno_count
;
2173 if (current
->reloc_count
!= 0)
2175 if (current
->lineno_count
!= 0)
2178 section
.s_flags
= sec_to_styp_flags(current
->name
,current
->flags
);
2180 if (!strcmp(current
->name
, _TEXT
)) {
2182 } else if (!strcmp(current
->name
, _DATA
)) {
2184 } else if (!strcmp(current
->name
, _BSS
)) {
2189 section
.s_align
= (current
->alignment_power
2190 ? 1 << current
->alignment_power
2197 coff_swap_scnhdr_out(abfd
, §ion
, &buff
);
2198 bfd_write((PTR
) (&buff
), 1, SCNHSZ
, abfd
);
2205 /* OK, now set up the filehdr... */
2206 internal_f
.f_nscns
= abfd
->section_count
;
2208 We will NOT put a fucking timestamp in the header here. Every time you
2209 put it back, I will come in and take it out again. I'm sorry. This
2210 field does not belong here. We fill it with a 0 so it compares the
2211 same but is not a reasonable time. -- gnu@cygnus.com
2214 Well, I like it, so I'm conditionally compiling it in.
2217 #ifdef COFF_TIMESTAMP
2218 internal_f
.f_timdat
= time(0);
2220 internal_f
.f_timdat
= 0;
2223 if (bfd_get_symcount(abfd
) != 0)
2224 internal_f
.f_symptr
= sym_base
;
2226 internal_f
.f_symptr
= 0;
2228 internal_f
.f_flags
= 0;
2230 if (abfd
->flags
& EXEC_P
)
2231 internal_f
.f_opthdr
= AOUTSZ
;
2233 internal_f
.f_opthdr
= 0;
2236 internal_f
.f_flags
|= F_RELFLG
;
2238 internal_f
.f_flags
|= F_LNNO
;
2239 if (0 == bfd_get_symcount(abfd
))
2240 internal_f
.f_flags
|= F_LSYMS
;
2241 if (abfd
->flags
& EXEC_P
)
2242 internal_f
.f_flags
|= F_EXEC
;
2244 internal_f
.f_flags
|= F_AR32W
;
2246 if (!abfd
->xvec
->byteorder_big_p
)
2247 internal_f
.f_flags
|= F_AR32WR
;
2250 FIXME, should do something about the other byte orders and
2254 /* Set up architecture-dependent stuff */
2256 { unsigned int magic
= 0;
2257 unsigned short flags
= 0;
2258 coff_set_flags(abfd
, &magic
, &flags
);
2259 internal_f
.f_magic
= magic
;
2260 internal_f
.f_flags
|= flags
;
2261 /* ...and the "opt"hdr... */
2264 # ifdef ULTRA3 /* NYU's machine */
2265 /* FIXME: This is a bogus check. I really want to see if there
2266 * is a .shbss or a .shdata section, if so then set the magic
2267 * number to indicate a shared data executable.
2269 if (internal_f
.f_nscns
>= 7)
2270 internal_a
.magic
= SHMAGIC
; /* Shared magic */
2272 # endif /* ULTRA3 */
2273 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
2274 #define __A_MAGIC_SET__
2277 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
2278 #define __A_MAGIC_SET__
2281 #define __A_MAGIC_SET__
2282 internal_a
.magic
= PAGEMAGICBCS
;
2285 #if M68 || I386 || MIPS
2286 #define __A_MAGIC_SET__
2287 /* Never was anything here for the 68k */
2291 #define __A_MAGIC_SET__
2292 internal_a
.magic
= (abfd
->flags
& D_PAGED
)? RS6K_AOUTHDR_ZMAGIC
:
2293 (abfd
->flags
& WP_TEXT
)? RS6K_AOUTHDR_NMAGIC
:
2294 RS6K_AOUTHDR_OMAGIC
;
2297 #ifndef __A_MAGIC_SET__
2298 # include "Your aouthdr magic number is not being set!"
2300 # undef __A_MAGIC_SET__
2303 /* Now should write relocs, strings, syms */
2304 obj_sym_filepos(abfd
) = sym_base
;
2306 #ifndef NO_COFF_SYMBOLS
2307 if (bfd_get_symcount(abfd
) != 0) {
2308 coff_renumber_symbols(abfd
);
2309 coff_mangle_symbols(abfd
);
2310 coff_write_symbols(abfd
);
2311 coff_write_linenumbers(abfd
);
2312 coff_write_relocs(abfd
);
2314 #endif /* NO_COFF_SYMBOLS */
2316 internal_a
.tsize
= text_sec
->size
;
2317 internal_a
.text_start
=text_sec
->size
? text_sec
->vma
: 0;
2320 internal_a
.dsize
= data_sec
->size
;
2321 internal_a
.data_start
= data_sec
->size
? data_sec
->vma
: 0;
2324 internal_a
.bsize
= bss_sec
->size
;
2327 internal_a
.entry
= bfd_get_start_address(abfd
);
2328 internal_f
.f_nsyms
= bfd_get_symcount(abfd
);
2330 /* now write them */
2331 if (bfd_seek(abfd
, 0L, SEEK_SET
) != 0)
2335 coff_swap_filehdr_out(abfd
, &internal_f
, &buff
);
2336 bfd_write((PTR
) &buff
, 1, FILHSZ
, abfd
);
2338 if (abfd
->flags
& EXEC_P
) {
2340 coff_swap_aouthdr_out(abfd
, &internal_a
, &buff
);
2341 bfd_write((PTR
) &buff
, 1, AOUTSZ
, abfd
);
2346 #ifndef NO_COFF_SYMBOLS
2349 this function transforms the offsets into the symbol table into
2350 pointers to syments.
2355 DEFUN(coff_pointerize_aux
,(ignore_abfd
, table_base
, type
, class, auxent
),
2356 bfd
*ignore_abfd AND
2357 combined_entry_type
*table_base AND
2360 combined_entry_type
*auxent
)
2362 /* Don't bother if this is a file or a section */
2363 if (class == C_STAT
&& type
== T_NULL
) return;
2364 if (class == C_FILE
) return;
2366 /* Otherwise patch up */
2367 if (ISFCN(type
) || ISTAG(class) || class == C_BLOCK
) {
2368 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
= table_base
+
2369 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2370 auxent
->fix_end
= 1;
2372 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
!= 0) {
2373 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
= table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
2374 auxent
->fix_tag
= 1;
2378 #endif /* NO_COFF_SYMBOLS */
2381 DEFUN(coff_set_section_contents
,(abfd
, section
, location
, offset
, count
),
2386 bfd_size_type count
)
2388 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
2389 coff_compute_section_file_positions(abfd
);
2391 bfd_seek(abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
);
2394 return (bfd_write(location
, 1, count
, abfd
) == count
) ? true : false;
2400 coff_close_and_cleanup(abfd
)
2403 if (!bfd_read_p(abfd
))
2404 switch (abfd
->format
) {
2406 if (!_bfd_write_archive_contents(abfd
))
2410 if (!coff_write_object_contents(abfd
))
2414 bfd_error
= invalid_operation
;
2418 /* We depend on bfd_close to free all the memory on the obstack. */
2419 /* FIXME if bfd_release is not using obstacks! */
2425 buy_and_read(abfd
, where
, seek_direction
, size
)
2431 PTR area
= (PTR
) bfd_alloc(abfd
, size
);
2433 bfd_error
= no_memory
;
2436 bfd_seek(abfd
, where
, seek_direction
);
2437 if (bfd_read(area
, 1, size
, abfd
) != size
) {
2438 bfd_error
= system_call_error
;
2442 } /* buy_and_read() */
2445 #ifndef NO_COFF_SYMBOLS
2448 DEFUN(build_string_table
,(abfd
),
2451 char string_table_size_buffer
[4];
2452 unsigned int string_table_size
;
2455 /* At this point we should be "seek"'d to the end of the
2456 symbols === the symbol table size. */
2457 if (bfd_read((char *) string_table_size_buffer
,
2458 sizeof(string_table_size_buffer
),
2459 1, abfd
) != sizeof(string_table_size
)) {
2460 bfd_error
= system_call_error
;
2464 string_table_size
= bfd_h_get_32(abfd
, (bfd_byte
*) string_table_size_buffer
);
2466 if ((string_table
= (PTR
) bfd_alloc(abfd
, string_table_size
-= 4)) == NULL
) {
2467 bfd_error
= no_memory
;
2469 } /* on mallocation error */
2470 if (bfd_read(string_table
, string_table_size
, 1, abfd
) != string_table_size
) {
2471 bfd_error
= system_call_error
;
2474 return string_table
;
2477 /* Allocate space for the ".debug" section, and read it.
2478 We did not read the debug section until now, because
2479 we didn't want to go to the trouble until someone needed it. */
2482 DEFUN(build_debug_section
,(abfd
),
2485 char *debug_section
;
2488 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
2491 bfd_error
= no_debug_section
;
2495 debug_section
= (PTR
) bfd_alloc (abfd
, bfd_section_size (abfd
, sect
));
2496 if (debug_section
== NULL
) {
2497 bfd_error
= no_memory
;
2501 /* Seek to the beginning of the `.debug' section and read it.
2502 Save the current position first; it is needed by our caller.
2503 Then read debug section and reset the file pointer. */
2505 position
= bfd_tell (abfd
);
2506 bfd_seek (abfd
, sect
->filepos
, SEEK_SET
);
2507 if (bfd_read (debug_section
, bfd_section_size (abfd
, sect
), 1, abfd
)
2508 != bfd_section_size (abfd
, sect
)) {
2509 bfd_error
= system_call_error
;
2512 bfd_seek (abfd
, position
, SEEK_SET
);
2513 return debug_section
;
2517 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
2518 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
2519 be \0-terminated. */
2521 DEFUN(copy_name
,(abfd
, name
, maxlen
),
2529 for (len
= 0; len
< maxlen
; ++len
) {
2530 if (name
[len
] == '\0') {
2535 if ((newname
= (PTR
) bfd_alloc(abfd
, len
+1)) == NULL
) {
2536 bfd_error
= no_memory
;
2539 strncpy(newname
, name
, len
);
2540 newname
[len
] = '\0';
2545 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
2546 knit the symbol names into a normalized form. By normalized here I
2547 mean that all symbols have an n_offset pointer that points to a null-
2548 terminated string. */
2550 #ifndef SYMNAME_IN_DEBUG
2551 #define SYMNAME_IN_DEBUG(x) 0
2554 static combined_entry_type
*
2555 DEFUN(get_normalized_symtab
,(abfd
),
2558 combined_entry_type
*internal
;
2559 combined_entry_type
*internal_ptr
;
2560 combined_entry_type
*internal_end
;
2564 char *string_table
= NULL
;
2565 char *debug_section
= NULL
;
2568 unsigned int raw_size
;
2569 if (obj_raw_syments(abfd
) != (combined_entry_type
*)NULL
) {
2570 return obj_raw_syments(abfd
);
2572 if ((size
= bfd_get_symcount(abfd
) * sizeof(combined_entry_type
)) == 0) {
2573 bfd_error
= no_symbols
;
2577 internal
= (combined_entry_type
*)bfd_alloc(abfd
, size
);
2578 internal_end
= internal
+ bfd_get_symcount(abfd
);
2580 raw_size
= bfd_get_symcount(abfd
) * SYMESZ
;
2581 raw
= (SYMENT
*)bfd_alloc(abfd
,raw_size
);
2583 if (bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
) == -1
2584 || bfd_read((PTR
)raw
, raw_size
, 1, abfd
) != raw_size
) {
2585 bfd_error
= system_call_error
;
2588 /* mark the end of the symbols */
2589 raw_end
= raw
+ bfd_get_symcount(abfd
);
2591 FIXME SOMEDAY. A string table size of zero is very weird, but
2592 probably possible. If one shows up, it will probably kill us.
2595 /* Swap all the raw entries */
2596 for (raw_src
= raw
, internal_ptr
= internal
;
2598 raw_src
++, internal_ptr
++) {
2601 coff_swap_sym_in(abfd
, (char *)raw_src
, (char *)&internal_ptr
->u
.syment
);
2602 internal_ptr
->fix_tag
= 0;
2603 internal_ptr
->fix_end
= 0;
2605 for (i
= internal_ptr
->u
.syment
.n_numaux
;
2607 --i
, raw_src
++, internal_ptr
++) {
2609 (internal_ptr
+1)->fix_tag
= 0;
2610 (internal_ptr
+1)->fix_end
= 0;
2612 coff_swap_aux_in(abfd
, (char *)(raw_src
+1),
2613 internal_ptr
->u
.syment
.n_type
,
2614 internal_ptr
->u
.syment
.n_sclass
,
2615 &(internal_ptr
+1)->u
.auxent
);
2617 coff_pointerize_aux(abfd
,
2619 internal_ptr
->u
.syment
.n_type
,
2620 internal_ptr
->u
.syment
.n_sclass
,
2625 /* Free all the raw stuff */
2626 bfd_release(abfd
, raw
);
2628 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
2631 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
) {
2632 /* make a file symbol point to the name in the auxent, since
2633 the text ".file" is redundant */
2634 if ((internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_zeroes
== 0) {
2635 /* the filename is a long one, point into the string table */
2636 if (string_table
== NULL
) {
2637 string_table
= build_string_table(abfd
);
2640 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
2641 (int) (string_table
- 4 +
2642 (internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_offset
);
2645 /* ordinary short filename, put into memory anyway */
2646 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2647 copy_name(abfd
, (internal_ptr
+1)->u
.auxent
.x_file
.x_fname
,
2652 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0) {
2653 /* This is a "short" name. Make it long. */
2654 unsigned long i
= 0;
2655 char *newstring
= NULL
;
2657 /* find the length of this string without walking into memory
2659 for (i
= 0; i
< 8; ++i
) {
2660 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0') {
2662 } /* if end of string */
2663 } /* possible lengths of this string. */
2665 if ((newstring
= (PTR
) bfd_alloc(abfd
, ++i
)) == NULL
) {
2666 bfd_error
= no_memory
;
2669 bzero(newstring
, i
);
2670 strncpy(newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
-1);
2671 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int) newstring
;
2672 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
2674 else if (!SYMNAME_IN_DEBUG(&internal_ptr
->u
.syment
)) {
2675 /* Long name already. Point symbol at the string in the table. */
2676 if (string_table
== NULL
) {
2677 string_table
= build_string_table(abfd
);
2679 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2680 (string_table
- 4 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
2683 /* Long name in debug section. Very similar. */
2684 if (debug_section
== NULL
) {
2685 debug_section
= build_debug_section(abfd
);
2687 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2688 (debug_section
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
2691 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
2694 obj_raw_syments(abfd
) = internal
;
2697 } /* get_normalized_symtab() */
2699 #endif /* NO_COFF_SYMBOLS */
2703 DEFUN(section_from_bfd_index
,(abfd
, index
),
2708 struct sec
*answer
= abfd
->sections
;
2710 answer
= answer
->next
;
2717 #ifndef NO_COFF_LINENOS
2724 Creating the linenumber table is done by reading in the entire
2725 coff linenumber table, and creating another table for internal use.
2727 A coff line number table is structured so that each function
2728 is marked as having a line number of 0. Each line within the
2729 function is an offset from the first line in the function. The
2730 base of the line number information for the table is stored in
2731 the symbol associated with the function.
2733 The information is copied from the external to the internal
2734 table, and each symbol which marks a function is marked by
2737 How does this work ?
2742 coff_slurp_line_table(abfd
, asect
)
2746 LINENO
*native_lineno
;
2747 alent
*lineno_cache
;
2749 BFD_ASSERT(asect
->lineno
== (alent
*) NULL
);
2751 native_lineno
= (LINENO
*) buy_and_read(abfd
,
2752 asect
->line_filepos
,
2755 asect
->lineno_count
));
2757 (alent
*) bfd_alloc(abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof(alent
)));
2758 if (lineno_cache
== NULL
) {
2759 bfd_error
= no_memory
;
2762 unsigned int counter
= 0;
2763 alent
*cache_ptr
= lineno_cache
;
2764 LINENO
*src
= native_lineno
;
2766 while (counter
< asect
->lineno_count
) {
2767 struct internal_lineno dst
;
2768 coff_swap_lineno_in(abfd
, src
, &dst
);
2769 cache_ptr
->line_number
= dst
.l_lnno
;
2771 if (cache_ptr
->line_number
== 0) {
2772 coff_symbol_type
*sym
=
2773 (coff_symbol_type
*) (dst
.l_addr
.l_symndx
2774 + obj_raw_syments(abfd
))->u
.syment
._n
._n_n
._n_zeroes
;
2775 cache_ptr
->u
.sym
= (asymbol
*) sym
;
2776 sym
->lineno
= cache_ptr
;
2779 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
2780 - bfd_section_vma(abfd
, asect
);
2781 } /* If no linenumber expect a symbol index */
2787 cache_ptr
->line_number
= 0;
2790 asect
->lineno
= lineno_cache
;
2791 /* FIXME, free native_lineno here, or use alloca or something. */
2793 } /* coff_slurp_line_table() */
2795 #endif /* NO_COFF_LINENOS */
2797 #ifndef NO_COFF_LINENOS
2800 DEFUN(coff_slurp_symbol_table
,(abfd
),
2803 combined_entry_type
*native_symbols
;
2804 coff_symbol_type
*cached_area
;
2805 unsigned int *table_ptr
;
2807 unsigned int number_of_symbols
= 0;
2808 if (obj_symbols(abfd
))
2810 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
2812 /* Read in the symbol table */
2813 if ((native_symbols
= get_normalized_symtab(abfd
)) == NULL
) {
2817 /* Allocate enough room for all the symbols in cached form */
2819 (coff_symbol_type
*)
2820 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(coff_symbol_type
)));
2822 if (cached_area
== NULL
) {
2823 bfd_error
= no_memory
;
2828 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(unsigned int)));
2830 if (table_ptr
== NULL
) {
2831 bfd_error
= no_memory
;
2836 coff_symbol_type
*dst
= cached_area
;
2837 unsigned int last_native_index
= bfd_get_symcount(abfd
);
2838 unsigned int this_index
= 0;
2839 while (this_index
< last_native_index
) {
2840 combined_entry_type
*src
= native_symbols
+ this_index
;
2841 table_ptr
[this_index
] = number_of_symbols
;
2842 dst
->symbol
.the_bfd
= abfd
;
2844 dst
->symbol
.name
= (char *)(src
->u
.syment
._n
._n_n
._n_offset
);
2846 We use the native name field to point to the cached field
2848 src
->u
.syment
._n
._n_n
._n_zeroes
= (int) dst
;
2849 dst
->symbol
.section
= section_from_bfd_index(abfd
,
2850 src
->u
.syment
.n_scnum
);
2851 switch (src
->u
.syment
.n_sclass
) {
2855 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
2856 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2857 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
2859 /* Fall through to next case */
2867 if ((src
->u
.syment
.n_scnum
) == 0) {
2868 if ((src
->u
.syment
.n_value
) == 0) {
2869 dst
->symbol
.flags
= BSF_UNDEFINED
;
2870 dst
->symbol
.value
= 0;
2873 dst
->symbol
.flags
= BSF_FORT_COMM
;
2874 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2879 Base the value as an index from the base of the
2882 if (dst
->symbol
.section
== (asection
*) NULL
) {
2883 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
| BSF_ABSOLUTE
;
2884 dst
->symbol
.value
= src
->u
.syment
.n_value
;
2887 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2888 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
2890 if (ISFCN((src
->u
.syment
.n_type
))) {
2892 A function ext does not go at the end of a file
2894 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
2901 case C_STAT
: /* static */
2903 case C_LEAFSTAT
: /* static leaf procedure */
2905 case C_LABEL
: /* label */
2906 if (src
->u
.syment
.n_scnum
== -2)
2907 dst
->symbol
.flags
= BSF_DEBUGGING
;
2909 dst
->symbol
.flags
= BSF_LOCAL
;
2911 Base the value as an index from the base of the section, if
2914 if (dst
->symbol
.section
)
2915 dst
->symbol
.value
= (src
->u
.syment
.n_value
) -
2916 dst
->symbol
.section
->vma
;
2918 dst
->symbol
.value
= (src
->u
.syment
.n_value
) ;
2921 case C_MOS
: /* member of structure */
2922 case C_EOS
: /* end of structure */
2923 #ifdef NOTDEF /* C_AUTOARG has the same value */
2925 case C_GLBLREG
: /* A29k-specific storage class */
2928 case C_REGPARM
: /* register parameter */
2929 case C_REG
: /* register variable */
2931 case C_AUTOARG
: /* 960-specific storage class */
2933 case C_TPDEF
: /* type definition */
2935 case C_AUTO
: /* automatic variable */
2936 case C_FIELD
: /* bit field */
2937 case C_ENTAG
: /* enumeration tag */
2938 case C_MOE
: /* member of enumeration */
2939 case C_MOU
: /* member of union */
2940 case C_UNTAG
: /* union tag */
2941 dst
->symbol
.flags
= BSF_DEBUGGING
;
2942 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2945 case C_FILE
: /* file name */
2946 case C_STRTAG
: /* structure tag */
2948 case C_BINCL
: /* beginning of include file */
2949 case C_EINCL
: /* ending of include file */
2962 dst
->symbol
.flags
= BSF_DEBUGGING
;
2963 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2966 case C_BLOCK
: /* ".bb" or ".eb" */
2967 case C_FCN
: /* ".bf" or ".ef" */
2968 case C_EFCN
: /* physical end of function */
2969 dst
->symbol
.flags
= BSF_LOCAL
;
2971 Base the value as an index from the base of the section
2973 dst
->symbol
.value
= (src
->u
.syment
.n_value
) - dst
->symbol
.section
->vma
;
2977 case C_EXTDEF
: /* external definition */
2978 case C_ULABEL
: /* undefined label */
2979 case C_USTATIC
: /* undefined static */
2980 case C_LINE
: /* line # reformatted as symbol table entry */
2981 case C_ALIAS
: /* duplicate tag */
2982 case C_HIDDEN
: /* ext symbol in dmert public lib */
2985 fprintf(stderr
,"Unrecognized storage class %d\n",
2986 src
->u
.syment
.n_sclass
);
2988 dst
->symbol
.flags
= BSF_DEBUGGING
;
2989 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2993 BFD_ASSERT(dst
->symbol
.flags
!= 0);
2997 dst
->symbol
.udata
= 0;
2998 dst
->lineno
= (alent
*) NULL
;
2999 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
3001 number_of_symbols
++;
3002 } /* walk the native symtab */
3003 } /* bfdize the native symtab */
3005 obj_symbols(abfd
) = cached_area
;
3006 obj_raw_syments(abfd
) = native_symbols
;
3008 bfd_get_symcount(abfd
) = number_of_symbols
;
3009 obj_convert(abfd
) = table_ptr
;
3010 /* Slurp the line tables for each section too */
3015 coff_slurp_line_table(abfd
, p
);
3020 } /* coff_slurp_symbol_table() */
3023 coff_get_symtab_upper_bound(abfd
)
3026 if (!coff_slurp_symbol_table(abfd
))
3029 return (bfd_get_symcount(abfd
) + 1) * (sizeof(coff_symbol_type
*));
3034 DEFUN(coff_get_symtab
, (abfd
, alocation
),
3036 asymbol
**alocation
)
3038 unsigned int counter
= 0;
3039 coff_symbol_type
*symbase
;
3040 coff_symbol_type
**location
= (coff_symbol_type
**) (alocation
);
3041 if (!coff_slurp_symbol_table(abfd
))
3044 symbase
= obj_symbols(abfd
);
3045 while (counter
< bfd_get_symcount(abfd
))
3047 /* This nasty code looks at the symbol to decide whether or
3048 not it is descibes a constructor/destructor entry point. It
3049 is structured this way to (hopefully) speed non matches */
3051 if (0 && symbase
->symbol
.name
[9] == '$')
3053 bfd_constructor_entry(abfd
,
3054 (asymbol
**)location
,
3055 symbase
->symbol
.name
[10] == 'I' ?
3059 *(location
++) = symbase
++;
3063 return bfd_get_symcount(abfd
);
3066 #endif /* NO_COFF_SYMBOLS */
3069 coff_get_reloc_upper_bound(abfd
, asect
)
3073 if (bfd_get_format(abfd
) != bfd_object
) {
3074 bfd_error
= invalid_operation
;
3077 return (asect
->reloc_count
+ 1) * sizeof(arelent
*);
3085 Coff relocations are easily transformed into the internal BFD form
3088 Reading a coff relocation table is done in the following stages:
3090 o The entire coff relocation table is read into memory.
3092 o Each relocation is processed in turn, first it is swapped from the
3093 external to the internal form.
3095 o The symbol referenced in the relocation's symbol index is
3096 turned intoa pointer into the canonical symbol table. Note
3097 that this table is the same as the one returned by a call to
3098 @code{bfd_canonicalize_symtab}. The back end will call the
3099 routine and save the result if a canonicalization hasn't been done.
3101 o The reloc index is turned into a pointer to a howto
3102 structure, in a back end specific way. For instance, the 386
3103 and 960 use the @code{r_type} to directly produce an index
3104 into a howto table vector; the 88k subtracts a number from the
3105 @code{r_type} field and creates an addend field.
3111 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
3112 if (ptr && ptr->the_bfd == abfd \
3113 && ptr->section != (asection *) NULL \
3114 && ((ptr->flags & BSF_OLD_COMMON)== 0)) \
3116 cache_ptr->addend = -(ptr->section->vma + ptr->value); \
3119 cache_ptr->addend = 0; \
3124 DEFUN(coff_slurp_reloc_table
,(abfd
, asect
, symbols
),
3129 RELOC
*native_relocs
;
3130 arelent
*reloc_cache
;
3135 if (asect
->relocation
)
3137 if (asect
->reloc_count
== 0)
3139 if (asect
->flags
& SEC_CONSTRUCTOR
)
3141 #ifndef NO_COFF_SYMBOLS
3142 if (!coff_slurp_symbol_table(abfd
))
3146 (RELOC
*) buy_and_read(abfd
,
3150 asect
->reloc_count
));
3151 reloc_cache
= (arelent
*)
3152 bfd_alloc(abfd
, (size_t) (asect
->reloc_count
* sizeof(arelent
)));
3154 if (reloc_cache
== NULL
) {
3155 bfd_error
= no_memory
;
3160 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
3162 struct internal_reloc dst
;
3164 struct external_reloc
*src
;
3166 cache_ptr
= reloc_cache
+ idx
;
3167 src
= native_relocs
+ idx
;
3169 bfd_swap_reloc_in(abfd
, src
, &dst
);
3172 #ifdef RELOC_PROCESSING
3173 RELOC_PROCESSING(cache_ptr
, &dst
, symbols
, abfd
, asect
);
3176 cache_ptr
->address
= dst
.r_vaddr
;
3178 if (dst
.r_symndx
!= -1)
3180 cache_ptr
->sym_ptr_ptr
= symbols
+ obj_convert(abfd
)[dst
.r_symndx
];
3181 ptr
= *(cache_ptr
->sym_ptr_ptr
);
3185 cache_ptr
->sym_ptr_ptr
= 0;
3191 The symbols definitions that we have read in have been
3192 relocated as if their sections started at 0. But the offsets
3193 refering to the symbols in the raw data have not been
3194 modified, so we have to have a negative addend to compensate.
3196 Note that symbols which used to be common must be left alone */
3198 /* Calculate any reloc addend by looking at the symbol */
3199 CALC_ADDEND(abfd
, ptr
, dst
, cache_ptr
);
3201 cache_ptr
->address
-= asect
->vma
;
3202 cache_ptr
->section
= (asection
*) NULL
;
3204 /* Fill in the cache_ptr->howto field from dst.r_type */
3205 RTYPE2HOWTO(cache_ptr
, dst
);
3210 asect
->relocation
= reloc_cache
;
3215 /* This is stupid. This function should be a boolean predicate */
3217 DEFUN(coff_canonicalize_reloc
, (abfd
, section
, relptr
, symbols
),
3220 arelent
**relptr AND
3223 arelent
*tblptr
= section
->relocation
;
3224 unsigned int count
= 0;
3227 if (section
->flags
& SEC_CONSTRUCTOR
)
3229 /* this section has relocs made up by us, they are not in the
3230 file, so take them out of their chain and place them into
3231 the data area provided */
3232 arelent_chain
*chain
= section
->constructor_chain
;
3233 for (count
= 0; count
< section
->reloc_count
; count
++)
3235 *relptr
++ = &chain
->relent
;
3236 chain
= chain
->next
;
3242 coff_slurp_reloc_table(abfd
, section
, symbols
);
3245 tblptr
= section
->relocation
;
3249 for (; count
++ < section
->reloc_count
;)
3250 *relptr
++ = tblptr
++;
3255 return section
->reloc_count
;
3258 #ifndef NO_COFF_SYMBOLS
3261 provided a BFD, a section and an offset into the section, calculate and
3262 return the name of the source file and the line nearest to the wanted
3267 DEFUN(coff_find_nearest_line
,(abfd
,
3275 asection
*section AND
3276 asymbol
**ignore_symbols AND
3278 CONST
char **filename_ptr AND
3279 CONST
char **functionname_ptr AND
3280 unsigned int *line_ptr
)
3282 static bfd
*cache_abfd
;
3283 static asection
*cache_section
;
3284 static bfd_vma cache_offset
;
3285 static unsigned int cache_i
;
3286 static alent
*cache_l
;
3289 coff_data_type
*cof
= coff_data(abfd
);
3290 /* Run through the raw syments if available */
3291 combined_entry_type
*p
;
3293 unsigned int line_base
= 0;
3297 *functionname_ptr
= 0;
3300 /* Don't try and find line numbers in a non coff file */
3301 if (abfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
3307 p
= cof
->raw_syments
;
3309 for (i
= 0; i
< cof
->raw_syment_count
; i
++) {
3310 if (p
->u
.syment
.n_sclass
== C_FILE
) {
3311 /* File name has been moved into symbol */
3312 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
3315 p
+= 1 + p
->u
.syment
.n_numaux
;
3317 /* Now wander though the raw linenumbers of the section */
3319 If this is the same BFD as we were previously called with and this is
3320 the same section, and the offset we want is further down then we can
3321 prime the lookup loop
3323 if (abfd
== cache_abfd
&&
3324 section
== cache_section
&&
3325 offset
>= cache_offset
) {
3331 l
= section
->lineno
;
3334 for (; i
< section
->lineno_count
; i
++) {
3335 if (l
->line_number
== 0) {
3336 /* Get the symbol this line number points at */
3337 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
3338 *functionname_ptr
= coff
->symbol
.name
;
3340 combined_entry_type
*s
= coff
->native
;
3341 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
3343 S should now point to the .bf of the function
3345 if (s
->u
.syment
.n_numaux
) {
3347 The linenumber is stored in the auxent
3349 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
3350 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
3355 if (l
->u
.offset
> offset
)
3357 *line_ptr
= l
->line_number
+ line_base
+ 1;
3363 cache_section
= section
;
3364 cache_offset
= offset
;
3373 coff_sym_filepos(abfd
)
3376 return obj_sym_filepos(abfd
);
3380 #endif /* NO_COFF_SYMBOLS */
3384 DEFUN(coff_sizeof_headers
,(abfd
, reloc
),
3390 if (reloc
== false) {
3391 size
= FILHSZ
+ AOUTSZ
;
3397 size
+= abfd
->section_count
* SCNHSZ
;
3402 #define coff_core_file_failing_command _bfd_dummy_core_file_failing_command
3403 #define coff_core_file_failing_signal _bfd_dummy_core_file_failing_signal
3404 #define coff_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
3405 #define coff_slurp_armap bfd_slurp_coff_armap
3406 #define coff_slurp_extended_name_table _bfd_slurp_extended_name_table
3407 #define coff_truncate_arname bfd_dont_truncate_arname
3408 #define coff_openr_next_archived_file bfd_generic_openr_next_archived_file
3409 #define coff_generic_stat_arch_elt bfd_generic_stat_arch_elt
3410 #define coff_get_section_contents bfd_generic_get_section_contents
3411 #define coff_close_and_cleanup bfd_generic_close_and_cleanup
3413 #define coff_bfd_debug_info_start bfd_void
3414 #define coff_bfd_debug_info_end bfd_void
3415 #define coff_bfd_debug_info_accumulate (PROTO(void,(*),(bfd*, struct sec *))) bfd_void