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
, reloc_src
->r_offset
);
430 DEFUN(coff_swap_reloc_out
,(abfd
, src
, dst
),
435 struct internal_reloc
*reloc_src
= (struct internal_reloc
*)src
;
436 struct external_reloc
*reloc_dst
= (struct external_reloc
*)dst
;
437 bfd_h_put_32(abfd
, reloc_src
->r_vaddr
, (bfd_byte
*) reloc_dst
->r_vaddr
);
438 bfd_h_put_32(abfd
, reloc_src
->r_symndx
, (bfd_byte
*) reloc_dst
->r_symndx
);
439 bfd_h_put_16(abfd
, reloc_src
->r_type
, (bfd_byte
*)
442 #ifdef SWAP_OUT_RELOC_OFFSET
443 SWAP_OUT_RELOC_OFFSET(abfd
,
445 (bfd_byte
*) reloc_dst
->r_offset
);
447 #ifdef SWAP_OUT_RELOC_EXTRA
448 SWAP_OUT_RELOC_EXTRA(abfd
,reloc_src
, reloc_dst
);
451 return sizeof(struct external_reloc
);
455 DEFUN(bfd_swap_filehdr_in
,(abfd
, filehdr_src
, filehdr_dst
),
457 FILHDR
*filehdr_src AND
458 struct internal_filehdr
*filehdr_dst
)
460 filehdr_dst
->f_magic
= bfd_h_get_16(abfd
, (bfd_byte
*) filehdr_src
->f_magic
);
461 filehdr_dst
->f_nscns
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_nscns
);
462 filehdr_dst
->f_timdat
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_timdat
);
463 filehdr_dst
->f_symptr
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_symptr
);
464 filehdr_dst
->f_nsyms
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_nsyms
);
465 filehdr_dst
->f_opthdr
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_opthdr
);
466 filehdr_dst
->f_flags
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_flags
);
470 DEFUN(coff_swap_filehdr_out
,(abfd
, in
, out
),
475 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*)in
;
476 FILHDR
*filehdr_out
= (FILHDR
*)out
;
477 bfd_h_put_16(abfd
, filehdr_in
->f_magic
, (bfd_byte
*) filehdr_out
->f_magic
);
478 bfd_h_put_16(abfd
, filehdr_in
->f_nscns
, (bfd_byte
*) filehdr_out
->f_nscns
);
479 bfd_h_put_32(abfd
, filehdr_in
->f_timdat
, (bfd_byte
*) filehdr_out
->f_timdat
);
480 bfd_h_put_32(abfd
, filehdr_in
->f_symptr
, (bfd_byte
*) filehdr_out
->f_symptr
);
481 bfd_h_put_32(abfd
, filehdr_in
->f_nsyms
, (bfd_byte
*) filehdr_out
->f_nsyms
);
482 bfd_h_put_16(abfd
, filehdr_in
->f_opthdr
, (bfd_byte
*) filehdr_out
->f_opthdr
);
483 bfd_h_put_16(abfd
, filehdr_in
->f_flags
, (bfd_byte
*) filehdr_out
->f_flags
);
484 return sizeof(FILHDR
);
488 #ifndef NO_COFF_SYMBOLS
491 DEFUN(coff_swap_sym_in
,(abfd
, ext1
, in1
),
496 SYMENT
*ext
= (SYMENT
*)ext1
;
497 struct internal_syment
*in
= (struct internal_syment
*)in1
;
499 if( ext
->e
.e_name
[0] == 0) {
500 in
->_n
._n_n
._n_zeroes
= 0;
501 in
->_n
._n_n
._n_offset
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e
.e
.e_offset
);
504 #if SYMNMLEN != E_SYMNMLEN
505 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
507 memcpy(in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
510 in
->n_value
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_value
);
511 in
->n_scnum
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_scnum
);
512 if (sizeof(ext
->e_type
) == 2){
513 in
->n_type
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_type
);
516 in
->n_type
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_type
);
518 in
->n_sclass
= bfd_h_get_8(abfd
, ext
->e_sclass
);
519 in
->n_numaux
= bfd_h_get_8(abfd
, ext
->e_numaux
);
523 DEFUN(coff_swap_sym_out
,(abfd
, inp
, extp
),
528 struct internal_syment
*in
= (struct internal_syment
*)inp
;
529 SYMENT
*ext
=(SYMENT
*)extp
;
530 if(in
->_n
._n_name
[0] == 0) {
531 bfd_h_put_32(abfd
, 0, (bfd_byte
*) ext
->e
.e
.e_zeroes
);
532 bfd_h_put_32(abfd
, in
->_n
._n_n
._n_offset
, (bfd_byte
*) ext
->e
.e
.e_offset
);
535 #if SYMNMLEN != E_SYMNMLEN
536 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
538 memcpy(ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
541 bfd_h_put_32(abfd
, in
->n_value
, (bfd_byte
*) ext
->e_value
);
542 bfd_h_put_16(abfd
, in
->n_scnum
, (bfd_byte
*) ext
->e_scnum
);
543 if (sizeof(ext
->e_type
) == 2)
545 bfd_h_put_16(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
549 bfd_h_put_32(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
551 bfd_h_put_8(abfd
, in
->n_sclass
, ext
->e_sclass
);
552 bfd_h_put_8(abfd
, in
->n_numaux
, ext
->e_numaux
);
553 return sizeof(SYMENT
);
557 DEFUN(coff_swap_aux_in
,(abfd
, ext1
, type
, class, in1
),
564 AUXENT
*ext
= (AUXENT
*)ext1
;
565 union internal_auxent
*in
= (union internal_auxent
*)in1
;
568 if (ext
->x_file
.x_fname
[0] == 0) {
569 in
->x_file
.x_n
.x_zeroes
= 0;
570 in
->x_file
.x_n
.x_offset
=
571 bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
573 #if FILNMLEN != E_FILNMLEN
574 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
576 memcpy (in
->x_file
.x_fname
, ext
->x_file
.x_fname
, FILNMLEN
);
581 /* RS/6000 "csect" auxents */
585 in
->x_csect
.x_scnlen
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_scnlen
);
586 in
->x_csect
.x_parmhash
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_parmhash
);
587 in
->x_csect
.x_snhash
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snhash
);
588 /* We don't have to hack bitfields in x_smtyp because it's defined by
589 shifts-and-ands, which are equivalent on all byte orders. */
590 in
->x_csect
.x_smtyp
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smtyp
);
591 in
->x_csect
.x_smclas
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smclas
);
592 in
->x_csect
.x_stab
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_stab
);
593 in
->x_csect
.x_snstab
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snstab
);
602 if (type
== T_NULL
) {
603 in
->x_scn
.x_scnlen
= GET_SCN_SCNLEN(abfd
, ext
);
604 in
->x_scn
.x_nreloc
= GET_SCN_NRELOC(abfd
, ext
);
605 in
->x_scn
.x_nlinno
= GET_SCN_NLINNO(abfd
, ext
);
609 in
->x_sym
.x_tagndx
.l
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
611 in
->x_sym
.x_tvndx
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
614 if (ISARY(type
) || class == C_BLOCK
) {
615 #if DIMNUM != E_DIMNUM
616 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
618 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]);
619 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]);
620 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]);
621 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]);
624 in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= GET_FCN_LNNOPTR(abfd
, ext
);
625 in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= GET_FCN_ENDNDX(abfd
, ext
);
628 in
->x_sym
.x_misc
.x_fsize
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
631 in
->x_sym
.x_misc
.x_lnsz
.x_lnno
= GET_LNSZ_LNNO(abfd
, ext
);
632 in
->x_sym
.x_misc
.x_lnsz
.x_size
= GET_LNSZ_SIZE(abfd
, ext
);
638 DEFUN(coff_swap_aux_out
,(abfd
, inp
, type
, class, extp
),
645 union internal_auxent
*in
= (union internal_auxent
*)inp
;
646 AUXENT
*ext
= (AUXENT
*)extp
;
649 if (in
->x_file
.x_fname
[0] == 0) {
650 PUTWORD(abfd
, 0, (bfd_byte
*) ext
->x_file
.x_n
.x_zeroes
);
652 in
->x_file
.x_n
.x_offset
,
653 (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
656 #if FILNMLEN != E_FILNMLEN
657 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
659 memcpy (ext
->x_file
.x_fname
, in
->x_file
.x_fname
, FILNMLEN
);
665 /* RS/6000 "csect" auxents */
668 PUTWORD (abfd
, in
->x_csect
.x_scnlen
, ext
->x_csect
.x_scnlen
);
669 PUTWORD (abfd
, in
->x_csect
.x_parmhash
, ext
->x_csect
.x_parmhash
);
670 PUTHALF (abfd
, in
->x_csect
.x_snhash
, ext
->x_csect
.x_snhash
);
671 /* We don't have to hack bitfields in x_smtyp because it's defined by
672 shifts-and-ands, which are equivalent on all byte orders. */
673 PUTBYTE (abfd
, in
->x_csect
.x_smtyp
, ext
->x_csect
.x_smtyp
);
674 PUTBYTE (abfd
, in
->x_csect
.x_smclas
, ext
->x_csect
.x_smclas
);
675 PUTWORD (abfd
, in
->x_csect
.x_stab
, ext
->x_csect
.x_stab
);
676 PUTHALF (abfd
, in
->x_csect
.x_snstab
, ext
->x_csect
.x_snstab
);
685 if (type
== T_NULL
) {
686 PUT_SCN_SCNLEN(abfd
, in
->x_scn
.x_scnlen
, ext
);
687 PUT_SCN_NRELOC(abfd
, in
->x_scn
.x_nreloc
, ext
);
688 PUT_SCN_NLINNO(abfd
, in
->x_scn
.x_nlinno
, ext
);
692 PUTWORD(abfd
, in
->x_sym
.x_tagndx
.l
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
694 PUTWORD(abfd
, in
->x_sym
.x_tvndx
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
698 PUTWORD(abfd
, in
->x_sym
.x_misc
.x_fsize
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
699 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
700 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
704 if (ISARY(type
) || class == C_BLOCK
) {
705 #if DIMNUM != E_DIMNUM
706 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
708 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]);
709 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]);
710 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]);
711 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]);
714 PUT_LNSZ_LNNO(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
715 PUT_LNSZ_SIZE(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
717 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
718 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
723 return sizeof(AUXENT
);
726 #endif /* NO_COFF_SYMBOLS */
728 #ifndef NO_COFF_LINENOS
731 DEFUN(coff_swap_lineno_in
,(abfd
, ext1
, in1
),
736 LINENO
*ext
= (LINENO
*)ext1
;
737 struct internal_lineno
*in
= (struct internal_lineno
*)in1
;
739 in
->l_addr
.l_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->l_addr
.l_symndx
);
740 in
->l_lnno
= GET_LINENO_LNNO(abfd
, ext
);
744 DEFUN(coff_swap_lineno_out
,(abfd
, inp
, outp
),
749 struct internal_lineno
*in
= (struct internal_lineno
*)inp
;
750 struct external_lineno
*ext
= (struct external_lineno
*)outp
;
751 PUTWORD(abfd
, in
->l_addr
.l_symndx
, (bfd_byte
*)
752 ext
->l_addr
.l_symndx
);
754 PUT_LINENO_LNNO (abfd
, in
->l_lnno
, ext
);
755 return sizeof(struct external_lineno
);
758 #endif /* NO_COFF_LINENOS */
762 DEFUN(bfd_swap_aouthdr_in
,(abfd
, aouthdr_ext1
, aouthdr_int1
),
767 AOUTHDR
*aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
768 struct internal_aouthdr
*aouthdr_int
= (struct internal_aouthdr
*)aouthdr_int1
;
770 aouthdr_int
->magic
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->magic
);
771 aouthdr_int
->vstamp
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->vstamp
);
772 aouthdr_int
->tsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tsize
);
773 aouthdr_int
->dsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->dsize
);
774 aouthdr_int
->bsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->bsize
);
775 aouthdr_int
->entry
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->entry
);
776 aouthdr_int
->text_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->text_start
);
777 aouthdr_int
->data_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->data_start
);
779 aouthdr_int
->tagentries
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tagentries
);
783 aouthdr_int
->o_toc
= bfd_h_get_32(abfd
, aouthdr_ext
->o_toc
);
784 aouthdr_int
->o_snentry
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snentry
);
785 aouthdr_int
->o_sntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntext
);
786 aouthdr_int
->o_sndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sndata
);
787 aouthdr_int
->o_sntoc
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntoc
);
788 aouthdr_int
->o_snloader
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snloader
);
789 aouthdr_int
->o_snbss
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snbss
);
790 aouthdr_int
->o_algntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algntext
);
791 aouthdr_int
->o_algndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algndata
);
792 aouthdr_int
->o_modtype
= bfd_h_get_16(abfd
, aouthdr_ext
->o_modtype
);
793 aouthdr_int
->o_maxstack
= bfd_h_get_32(abfd
, aouthdr_ext
->o_maxstack
);
798 DEFUN(coff_swap_aouthdr_out
,(abfd
, in
, out
),
803 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*)in
;
804 AOUTHDR
*aouthdr_out
= (AOUTHDR
*)out
;
805 bfd_h_put_16(abfd
, aouthdr_in
->magic
, (bfd_byte
*) aouthdr_out
->magic
);
806 bfd_h_put_16(abfd
, aouthdr_in
->vstamp
, (bfd_byte
*) aouthdr_out
->vstamp
);
807 bfd_h_put_32(abfd
, aouthdr_in
->tsize
, (bfd_byte
*) aouthdr_out
->tsize
);
808 bfd_h_put_32(abfd
, aouthdr_in
->dsize
, (bfd_byte
*) aouthdr_out
->dsize
);
809 bfd_h_put_32(abfd
, aouthdr_in
->bsize
, (bfd_byte
*) aouthdr_out
->bsize
);
810 bfd_h_put_32(abfd
, aouthdr_in
->entry
, (bfd_byte
*) aouthdr_out
->entry
);
811 bfd_h_put_32(abfd
, aouthdr_in
->text_start
,
812 (bfd_byte
*) aouthdr_out
->text_start
);
813 bfd_h_put_32(abfd
, aouthdr_in
->data_start
, (bfd_byte
*) aouthdr_out
->data_start
);
815 bfd_h_put_32(abfd
, aouthdr_in
->tagentries
, (bfd_byte
*) aouthdr_out
->tagentries
);
817 return sizeof(AOUTHDR
);
821 DEFUN(coff_swap_scnhdr_in
,(abfd
, scnhdr_ext
, scnhdr_int
),
823 SCNHDR
*scnhdr_ext AND
824 struct internal_scnhdr
*scnhdr_int
)
826 memcpy(scnhdr_int
->s_name
, scnhdr_ext
->s_name
, sizeof(scnhdr_int
->s_name
));
827 scnhdr_int
->s_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
828 scnhdr_int
->s_paddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
829 scnhdr_int
->s_size
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_size
);
830 scnhdr_int
->s_scnptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
831 scnhdr_int
->s_relptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
832 scnhdr_int
->s_lnnoptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
833 scnhdr_int
->s_flags
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_flags
);
835 scnhdr_int
->s_nreloc
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
836 scnhdr_int
->s_nlnno
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
838 scnhdr_int
->s_nreloc
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
839 scnhdr_int
->s_nlnno
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
842 scnhdr_int
->s_align
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_align
);
847 DEFUN(coff_swap_scnhdr_out
,(abfd
, in
, out
),
852 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*)in
;
853 SCNHDR
*scnhdr_ext
= (SCNHDR
*)out
;
854 memcpy(scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof(scnhdr_int
->s_name
));
855 PUTWORD(abfd
, scnhdr_int
->s_vaddr
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
856 PUTWORD(abfd
, scnhdr_int
->s_paddr
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
857 PUTWORD(abfd
, scnhdr_int
->s_size
, (bfd_byte
*) scnhdr_ext
->s_size
);
858 PUTWORD(abfd
, scnhdr_int
->s_scnptr
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
859 PUTWORD(abfd
, scnhdr_int
->s_relptr
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
860 PUTWORD(abfd
, scnhdr_int
->s_lnnoptr
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
861 PUTWORD(abfd
, scnhdr_int
->s_flags
, (bfd_byte
*) scnhdr_ext
->s_flags
);
863 PUTWORD(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
864 PUTWORD(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
866 PUTHALF(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
867 PUTHALF(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
871 PUTWORD(abfd
, scnhdr_int
->s_align
, (bfd_byte
*) scnhdr_ext
->s_align
);
873 return sizeof(SCNHDR
);
878 initialize a section structure with information peculiar to this
879 particular implementation of coff
883 DEFUN(coff_new_section_hook
,(abfd_ignore
, section_ignore
),
885 asection
*section_ignore
)
887 section_ignore
->alignment_power
= abfd_ignore
->xvec
->align_power_min
;
891 /* Take a section header read from a coff file (in HOST byte order),
892 and make a BFD "section" out of it. */
894 DEFUN(make_a_section_from_file
,(abfd
, hdr
),
896 struct internal_scnhdr
*hdr
)
898 asection
*return_section
;
901 /* Assorted wastage to null-terminate the name, thanks AT&T! */
902 char *name
= bfd_alloc(abfd
, sizeof (hdr
->s_name
)+1);
904 bfd_error
= no_memory
;
907 strncpy(name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
908 name
[sizeof (hdr
->s_name
)] = 0;
910 return_section
= bfd_make_section(abfd
, name
);
911 if (return_section
== NULL
)
915 /* s_paddr is presumed to be = to s_vaddr */
916 #define assign(to, from) return_section->to = hdr->from
917 assign(vma
, s_vaddr
);
918 /* assign (vma, s_vaddr); */
919 assign(size
, s_size
);
920 assign(filepos
, s_scnptr
);
921 assign(rel_filepos
, s_relptr
);
922 assign(reloc_count
, s_nreloc
);
925 /* FIXME, use a temp var rather than alignment_power */
926 assign(alignment_power
, s_align
);
929 for (i
= 0; i
< 32; i
++) {
930 if ((1 << i
) >= (int) (return_section
->alignment_power
)) {
931 return_section
->alignment_power
= i
;
938 assign(line_filepos
, s_lnnoptr
);
940 return_section->linesize = hdr->s_nlnno * sizeof (struct lineno);
943 return_section
->lineno_count
= hdr
->s_nlnno
;
944 return_section
->userdata
= NULL
;
945 return_section
->next
= (asection
*) NULL
;
946 return_section
->flags
= styp_to_sec_flags(hdr
->s_flags
);
949 if (hdr
->s_nreloc
!= 0)
950 return_section
->flags
|= SEC_RELOC
;
951 /* FIXME: should this check 'hdr->s_size > 0' */
952 if (hdr
->s_scnptr
!= 0)
953 return_section
->flags
|= SEC_HAS_CONTENTS
;
957 DEFUN(coff_mkobject
,(abfd
),
960 set_tdata (abfd
, bfd_zalloc (abfd
,sizeof(coff_data_type
)));
961 if (coff_data(abfd
) == 0) {
962 bfd_error
= no_memory
;
965 coff_data(abfd
)->relocbase
= 0;
971 DEFUN(coff_real_object_p
,(abfd
, nscns
, internal_f
, internal_a
),
974 struct internal_filehdr
*internal_f AND
975 struct internal_aouthdr
*internal_a
)
977 coff_data_type
*coff
;
978 enum bfd_architecture arch
;
980 size_t readsize
; /* length of file_info */
981 SCNHDR
*external_sections
;
983 /* Build a play area */
984 if (coff_mkobject(abfd
) != true)
986 coff
= coff_data(abfd
);
989 external_sections
= (SCNHDR
*)bfd_alloc(abfd
, readsize
= (nscns
* SCNHSZ
));
991 if (bfd_read((PTR
)external_sections
, 1, readsize
, abfd
) != readsize
) {
996 /* Now copy data as required; construct all asections etc */
997 coff
->symbol_index_slew
= 0;
999 coff
->raw_syment_count
= 0;
1000 coff
->raw_linenos
= 0;
1001 coff
->raw_syments
= 0;
1002 coff
->sym_filepos
=0;
1003 coff
->flags
= internal_f
->f_flags
;
1006 for (i
= 0; i
< nscns
; i
++) {
1007 struct internal_scnhdr tmp
;
1008 coff_swap_scnhdr_in(abfd
, external_sections
+ i
, &tmp
);
1009 make_a_section_from_file(abfd
,&tmp
);
1012 /* Determine the machine architecture and type. */
1014 switch (internal_f
->f_magic
) {
1017 arch
= bfd_arch_i386
;
1022 #ifdef A29K_MAGIC_BIG
1023 case A29K_MAGIC_BIG
:
1024 case A29K_MAGIC_LITTLE
:
1025 arch
= bfd_arch_a29k
;
1034 arch
= bfd_arch_mips
;
1042 arch
= bfd_arch_m68k
;
1050 arch
= bfd_arch_m88k
;
1058 arch
= bfd_arch_i960
;
1059 switch (F_I960TYPE
& internal_f
->f_flags
)
1063 machine
= bfd_mach_i960_core
;
1066 machine
= bfd_mach_i960_kb_sb
;
1069 machine
= bfd_mach_i960_mc
;
1072 machine
= bfd_mach_i960_xa
;
1075 machine
= bfd_mach_i960_ca
;
1078 machine
= bfd_mach_i960_ka_sa
;
1089 arch
= bfd_arch_rs6000
;
1096 arch
= bfd_arch_h8300
;
1101 default: /* Unreadable input file type */
1102 arch
= bfd_arch_obscure
;
1106 bfd_default_set_arch_mach(abfd
, arch
, machine
);
1107 if (!(internal_f
->f_flags
& F_RELFLG
))
1108 abfd
->flags
|= HAS_RELOC
;
1109 if ((internal_f
->f_flags
& F_EXEC
))
1110 abfd
->flags
|= EXEC_P
;
1111 if (!(internal_f
->f_flags
& F_LNNO
))
1112 abfd
->flags
|= HAS_LINENO
;
1113 if (!(internal_f
->f_flags
& F_LSYMS
))
1114 abfd
->flags
|= HAS_LOCALS
;
1117 bfd_get_symcount(abfd
) = internal_f
->f_nsyms
;
1118 if (internal_f
->f_nsyms
)
1119 abfd
->flags
|= HAS_SYMS
;
1121 coff
->sym_filepos
= internal_f
->f_symptr
;
1123 /* These members communicate important constants about the symbol table
1124 to GDB's symbol-reading code. These `constants' unfortunately vary
1125 from coff implementation to implementation... */
1126 #ifndef NO_COFF_SYMBOLS
1127 coff
->local_n_btmask
= N_BTMASK
;
1128 coff
->local_n_btshft
= N_BTSHFT
;
1129 coff
->local_n_tmask
= N_TMASK
;
1130 coff
->local_n_tshift
= N_TSHIFT
;
1131 coff
->local_symesz
= SYMESZ
;
1132 coff
->local_auxesz
= AUXESZ
;
1133 coff
->local_linesz
= LINESZ
;
1136 coff
->symbols
= (coff_symbol_type
*) NULL
;
1137 bfd_get_start_address(abfd
) = internal_f
->f_opthdr
? internal_a
->entry
: 0;
1141 bfd_release(abfd
, coff
);
1142 return (bfd_target
*)NULL
;
1146 DEFUN(coff_object_p
,(abfd
),
1152 struct internal_filehdr internal_f
;
1153 struct internal_aouthdr internal_a
;
1155 bfd_error
= system_call_error
;
1157 /* figure out how much to read */
1158 if (bfd_read((PTR
) &filehdr
, 1, FILHSZ
, abfd
) != FILHSZ
)
1161 bfd_swap_filehdr_in(abfd
, &filehdr
, &internal_f
);
1163 if (BADMAG(internal_f
)) {
1164 bfd_error
= wrong_format
;
1167 nscns
=internal_f
.f_nscns
;
1169 if (internal_f
.f_opthdr
) {
1170 if (bfd_read((PTR
) &opthdr
, 1,AOUTSZ
, abfd
) != AOUTSZ
) {
1173 bfd_swap_aouthdr_in(abfd
, (char *)&opthdr
, (char *)&internal_a
);
1176 /* Seek past the opt hdr stuff */
1177 bfd_seek(abfd
, internal_f
.f_opthdr
+ FILHSZ
, SEEK_SET
);
1179 /* if the optional header is NULL or not the correct size then
1180 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1181 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1182 optional header is of a different size.
1184 But the mips keeps extra stuff in it's opthdr, so dont check
1188 #if defined(M88) || defined(I960)
1189 if (internal_f
.f_opthdr
!= 0 && AOUTSZ
!= internal_f
.f_opthdr
)
1190 return (bfd_target
*)NULL
;
1193 return coff_real_object_p(abfd
, nscns
, &internal_f
, &internal_a
);
1198 #ifndef NO_COFF_LINENOS
1201 DEFUN(coff_count_linenumbers
,(abfd
),
1204 unsigned int limit
= bfd_get_symcount(abfd
);
1208 asection
*s
= abfd
->sections
->output_section
;
1210 BFD_ASSERT(s
->lineno_count
== 0);
1216 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++) {
1217 asymbol
*q_maybe
= *p
;
1218 if (q_maybe
->the_bfd
->xvec
->flavour
== bfd_target_coff_flavour
) {
1219 coff_symbol_type
*q
= coffsymbol(q_maybe
);
1222 This symbol has a linenumber, increment the owning
1223 section's linenumber count
1225 alent
*l
= q
->lineno
;
1226 q
->symbol
.section
->output_section
->lineno_count
++;
1228 while (l
->line_number
) {
1229 q
->symbol
.section
->output_section
->lineno_count
++;
1237 #endif /* NO_COFF_LINENOS */
1239 #ifndef NO_COFF_SYMBOLS
1242 Takes a bfd and a symbol, returns a pointer to the coff specific area
1243 of the symbol if there is one.
1245 static coff_symbol_type
*
1246 DEFUN(coff_symbol_from
,(ignore_abfd
, symbol
),
1247 bfd
*ignore_abfd AND
1250 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
1251 return (coff_symbol_type
*)NULL
;
1253 if (symbol
->the_bfd
->tdata
== (PTR
)NULL
)
1254 return (coff_symbol_type
*)NULL
;
1256 return (coff_symbol_type
*) symbol
;
1262 DEFUN(fixup_symbol_value
,(coff_symbol_ptr
, syment
),
1263 coff_symbol_type
*coff_symbol_ptr AND
1264 struct internal_syment
*syment
)
1267 /* Normalize the symbol flags */
1268 if (coff_symbol_ptr
->symbol
.flags
& BSF_FORT_COMM
) {
1269 /* a common symbol is undefined with a value */
1270 syment
->n_scnum
= N_UNDEF
;
1271 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1273 else if (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) {
1274 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1276 else if (coff_symbol_ptr
->symbol
.flags
& BSF_UNDEFINED
) {
1277 syment
->n_scnum
= N_UNDEF
;
1278 syment
->n_value
= 0;
1280 else if (coff_symbol_ptr
->symbol
.flags
& BSF_ABSOLUTE
) {
1281 syment
->n_scnum
= N_ABS
;
1282 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1285 if (coff_symbol_ptr
->symbol
.section
) {
1287 coff_symbol_ptr
->symbol
.section
->output_section
->index
+1;
1290 coff_symbol_ptr
->symbol
.value
+
1291 coff_symbol_ptr
->symbol
.section
->output_offset
+
1292 coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
1295 /* This can happen, but I don't know why yet (steve@cygnus.com) */
1296 syment
->n_scnum
= N_ABS
;
1297 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1302 /* run through all the symbols in the symbol table and work out what
1303 their indexes into the symbol table will be when output
1305 Coff requires that each C_FILE symbol points to the next one in the
1306 chain, and that the last one points to the first external symbol. We
1311 DEFUN(coff_renumber_symbols
,(bfd_ptr
),
1314 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1315 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1316 unsigned int native_index
= 0;
1317 struct internal_syment
*last_file
= (struct internal_syment
*)NULL
;
1318 unsigned int symbol_index
;
1319 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1321 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1322 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1323 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1326 if (s
->u
.syment
.n_sclass
== C_FILE
)
1328 if (last_file
!= (struct internal_syment
*)NULL
) {
1329 last_file
->n_value
= native_index
;
1331 last_file
= &(s
->u
.syment
);
1335 /* Modify the symbol values according to their section and
1338 fixup_symbol_value(coff_symbol_ptr
, &(s
->u
.syment
));
1340 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++) {
1341 s
[i
].offset
= native_index
++;
1352 Run thorough the symbol table again, and fix it so that all pointers to
1353 entries are changed to the entries' index in the output symbol table.
1357 DEFUN(coff_mangle_symbols
,(bfd_ptr
),
1360 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1361 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1362 unsigned int symbol_index
;
1364 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1366 coff_symbol_type
*coff_symbol_ptr
=
1367 coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1369 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1371 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1373 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++) {
1374 combined_entry_type
*a
= s
+ i
+ 1;
1376 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
1377 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
1380 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
1381 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
1389 static int string_size
;
1391 DEFUN(coff_fix_symbol_name
,(ignore_abfd
, symbol
, native
),
1392 bfd
*ignore_abfd AND
1394 combined_entry_type
*native
)
1396 unsigned int name_length
;
1397 union internal_auxent
*auxent
;
1398 char * name
= ( char *)(symbol
->name
);
1400 if (name
== (char *) NULL
) {
1401 /* coff symbols always have names, so we'll make one up */
1402 symbol
->name
= "strange";
1403 name
= (char *)symbol
->name
;
1405 name_length
= strlen(name
);
1407 if (native
->u
.syment
.n_sclass
== C_FILE
) {
1408 strncpy(native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
1409 auxent
= &(native
+1)->u
.auxent
;
1411 #ifdef COFF_LONG_FILENAMES
1412 if (name_length
<= FILNMLEN
) {
1413 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1416 auxent
->x_file
.x_n
.x_offset
= string_size
+ 4;
1417 auxent
->x_file
.x_n
.x_zeroes
= 0;
1418 string_size
+= name_length
+ 1;
1421 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1422 if (name_length
> FILNMLEN
) {
1423 name
[FILNMLEN
] = '\0';
1428 { /* NOT A C_FILE SYMBOL */
1429 if (name_length
<= SYMNMLEN
) {
1430 /* This name will fit into the symbol neatly */
1431 strncpy(native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
1434 native
->u
.syment
._n
._n_n
._n_offset
= string_size
+ 4;
1435 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1436 string_size
+= name_length
+ 1;
1444 DEFUN(coff_write_symbol
,(abfd
, symbol
, native
, written
),
1447 combined_entry_type
*native AND
1448 unsigned int written
)
1450 unsigned int numaux
= native
->u
.syment
.n_numaux
;
1451 int type
= native
->u
.syment
.n_type
;
1452 int class = native
->u
.syment
.n_sclass
;
1456 coff_fix_symbol_name(abfd
, symbol
, native
);
1457 coff_swap_sym_out(abfd
, &native
->u
.syment
, &buf
);
1458 bfd_write((PTR
)& buf
, 1, SYMESZ
, abfd
);
1459 for (j
= 0; j
!= native
->u
.syment
.n_numaux
; j
++)
1462 bzero((PTR
)&buf
, AUXESZ
);
1463 coff_swap_aux_out(abfd
,
1464 &( (native
+ j
+ 1)->u
.auxent
), type
, class, &buf1
);
1465 bfd_write((PTR
) (&buf1
), 1, AUXESZ
, abfd
);
1468 Reuse somewhere in the symbol to keep the index
1470 set_index(symbol
, written
);
1471 return written
+ 1 + numaux
;
1476 DEFUN(coff_write_alien_symbol
,(abfd
, symbol
, written
),
1479 unsigned int written
)
1482 This symbol has been created by the loader, or come from a non
1483 coff format. It has no native element to inherit, make our
1486 combined_entry_type
*native
;
1487 combined_entry_type dummy
;
1489 native
->u
.syment
.n_type
= T_NULL
;
1491 native
->u
.syment
.n_flags
= 0;
1493 if (symbol
->flags
& BSF_ABSOLUTE
) {
1494 native
->u
.syment
.n_scnum
= N_ABS
;
1495 native
->u
.syment
.n_value
= symbol
->value
;
1497 else if (symbol
->flags
& (BSF_UNDEFINED
| BSF_FORT_COMM
)) {
1498 native
->u
.syment
.n_scnum
= N_UNDEF
;
1499 native
->u
.syment
.n_value
= symbol
->value
;
1501 else if (symbol
->flags
& BSF_DEBUGGING
) {
1503 remove name so it doesn't take up any space
1508 native
->u
.syment
.n_scnum
= symbol
->section
->output_section
->index
+
1510 native
->u
.syment
.n_value
= symbol
->value
+
1511 symbol
->section
->output_section
->vma
+
1512 symbol
->section
->output_offset
;
1514 /* Copy the any flags from the the file hdr into the symbol */
1516 coff_symbol_type
*c
= coff_symbol_from(abfd
, symbol
);
1517 if (c
!= (coff_symbol_type
*)NULL
) {
1518 native
->u
.syment
.n_flags
= c
->symbol
.the_bfd
->flags
;
1525 native
->u
.syment
.pad1
[0] = 0;
1526 native
->u
.syment
.pad1
[0] = 0;
1529 native
->u
.syment
.n_type
= 0;
1530 if (symbol
->flags
& BSF_LOCAL
)
1531 native
->u
.syment
.n_sclass
= C_STAT
;
1533 native
->u
.syment
.n_sclass
= C_EXT
;
1534 native
->u
.syment
.n_numaux
= 0;
1536 return coff_write_symbol(abfd
, symbol
, native
, written
);
1540 DEFUN(coff_write_native_symbol
,(abfd
, symbol
, written
),
1542 coff_symbol_type
*symbol AND
1543 unsigned int written
)
1546 Does this symbol have an ascociated line number - if so then
1547 make it remember this symbol index. Also tag the auxent of
1548 this symbol to point to the right place in the lineno table
1550 combined_entry_type
*native
= symbol
->native
;
1552 alent
*lineno
= symbol
->lineno
;
1555 unsigned int count
= 0;
1556 lineno
[count
].u
.offset
= written
;
1557 if (native
->u
.syment
.n_numaux
) {
1558 union internal_auxent
*a
= &((native
+1)->u
.auxent
);
1560 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1561 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1564 And count and relocate all other linenumbers
1567 while (lineno
[count
].line_number
) {
1568 lineno
[count
].u
.offset
+=
1569 symbol
->symbol
.section
->output_section
->vma
+
1570 symbol
->symbol
.section
->output_offset
;
1573 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1576 return coff_write_symbol(abfd
, &( symbol
->symbol
), native
,written
);
1580 DEFUN(coff_write_symbols
,(abfd
),
1584 unsigned int limit
= bfd_get_symcount(abfd
);
1585 unsigned int written
= 0;
1592 /* Seek to the right place */
1593 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
1595 /* Output all the symbols we have */
1598 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1600 asymbol
*symbol
= *p
;
1601 coff_symbol_type
*c_symbol
= coff_symbol_from(abfd
, symbol
);
1603 if (c_symbol
== (coff_symbol_type
*) NULL
||
1604 c_symbol
->native
== (combined_entry_type
*)NULL
)
1606 written
= coff_write_alien_symbol(abfd
, symbol
, written
);
1610 written
= coff_write_native_symbol(abfd
, c_symbol
, written
);
1615 bfd_get_symcount(abfd
) = written
;
1617 /* Now write out strings */
1619 if (string_size
!= 0)
1621 unsigned int size
= string_size
+ 4;
1624 bfd_h_put_32(abfd
, size
, buffer
);
1625 bfd_write((PTR
) buffer
, 1, sizeof(buffer
), abfd
);
1626 for (p
= abfd
->outsymbols
, i
= 0;
1631 size_t name_length
= strlen(q
->name
);
1633 coff_symbol_type
* c_symbol
= coff_symbol_from(abfd
, q
);
1634 maxlen
= ((c_symbol
!= NULL
&& c_symbol
->native
!= NULL
) &&
1635 (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
)) ?
1636 FILNMLEN
: SYMNMLEN
;
1638 if (name_length
> maxlen
) {
1639 bfd_write((PTR
) (q
->name
), 1, name_length
+ 1, abfd
);
1644 /* We would normally not write anything here, but we'll write
1645 out 4 so that any stupid coff reader which tries to read
1646 the string table even when there isn't one won't croak.
1649 uint32e_type size
= 4;
1651 bfd_write((PTR
)&size
, 1, sizeof(size
), abfd
);
1661 To write relocations, all the back end does is step though the
1662 canonical relocation table, and create an
1663 @code{internal_reloc}. The symbol index to use is removed from
1664 the @code{offset} field in the symbol table supplied, the
1665 address comes directly from the sum of the section base
1666 address and the relocation offset and the type is dug directly
1667 from the howto field. Then the @code{internal_reloc} is
1668 swapped into the shape of an @code{external_reloc} and written
1674 DEFUN(coff_write_relocs
,(abfd
),
1678 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1680 struct external_reloc dst
;
1682 arelent
**p
= s
->orelocation
;
1683 bfd_seek(abfd
, s
->rel_filepos
, SEEK_SET
);
1684 for (i
= 0; i
< s
->reloc_count
; i
++) {
1685 struct internal_reloc n
;
1687 memset((PTR
)&n
, 0, sizeof(n
));
1688 n
.r_vaddr
= q
->address
+ s
->vma
;
1689 if (q
->sym_ptr_ptr
) {
1690 n
.r_symndx
= get_index((*(q
->sym_ptr_ptr
)));
1693 /* Work out reloc type from what is required */
1694 SELECT_RELOC(n
.r_type
, q
->howto
);
1696 n
.r_type
= q
->howto
->type
;
1698 coff_swap_reloc_out(abfd
, &n
, &dst
);
1699 bfd_write((PTR
) &n
, 1, RELSZ
, abfd
);
1703 #endif /* NO_COFF_SYMBOLS */
1705 #ifndef NO_COFF_LINENOS
1708 DEFUN(coff_write_linenumbers
,(abfd
),
1712 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1713 if (s
->lineno_count
) {
1714 asymbol
**q
= abfd
->outsymbols
;
1715 bfd_seek(abfd
, s
->line_filepos
, SEEK_SET
);
1716 /* Find all the linenumbers in this section */
1719 alent
*l
= BFD_SEND(p
->the_bfd
, _get_lineno
, (p
->the_bfd
, p
));
1721 /* Found a linenumber entry, output */
1722 struct internal_lineno out
;
1724 memset( (PTR
)&out
, 0, sizeof(out
));
1726 out
.l_addr
.l_symndx
= l
->u
.offset
;
1727 coff_swap_lineno_out(abfd
, &out
, &buff
);
1728 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1730 while (l
->line_number
) {
1731 out
.l_lnno
= l
->line_number
;
1732 out
.l_addr
.l_symndx
= l
->u
.offset
;
1733 coff_swap_lineno_out(abfd
, &out
, &buff
);
1734 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1745 DEFUN(coff_get_lineno
,(ignore_abfd
, symbol
),
1746 bfd
*ignore_abfd AND
1749 return coffsymbol(symbol
)->lineno
;
1752 #endif /* NO_COFF_LINENOS */
1755 coff_make_empty_symbol(abfd
)
1758 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc(abfd
, sizeof(coff_symbol_type
));
1760 bfd_error
= no_memory
;
1764 new->lineno
= (alent
*) NULL
;
1765 new->symbol
.the_bfd
= abfd
;
1766 return &new->symbol
;
1769 #ifndef NO_COFF_SYMBOLS
1772 DEFUN(coff_print_symbol
,(ignore_abfd
, filep
, symbol
, how
),
1773 bfd
*ignore_abfd AND
1776 bfd_print_symbol_type how
)
1778 FILE *file
= (FILE *)filep
;
1780 case bfd_print_symbol_name
:
1781 fprintf(file
, "%s", symbol
->name
);
1783 case bfd_print_symbol_more
:
1784 fprintf(file
, "coff %lx %lx", (unsigned long) coffsymbol(symbol
)->native
,
1785 (unsigned long) coffsymbol(symbol
)->lineno
);
1787 case bfd_print_symbol_nm
:
1790 CONST
char *section_name
= symbol
->section
== (asection
*) NULL
?
1791 "*abs" : symbol
->section
->name
;
1792 bfd_print_symbol_vandf((PTR
) file
, symbol
);
1795 fprintf(file
, " %-5s %s %s %s",
1797 coffsymbol(symbol
)->native
? "n" : "g",
1798 coffsymbol(symbol
)->lineno
? "l" : " ",
1804 case bfd_print_symbol_all
:
1805 /* Print out the symbols in a reasonable way */
1807 CONST
char *section_name
= symbol
->section
== (asection
*) NULL
?
1808 "*abs" : symbol
->section
->name
;
1811 if (coffsymbol(symbol
)->native
)
1814 combined_entry_type
*combined
= coffsymbol(symbol
)->native
;
1815 combined_entry_type
*root
= obj_raw_syments(ignore_abfd
);
1817 fprintf(file
,"[%3d]",
1821 fprintf(file
, "(sc %2d)(fl%4x)(ty%3x)(sc%3d) nx(%d) %08x %s",
1822 combined
->u
.syment
.n_scnum
,
1823 combined
->u
.syment
.n_flags
,
1824 combined
->u
.syment
.n_type
,
1825 combined
->u
.syment
.n_sclass
,
1826 combined
->u
.syment
.n_numaux
,
1827 combined
->u
.syment
.n_value
,
1830 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
1833 switch (combined
->u
.syment
.n_sclass
) {
1835 fprintf(file
, "File ");
1838 fprintf(file
, "AUX tv %x lnno %x size %x",
1839 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
1840 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
);
1853 bfd_print_symbol_vandf((PTR
) file
, symbol
);
1854 fprintf(file
, " %-5s %s %s %s",
1856 coffsymbol(symbol
)->native
? "n" : "g",
1857 coffsymbol(symbol
)->lineno
? "l" : " ",
1866 #endif /* NO_COFF_SYMBOLS */
1868 /* Set flags and magic number of a coff file from architecture and machine
1869 type. Result is true if we can represent the arch&type, false if not. */
1872 DEFUN(coff_set_flags
,(abfd
, magicp
, flagsp
),
1874 unsigned *magicp AND
1875 unsigned short *flagsp
)
1877 switch (bfd_get_arch(abfd
)) {
1885 *magicp
= I960ROMAGIC
;
1887 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1888 I960RWMAGIC); FIXME???
1890 switch (bfd_get_mach(abfd
)) {
1891 case bfd_mach_i960_core
:
1894 case bfd_mach_i960_kb_sb
:
1897 case bfd_mach_i960_mc
:
1900 case bfd_mach_i960_xa
:
1903 case bfd_mach_i960_ca
:
1906 case bfd_mach_i960_ka_sa
:
1919 *magicp
= MIPS_MAGIC_2
;
1925 *magicp
= I386MAGIC
;
1930 *magicp
= MC68MAGIC
;
1936 *magicp
= MC88OMAGIC
;
1941 case bfd_arch_h8300
:
1942 *magicp
= H8300MAGIC
;
1946 #ifdef A29K_MAGIC_BIG
1948 if (abfd
->xvec
->byteorder_big_p
)
1949 *magicp
= A29K_MAGIC_BIG
;
1951 *magicp
= A29K_MAGIC_LITTLE
;
1957 case bfd_arch_rs6000
:
1958 *magicp
= U802TOCMAGIC
;
1962 default: /* Unknown architecture */
1963 /* return false; -- fall through to "return false" below, to avoid
1964 "statement never reached" errors on the one below. */
1973 DEFUN(coff_set_arch_mach
,(abfd
, arch
, machine
),
1975 enum bfd_architecture arch AND
1976 unsigned long machine
)
1979 unsigned short dummy2
;
1980 bfd_default_set_arch_mach(abfd
, arch
, machine
);
1982 if (arch
!= bfd_arch_unknown
&&
1983 coff_set_flags(abfd
, &dummy1
, &dummy2
) != true)
1984 return false; /* We can't represent this type */
1985 return true; /* We're easy ... */
1989 /* Calculate the file position for each section. */
1992 DEFUN(coff_compute_section_file_positions
,(abfd
),
1996 asection
*previous
= (asection
*)NULL
;
1997 file_ptr sofar
= FILHSZ
;
1999 if (bfd_get_start_address(abfd
))
2001 /* A start address may have been added to the original file. In this
2002 case it will need an optional header to record it. */
2003 abfd
->flags
|= EXEC_P
;
2006 if (abfd
->flags
& EXEC_P
)
2009 sofar
+= abfd
->section_count
* SCNHSZ
;
2010 for (current
= abfd
->sections
;
2011 current
!= (asection
*)NULL
;
2012 current
= current
->next
) {
2014 /* Only deal with sections which have contents */
2015 if (!(current
->flags
& SEC_HAS_CONTENTS
))
2018 /* Align the sections in the file to the same boundary on
2019 which they are aligned in virtual memory. I960 doesn't
2020 do this (FIXME) so we can stay in sync with Intel. 960
2021 doesn't yet page from files... */
2024 /* make sure this section is aligned on the right boundary - by
2025 padding the previous section up if necessary */
2028 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2029 if (previous
!= (asection
*)NULL
) {
2030 previous
->size
+= sofar
- old_sofar
;
2035 /* FIXME, in demand paged files, the low order bits of the file
2036 offset must match the low order bits of the virtual address.
2037 "Low order" is apparently implementation defined. Add code
2038 here to round sofar up to match the virtual address. */
2040 current
->filepos
= sofar
;
2042 /* make sure that this section is of the right size too */
2043 old_sofar
= sofar
+= current
->size
;
2044 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2045 current
->size
+= sofar
- old_sofar
;
2049 obj_relocbase(abfd
) = sofar
;
2058 DEFUN(coff_write_object_contents
,(abfd
),
2062 boolean hasrelocs
= false;
2063 boolean haslinno
= false;
2064 file_ptr reloc_base
;
2065 file_ptr lineno_base
;
2069 unsigned long reloc_size
= 0;
2070 unsigned long lnno_size
= 0;
2071 asection
*text_sec
= NULL
;
2072 asection
*data_sec
= NULL
;
2073 asection
*bss_sec
= NULL
;
2075 struct internal_filehdr internal_f
;
2076 struct internal_aouthdr internal_a
;
2079 bfd_error
= system_call_error
;
2082 if(abfd
->output_has_begun
== false) {
2083 coff_compute_section_file_positions(abfd
);
2086 if (abfd
->sections
!= (asection
*)NULL
) {
2087 scn_base
= abfd
->sections
->filepos
;
2092 if (bfd_seek(abfd
, scn_base
, SEEK_SET
) != 0)
2094 reloc_base
= obj_relocbase(abfd
);
2096 /* Make a pass through the symbol table to count line number entries and
2097 put them into the correct asections */
2099 #ifndef NO_COFF_LINENOS
2100 coff_count_linenumbers(abfd
);
2102 data_base
= scn_base
;
2104 /* Work out the size of the reloc and linno areas */
2106 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
) {
2107 reloc_size
+= current
->reloc_count
* RELSZ
;
2108 #ifndef NO_COFF_LINENOS
2109 lnno_size
+= current
->lineno_count
* LINESZ
;
2111 data_base
+= SCNHSZ
;
2114 lineno_base
= reloc_base
+ reloc_size
;
2115 sym_base
= lineno_base
+ lnno_size
;
2117 /* Indicate in each section->line_filepos its actual file address */
2118 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
) {
2119 if (current
->lineno_count
) {
2120 current
->line_filepos
= lineno_base
;
2121 current
->moving_line_filepos
= lineno_base
;
2122 #ifndef NO_COFF_LINENOS
2123 lineno_base
+= current
->lineno_count
* LINESZ
;
2127 current
->line_filepos
= 0;
2129 if (current
->reloc_count
) {
2130 current
->rel_filepos
= reloc_base
;
2131 reloc_base
+= current
->reloc_count
* sizeof(struct internal_reloc
);
2134 current
->rel_filepos
= 0;
2138 /* Write section headers to the file. */
2141 (file_ptr
) ((abfd
->flags
& EXEC_P
) ?
2142 (FILHSZ
+ AOUTSZ
) : FILHSZ
),
2147 unsigned int pad
= abfd
->flags
& D_PAGED
? data_base
: 0;
2149 unsigned int pad
= 0;
2151 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
) {
2152 struct internal_scnhdr section
;
2153 strncpy(&(section
.s_name
[0]), current
->name
, 8);
2154 section
.s_vaddr
= current
->vma
+ pad
;
2155 section
.s_paddr
= current
->vma
+ pad
;
2156 section
.s_size
= current
->size
- pad
;
2158 If this section has no size or is unloadable then the scnptr
2161 if (current
->size
- pad
== 0 ||
2162 (current
->flags
& SEC_LOAD
) == 0) {
2163 section
.s_scnptr
= 0;
2166 section
.s_scnptr
= current
->filepos
;
2168 section
.s_relptr
= current
->rel_filepos
;
2169 section
.s_lnnoptr
= current
->line_filepos
;
2170 section
.s_nreloc
= current
->reloc_count
;
2171 section
.s_nlnno
= current
->lineno_count
;
2172 if (current
->reloc_count
!= 0)
2174 if (current
->lineno_count
!= 0)
2177 section
.s_flags
= sec_to_styp_flags(current
->name
,current
->flags
);
2179 if (!strcmp(current
->name
, _TEXT
)) {
2181 } else if (!strcmp(current
->name
, _DATA
)) {
2183 } else if (!strcmp(current
->name
, _BSS
)) {
2188 section
.s_align
= (current
->alignment_power
2189 ? 1 << current
->alignment_power
2196 coff_swap_scnhdr_out(abfd
, §ion
, &buff
);
2197 bfd_write((PTR
) (&buff
), 1, SCNHSZ
, abfd
);
2204 /* OK, now set up the filehdr... */
2205 internal_f
.f_nscns
= abfd
->section_count
;
2207 We will NOT put a fucking timestamp in the header here. Every time you
2208 put it back, I will come in and take it out again. I'm sorry. This
2209 field does not belong here. We fill it with a 0 so it compares the
2210 same but is not a reasonable time. -- gnu@cygnus.com
2213 Well, I like it, so I'm conditionally compiling it in.
2216 #ifdef COFF_TIMESTAMP
2217 internal_f
.f_timdat
= time(0);
2219 internal_f
.f_timdat
= 0;
2222 if (bfd_get_symcount(abfd
) != 0)
2223 internal_f
.f_symptr
= sym_base
;
2225 internal_f
.f_symptr
= 0;
2227 internal_f
.f_flags
= 0;
2229 if (abfd
->flags
& EXEC_P
)
2230 internal_f
.f_opthdr
= AOUTSZ
;
2232 internal_f
.f_opthdr
= 0;
2235 internal_f
.f_flags
|= F_RELFLG
;
2237 internal_f
.f_flags
|= F_LNNO
;
2238 if (0 == bfd_get_symcount(abfd
))
2239 internal_f
.f_flags
|= F_LSYMS
;
2240 if (abfd
->flags
& EXEC_P
)
2241 internal_f
.f_flags
|= F_EXEC
;
2243 internal_f
.f_flags
|= F_AR32W
;
2245 if (!abfd
->xvec
->byteorder_big_p
)
2246 internal_f
.f_flags
|= F_AR32WR
;
2249 FIXME, should do something about the other byte orders and
2253 /* Set up architecture-dependent stuff */
2255 { unsigned int magic
= 0;
2256 unsigned short flags
= 0;
2257 coff_set_flags(abfd
, &magic
, &flags
);
2258 internal_f
.f_magic
= magic
;
2259 internal_f
.f_flags
|= flags
;
2260 /* ...and the "opt"hdr... */
2263 # ifdef ULTRA3 /* NYU's machine */
2264 /* FIXME: This is a bogus check. I really want to see if there
2265 * is a .shbss or a .shdata section, if so then set the magic
2266 * number to indicate a shared data executable.
2268 if (internal_f
.f_nscns
>= 7)
2269 internal_a
.magic
= SHMAGIC
; /* Shared magic */
2271 # endif /* ULTRA3 */
2272 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
2273 #define __A_MAGIC_SET__
2276 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
2277 #define __A_MAGIC_SET__
2280 #define __A_MAGIC_SET__
2281 internal_a
.magic
= PAGEMAGICBCS
;
2284 #if M68 || I386 || MIPS
2285 #define __A_MAGIC_SET__
2286 /* Never was anything here for the 68k */
2290 #define __A_MAGIC_SET__
2291 internal_a
.magic
= (abfd
->flags
& D_PAGED
)? RS6K_AOUTHDR_ZMAGIC
:
2292 (abfd
->flags
& WP_TEXT
)? RS6K_AOUTHDR_NMAGIC
:
2293 RS6K_AOUTHDR_OMAGIC
;
2296 #ifndef __A_MAGIC_SET__
2297 # include "Your aouthdr magic number is not being set!"
2299 # undef __A_MAGIC_SET__
2302 /* Now should write relocs, strings, syms */
2303 obj_sym_filepos(abfd
) = sym_base
;
2305 #ifndef NO_COFF_SYMBOLS
2306 if (bfd_get_symcount(abfd
) != 0) {
2307 coff_renumber_symbols(abfd
);
2308 coff_mangle_symbols(abfd
);
2309 coff_write_symbols(abfd
);
2310 coff_write_linenumbers(abfd
);
2311 coff_write_relocs(abfd
);
2313 #endif /* NO_COFF_SYMBOLS */
2315 internal_a
.tsize
= text_sec
->size
;
2316 internal_a
.text_start
=text_sec
->size
? text_sec
->vma
: 0;
2319 internal_a
.dsize
= data_sec
->size
;
2320 internal_a
.data_start
= data_sec
->size
? data_sec
->vma
: 0;
2323 internal_a
.bsize
= bss_sec
->size
;
2326 internal_a
.entry
= bfd_get_start_address(abfd
);
2327 internal_f
.f_nsyms
= bfd_get_symcount(abfd
);
2329 /* now write them */
2330 if (bfd_seek(abfd
, 0L, SEEK_SET
) != 0)
2334 coff_swap_filehdr_out(abfd
, &internal_f
, &buff
);
2335 bfd_write((PTR
) &buff
, 1, FILHSZ
, abfd
);
2337 if (abfd
->flags
& EXEC_P
) {
2339 coff_swap_aouthdr_out(abfd
, &internal_a
, &buff
);
2340 bfd_write((PTR
) &buff
, 1, AOUTSZ
, abfd
);
2345 #ifndef NO_COFF_SYMBOLS
2348 this function transforms the offsets into the symbol table into
2349 pointers to syments.
2354 DEFUN(coff_pointerize_aux
,(ignore_abfd
, table_base
, type
, class, auxent
),
2355 bfd
*ignore_abfd AND
2356 combined_entry_type
*table_base AND
2359 combined_entry_type
*auxent
)
2361 /* Don't bother if this is a file or a section */
2362 if (class == C_STAT
&& type
== T_NULL
) return;
2363 if (class == C_FILE
) return;
2365 /* Otherwise patch up */
2366 if (ISFCN(type
) || ISTAG(class) || class == C_BLOCK
) {
2367 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
= table_base
+
2368 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2369 auxent
->fix_end
= 1;
2371 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
!= 0) {
2372 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
= table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
2373 auxent
->fix_tag
= 1;
2377 #endif /* NO_COFF_SYMBOLS */
2380 DEFUN(coff_set_section_contents
,(abfd
, section
, location
, offset
, count
),
2385 bfd_size_type count
)
2387 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
2388 coff_compute_section_file_positions(abfd
);
2390 bfd_seek(abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
);
2393 return (bfd_write(location
, 1, count
, abfd
) == count
) ? true : false;
2399 coff_close_and_cleanup(abfd
)
2402 if (!bfd_read_p(abfd
))
2403 switch (abfd
->format
) {
2405 if (!_bfd_write_archive_contents(abfd
))
2409 if (!coff_write_object_contents(abfd
))
2413 bfd_error
= invalid_operation
;
2417 /* We depend on bfd_close to free all the memory on the obstack. */
2418 /* FIXME if bfd_release is not using obstacks! */
2424 buy_and_read(abfd
, where
, seek_direction
, size
)
2430 PTR area
= (PTR
) bfd_alloc(abfd
, size
);
2432 bfd_error
= no_memory
;
2435 bfd_seek(abfd
, where
, seek_direction
);
2436 if (bfd_read(area
, 1, size
, abfd
) != size
) {
2437 bfd_error
= system_call_error
;
2441 } /* buy_and_read() */
2444 #ifndef NO_COFF_SYMBOLS
2447 DEFUN(build_string_table
,(abfd
),
2450 char string_table_size_buffer
[4];
2451 unsigned int string_table_size
;
2454 /* At this point we should be "seek"'d to the end of the
2455 symbols === the symbol table size. */
2456 if (bfd_read((char *) string_table_size_buffer
,
2457 sizeof(string_table_size_buffer
),
2458 1, abfd
) != sizeof(string_table_size
)) {
2459 bfd_error
= system_call_error
;
2463 string_table_size
= bfd_h_get_32(abfd
, (bfd_byte
*) string_table_size_buffer
);
2465 if ((string_table
= (PTR
) bfd_alloc(abfd
, string_table_size
-= 4)) == NULL
) {
2466 bfd_error
= no_memory
;
2468 } /* on mallocation error */
2469 if (bfd_read(string_table
, string_table_size
, 1, abfd
) != string_table_size
) {
2470 bfd_error
= system_call_error
;
2473 return string_table
;
2476 /* Allocate space for the ".debug" section, and read it.
2477 We did not read the debug section until now, because
2478 we didn't want to go to the trouble until someone needed it. */
2481 DEFUN(build_debug_section
,(abfd
),
2484 char *debug_section
;
2487 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
2490 bfd_error
= no_debug_section
;
2494 debug_section
= (PTR
) bfd_alloc (abfd
, bfd_section_size (abfd
, sect
));
2495 if (debug_section
== NULL
) {
2496 bfd_error
= no_memory
;
2500 /* Seek to the beginning of the `.debug' section and read it.
2501 Save the current position first; it is needed by our caller.
2502 Then read debug section and reset the file pointer. */
2504 position
= bfd_tell (abfd
);
2505 bfd_seek (abfd
, sect
->filepos
, SEEK_SET
);
2506 if (bfd_read (debug_section
, bfd_section_size (abfd
, sect
), 1, abfd
)
2507 != bfd_section_size (abfd
, sect
)) {
2508 bfd_error
= system_call_error
;
2511 bfd_seek (abfd
, position
, SEEK_SET
);
2512 return debug_section
;
2516 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
2517 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
2518 be \0-terminated. */
2520 DEFUN(copy_name
,(abfd
, name
, maxlen
),
2528 for (len
= 0; len
< maxlen
; ++len
) {
2529 if (name
[len
] == '\0') {
2534 if ((newname
= (PTR
) bfd_alloc(abfd
, len
+1)) == NULL
) {
2535 bfd_error
= no_memory
;
2538 strncpy(newname
, name
, len
);
2539 newname
[len
] = '\0';
2544 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
2545 knit the symbol names into a normalized form. By normalized here I
2546 mean that all symbols have an n_offset pointer that points to a null-
2547 terminated string. */
2549 #ifndef SYMNAME_IN_DEBUG
2550 #define SYMNAME_IN_DEBUG(x) 0
2553 static combined_entry_type
*
2554 DEFUN(get_normalized_symtab
,(abfd
),
2557 combined_entry_type
*internal
;
2558 combined_entry_type
*internal_ptr
;
2559 combined_entry_type
*internal_end
;
2563 char *string_table
= NULL
;
2564 char *debug_section
= NULL
;
2567 unsigned int raw_size
;
2568 if (obj_raw_syments(abfd
) != (combined_entry_type
*)NULL
) {
2569 return obj_raw_syments(abfd
);
2571 if ((size
= bfd_get_symcount(abfd
) * sizeof(combined_entry_type
)) == 0) {
2572 bfd_error
= no_symbols
;
2576 internal
= (combined_entry_type
*)bfd_alloc(abfd
, size
);
2577 internal_end
= internal
+ bfd_get_symcount(abfd
);
2579 raw_size
= bfd_get_symcount(abfd
) * SYMESZ
;
2580 raw
= (SYMENT
*)bfd_alloc(abfd
,raw_size
);
2582 if (bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
) == -1
2583 || bfd_read((PTR
)raw
, raw_size
, 1, abfd
) != raw_size
) {
2584 bfd_error
= system_call_error
;
2587 /* mark the end of the symbols */
2588 raw_end
= raw
+ bfd_get_symcount(abfd
);
2590 FIXME SOMEDAY. A string table size of zero is very weird, but
2591 probably possible. If one shows up, it will probably kill us.
2594 /* Swap all the raw entries */
2595 for (raw_src
= raw
, internal_ptr
= internal
;
2597 raw_src
++, internal_ptr
++) {
2600 coff_swap_sym_in(abfd
, (char *)raw_src
, (char *)&internal_ptr
->u
.syment
);
2601 internal_ptr
->fix_tag
= 0;
2602 internal_ptr
->fix_end
= 0;
2604 for (i
= internal_ptr
->u
.syment
.n_numaux
;
2606 --i
, raw_src
++, internal_ptr
++) {
2608 (internal_ptr
+1)->fix_tag
= 0;
2609 (internal_ptr
+1)->fix_end
= 0;
2611 coff_swap_aux_in(abfd
, (char *)(raw_src
+1),
2612 internal_ptr
->u
.syment
.n_type
,
2613 internal_ptr
->u
.syment
.n_sclass
,
2614 &(internal_ptr
+1)->u
.auxent
);
2616 coff_pointerize_aux(abfd
,
2618 internal_ptr
->u
.syment
.n_type
,
2619 internal_ptr
->u
.syment
.n_sclass
,
2624 /* Free all the raw stuff */
2625 bfd_release(abfd
, raw
);
2627 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
2630 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
) {
2631 /* make a file symbol point to the name in the auxent, since
2632 the text ".file" is redundant */
2633 if ((internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_zeroes
== 0) {
2634 /* the filename is a long one, point into the string table */
2635 if (string_table
== NULL
) {
2636 string_table
= build_string_table(abfd
);
2639 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
2640 (int) (string_table
- 4 +
2641 (internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_offset
);
2644 /* ordinary short filename, put into memory anyway */
2645 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2646 copy_name(abfd
, (internal_ptr
+1)->u
.auxent
.x_file
.x_fname
,
2651 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0) {
2652 /* This is a "short" name. Make it long. */
2653 unsigned long i
= 0;
2654 char *newstring
= NULL
;
2656 /* find the length of this string without walking into memory
2658 for (i
= 0; i
< 8; ++i
) {
2659 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0') {
2661 } /* if end of string */
2662 } /* possible lengths of this string. */
2664 if ((newstring
= (PTR
) bfd_alloc(abfd
, ++i
)) == NULL
) {
2665 bfd_error
= no_memory
;
2668 bzero(newstring
, i
);
2669 strncpy(newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
-1);
2670 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int) newstring
;
2671 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
2673 else if (!SYMNAME_IN_DEBUG(&internal_ptr
->u
.syment
)) {
2674 /* Long name already. Point symbol at the string in the table. */
2675 if (string_table
== NULL
) {
2676 string_table
= build_string_table(abfd
);
2678 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2679 (string_table
- 4 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
2682 /* Long name in debug section. Very similar. */
2683 if (debug_section
== NULL
) {
2684 debug_section
= build_debug_section(abfd
);
2686 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2687 (debug_section
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
2690 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
2693 obj_raw_syments(abfd
) = internal
;
2696 } /* get_normalized_symtab() */
2698 #endif /* NO_COFF_SYMBOLS */
2702 DEFUN(section_from_bfd_index
,(abfd
, index
),
2707 struct sec
*answer
= abfd
->sections
;
2709 answer
= answer
->next
;
2716 #ifndef NO_COFF_LINENOS
2723 Creating the linenumber table is done by reading in the entire
2724 coff linenumber table, and creating another table for internal use.
2726 A coff line number table is structured so that each function
2727 is marked as having a line number of 0. Each line within the
2728 function is an offset from the first line in the function. The
2729 base of the line number information for the table is stored in
2730 the symbol associated with the function.
2732 The information is copied from the external to the internal
2733 table, and each symbol which marks a function is marked by
2736 How does this work ?
2741 coff_slurp_line_table(abfd
, asect
)
2745 LINENO
*native_lineno
;
2746 alent
*lineno_cache
;
2748 BFD_ASSERT(asect
->lineno
== (alent
*) NULL
);
2750 native_lineno
= (LINENO
*) buy_and_read(abfd
,
2751 asect
->line_filepos
,
2754 asect
->lineno_count
));
2756 (alent
*) bfd_alloc(abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof(alent
)));
2757 if (lineno_cache
== NULL
) {
2758 bfd_error
= no_memory
;
2761 unsigned int counter
= 0;
2762 alent
*cache_ptr
= lineno_cache
;
2763 LINENO
*src
= native_lineno
;
2765 while (counter
< asect
->lineno_count
) {
2766 struct internal_lineno dst
;
2767 coff_swap_lineno_in(abfd
, src
, &dst
);
2768 cache_ptr
->line_number
= dst
.l_lnno
;
2770 if (cache_ptr
->line_number
== 0) {
2771 coff_symbol_type
*sym
=
2772 (coff_symbol_type
*) (dst
.l_addr
.l_symndx
2773 + obj_raw_syments(abfd
))->u
.syment
._n
._n_n
._n_zeroes
;
2774 cache_ptr
->u
.sym
= (asymbol
*) sym
;
2775 sym
->lineno
= cache_ptr
;
2778 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
2779 - bfd_section_vma(abfd
, asect
);
2780 } /* If no linenumber expect a symbol index */
2786 cache_ptr
->line_number
= 0;
2789 asect
->lineno
= lineno_cache
;
2790 /* FIXME, free native_lineno here, or use alloca or something. */
2792 } /* coff_slurp_line_table() */
2794 #endif /* NO_COFF_LINENOS */
2796 #ifndef NO_COFF_LINENOS
2799 DEFUN(coff_slurp_symbol_table
,(abfd
),
2802 combined_entry_type
*native_symbols
;
2803 coff_symbol_type
*cached_area
;
2804 unsigned int *table_ptr
;
2806 unsigned int number_of_symbols
= 0;
2807 if (obj_symbols(abfd
))
2809 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
2811 /* Read in the symbol table */
2812 if ((native_symbols
= get_normalized_symtab(abfd
)) == NULL
) {
2816 /* Allocate enough room for all the symbols in cached form */
2818 (coff_symbol_type
*)
2819 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(coff_symbol_type
)));
2821 if (cached_area
== NULL
) {
2822 bfd_error
= no_memory
;
2827 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(unsigned int)));
2829 if (table_ptr
== NULL
) {
2830 bfd_error
= no_memory
;
2835 coff_symbol_type
*dst
= cached_area
;
2836 unsigned int last_native_index
= bfd_get_symcount(abfd
);
2837 unsigned int this_index
= 0;
2838 while (this_index
< last_native_index
) {
2839 combined_entry_type
*src
= native_symbols
+ this_index
;
2840 table_ptr
[this_index
] = number_of_symbols
;
2841 dst
->symbol
.the_bfd
= abfd
;
2843 dst
->symbol
.name
= (char *)(src
->u
.syment
._n
._n_n
._n_offset
);
2845 We use the native name field to point to the cached field
2847 src
->u
.syment
._n
._n_n
._n_zeroes
= (int) dst
;
2848 dst
->symbol
.section
= section_from_bfd_index(abfd
,
2849 src
->u
.syment
.n_scnum
);
2850 switch (src
->u
.syment
.n_sclass
) {
2854 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
2855 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2856 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
2858 /* Fall through to next case */
2866 if ((src
->u
.syment
.n_scnum
) == 0) {
2867 if ((src
->u
.syment
.n_value
) == 0) {
2868 dst
->symbol
.flags
= BSF_UNDEFINED
;
2869 dst
->symbol
.value
= 0;
2872 dst
->symbol
.flags
= BSF_FORT_COMM
;
2873 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2878 Base the value as an index from the base of the
2881 if (dst
->symbol
.section
== (asection
*) NULL
) {
2882 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
| BSF_ABSOLUTE
;
2883 dst
->symbol
.value
= src
->u
.syment
.n_value
;
2886 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2887 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
2889 if (ISFCN((src
->u
.syment
.n_type
))) {
2891 A function ext does not go at the end of a file
2893 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
2900 case C_STAT
: /* static */
2902 case C_LEAFSTAT
: /* static leaf procedure */
2904 case C_LABEL
: /* label */
2905 if (src
->u
.syment
.n_scnum
== -2)
2906 dst
->symbol
.flags
= BSF_DEBUGGING
;
2908 dst
->symbol
.flags
= BSF_LOCAL
;
2910 Base the value as an index from the base of the section, if
2913 if (dst
->symbol
.section
)
2914 dst
->symbol
.value
= (src
->u
.syment
.n_value
) -
2915 dst
->symbol
.section
->vma
;
2917 dst
->symbol
.value
= (src
->u
.syment
.n_value
) ;
2920 case C_MOS
: /* member of structure */
2921 case C_EOS
: /* end of structure */
2922 #ifdef NOTDEF /* C_AUTOARG has the same value */
2924 case C_GLBLREG
: /* A29k-specific storage class */
2927 case C_REGPARM
: /* register parameter */
2928 case C_REG
: /* register variable */
2930 case C_AUTOARG
: /* 960-specific storage class */
2932 case C_TPDEF
: /* type definition */
2934 case C_AUTO
: /* automatic variable */
2935 case C_FIELD
: /* bit field */
2936 case C_ENTAG
: /* enumeration tag */
2937 case C_MOE
: /* member of enumeration */
2938 case C_MOU
: /* member of union */
2939 case C_UNTAG
: /* union tag */
2940 dst
->symbol
.flags
= BSF_DEBUGGING
;
2941 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2944 case C_FILE
: /* file name */
2945 case C_STRTAG
: /* structure tag */
2947 case C_BINCL
: /* beginning of include file */
2948 case C_EINCL
: /* ending of include file */
2961 dst
->symbol
.flags
= BSF_DEBUGGING
;
2962 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2965 case C_BLOCK
: /* ".bb" or ".eb" */
2966 case C_FCN
: /* ".bf" or ".ef" */
2967 case C_EFCN
: /* physical end of function */
2968 dst
->symbol
.flags
= BSF_LOCAL
;
2970 Base the value as an index from the base of the section
2972 dst
->symbol
.value
= (src
->u
.syment
.n_value
) - dst
->symbol
.section
->vma
;
2976 case C_EXTDEF
: /* external definition */
2977 case C_ULABEL
: /* undefined label */
2978 case C_USTATIC
: /* undefined static */
2979 case C_LINE
: /* line # reformatted as symbol table entry */
2980 case C_ALIAS
: /* duplicate tag */
2981 case C_HIDDEN
: /* ext symbol in dmert public lib */
2984 fprintf(stderr
,"Unrecognized storage class %d\n",
2985 src
->u
.syment
.n_sclass
);
2987 dst
->symbol
.flags
= BSF_DEBUGGING
;
2988 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2992 BFD_ASSERT(dst
->symbol
.flags
!= 0);
2996 dst
->symbol
.udata
= 0;
2997 dst
->lineno
= (alent
*) NULL
;
2998 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
3000 number_of_symbols
++;
3001 } /* walk the native symtab */
3002 } /* bfdize the native symtab */
3004 obj_symbols(abfd
) = cached_area
;
3005 obj_raw_syments(abfd
) = native_symbols
;
3007 bfd_get_symcount(abfd
) = number_of_symbols
;
3008 obj_convert(abfd
) = table_ptr
;
3009 /* Slurp the line tables for each section too */
3014 coff_slurp_line_table(abfd
, p
);
3019 } /* coff_slurp_symbol_table() */
3022 coff_get_symtab_upper_bound(abfd
)
3025 if (!coff_slurp_symbol_table(abfd
))
3028 return (bfd_get_symcount(abfd
) + 1) * (sizeof(coff_symbol_type
*));
3033 DEFUN(coff_get_symtab
, (abfd
, alocation
),
3035 asymbol
**alocation
)
3037 unsigned int counter
= 0;
3038 coff_symbol_type
*symbase
;
3039 coff_symbol_type
**location
= (coff_symbol_type
**) (alocation
);
3040 if (!coff_slurp_symbol_table(abfd
))
3043 symbase
= obj_symbols(abfd
);
3044 while (counter
< bfd_get_symcount(abfd
))
3046 /* This nasty code looks at the symbol to decide whether or
3047 not it is descibes a constructor/destructor entry point. It
3048 is structured this way to (hopefully) speed non matches */
3050 if (0 && symbase
->symbol
.name
[9] == '$')
3052 bfd_constructor_entry(abfd
,
3053 (asymbol
**)location
,
3054 symbase
->symbol
.name
[10] == 'I' ?
3058 *(location
++) = symbase
++;
3062 return bfd_get_symcount(abfd
);
3065 #endif /* NO_COFF_SYMBOLS */
3068 coff_get_reloc_upper_bound(abfd
, asect
)
3072 if (bfd_get_format(abfd
) != bfd_object
) {
3073 bfd_error
= invalid_operation
;
3076 return (asect
->reloc_count
+ 1) * sizeof(arelent
*);
3084 Coff relocations are easily transformed into the internal BFD form
3087 Reading a coff relocation table is done in the following stages:
3089 o The entire coff relocation table is read into memory.
3091 o Each relocation is processed in turn, first it is swapped from the
3092 external to the internal form.
3094 o The symbol referenced in the relocation's symbol index is
3095 turned intoa pointer into the canonical symbol table. Note
3096 that this table is the same as the one returned by a call to
3097 @code{bfd_canonicalize_symtab}. The back end will call the
3098 routine and save the result if a canonicalization hasn't been done.
3100 o The reloc index is turned into a pointer to a howto
3101 structure, in a back end specific way. For instance, the 386
3102 and 960 use the @code{r_type} to directly produce an index
3103 into a howto table vector; the 88k subtracts a number from the
3104 @code{r_type} field and creates an addend field.
3110 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
3111 if (ptr && ptr->the_bfd == abfd \
3112 && ptr->section != (asection *) NULL \
3113 && ((ptr->flags & BSF_OLD_COMMON)== 0)) \
3115 cache_ptr->addend = -(ptr->section->vma + ptr->value); \
3118 cache_ptr->addend = 0; \
3123 DEFUN(coff_slurp_reloc_table
,(abfd
, asect
, symbols
),
3128 RELOC
*native_relocs
;
3129 arelent
*reloc_cache
;
3134 if (asect
->relocation
)
3136 if (asect
->reloc_count
== 0)
3138 if (asect
->flags
& SEC_CONSTRUCTOR
)
3140 #ifndef NO_COFF_SYMBOLS
3141 if (!coff_slurp_symbol_table(abfd
))
3145 (RELOC
*) buy_and_read(abfd
,
3149 asect
->reloc_count
));
3150 reloc_cache
= (arelent
*)
3151 bfd_alloc(abfd
, (size_t) (asect
->reloc_count
* sizeof(arelent
)));
3153 if (reloc_cache
== NULL
) {
3154 bfd_error
= no_memory
;
3159 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
3161 struct internal_reloc dst
;
3163 struct external_reloc
*src
;
3165 cache_ptr
= reloc_cache
+ idx
;
3166 src
= native_relocs
+ idx
;
3168 bfd_swap_reloc_in(abfd
, src
, &dst
);
3171 if (dst
.r_symndx
!= -1)
3173 cache_ptr
->sym_ptr_ptr
= symbols
+ obj_convert(abfd
)[dst
.r_symndx
];
3177 cache_ptr
->sym_ptr_ptr
= 0;
3184 /* AMD has two relocation entries for the 'consth' instruction.
3185 * The first is R_IHIHALF (part 1), the second is R_IHCONST
3186 * (part 2). The second entry's r_symndx does not contain
3187 * an index to a symbol but rather a value (apparently).
3188 * Also, see the ifdef below for saving the r_symndx value in addend.
3190 if (dst
.r_type
== R_IHCONST
) {
3195 ptr
= *(cache_ptr
->sym_ptr_ptr
);
3196 cache_ptr
->address
= dst
.r_vaddr
;
3198 The symbols definitions that we have read in have been
3199 relocated as if their sections started at 0. But the offsets
3200 refering to the symbols in the raw data have not been
3201 modified, so we have to have a negative addend to compensate.
3203 Note that symbols which used to be common must be left alone */
3206 cache_ptr
->address
= dst
.r_vaddr
;
3208 The symbols definitions that we have read in have been
3209 relocated as if their sections started at 0. But the offsets
3210 refering to the symbols in the raw data have not been
3211 modified, so we have to have a negative addend to compensate.
3213 Note that symbols which used to be common must be left alone */
3215 /* Calculate any reloc addend by looking at the symbol */
3216 CALC_ADDEND(abfd
, ptr
, dst
, cache_ptr
);
3218 cache_ptr
->address
-= asect
->vma
;
3219 cache_ptr
->section
= (asection
*) NULL
;
3221 /* Fill in the cache_ptr->howto field from dst.r_type */
3222 RTYPE2HOWTO(cache_ptr
, dst
);
3225 asect
->relocation
= reloc_cache
;
3230 /* This is stupid. This function should be a boolean predicate */
3232 DEFUN(coff_canonicalize_reloc
, (abfd
, section
, relptr
, symbols
),
3235 arelent
**relptr AND
3238 arelent
*tblptr
= section
->relocation
;
3239 unsigned int count
= 0;
3242 if (section
->flags
& SEC_CONSTRUCTOR
)
3244 /* this section has relocs made up by us, they are not in the
3245 file, so take them out of their chain and place them into
3246 the data area provided */
3247 arelent_chain
*chain
= section
->constructor_chain
;
3248 for (count
= 0; count
< section
->reloc_count
; count
++)
3250 *relptr
++ = &chain
->relent
;
3251 chain
= chain
->next
;
3257 coff_slurp_reloc_table(abfd
, section
, symbols
);
3260 tblptr
= section
->relocation
;
3264 for (; count
++ < section
->reloc_count
;)
3265 *relptr
++ = tblptr
++;
3270 return section
->reloc_count
;
3273 #ifndef NO_COFF_SYMBOLS
3276 provided a BFD, a section and an offset into the section, calculate and
3277 return the name of the source file and the line nearest to the wanted
3282 DEFUN(coff_find_nearest_line
,(abfd
,
3290 asection
*section AND
3291 asymbol
**ignore_symbols AND
3293 CONST
char **filename_ptr AND
3294 CONST
char **functionname_ptr AND
3295 unsigned int *line_ptr
)
3297 static bfd
*cache_abfd
;
3298 static asection
*cache_section
;
3299 static bfd_vma cache_offset
;
3300 static unsigned int cache_i
;
3301 static alent
*cache_l
;
3304 coff_data_type
*cof
= coff_data(abfd
);
3305 /* Run through the raw syments if available */
3306 combined_entry_type
*p
;
3308 unsigned int line_base
= 0;
3312 *functionname_ptr
= 0;
3315 /* Don't try and find line numbers in a non coff file */
3316 if (abfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
3322 p
= cof
->raw_syments
;
3324 for (i
= 0; i
< cof
->raw_syment_count
; i
++) {
3325 if (p
->u
.syment
.n_sclass
== C_FILE
) {
3326 /* File name has been moved into symbol */
3327 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
3330 p
+= 1 + p
->u
.syment
.n_numaux
;
3332 /* Now wander though the raw linenumbers of the section */
3334 If this is the same BFD as we were previously called with and this is
3335 the same section, and the offset we want is further down then we can
3336 prime the lookup loop
3338 if (abfd
== cache_abfd
&&
3339 section
== cache_section
&&
3340 offset
>= cache_offset
) {
3346 l
= section
->lineno
;
3349 for (; i
< section
->lineno_count
; i
++) {
3350 if (l
->line_number
== 0) {
3351 /* Get the symbol this line number points at */
3352 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
3353 *functionname_ptr
= coff
->symbol
.name
;
3355 combined_entry_type
*s
= coff
->native
;
3356 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
3358 S should now point to the .bf of the function
3360 if (s
->u
.syment
.n_numaux
) {
3362 The linenumber is stored in the auxent
3364 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
3365 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
3370 if (l
->u
.offset
> offset
)
3372 *line_ptr
= l
->line_number
+ line_base
+ 1;
3378 cache_section
= section
;
3379 cache_offset
= offset
;
3388 coff_sym_filepos(abfd
)
3391 return obj_sym_filepos(abfd
);
3395 #endif /* NO_COFF_SYMBOLS */
3399 DEFUN(coff_sizeof_headers
,(abfd
, reloc
),
3405 if (reloc
== false) {
3406 size
= FILHSZ
+ AOUTSZ
;
3412 size
+= abfd
->section_count
* SCNHSZ
;
3417 #define coff_core_file_failing_command _bfd_dummy_core_file_failing_command
3418 #define coff_core_file_failing_signal _bfd_dummy_core_file_failing_signal
3419 #define coff_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
3420 #define coff_slurp_armap bfd_slurp_coff_armap
3421 #define coff_slurp_extended_name_table _bfd_slurp_extended_name_table
3422 #define coff_truncate_arname bfd_dont_truncate_arname
3423 #define coff_openr_next_archived_file bfd_generic_openr_next_archived_file
3424 #define coff_generic_stat_arch_elt bfd_generic_stat_arch_elt
3425 #define coff_get_section_contents bfd_generic_get_section_contents
3426 #define coff_close_and_cleanup bfd_generic_close_and_cleanup
3428 #define coff_bfd_debug_info_start bfd_void
3429 #define coff_bfd_debug_info_end bfd_void
3430 #define coff_bfd_debug_info_accumulate (PROTO(void,(*),(bfd*, struct sec *))) bfd_void