1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright (C) 1990-1991 Free Software Foundation, Inc.
3 Written by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
26 BFD supports a number of different flavours of coff format.
27 The major difference between formats are the sizes and
28 alignments of fields in structures on disk, and the occasional
31 Coff in all its varieties is implimented with a few common
32 files and a number of implementation specific files. For
33 example, The 88k bcs coff format is implemented in the file
34 @code{coff-m88k.c}. This file @code{#include}s
35 @code{coff-m88k.h} which defines the external structure of the
36 coff format for the 88k, and @code{internalcoff.h} which
37 defines the internal structure. @code{coff-m88k.c} also
38 defines pthe relocations used by the 88k format
39 @xref{Relocations}. Then the major portion of coff code is
40 included (@code{coffcode.h}) which defines the methods used to
41 act upon the types defined in @code{coff-m88k.h} and
42 @code{internalcoff.h}.
45 The Intel i960 processor version of coff is implemented in
46 @code{coff-i960.c}. This file has the same structure as
47 @code{coff-m88k.c}, except that it includes @code{coff-i960.h}
48 rather than @code{coff-m88k.h}.
51 Porting To A New Version of Coff
53 The recommended method is to select from the existing
54 implimentations the version of coff which is most like the one
55 you want to use, for our purposes, we'll say that i386 coff is
56 the one you select, and that your coff flavour is called foo.
57 Copy the @code{i386coff.c} to @code{foocoff.c}, copy
58 @code{../include/i386coff.h} to @code{../include/foocoff.h}
59 and add the lines to @code{targets.c} and @code{Makefile.in}
60 so that your new back end is used. Alter the shapes of the
61 structures in @code{../include/foocoff.h} so that they match
62 what you need. You will probably also have to add
63 @code{#ifdef}s to the code in @code{internalcoff.h} and
64 @code{coffcode.h} if your version of coff is too wild.
66 You can verify that your new BFD backend works quite simply by
67 building @code{objdump} from the @code{binutils} directory,
68 and making sure that its version of what's going on at your
69 host systems idea (assuming it has the pretty standard coff
70 dump utility (usually called @code{att-dump} or just
71 @code{dump})) are the same. Then clean up your code, and send
72 what you've done to Cygnus. Then your stuff will be in the
73 next release, and you won't have to keep integrating it.
76 How The Coff Backend Works
81 Each flavour of coff supported in BFD has its own header file
82 descibing the external layout of the structures. There is also
83 an internal description of the coff layout (in
84 @code{internalcoff.h}) file (@code{}). A major function of the
85 coff backend is swapping the bytes and twiddling the bits to
86 translate the external form of the structures into the normal
87 internal form. This is all performed in the
88 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
89 elements are different sizes between different versions of
90 coff, it is the duty of the coff version specific include file
91 to override the definitions of various packing routines in
92 @code{coffcode.h}. Eg the size of line number entry in coff is
93 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
94 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
95 correct one. No doubt, some day someone will find a version of
96 coff which has a varying field size not catered for at the
97 moment. To port BFD, that person will have to add more @code{#defines}.
98 Three of the bit twiddling routines are exported to
99 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
100 and @code{coff_swap_linno_in}. @code{GDB} reads the symbol
101 table on its own, but uses BFD to fix things up. More of the
102 bit twiddlers are exported for @code{gas};
103 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
104 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
105 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
106 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
107 of all the symbol table and reloc drudgery itself, thereby
108 saving the internal BFD overhead, but uses BFD to swap things
109 on the way out, making cross ports much safer. This also
110 allows BFD (and thus the linker) to use the same header files
111 as @code{gas}, which makes one avenue to disaster disappear.
116 The simple canonical form for symbols used by BFD is not rich
117 enough to keep all the information available in a coff symbol
118 table. The back end gets around this by keeping the original
119 symbol table around, "behind the scenes".
121 When a symbol table is requested (through a call to
122 @code{bfd_canonicalize_symtab}, a request gets through to
123 @code{get_normalized_symtab}. This reads the symbol table from
124 the coff file and swaps all the structures inside into the
125 internal form. It also fixes up all the pointers in the table
126 (represented in the file by offsets from the first symbol in
127 the table) into physical pointers to elements in the new
128 internal table. This involves some work since the meanings of
129 fields changes depending upon context; a field that is a
130 pointer to another structure in the symbol table at one moment
131 may be the size in bytes of a structure in the next. Another
132 pass is made over the table. All symbols which mark file names
133 (<<C_FILE>> symbols) are modified so that the internal
134 string points to the value in the auxent (the real filename)
135 rather than the normal text associated with the symbol
138 At this time the symbol names are moved around. Coff stores
139 all symbols less than nine characters long physically
140 within the symbol table, longer strings are kept at the end of
141 the file in the string table. This pass moves all strings
142 into memory, and replaces them with pointers to the strings.
145 The symbol table is massaged once again, this time to create
146 the canonical table used by the BFD application. Each symbol
147 is inspected in turn, and a decision made (using the
148 @code{sclass} field) about the various flags to set in the
149 @code{asymbol} @xref{Symbols}. The generated canonical table
150 shares strings with the hidden internal symbol table.
152 Any linenumbers are read from the coff file too, and attached
153 to the symbols which own the functions the linenumbers belong to.
158 Writing a symbol to a coff file which didn't come from a coff
159 file will lose any debugging information. The @code{asymbol}
160 structure remembers the BFD from which was born, and on output
161 the back end makes sure that the same destination target as
162 source target is present.
164 When the symbols have come from a coff file then all the
165 debugging information is preserved.
167 Symbol tables are provided for writing to the back end in a
168 vector of pointers to pointers. This allows applications like
169 the linker to accumulate and output large symbol tables
170 without having to do too much byte copying.
172 This function runs through the provided symbol table and
173 patches each symbol marked as a file place holder
174 (@code{C_FILE}) to point to the next file place holder in the
175 list. It also marks each @code{offset} field in the list with
176 the offset from the first symbol of the current symbol.
178 Another function of this procedure is to turn the canonical
179 value form of BFD into the form used by coff. Internally, BFD
180 expects symbol values to be offsets from a section base; so a
181 symbol physically at 0x120, but in a section starting at
182 0x100, would have the value 0x20. Coff expects symbols to
183 contain their final value, so symbols have their values
184 changed at this point to reflect their sum with their owning
185 section. Note that this transformation uses the
186 <<output_section>> field of the @code{asymbol}'s
187 @code{asection} @xref{Sections}.
189 o coff_mangle_symbols
191 This routine runs though the provided symbol table and uses
192 the offsets generated by the previous pass and the pointers
193 generated when the symbol table was read in to create the
194 structured hierachy required by coff. It changes each pointer
195 to a symbol to an index into the symbol table of the symbol
200 This routine runs through the symbol table and patches up the
201 symbols from their internal form into the coff way, calls the
202 bit twiddlers and writes out the tabel to the file.
211 The hidden information for an asymbol is described in a
212 coff_ptr_struct, which is typedefed to a combined_entry_type
216 .typedef struct coff_ptr_struct
219 . {* Remembers the offset from the first symbol in the file for
220 . this symbol. Generated by coff_renumber_symbols. *}
221 .unsigned int offset;
223 . {* Should the tag field of this symbol be renumbered.
224 . Created by coff_pointerize_aux. *}
227 . {* Should the endidx field of this symbol be renumbered.
228 . Created by coff_pointerize_aux. *}
231 . {* The container for the symbol structure as read and translated
235 . union internal_auxent auxent;
236 . struct internal_syment syment;
238 .} combined_entry_type;
241 .{* Each canonical asymbol really looks like this: *}
243 .typedef struct coff_symbol_struct
245 . {* The actual symbol which the rest of BFD works with *}
248 . {* A pointer to the hidden information for this symbol *}
249 .combined_entry_type *native;
251 . {* A pointer to the linenumber information for this symbol *}
252 .struct lineno_cache_entry *lineno;
259 /* Most of this hacked by Steve Chamberlain, steve@cygnus.com */
262 #define PUTWORD bfd_h_put_32
263 #define PUTHALF bfd_h_put_16
264 #define PUTBYTE bfd_h_put_8
266 #ifndef GET_FCN_LNNOPTR
267 #define GET_FCN_LNNOPTR(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
270 #ifndef GET_FCN_ENDNDX
271 #define GET_FCN_ENDNDX(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
274 #ifndef PUT_FCN_LNNOPTR
275 #define PUT_FCN_LNNOPTR(abfd, in, ext) PUTWORD(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
277 #ifndef PUT_FCN_ENDNDX
278 #define PUT_FCN_ENDNDX(abfd, in, ext) PUTWORD(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
280 #ifndef GET_LNSZ_LNNO
281 #define GET_LNSZ_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_lnno)
283 #ifndef GET_LNSZ_SIZE
284 #define GET_LNSZ_SIZE(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_size)
286 #ifndef PUT_LNSZ_LNNO
287 #define PUT_LNSZ_LNNO(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_sym.x_misc.x_lnsz.x_lnno)
289 #ifndef PUT_LNSZ_SIZE
290 #define PUT_LNSZ_SIZE(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte*) ext->x_sym.x_misc.x_lnsz.x_size)
292 #ifndef GET_SCN_SCNLEN
293 #define GET_SCN_SCNLEN(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_scn.x_scnlen)
295 #ifndef GET_SCN_NRELOC
296 #define GET_SCN_NRELOC(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nreloc)
298 #ifndef GET_SCN_NLINNO
299 #define GET_SCN_NLINNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nlinno)
301 #ifndef PUT_SCN_SCNLEN
302 #define PUT_SCN_SCNLEN(abfd,in, ext) bfd_h_put_32(abfd, in, (bfd_byte *) ext->x_scn.x_scnlen)
304 #ifndef PUT_SCN_NRELOC
305 #define PUT_SCN_NRELOC(abfd,in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_scn.x_nreloc)
307 #ifndef PUT_SCN_NLINNO
308 #define PUT_SCN_NLINNO(abfd,in, ext) bfd_h_put_16(abfd,in, (bfd_byte *) ext->x_scn.x_nlinno)
310 #ifndef GET_LINENO_LNNO
311 #define GET_LINENO_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) (ext->l_lnno));
313 #ifndef PUT_LINENO_LNNO
314 #define PUT_LINENO_LNNO(abfd,val, ext) bfd_h_put_16(abfd,val, (bfd_byte *) (ext->l_lnno));
318 /* void warning(); */
321 * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the
322 * incoming SEC_* flags. The inverse of this function is styp_to_sec_flags().
323 * NOTE: If you add to/change this routine, you should mirror the changes
324 * in styp_to_sec_flags().
327 DEFUN(sec_to_styp_flags
, (sec_name
, sec_flags
),
328 CONST
char * sec_name AND
333 if (!strcmp(sec_name
, _TEXT
)) {
334 return((long)STYP_TEXT
);
335 } else if (!strcmp(sec_name
, _DATA
)) {
336 return((long)STYP_DATA
);
337 } else if (!strcmp(sec_name
, _BSS
)) {
338 return((long)STYP_BSS
);
340 } else if (!strcmp(sec_name
, _COMMENT
)) {
341 return((long)STYP_INFO
);
342 #endif /* _COMMENT */
345 /* Try and figure out what it should be */
346 if (sec_flags
& SEC_CODE
) styp_flags
= STYP_TEXT
;
347 if (sec_flags
& SEC_DATA
) styp_flags
= STYP_DATA
;
348 else if (sec_flags
& SEC_READONLY
)
349 #ifdef STYP_LIT /* 29k readonly text/data section */
350 styp_flags
= STYP_LIT
;
352 styp_flags
= STYP_TEXT
;
353 #endif /* STYP_LIT */
354 else if (sec_flags
& SEC_LOAD
) styp_flags
= STYP_TEXT
;
356 if (styp_flags
== 0) styp_flags
= STYP_BSS
;
361 * Return a word with SEC_* flags set to represent the incoming
362 * STYP_* flags (from scnhdr.s_flags). The inverse of this
363 * function is sec_to_styp_flags().
364 * NOTE: If you add to/change this routine, you should mirror the changes
365 * in sec_to_styp_flags().
368 DEFUN(styp_to_sec_flags
, (styp_flags
),
371 flagword sec_flags
=0;
373 if ((styp_flags
& STYP_TEXT
) || (styp_flags
& STYP_DATA
))
374 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
375 else if (styp_flags
& STYP_BSS
)
376 sec_flags
= SEC_ALLOC
;
378 #ifdef STYP_LIT /* A29k readonly text/data section type */
379 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
380 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
381 #endif /* STYP_LIT */
382 #ifdef STYP_OTHER_LOAD /* Other loaded sections */
383 if (styp_flags
& STYP_OTHER_LOAD
)
384 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
385 #endif /* STYP_SDATA */
390 #define get_index(symbol) ((int) (symbol)->value)
391 #define set_index(symbol, idx) ((symbol)->value = (idx))
393 /* **********************************************************************
394 Here are all the routines for swapping the structures seen in the
395 outside world into the internal forms.
400 DEFUN(bfd_swap_reloc_in
,(abfd
, reloc_src
, reloc_dst
),
403 struct internal_reloc
*reloc_dst
)
405 reloc_dst
->r_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*)reloc_src
->r_vaddr
);
406 reloc_dst
->r_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) reloc_src
->r_symndx
);
409 reloc_dst
->r_type
= bfd_h_get_8(abfd
, reloc_src
->r_type
);
410 reloc_dst
->r_size
= bfd_h_get_8(abfd
, reloc_src
->r_size
);
412 reloc_dst
->r_type
= bfd_h_get_16(abfd
, (bfd_byte
*) reloc_src
->r_type
);
415 #ifdef SWAP_IN_RELOC_OFFSET
416 reloc_dst
->r_offset
= SWAP_IN_RELOC_OFFSET(abfd
,
417 (bfd_byte
*) reloc_src
->r_offset
);
423 DEFUN(coff_swap_reloc_out
,(abfd
, src
, dst
),
428 struct internal_reloc
*reloc_src
= (struct internal_reloc
*)src
;
429 struct external_reloc
*reloc_dst
= (struct external_reloc
*)dst
;
430 bfd_h_put_32(abfd
, reloc_src
->r_vaddr
, (bfd_byte
*) reloc_dst
->r_vaddr
);
431 bfd_h_put_32(abfd
, reloc_src
->r_symndx
, (bfd_byte
*) reloc_dst
->r_symndx
);
432 bfd_h_put_16(abfd
, reloc_src
->r_type
, (bfd_byte
*)
435 #ifdef SWAP_OUT_RELOC_OFFSET
436 SWAP_OUT_RELOC_OFFSET(abfd
,
438 (bfd_byte
*) reloc_dst
->r_offset
);
440 #ifdef SWAP_OUT_RELOC_EXTRA
441 SWAP_OUT_RELOC_EXTRA(abfd
,reloc_src
, reloc_dst
);
444 return sizeof(struct external_reloc
);
448 DEFUN(bfd_swap_filehdr_in
,(abfd
, filehdr_src
, filehdr_dst
),
450 FILHDR
*filehdr_src AND
451 struct internal_filehdr
*filehdr_dst
)
453 filehdr_dst
->f_magic
= bfd_h_get_16(abfd
, (bfd_byte
*) filehdr_src
->f_magic
);
454 filehdr_dst
->f_nscns
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_nscns
);
455 filehdr_dst
->f_timdat
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_timdat
);
456 filehdr_dst
->f_symptr
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_symptr
);
457 filehdr_dst
->f_nsyms
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_nsyms
);
458 filehdr_dst
->f_opthdr
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_opthdr
);
459 filehdr_dst
->f_flags
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_flags
);
463 DEFUN(coff_swap_filehdr_out
,(abfd
, in
, out
),
468 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*)in
;
469 FILHDR
*filehdr_out
= (FILHDR
*)out
;
470 bfd_h_put_16(abfd
, filehdr_in
->f_magic
, (bfd_byte
*) filehdr_out
->f_magic
);
471 bfd_h_put_16(abfd
, filehdr_in
->f_nscns
, (bfd_byte
*) filehdr_out
->f_nscns
);
472 bfd_h_put_32(abfd
, filehdr_in
->f_timdat
, (bfd_byte
*) filehdr_out
->f_timdat
);
473 bfd_h_put_32(abfd
, filehdr_in
->f_symptr
, (bfd_byte
*) filehdr_out
->f_symptr
);
474 bfd_h_put_32(abfd
, filehdr_in
->f_nsyms
, (bfd_byte
*) filehdr_out
->f_nsyms
);
475 bfd_h_put_16(abfd
, filehdr_in
->f_opthdr
, (bfd_byte
*) filehdr_out
->f_opthdr
);
476 bfd_h_put_16(abfd
, filehdr_in
->f_flags
, (bfd_byte
*) filehdr_out
->f_flags
);
477 return sizeof(FILHDR
);
481 #ifndef NO_COFF_SYMBOLS
484 DEFUN(coff_swap_sym_in
,(abfd
, ext1
, in1
),
489 SYMENT
*ext
= (SYMENT
*)ext1
;
490 struct internal_syment
*in
= (struct internal_syment
*)in1
;
492 if( ext
->e
.e_name
[0] == 0) {
493 in
->_n
._n_n
._n_zeroes
= 0;
494 in
->_n
._n_n
._n_offset
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e
.e
.e_offset
);
497 #if SYMNMLEN != E_SYMNMLEN
498 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
500 memcpy(in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
503 in
->n_value
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_value
);
504 in
->n_scnum
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_scnum
);
505 if (sizeof(ext
->e_type
) == 2){
506 in
->n_type
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_type
);
509 in
->n_type
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_type
);
511 in
->n_sclass
= bfd_h_get_8(abfd
, ext
->e_sclass
);
512 in
->n_numaux
= bfd_h_get_8(abfd
, ext
->e_numaux
);
516 DEFUN(coff_swap_sym_out
,(abfd
, inp
, extp
),
521 struct internal_syment
*in
= (struct internal_syment
*)inp
;
522 SYMENT
*ext
=(SYMENT
*)extp
;
523 if(in
->_n
._n_name
[0] == 0) {
524 bfd_h_put_32(abfd
, 0, (bfd_byte
*) ext
->e
.e
.e_zeroes
);
525 bfd_h_put_32(abfd
, in
->_n
._n_n
._n_offset
, (bfd_byte
*) ext
->e
.e
.e_offset
);
528 #if SYMNMLEN != E_SYMNMLEN
529 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
531 memcpy(ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
534 bfd_h_put_32(abfd
, in
->n_value
, (bfd_byte
*) ext
->e_value
);
535 bfd_h_put_16(abfd
, in
->n_scnum
, (bfd_byte
*) ext
->e_scnum
);
536 if (sizeof(ext
->e_type
) == 2)
538 bfd_h_put_16(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
542 bfd_h_put_32(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
544 bfd_h_put_8(abfd
, in
->n_sclass
, ext
->e_sclass
);
545 bfd_h_put_8(abfd
, in
->n_numaux
, ext
->e_numaux
);
546 return sizeof(SYMENT
);
550 DEFUN(coff_swap_aux_in
,(abfd
, ext1
, type
, class, in1
),
557 AUXENT
*ext
= (AUXENT
*)ext1
;
558 union internal_auxent
*in
= (union internal_auxent
*)in1
;
561 if (ext
->x_file
.x_fname
[0] == 0) {
562 in
->x_file
.x_n
.x_zeroes
= 0;
563 in
->x_file
.x_n
.x_offset
=
564 bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
566 #if FILNMLEN != E_FILNMLEN
567 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
569 memcpy (in
->x_file
.x_fname
, ext
->x_file
.x_fname
, FILNMLEN
);
574 /* RS/6000 "csect" auxents */
578 in
->x_csect
.x_scnlen
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_scnlen
);
579 in
->x_csect
.x_parmhash
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_parmhash
);
580 in
->x_csect
.x_snhash
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snhash
);
581 /* We don't have to hack bitfields in x_smtyp because it's defined by
582 shifts-and-ands, which are equivalent on all byte orders. */
583 in
->x_csect
.x_smtyp
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smtyp
);
584 in
->x_csect
.x_smclas
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smclas
);
585 in
->x_csect
.x_stab
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_stab
);
586 in
->x_csect
.x_snstab
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snstab
);
595 if (type
== T_NULL
) {
596 in
->x_scn
.x_scnlen
= GET_SCN_SCNLEN(abfd
, ext
);
597 in
->x_scn
.x_nreloc
= GET_SCN_NRELOC(abfd
, ext
);
598 in
->x_scn
.x_nlinno
= GET_SCN_NLINNO(abfd
, ext
);
602 in
->x_sym
.x_tagndx
.l
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
604 in
->x_sym
.x_tvndx
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
607 if (ISARY(type
) || class == C_BLOCK
) {
608 #if DIMNUM != E_DIMNUM
609 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
611 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]);
612 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]);
613 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]);
614 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]);
617 in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= GET_FCN_LNNOPTR(abfd
, ext
);
618 in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= GET_FCN_ENDNDX(abfd
, ext
);
621 in
->x_sym
.x_misc
.x_fsize
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
624 in
->x_sym
.x_misc
.x_lnsz
.x_lnno
= GET_LNSZ_LNNO(abfd
, ext
);
625 in
->x_sym
.x_misc
.x_lnsz
.x_size
= GET_LNSZ_SIZE(abfd
, ext
);
631 DEFUN(coff_swap_aux_out
,(abfd
, inp
, type
, class, extp
),
638 union internal_auxent
*in
= (union internal_auxent
*)inp
;
639 AUXENT
*ext
= (AUXENT
*)extp
;
642 if (in
->x_file
.x_fname
[0] == 0) {
643 PUTWORD(abfd
, 0, (bfd_byte
*) ext
->x_file
.x_n
.x_zeroes
);
645 in
->x_file
.x_n
.x_offset
,
646 (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
649 #if FILNMLEN != E_FILNMLEN
650 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
652 memcpy (ext
->x_file
.x_fname
, in
->x_file
.x_fname
, FILNMLEN
);
658 /* RS/6000 "csect" auxents */
661 PUTWORD (abfd
, in
->x_csect
.x_scnlen
, ext
->x_csect
.x_scnlen
);
662 PUTWORD (abfd
, in
->x_csect
.x_parmhash
, ext
->x_csect
.x_parmhash
);
663 PUTHALF (abfd
, in
->x_csect
.x_snhash
, ext
->x_csect
.x_snhash
);
664 /* We don't have to hack bitfields in x_smtyp because it's defined by
665 shifts-and-ands, which are equivalent on all byte orders. */
666 PUTBYTE (abfd
, in
->x_csect
.x_smtyp
, ext
->x_csect
.x_smtyp
);
667 PUTBYTE (abfd
, in
->x_csect
.x_smclas
, ext
->x_csect
.x_smclas
);
668 PUTWORD (abfd
, in
->x_csect
.x_stab
, ext
->x_csect
.x_stab
);
669 PUTHALF (abfd
, in
->x_csect
.x_snstab
, ext
->x_csect
.x_snstab
);
678 if (type
== T_NULL
) {
679 PUT_SCN_SCNLEN(abfd
, in
->x_scn
.x_scnlen
, ext
);
680 PUT_SCN_NRELOC(abfd
, in
->x_scn
.x_nreloc
, ext
);
681 PUT_SCN_NLINNO(abfd
, in
->x_scn
.x_nlinno
, ext
);
685 PUTWORD(abfd
, in
->x_sym
.x_tagndx
.l
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
687 PUTWORD(abfd
, in
->x_sym
.x_tvndx
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
691 PUTWORD(abfd
, in
->x_sym
.x_misc
.x_fsize
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
692 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
693 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
697 if (ISARY(type
) || class == C_BLOCK
) {
698 #if DIMNUM != E_DIMNUM
699 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
701 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]);
702 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]);
703 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]);
704 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]);
707 PUT_LNSZ_LNNO(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
708 PUT_LNSZ_SIZE(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
710 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
711 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
716 return sizeof(AUXENT
);
719 #endif /* NO_COFF_SYMBOLS */
721 #ifndef NO_COFF_LINENOS
724 DEFUN(coff_swap_lineno_in
,(abfd
, ext1
, in1
),
729 LINENO
*ext
= (LINENO
*)ext1
;
730 struct internal_lineno
*in
= (struct internal_lineno
*)in1
;
732 in
->l_addr
.l_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->l_addr
.l_symndx
);
733 in
->l_lnno
= GET_LINENO_LNNO(abfd
, ext
);
737 DEFUN(coff_swap_lineno_out
,(abfd
, inp
, outp
),
742 struct internal_lineno
*in
= (struct internal_lineno
*)inp
;
743 struct external_lineno
*ext
= (struct external_lineno
*)outp
;
744 PUTWORD(abfd
, in
->l_addr
.l_symndx
, (bfd_byte
*)
745 ext
->l_addr
.l_symndx
);
747 PUT_LINENO_LNNO (abfd
, in
->l_lnno
, ext
);
748 return sizeof(struct external_lineno
);
751 #endif /* NO_COFF_LINENOS */
755 DEFUN(bfd_swap_aouthdr_in
,(abfd
, aouthdr_ext1
, aouthdr_int1
),
760 AOUTHDR
*aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
761 struct internal_aouthdr
*aouthdr_int
= (struct internal_aouthdr
*)aouthdr_int1
;
763 aouthdr_int
->magic
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->magic
);
764 aouthdr_int
->vstamp
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->vstamp
);
765 aouthdr_int
->tsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tsize
);
766 aouthdr_int
->dsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->dsize
);
767 aouthdr_int
->bsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->bsize
);
768 aouthdr_int
->entry
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->entry
);
769 aouthdr_int
->text_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->text_start
);
770 aouthdr_int
->data_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->data_start
);
772 aouthdr_int
->tagentries
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tagentries
);
776 aouthdr_int
->o_toc
= bfd_h_get_32(abfd
, aouthdr_ext
->o_toc
);
777 aouthdr_int
->o_snentry
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snentry
);
778 aouthdr_int
->o_sntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntext
);
779 aouthdr_int
->o_sndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sndata
);
780 aouthdr_int
->o_sntoc
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntoc
);
781 aouthdr_int
->o_snloader
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snloader
);
782 aouthdr_int
->o_snbss
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snbss
);
783 aouthdr_int
->o_algntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algntext
);
784 aouthdr_int
->o_algndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algndata
);
785 aouthdr_int
->o_modtype
= bfd_h_get_16(abfd
, aouthdr_ext
->o_modtype
);
786 aouthdr_int
->o_maxstack
= bfd_h_get_32(abfd
, aouthdr_ext
->o_maxstack
);
791 DEFUN(coff_swap_aouthdr_out
,(abfd
, in
, out
),
796 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*)in
;
797 AOUTHDR
*aouthdr_out
= (AOUTHDR
*)out
;
798 bfd_h_put_16(abfd
, aouthdr_in
->magic
, (bfd_byte
*) aouthdr_out
->magic
);
799 bfd_h_put_16(abfd
, aouthdr_in
->vstamp
, (bfd_byte
*) aouthdr_out
->vstamp
);
800 bfd_h_put_32(abfd
, aouthdr_in
->tsize
, (bfd_byte
*) aouthdr_out
->tsize
);
801 bfd_h_put_32(abfd
, aouthdr_in
->dsize
, (bfd_byte
*) aouthdr_out
->dsize
);
802 bfd_h_put_32(abfd
, aouthdr_in
->bsize
, (bfd_byte
*) aouthdr_out
->bsize
);
803 bfd_h_put_32(abfd
, aouthdr_in
->entry
, (bfd_byte
*) aouthdr_out
->entry
);
804 bfd_h_put_32(abfd
, aouthdr_in
->text_start
,
805 (bfd_byte
*) aouthdr_out
->text_start
);
806 bfd_h_put_32(abfd
, aouthdr_in
->data_start
, (bfd_byte
*) aouthdr_out
->data_start
);
808 bfd_h_put_32(abfd
, aouthdr_in
->tagentries
, (bfd_byte
*) aouthdr_out
->tagentries
);
810 return sizeof(AOUTHDR
);
814 DEFUN(coff_swap_scnhdr_in
,(abfd
, scnhdr_ext
, scnhdr_int
),
816 SCNHDR
*scnhdr_ext AND
817 struct internal_scnhdr
*scnhdr_int
)
819 memcpy(scnhdr_int
->s_name
, scnhdr_ext
->s_name
, sizeof(scnhdr_int
->s_name
));
820 scnhdr_int
->s_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
821 scnhdr_int
->s_paddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
822 scnhdr_int
->s_size
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_size
);
824 scnhdr_int
->s_scnptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
825 scnhdr_int
->s_relptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
826 scnhdr_int
->s_lnnoptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
827 scnhdr_int
->s_flags
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_flags
);
829 scnhdr_int
->s_nreloc
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
830 scnhdr_int
->s_nlnno
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
832 scnhdr_int
->s_nreloc
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
833 scnhdr_int
->s_nlnno
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
836 scnhdr_int
->s_align
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_align
);
841 DEFUN(coff_swap_scnhdr_out
,(abfd
, in
, out
),
846 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*)in
;
847 SCNHDR
*scnhdr_ext
= (SCNHDR
*)out
;
848 memcpy(scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof(scnhdr_int
->s_name
));
849 PUTWORD(abfd
, scnhdr_int
->s_vaddr
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
850 PUTWORD(abfd
, scnhdr_int
->s_paddr
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
851 PUTWORD(abfd
, scnhdr_int
->s_size
, (bfd_byte
*) scnhdr_ext
->s_size
);
852 PUTWORD(abfd
, scnhdr_int
->s_scnptr
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
853 PUTWORD(abfd
, scnhdr_int
->s_relptr
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
854 PUTWORD(abfd
, scnhdr_int
->s_lnnoptr
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
855 PUTWORD(abfd
, scnhdr_int
->s_flags
, (bfd_byte
*) scnhdr_ext
->s_flags
);
857 PUTWORD(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
858 PUTWORD(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
860 PUTHALF(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
861 PUTHALF(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
865 PUTWORD(abfd
, scnhdr_int
->s_align
, (bfd_byte
*) scnhdr_ext
->s_align
);
867 return sizeof(SCNHDR
);
872 initialize a section structure with information peculiar to this
873 particular implementation of coff
877 DEFUN(coff_new_section_hook
,(abfd_ignore
, section
),
881 section
->alignment_power
= abfd_ignore
->xvec
->align_power_min
;
886 DEFUN(make_abs_section
,(abfd
),
893 /* Take a section header read from a coff file (in HOST byte order),
894 and make a BFD "section" out of it. */
896 DEFUN(make_a_section_from_file
,(abfd
, hdr
, target_index
),
898 struct internal_scnhdr
*hdr AND
899 unsigned int target_index
)
901 asection
*return_section
;
904 /* Assorted wastage to null-terminate the name, thanks AT&T! */
905 name
= bfd_alloc(abfd
, sizeof (hdr
->s_name
)+1);
907 bfd_error
= no_memory
;
910 strncpy(name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
911 name
[sizeof (hdr
->s_name
)] = 0;
913 return_section
= bfd_make_section(abfd
, name
);
914 if (return_section
== NULL
)
917 /* s_paddr is presumed to be = to s_vaddr */
919 return_section
->vma
= hdr
->s_vaddr
;
920 return_section
->_raw_size
= hdr
->s_size
;
921 return_section
->filepos
= hdr
->s_scnptr
;
922 return_section
->rel_filepos
= hdr
->s_relptr
;
923 return_section
->reloc_count
= hdr
->s_nreloc
;
926 /* FIXME, use a temp var rather than alignment_power */
927 return_section
->alignment_power
= hdr
->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 return_section
->line_filepos
= hdr
->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
);
949 return_section
->target_index
= target_index
;
951 if (hdr
->s_nreloc
!= 0)
952 return_section
->flags
|= SEC_RELOC
;
953 /* FIXME: should this check 'hdr->s_size > 0' */
954 if (hdr
->s_scnptr
!= 0)
955 return_section
->flags
|= SEC_HAS_CONTENTS
;
959 DEFUN(coff_mkobject
,(abfd
),
962 abfd
->tdata
.coff_obj_data
= (struct coff_tdata
*)bfd_zalloc (abfd
,sizeof(coff_data_type
));
963 if (abfd
->tdata
.coff_obj_data
== 0){
964 bfd_error
= no_memory
;
967 coff_data(abfd
)->relocbase
= 0;
968 make_abs_section(abfd
);
974 DEFUN(coff_real_object_p
,(abfd
, nscns
, internal_f
, internal_a
),
977 struct internal_filehdr
*internal_f AND
978 struct internal_aouthdr
*internal_a
)
980 coff_data_type
*coff
;
981 enum bfd_architecture arch
;
983 size_t readsize
; /* length of file_info */
984 SCNHDR
*external_sections
;
986 /* Build a play area */
987 if (coff_mkobject(abfd
) != true)
990 coff
= coff_data(abfd
);
993 external_sections
= (SCNHDR
*)bfd_alloc(abfd
, readsize
= (nscns
* SCNHSZ
));
995 if (bfd_read((PTR
)external_sections
, 1, readsize
, abfd
) != readsize
) {
1000 /* Now copy data as required; construct all asections etc */
1001 coff
->symbol_index_slew
= 0;
1003 coff
->raw_syment_count
= 0;
1004 coff
->raw_linenos
= 0;
1005 coff
->raw_syments
= 0;
1006 coff
->sym_filepos
=0;
1007 coff
->flags
= internal_f
->f_flags
;
1010 for (i
= 0; i
< nscns
; i
++) {
1011 struct internal_scnhdr tmp
;
1012 coff_swap_scnhdr_in(abfd
, external_sections
+ i
, &tmp
);
1013 make_a_section_from_file(abfd
,&tmp
, i
+1);
1017 /* make_abs_section(abfd);*/
1019 /* Determine the machine architecture and type. */
1021 switch (internal_f
->f_magic
) {
1024 arch
= bfd_arch_i386
;
1029 #ifdef A29K_MAGIC_BIG
1030 case A29K_MAGIC_BIG
:
1031 case A29K_MAGIC_LITTLE
:
1032 arch
= bfd_arch_a29k
;
1041 arch
= bfd_arch_mips
;
1049 arch
= bfd_arch_m68k
;
1057 arch
= bfd_arch_m88k
;
1065 arch
= bfd_arch_i960
;
1066 switch (F_I960TYPE
& internal_f
->f_flags
)
1070 machine
= bfd_mach_i960_core
;
1073 machine
= bfd_mach_i960_kb_sb
;
1076 machine
= bfd_mach_i960_mc
;
1079 machine
= bfd_mach_i960_xa
;
1082 machine
= bfd_mach_i960_ca
;
1085 machine
= bfd_mach_i960_ka_sa
;
1096 arch
= bfd_arch_rs6000
;
1103 arch
= bfd_arch_h8300
;
1108 default: /* Unreadable input file type */
1109 arch
= bfd_arch_obscure
;
1113 bfd_default_set_arch_mach(abfd
, arch
, machine
);
1114 if (!(internal_f
->f_flags
& F_RELFLG
))
1115 abfd
->flags
|= HAS_RELOC
;
1116 if ((internal_f
->f_flags
& F_EXEC
))
1117 abfd
->flags
|= EXEC_P
;
1118 if (!(internal_f
->f_flags
& F_LNNO
))
1119 abfd
->flags
|= HAS_LINENO
;
1120 if (!(internal_f
->f_flags
& F_LSYMS
))
1121 abfd
->flags
|= HAS_LOCALS
;
1124 bfd_get_symcount(abfd
) = internal_f
->f_nsyms
;
1125 if (internal_f
->f_nsyms
)
1126 abfd
->flags
|= HAS_SYMS
;
1128 coff
->sym_filepos
= internal_f
->f_symptr
;
1130 /* These members communicate important constants about the symbol table
1131 to GDB's symbol-reading code. These `constants' unfortunately vary
1132 from coff implementation to implementation... */
1133 #ifndef NO_COFF_SYMBOLS
1134 coff
->local_n_btmask
= N_BTMASK
;
1135 coff
->local_n_btshft
= N_BTSHFT
;
1136 coff
->local_n_tmask
= N_TMASK
;
1137 coff
->local_n_tshift
= N_TSHIFT
;
1138 coff
->local_symesz
= SYMESZ
;
1139 coff
->local_auxesz
= AUXESZ
;
1140 coff
->local_linesz
= LINESZ
;
1143 coff
->symbols
= (coff_symbol_type
*) NULL
;
1144 bfd_get_start_address(abfd
) = internal_f
->f_opthdr
? internal_a
->entry
: 0;
1148 bfd_release(abfd
, coff
);
1149 return (bfd_target
*)NULL
;
1153 DEFUN(coff_object_p
,(abfd
),
1159 struct internal_filehdr internal_f
;
1160 struct internal_aouthdr internal_a
;
1162 bfd_error
= system_call_error
;
1164 /* figure out how much to read */
1165 if (bfd_read((PTR
) &filehdr
, 1, FILHSZ
, abfd
) != FILHSZ
)
1168 bfd_swap_filehdr_in(abfd
, &filehdr
, &internal_f
);
1170 if (BADMAG(internal_f
)) {
1171 bfd_error
= wrong_format
;
1174 nscns
=internal_f
.f_nscns
;
1176 if (internal_f
.f_opthdr
) {
1177 if (bfd_read((PTR
) &opthdr
, 1,AOUTSZ
, abfd
) != AOUTSZ
) {
1180 bfd_swap_aouthdr_in(abfd
, (char *)&opthdr
, (char *)&internal_a
);
1183 /* Seek past the opt hdr stuff */
1184 bfd_seek(abfd
, internal_f
.f_opthdr
+ FILHSZ
, SEEK_SET
);
1186 /* if the optional header is NULL or not the correct size then
1187 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1188 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1189 optional header is of a different size.
1191 But the mips keeps extra stuff in it's opthdr, so dont check
1195 #if defined(M88) || defined(I960)
1196 if (internal_f
.f_opthdr
!= 0 && AOUTSZ
!= internal_f
.f_opthdr
)
1197 return (bfd_target
*)NULL
;
1200 return coff_real_object_p(abfd
, nscns
, &internal_f
, &internal_a
);
1205 #ifndef NO_COFF_LINENOS
1208 DEFUN(coff_count_linenumbers
,(abfd
),
1211 unsigned int limit
= bfd_get_symcount(abfd
);
1215 asection
*s
= abfd
->sections
->output_section
;
1217 BFD_ASSERT(s
->lineno_count
== 0);
1223 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++) {
1224 asymbol
*q_maybe
= *p
;
1225 if (q_maybe
->the_bfd
->xvec
->flavour
== bfd_target_coff_flavour
) {
1226 coff_symbol_type
*q
= coffsymbol(q_maybe
);
1229 This symbol has a linenumber, increment the owning
1230 section's linenumber count
1232 alent
*l
= q
->lineno
;
1233 q
->symbol
.section
->output_section
->lineno_count
++;
1235 while (l
->line_number
) {
1236 q
->symbol
.section
->output_section
->lineno_count
++;
1244 #endif /* NO_COFF_LINENOS */
1246 #ifndef NO_COFF_SYMBOLS
1249 Takes a bfd and a symbol, returns a pointer to the coff specific area
1250 of the symbol if there is one.
1252 static coff_symbol_type
*
1253 DEFUN(coff_symbol_from
,(ignore_abfd
, symbol
),
1254 bfd
*ignore_abfd AND
1257 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
1258 return (coff_symbol_type
*)NULL
;
1260 if (symbol
->the_bfd
->tdata
.coff_obj_data
== (coff_data_type
*)NULL
)
1261 return (coff_symbol_type
*)NULL
;
1263 return (coff_symbol_type
*) symbol
;
1269 DEFUN(fixup_symbol_value
,(coff_symbol_ptr
, syment
),
1270 coff_symbol_type
*coff_symbol_ptr AND
1271 struct internal_syment
*syment
)
1274 /* Normalize the symbol flags */
1275 if (coff_symbol_ptr
->symbol
.section
== &bfd_com_section
) {
1276 /* a common symbol is undefined with a value */
1277 syment
->n_scnum
= N_UNDEF
;
1278 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1280 else if (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) {
1281 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1283 else if (coff_symbol_ptr
->symbol
.section
== & bfd_und_section
) {
1284 syment
->n_scnum
= N_UNDEF
;
1285 syment
->n_value
= 0;
1288 if (coff_symbol_ptr
->symbol
.section
) {
1290 coff_symbol_ptr
->symbol
.section
->output_section
->target_index
;
1293 coff_symbol_ptr
->symbol
.value
+
1294 coff_symbol_ptr
->symbol
.section
->output_offset
+
1295 coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
1299 /* This can happen, but I don't know why yet (steve@cygnus.com) */
1300 syment
->n_scnum
= N_ABS
;
1301 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1306 /* run through all the symbols in the symbol table and work out what
1307 their indexes into the symbol table will be when output
1309 Coff requires that each C_FILE symbol points to the next one in the
1310 chain, and that the last one points to the first external symbol. We
1315 DEFUN(coff_renumber_symbols
,(bfd_ptr
),
1318 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1319 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1320 unsigned int native_index
= 0;
1321 struct internal_syment
*last_file
= (struct internal_syment
*)NULL
;
1322 unsigned int symbol_index
;
1323 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1325 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1326 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1327 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1330 if (s
->u
.syment
.n_sclass
== C_FILE
)
1332 if (last_file
!= (struct internal_syment
*)NULL
) {
1333 last_file
->n_value
= native_index
;
1335 last_file
= &(s
->u
.syment
);
1339 /* Modify the symbol values according to their section and
1342 fixup_symbol_value(coff_symbol_ptr
, &(s
->u
.syment
));
1344 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++) {
1345 s
[i
].offset
= native_index
++;
1356 Run thorough the symbol table again, and fix it so that all pointers to
1357 entries are changed to the entries' index in the output symbol table.
1361 DEFUN(coff_mangle_symbols
,(bfd_ptr
),
1364 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1365 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1366 unsigned int symbol_index
;
1368 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1370 coff_symbol_type
*coff_symbol_ptr
=
1371 coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1373 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1375 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1377 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++) {
1378 combined_entry_type
*a
= s
+ i
+ 1;
1380 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
1381 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
1384 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
1385 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
1393 static int string_size
;
1395 DEFUN(coff_fix_symbol_name
,(ignore_abfd
, symbol
, native
),
1396 bfd
*ignore_abfd AND
1398 combined_entry_type
*native
)
1400 unsigned int name_length
;
1401 union internal_auxent
*auxent
;
1402 char * name
= ( char *)(symbol
->name
);
1404 if (name
== (char *) NULL
) {
1405 /* coff symbols always have names, so we'll make one up */
1406 symbol
->name
= "strange";
1407 name
= (char *)symbol
->name
;
1409 name_length
= strlen(name
);
1411 if (native
->u
.syment
.n_sclass
== C_FILE
) {
1412 strncpy(native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
1413 auxent
= &(native
+1)->u
.auxent
;
1415 #ifdef COFF_LONG_FILENAMES
1416 if (name_length
<= FILNMLEN
) {
1417 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1420 auxent
->x_file
.x_n
.x_offset
= string_size
+ 4;
1421 auxent
->x_file
.x_n
.x_zeroes
= 0;
1422 string_size
+= name_length
+ 1;
1425 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1426 if (name_length
> FILNMLEN
) {
1427 name
[FILNMLEN
] = '\0';
1432 { /* NOT A C_FILE SYMBOL */
1433 if (name_length
<= SYMNMLEN
) {
1434 /* This name will fit into the symbol neatly */
1435 strncpy(native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
1438 native
->u
.syment
._n
._n_n
._n_offset
= string_size
+ 4;
1439 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1440 string_size
+= name_length
+ 1;
1448 DEFUN(coff_write_symbol
,(abfd
, symbol
, native
, written
),
1451 combined_entry_type
*native AND
1452 unsigned int written
)
1454 unsigned int numaux
= native
->u
.syment
.n_numaux
;
1455 int type
= native
->u
.syment
.n_type
;
1456 int class = native
->u
.syment
.n_sclass
;
1459 native
->u
.syment
.n_scnum
= symbol
->section
->output_section
->target_index
;
1461 coff_fix_symbol_name(abfd
, symbol
, native
);
1463 coff_swap_sym_out(abfd
, &native
->u
.syment
, &buf
);
1464 bfd_write((PTR
)& buf
, 1, SYMESZ
, abfd
);
1465 for (j
= 0; j
!= native
->u
.syment
.n_numaux
; j
++)
1468 bzero((PTR
)&buf
, AUXESZ
);
1469 coff_swap_aux_out(abfd
,
1470 &( (native
+ j
+ 1)->u
.auxent
), type
, class, &buf1
);
1471 bfd_write((PTR
) (&buf1
), 1, AUXESZ
, abfd
);
1474 Reuse somewhere in the symbol to keep the index
1476 set_index(symbol
, written
);
1477 return written
+ 1 + numaux
;
1482 DEFUN(coff_write_alien_symbol
,(abfd
, symbol
, written
),
1485 unsigned int written
)
1488 This symbol has been created by the loader, or come from a non
1489 coff format. It has no native element to inherit, make our
1492 combined_entry_type
*native
;
1493 combined_entry_type dummy
;
1495 native
->u
.syment
.n_type
= T_NULL
;
1497 native
->u
.syment
.n_flags
= 0;
1499 if (symbol
->section
== &bfd_und_section
) {
1500 native
->u
.syment
.n_scnum
= N_UNDEF
;
1501 native
->u
.syment
.n_value
= symbol
->value
;
1503 else if (symbol
->section
== &bfd_com_section
)
1505 native
->u
.syment
.n_scnum
= N_UNDEF
;
1506 native
->u
.syment
.n_value
= symbol
->value
;
1510 else if (symbol
->flags
& BSF_DEBUGGING
) {
1512 remove name so it doesn't take up any space
1517 native
->u
.syment
.n_scnum
= symbol
->section
->output_section
->target_index
;
1518 native
->u
.syment
.n_value
= symbol
->value
+
1519 symbol
->section
->output_section
->vma
+
1520 symbol
->section
->output_offset
;
1522 /* Copy the any flags from the the file hdr into the symbol */
1524 coff_symbol_type
*c
= coff_symbol_from(abfd
, symbol
);
1525 if (c
!= (coff_symbol_type
*)NULL
) {
1526 native
->u
.syment
.n_flags
= c
->symbol
.the_bfd
->flags
;
1533 native
->u
.syment
.pad1
[0] = 0;
1534 native
->u
.syment
.pad1
[0] = 0;
1537 native
->u
.syment
.n_type
= 0;
1538 if (symbol
->flags
& BSF_LOCAL
)
1539 native
->u
.syment
.n_sclass
= C_STAT
;
1541 native
->u
.syment
.n_sclass
= C_EXT
;
1542 native
->u
.syment
.n_numaux
= 0;
1544 return coff_write_symbol(abfd
, symbol
, native
, written
);
1548 DEFUN(coff_write_native_symbol
,(abfd
, symbol
, written
),
1550 coff_symbol_type
*symbol AND
1551 unsigned int written
)
1554 Does this symbol have an ascociated line number - if so then
1555 make it remember this symbol index. Also tag the auxent of
1556 this symbol to point to the right place in the lineno table
1558 combined_entry_type
*native
= symbol
->native
;
1560 alent
*lineno
= symbol
->lineno
;
1563 unsigned int count
= 0;
1564 lineno
[count
].u
.offset
= written
;
1565 if (native
->u
.syment
.n_numaux
) {
1566 union internal_auxent
*a
= &((native
+1)->u
.auxent
);
1568 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1569 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1572 And count and relocate all other linenumbers
1576 while (lineno
[count
].line_number
) {
1577 lineno
[count
].u
.offset
+=
1578 symbol
->symbol
.section
->output_section
->vma
+
1579 symbol
->symbol
.section
->output_offset
;
1582 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1585 return coff_write_symbol(abfd
, &( symbol
->symbol
), native
,written
);
1589 DEFUN(coff_write_symbols
,(abfd
),
1593 unsigned int limit
= bfd_get_symcount(abfd
);
1594 unsigned int written
= 0;
1601 /* Seek to the right place */
1602 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
1604 /* Output all the symbols we have */
1607 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1609 asymbol
*symbol
= *p
;
1610 coff_symbol_type
*c_symbol
= coff_symbol_from(abfd
, symbol
);
1612 if (c_symbol
== (coff_symbol_type
*) NULL
||
1613 c_symbol
->native
== (combined_entry_type
*)NULL
)
1615 written
= coff_write_alien_symbol(abfd
, symbol
, written
);
1619 written
= coff_write_native_symbol(abfd
, c_symbol
, written
);
1624 bfd_get_symcount(abfd
) = written
;
1626 /* Now write out strings */
1628 if (string_size
!= 0)
1630 unsigned int size
= string_size
+ 4;
1633 bfd_h_put_32(abfd
, size
, buffer
);
1634 bfd_write((PTR
) buffer
, 1, sizeof(buffer
), abfd
);
1635 for (p
= abfd
->outsymbols
, i
= 0;
1640 size_t name_length
= strlen(q
->name
);
1642 coff_symbol_type
* c_symbol
= coff_symbol_from(abfd
, q
);
1643 maxlen
= ((c_symbol
!= NULL
&& c_symbol
->native
!= NULL
) &&
1644 (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
)) ?
1645 FILNMLEN
: SYMNMLEN
;
1647 if (name_length
> maxlen
) {
1648 bfd_write((PTR
) (q
->name
), 1, name_length
+ 1, abfd
);
1653 /* We would normally not write anything here, but we'll write
1654 out 4 so that any stupid coff reader which tries to read
1655 the string table even when there isn't one won't croak.
1658 uint32e_type size
= 4;
1660 bfd_write((PTR
)&size
, 1, sizeof(size
), abfd
);
1669 To write relocations, all the back end does is step though the
1670 canonical relocation table, and create an
1671 @code{internal_reloc}. The symbol index to use is removed from
1672 the @code{offset} field in the symbol table supplied, the
1673 address comes directly from the sum of the section base
1674 address and the relocation offset and the type is dug directly
1675 from the howto field. Then the @code{internal_reloc} is
1676 swapped into the shape of an @code{external_reloc} and written
1682 DEFUN(coff_write_relocs
,(abfd
),
1686 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1688 struct external_reloc dst
;
1690 arelent
**p
= s
->orelocation
;
1691 bfd_seek(abfd
, s
->rel_filepos
, SEEK_SET
);
1692 for (i
= 0; i
< s
->reloc_count
; i
++) {
1693 struct internal_reloc n
;
1695 memset((PTR
)&n
, 0, sizeof(n
));
1696 n
.r_vaddr
= q
->address
+ s
->vma
;
1697 if (q
->sym_ptr_ptr
) {
1698 n
.r_symndx
= get_index((*(q
->sym_ptr_ptr
)));
1701 /* Work out reloc type from what is required */
1702 SELECT_RELOC(n
.r_type
, q
->howto
);
1704 n
.r_type
= q
->howto
->type
;
1706 coff_swap_reloc_out(abfd
, &n
, &dst
);
1707 bfd_write((PTR
) &n
, 1, RELSZ
, abfd
);
1711 #endif /* NO_COFF_SYMBOLS */
1713 #ifndef NO_COFF_LINENOS
1716 DEFUN(coff_write_linenumbers
,(abfd
),
1720 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1721 if (s
->lineno_count
) {
1722 asymbol
**q
= abfd
->outsymbols
;
1723 bfd_seek(abfd
, s
->line_filepos
, SEEK_SET
);
1724 /* Find all the linenumbers in this section */
1727 alent
*l
= BFD_SEND(p
->the_bfd
, _get_lineno
, (p
->the_bfd
, p
));
1729 /* Found a linenumber entry, output */
1730 struct internal_lineno out
;
1732 memset( (PTR
)&out
, 0, sizeof(out
));
1734 out
.l_addr
.l_symndx
= l
->u
.offset
;
1735 coff_swap_lineno_out(abfd
, &out
, &buff
);
1736 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1738 while (l
->line_number
) {
1739 out
.l_lnno
= l
->line_number
;
1740 out
.l_addr
.l_symndx
= l
->u
.offset
;
1741 coff_swap_lineno_out(abfd
, &out
, &buff
);
1742 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1753 DEFUN(coff_get_lineno
,(ignore_abfd
, symbol
),
1754 bfd
*ignore_abfd AND
1757 return coffsymbol(symbol
)->lineno
;
1760 #endif /* NO_COFF_LINENOS */
1763 coff_make_empty_symbol(abfd
)
1766 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc(abfd
, sizeof(coff_symbol_type
));
1768 bfd_error
= no_memory
;
1772 new->lineno
= (alent
*) NULL
;
1773 new->symbol
.the_bfd
= abfd
;
1774 return &new->symbol
;
1777 #ifndef NO_COFF_SYMBOLS
1780 DEFUN(coff_print_symbol
,(ignore_abfd
, filep
, symbol
, how
),
1781 bfd
*ignore_abfd AND
1784 bfd_print_symbol_type how
)
1786 FILE *file
= (FILE *)filep
;
1788 case bfd_print_symbol_name
:
1789 fprintf(file
, "%s", symbol
->name
);
1791 case bfd_print_symbol_more
:
1792 fprintf(file
, "coff %lx %lx", (unsigned long) coffsymbol(symbol
)->native
,
1793 (unsigned long) coffsymbol(symbol
)->lineno
);
1795 case bfd_print_symbol_nm
:
1798 CONST
char *section_name
= symbol
->section
->name
;
1799 bfd_print_symbol_vandf((PTR
) file
, symbol
);
1802 fprintf(file
, " %-5s %s %s %s",
1804 coffsymbol(symbol
)->native
? "n" : "g",
1805 coffsymbol(symbol
)->lineno
? "l" : " ",
1811 case bfd_print_symbol_all
:
1812 /* Print out the symbols in a reasonable way */
1814 CONST
char *section_name
= symbol
->section
->name
;
1817 if (coffsymbol(symbol
)->native
)
1820 combined_entry_type
*combined
= coffsymbol(symbol
)->native
;
1821 combined_entry_type
*root
= obj_raw_syments(ignore_abfd
);
1823 fprintf(file
,"[%3d]",
1827 fprintf(file
, "(sc %2d)(fl%4x)(ty%3x)(sc%3d) nx(%d) %08x %s",
1828 combined
->u
.syment
.n_scnum
,
1829 combined
->u
.syment
.n_flags
,
1830 combined
->u
.syment
.n_type
,
1831 combined
->u
.syment
.n_sclass
,
1832 combined
->u
.syment
.n_numaux
,
1833 combined
->u
.syment
.n_value
,
1836 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
1839 switch (combined
->u
.syment
.n_sclass
) {
1841 fprintf(file
, "File ");
1844 fprintf(file
, "AUX lnno %x size %x",
1845 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
1846 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
);
1859 bfd_print_symbol_vandf((PTR
) file
, symbol
);
1860 fprintf(file
, " %-5s %s %s %s",
1862 coffsymbol(symbol
)->native
? "n" : "g",
1863 coffsymbol(symbol
)->lineno
? "l" : " ",
1872 #endif /* NO_COFF_SYMBOLS */
1874 /* Set flags and magic number of a coff file from architecture and machine
1875 type. Result is true if we can represent the arch&type, false if not. */
1878 DEFUN(coff_set_flags
,(abfd
, magicp
, flagsp
),
1880 unsigned *magicp AND
1881 unsigned short *flagsp
)
1883 switch (bfd_get_arch(abfd
)) {
1891 *magicp
= I960ROMAGIC
;
1893 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1894 I960RWMAGIC); FIXME???
1896 switch (bfd_get_mach(abfd
)) {
1897 case bfd_mach_i960_core
:
1900 case bfd_mach_i960_kb_sb
:
1903 case bfd_mach_i960_mc
:
1906 case bfd_mach_i960_xa
:
1909 case bfd_mach_i960_ca
:
1912 case bfd_mach_i960_ka_sa
:
1925 *magicp
= MIPS_MAGIC_2
;
1931 *magicp
= I386MAGIC
;
1936 *magicp
= MC68MAGIC
;
1942 *magicp
= MC88OMAGIC
;
1947 case bfd_arch_h8300
:
1948 *magicp
= H8300MAGIC
;
1952 #ifdef A29K_MAGIC_BIG
1954 if (abfd
->xvec
->byteorder_big_p
)
1955 *magicp
= A29K_MAGIC_BIG
;
1957 *magicp
= A29K_MAGIC_LITTLE
;
1963 case bfd_arch_rs6000
:
1964 *magicp
= U802TOCMAGIC
;
1968 default: /* Unknown architecture */
1969 /* return false; -- fall through to "return false" below, to avoid
1970 "statement never reached" errors on the one below. */
1979 DEFUN(coff_set_arch_mach
,(abfd
, arch
, machine
),
1981 enum bfd_architecture arch AND
1982 unsigned long machine
)
1985 unsigned short dummy2
;
1986 bfd_default_set_arch_mach(abfd
, arch
, machine
);
1988 if (arch
!= bfd_arch_unknown
&&
1989 coff_set_flags(abfd
, &dummy1
, &dummy2
) != true)
1990 return false; /* We can't represent this type */
1991 return true; /* We're easy ... */
1995 /* Calculate the file position for each section. */
1998 DEFUN(coff_compute_section_file_positions
,(abfd
),
2002 asection
*previous
= (asection
*)NULL
;
2003 file_ptr sofar
= FILHSZ
;
2005 if (bfd_get_start_address(abfd
))
2007 /* A start address may have been added to the original file. In this
2008 case it will need an optional header to record it. */
2009 abfd
->flags
|= EXEC_P
;
2012 if (abfd
->flags
& EXEC_P
)
2015 sofar
+= abfd
->section_count
* SCNHSZ
;
2016 for (current
= abfd
->sections
;
2017 current
!= (asection
*)NULL
;
2018 current
= current
->next
) {
2020 /* Only deal with sections which have contents */
2021 if (!(current
->flags
& SEC_HAS_CONTENTS
))
2024 /* Align the sections in the file to the same boundary on
2025 which they are aligned in virtual memory. I960 doesn't
2026 do this (FIXME) so we can stay in sync with Intel. 960
2027 doesn't yet page from files... */
2030 /* make sure this section is aligned on the right boundary - by
2031 padding the previous section up if necessary */
2034 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2035 if (previous
!= (asection
*)NULL
) {
2036 previous
->_cooked_size
+= sofar
- old_sofar
;
2041 /* FIXME, in demand paged files, the low order bits of the file
2042 offset must match the low order bits of the virtual address.
2043 "Low order" is apparently implementation defined. Add code
2044 here to round sofar up to match the virtual address. */
2046 current
->filepos
= sofar
;
2048 /* make sure that this section is of the right size too */
2049 old_sofar
= sofar
+= current
->_cooked_size
;
2050 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2051 current
->_raw_size
+= sofar
- old_sofar
;
2055 obj_relocbase(abfd
) = sofar
;
2064 DEFUN(coff_write_object_contents
,(abfd
),
2070 boolean hasrelocs
= false;
2071 boolean haslinno
= false;
2072 file_ptr reloc_base
;
2073 file_ptr lineno_base
;
2077 unsigned long reloc_size
= 0;
2078 unsigned long lnno_size
= 0;
2079 asection
*text_sec
= NULL
;
2080 asection
*data_sec
= NULL
;
2081 asection
*bss_sec
= NULL
;
2083 struct internal_filehdr internal_f
;
2084 struct internal_aouthdr internal_a
;
2087 bfd_error
= system_call_error
;
2088 /* Number the output sections, starting from one on the first section
2089 with a name which doesn't start with a * */
2091 for (current
= abfd
->sections
; current
!= (asection
*)NULL
;
2092 current
= current
->next
)
2094 if (current
->name
[0] != '*')
2096 current
->target_index
= count
;
2103 if(abfd
->output_has_begun
== false) {
2104 coff_compute_section_file_positions(abfd
);
2107 if (abfd
->sections
!= (asection
*)NULL
) {
2108 scn_base
= abfd
->sections
->filepos
;
2113 if (bfd_seek(abfd
, scn_base
, SEEK_SET
) != 0)
2115 reloc_base
= obj_relocbase(abfd
);
2117 /* Make a pass through the symbol table to count line number entries and
2118 put them into the correct asections */
2120 #ifndef NO_COFF_LINENOS
2121 coff_count_linenumbers(abfd
);
2123 data_base
= scn_base
;
2125 /* Work out the size of the reloc and linno areas */
2127 for (current
= abfd
->sections
; current
!= NULL
; current
=
2130 /* We give section headers to +ve indexes */
2131 if (current
->target_index
> 0)
2134 reloc_size
+= current
->reloc_count
* RELSZ
;
2135 #ifndef NO_COFF_LINENOS
2136 lnno_size
+= current
->lineno_count
* LINESZ
;
2138 data_base
+= SCNHSZ
;
2143 lineno_base
= reloc_base
+ reloc_size
;
2144 sym_base
= lineno_base
+ lnno_size
;
2146 /* Indicate in each section->line_filepos its actual file address */
2147 for (current
= abfd
->sections
; current
!= NULL
; current
=
2150 if (current
->target_index
> 0)
2153 if (current
->lineno_count
) {
2154 current
->line_filepos
= lineno_base
;
2155 current
->moving_line_filepos
= lineno_base
;
2156 #ifndef NO_COFF_LINENOS
2157 lineno_base
+= current
->lineno_count
* LINESZ
;
2161 current
->line_filepos
= 0;
2163 if (current
->reloc_count
) {
2164 current
->rel_filepos
= reloc_base
;
2165 reloc_base
+= current
->reloc_count
* sizeof(struct internal_reloc
);
2168 current
->rel_filepos
= 0;
2175 /* Write section headers to the file. */
2176 internal_f
.f_nscns
= 0;
2178 (file_ptr
) ((abfd
->flags
& EXEC_P
) ?
2179 (FILHSZ
+ AOUTSZ
) : FILHSZ
),
2184 unsigned int pad
= abfd
->flags
& D_PAGED
? data_base
: 0;
2186 unsigned int pad
= 0;
2188 for (current
= abfd
->sections
;
2190 current
= current
->next
) {
2191 struct internal_scnhdr section
;
2192 if (current
->target_index
> 0)
2194 internal_f
.f_nscns
++;
2195 strncpy(&(section
.s_name
[0]), current
->name
, 8);
2196 section
.s_vaddr
= current
->vma
+ pad
;
2197 section
.s_paddr
= current
->vma
+ pad
;
2198 section
.s_size
= current
->_cooked_size
- pad
;
2200 If this section has no size or is unloadable then the scnptr
2203 if (current
->_cooked_size
- pad
== 0 ||
2204 (current
->flags
& SEC_LOAD
) == 0) {
2205 section
.s_scnptr
= 0;
2208 section
.s_scnptr
= current
->filepos
;
2210 section
.s_relptr
= current
->rel_filepos
;
2211 section
.s_lnnoptr
= current
->line_filepos
;
2212 section
.s_nreloc
= current
->reloc_count
;
2213 section
.s_nlnno
= current
->lineno_count
;
2214 if (current
->reloc_count
!= 0)
2216 if (current
->lineno_count
!= 0)
2219 section
.s_flags
= sec_to_styp_flags(current
->name
,current
->flags
);
2221 if (!strcmp(current
->name
, _TEXT
)) {
2223 } else if (!strcmp(current
->name
, _DATA
)) {
2225 } else if (!strcmp(current
->name
, _BSS
)) {
2230 section
.s_align
= (current
->alignment_power
2231 ? 1 << current
->alignment_power
2238 coff_swap_scnhdr_out(abfd
, §ion
, &buff
);
2239 bfd_write((PTR
) (&buff
), 1, SCNHSZ
, abfd
);
2249 /* OK, now set up the filehdr... */
2251 /* Don't include the internal abs section in the section count */
2254 We will NOT put a fucking timestamp in the header here. Every time you
2255 put it back, I will come in and take it out again. I'm sorry. This
2256 field does not belong here. We fill it with a 0 so it compares the
2257 same but is not a reasonable time. -- gnu@cygnus.com
2260 Well, I like it, so I'm conditionally compiling it in.
2263 #ifdef COFF_TIMESTAMP
2264 internal_f
.f_timdat
= time(0);
2266 internal_f
.f_timdat
= 0;
2269 if (bfd_get_symcount(abfd
) != 0)
2270 internal_f
.f_symptr
= sym_base
;
2272 internal_f
.f_symptr
= 0;
2274 internal_f
.f_flags
= 0;
2276 if (abfd
->flags
& EXEC_P
)
2277 internal_f
.f_opthdr
= AOUTSZ
;
2279 internal_f
.f_opthdr
= 0;
2282 internal_f
.f_flags
|= F_RELFLG
;
2284 internal_f
.f_flags
|= F_LNNO
;
2285 if (0 == bfd_get_symcount(abfd
))
2286 internal_f
.f_flags
|= F_LSYMS
;
2287 if (abfd
->flags
& EXEC_P
)
2288 internal_f
.f_flags
|= F_EXEC
;
2290 internal_f
.f_flags
|= F_AR32W
;
2292 if (!abfd
->xvec
->byteorder_big_p
)
2293 internal_f
.f_flags
|= F_AR32WR
;
2296 FIXME, should do something about the other byte orders and
2300 /* Set up architecture-dependent stuff */
2302 { unsigned int magic
= 0;
2303 unsigned short flags
= 0;
2304 coff_set_flags(abfd
, &magic
, &flags
);
2305 internal_f
.f_magic
= magic
;
2306 internal_f
.f_flags
|= flags
;
2307 /* ...and the "opt"hdr... */
2310 # ifdef ULTRA3 /* NYU's machine */
2311 /* FIXME: This is a bogus check. I really want to see if there
2312 * is a .shbss or a .shdata section, if so then set the magic
2313 * number to indicate a shared data executable.
2315 if (internal_f
.f_nscns
>= 7)
2316 internal_a
.magic
= SHMAGIC
; /* Shared magic */
2318 # endif /* ULTRA3 */
2319 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
2320 #define __A_MAGIC_SET__
2323 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
2324 #define __A_MAGIC_SET__
2327 #define __A_MAGIC_SET__
2328 internal_a
.magic
= PAGEMAGICBCS
;
2331 #if M68 || I386 || MIPS
2332 #define __A_MAGIC_SET__
2333 /* Never was anything here for the 68k */
2337 #define __A_MAGIC_SET__
2338 internal_a
.magic
= (abfd
->flags
& D_PAGED
)? RS6K_AOUTHDR_ZMAGIC
:
2339 (abfd
->flags
& WP_TEXT
)? RS6K_AOUTHDR_NMAGIC
:
2340 RS6K_AOUTHDR_OMAGIC
;
2343 #ifndef __A_MAGIC_SET__
2344 # include "Your aouthdr magic number is not being set!"
2346 # undef __A_MAGIC_SET__
2349 /* Now should write relocs, strings, syms */
2350 obj_sym_filepos(abfd
) = sym_base
;
2352 #ifndef NO_COFF_SYMBOLS
2353 if (bfd_get_symcount(abfd
) != 0) {
2354 coff_renumber_symbols(abfd
);
2355 coff_mangle_symbols(abfd
);
2356 coff_write_symbols(abfd
);
2357 coff_write_linenumbers(abfd
);
2358 coff_write_relocs(abfd
);
2360 #endif /* NO_COFF_SYMBOLS */
2362 internal_a
.tsize
= bfd_get_section_size_after_reloc(text_sec
);
2363 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
2366 internal_a
.dsize
= bfd_get_section_size_after_reloc(data_sec
);
2367 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
2370 internal_a
.bsize
= bfd_get_section_size_after_reloc(bss_sec
);
2373 internal_a
.entry
= bfd_get_start_address(abfd
);
2374 internal_f
.f_nsyms
= bfd_get_symcount(abfd
);
2376 /* now write them */
2377 if (bfd_seek(abfd
, 0L, SEEK_SET
) != 0)
2381 coff_swap_filehdr_out(abfd
, &internal_f
, &buff
);
2382 bfd_write((PTR
) &buff
, 1, FILHSZ
, abfd
);
2384 if (abfd
->flags
& EXEC_P
) {
2386 coff_swap_aouthdr_out(abfd
, &internal_a
, &buff
);
2387 bfd_write((PTR
) &buff
, 1, AOUTSZ
, abfd
);
2392 #ifndef NO_COFF_SYMBOLS
2395 this function transforms the offsets into the symbol table into
2396 pointers to syments.
2401 DEFUN(coff_pointerize_aux
,(ignore_abfd
, table_base
, type
, class, auxent
),
2402 bfd
*ignore_abfd AND
2403 combined_entry_type
*table_base AND
2406 combined_entry_type
*auxent
)
2408 /* Don't bother if this is a file or a section */
2409 if (class == C_STAT
&& type
== T_NULL
) return;
2410 if (class == C_FILE
) return;
2412 /* Otherwise patch up */
2413 if (ISFCN(type
) || ISTAG(class) || class == C_BLOCK
) {
2414 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
= table_base
+
2415 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2416 auxent
->fix_end
= 1;
2418 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
!= 0) {
2419 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
= table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
2420 auxent
->fix_tag
= 1;
2424 #endif /* NO_COFF_SYMBOLS */
2427 DEFUN(coff_set_section_contents
,(abfd
, section
, location
, offset
, count
),
2432 bfd_size_type count
)
2434 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
2435 coff_compute_section_file_positions(abfd
);
2437 bfd_seek(abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
);
2440 return (bfd_write(location
, 1, count
, abfd
) == count
) ? true : false;
2446 coff_close_and_cleanup(abfd
)
2449 if (!bfd_read_p(abfd
))
2450 switch (abfd
->format
) {
2452 if (!_bfd_write_archive_contents(abfd
))
2456 if (!coff_write_object_contents(abfd
))
2460 bfd_error
= invalid_operation
;
2464 /* We depend on bfd_close to free all the memory on the obstack. */
2465 /* FIXME if bfd_release is not using obstacks! */
2471 buy_and_read(abfd
, where
, seek_direction
, size
)
2477 PTR area
= (PTR
) bfd_alloc(abfd
, size
);
2479 bfd_error
= no_memory
;
2482 bfd_seek(abfd
, where
, seek_direction
);
2483 if (bfd_read(area
, 1, size
, abfd
) != size
) {
2484 bfd_error
= system_call_error
;
2488 } /* buy_and_read() */
2491 #ifndef NO_COFF_SYMBOLS
2494 DEFUN(build_string_table
,(abfd
),
2497 char string_table_size_buffer
[4];
2498 unsigned int string_table_size
;
2501 /* At this point we should be "seek"'d to the end of the
2502 symbols === the symbol table size. */
2503 if (bfd_read((char *) string_table_size_buffer
,
2504 sizeof(string_table_size_buffer
),
2505 1, abfd
) != sizeof(string_table_size
)) {
2506 bfd_error
= system_call_error
;
2510 string_table_size
= bfd_h_get_32(abfd
, (bfd_byte
*) string_table_size_buffer
);
2512 if ((string_table
= (PTR
) bfd_alloc(abfd
, string_table_size
-= 4)) == NULL
) {
2513 bfd_error
= no_memory
;
2515 } /* on mallocation error */
2516 if (bfd_read(string_table
, string_table_size
, 1, abfd
) != string_table_size
) {
2517 bfd_error
= system_call_error
;
2520 return string_table
;
2523 /* Allocate space for the ".debug" section, and read it.
2524 We did not read the debug section until now, because
2525 we didn't want to go to the trouble until someone needed it. */
2528 DEFUN(build_debug_section
,(abfd
),
2531 char *debug_section
;
2534 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
2537 bfd_error
= no_debug_section
;
2541 debug_section
= (PTR
) bfd_alloc (abfd
,
2542 bfd_get_section_size_before_reloc (sect
));
2543 if (debug_section
== NULL
) {
2544 bfd_error
= no_memory
;
2548 /* Seek to the beginning of the `.debug' section and read it.
2549 Save the current position first; it is needed by our caller.
2550 Then read debug section and reset the file pointer. */
2552 position
= bfd_tell (abfd
);
2553 bfd_seek (abfd
, sect
->filepos
, SEEK_SET
);
2554 if (bfd_read (debug_section
,
2555 bfd_get_section_size_before_reloc (sect
), 1, abfd
)
2556 != bfd_get_section_size_before_reloc(sect
)) {
2557 bfd_error
= system_call_error
;
2560 bfd_seek (abfd
, position
, SEEK_SET
);
2561 return debug_section
;
2565 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
2566 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
2567 be \0-terminated. */
2569 DEFUN(copy_name
,(abfd
, name
, maxlen
),
2577 for (len
= 0; len
< maxlen
; ++len
) {
2578 if (name
[len
] == '\0') {
2583 if ((newname
= (PTR
) bfd_alloc(abfd
, len
+1)) == NULL
) {
2584 bfd_error
= no_memory
;
2587 strncpy(newname
, name
, len
);
2588 newname
[len
] = '\0';
2593 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
2594 knit the symbol names into a normalized form. By normalized here I
2595 mean that all symbols have an n_offset pointer that points to a null-
2596 terminated string. */
2598 #ifndef SYMNAME_IN_DEBUG
2599 #define SYMNAME_IN_DEBUG(x) 0
2602 static combined_entry_type
*
2603 DEFUN(get_normalized_symtab
,(abfd
),
2606 combined_entry_type
*internal
;
2607 combined_entry_type
*internal_ptr
;
2608 combined_entry_type
*internal_end
;
2612 char *string_table
= NULL
;
2613 char *debug_section
= NULL
;
2616 unsigned int raw_size
;
2617 if (obj_raw_syments(abfd
) != (combined_entry_type
*)NULL
) {
2618 return obj_raw_syments(abfd
);
2620 if ((size
= bfd_get_symcount(abfd
) * sizeof(combined_entry_type
)) == 0) {
2621 bfd_error
= no_symbols
;
2625 internal
= (combined_entry_type
*)bfd_alloc(abfd
, size
);
2626 internal_end
= internal
+ bfd_get_symcount(abfd
);
2628 raw_size
= bfd_get_symcount(abfd
) * SYMESZ
;
2629 raw
= (SYMENT
*)bfd_alloc(abfd
,raw_size
);
2631 if (bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
) == -1
2632 || bfd_read((PTR
)raw
, raw_size
, 1, abfd
) != raw_size
) {
2633 bfd_error
= system_call_error
;
2636 /* mark the end of the symbols */
2637 raw_end
= raw
+ bfd_get_symcount(abfd
);
2639 FIXME SOMEDAY. A string table size of zero is very weird, but
2640 probably possible. If one shows up, it will probably kill us.
2643 /* Swap all the raw entries */
2644 for (raw_src
= raw
, internal_ptr
= internal
;
2646 raw_src
++, internal_ptr
++) {
2649 coff_swap_sym_in(abfd
, (char *)raw_src
, (char *)&internal_ptr
->u
.syment
);
2650 internal_ptr
->fix_tag
= 0;
2651 internal_ptr
->fix_end
= 0;
2653 for (i
= internal_ptr
->u
.syment
.n_numaux
;
2655 --i
, raw_src
++, internal_ptr
++) {
2657 (internal_ptr
+1)->fix_tag
= 0;
2658 (internal_ptr
+1)->fix_end
= 0;
2660 coff_swap_aux_in(abfd
, (char *)(raw_src
+1),
2661 internal_ptr
->u
.syment
.n_type
,
2662 internal_ptr
->u
.syment
.n_sclass
,
2663 &(internal_ptr
+1)->u
.auxent
);
2665 coff_pointerize_aux(abfd
,
2667 internal_ptr
->u
.syment
.n_type
,
2668 internal_ptr
->u
.syment
.n_sclass
,
2673 /* Free all the raw stuff */
2674 bfd_release(abfd
, raw
);
2676 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
2679 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
) {
2680 /* make a file symbol point to the name in the auxent, since
2681 the text ".file" is redundant */
2682 if ((internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_zeroes
== 0) {
2683 /* the filename is a long one, point into the string table */
2684 if (string_table
== NULL
) {
2685 string_table
= build_string_table(abfd
);
2688 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
2689 (int) (string_table
- 4 +
2690 (internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_offset
);
2693 /* ordinary short filename, put into memory anyway */
2694 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2695 copy_name(abfd
, (internal_ptr
+1)->u
.auxent
.x_file
.x_fname
,
2700 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0) {
2701 /* This is a "short" name. Make it long. */
2702 unsigned long i
= 0;
2703 char *newstring
= NULL
;
2705 /* find the length of this string without walking into memory
2707 for (i
= 0; i
< 8; ++i
) {
2708 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0') {
2710 } /* if end of string */
2711 } /* possible lengths of this string. */
2713 if ((newstring
= (PTR
) bfd_alloc(abfd
, ++i
)) == NULL
) {
2714 bfd_error
= no_memory
;
2717 bzero(newstring
, i
);
2718 strncpy(newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
-1);
2719 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int) newstring
;
2720 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
2722 else if (!SYMNAME_IN_DEBUG(&internal_ptr
->u
.syment
)) {
2723 /* Long name already. Point symbol at the string in the table. */
2724 if (string_table
== NULL
) {
2725 string_table
= build_string_table(abfd
);
2727 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2728 (string_table
- 4 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
2731 /* Long name in debug section. Very similar. */
2732 if (debug_section
== NULL
) {
2733 debug_section
= build_debug_section(abfd
);
2735 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2736 (debug_section
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
2739 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
2742 obj_raw_syments(abfd
) = internal
;
2745 } /* get_normalized_symtab() */
2747 #endif /* NO_COFF_SYMBOLS */
2751 DEFUN(section_from_bfd_index
,(abfd
, index
),
2755 struct sec
*answer
= abfd
->sections
;
2758 if (answer
->target_index
== index
)
2760 answer
= answer
->next
;
2765 #ifndef NO_COFF_LINENOS
2771 Creating the linenumber table is done by reading in the entire
2772 coff linenumber table, and creating another table for internal use.
2774 A coff line number table is structured so that each function
2775 is marked as having a line number of 0. Each line within the
2776 function is an offset from the first line in the function. The
2777 base of the line number information for the table is stored in
2778 the symbol associated with the function.
2780 The information is copied from the external to the internal
2781 table, and each symbol which marks a function is marked by
2784 How does this work ?
2789 coff_slurp_line_table(abfd
, asect
)
2793 LINENO
*native_lineno
;
2794 alent
*lineno_cache
;
2796 BFD_ASSERT(asect
->lineno
== (alent
*) NULL
);
2798 native_lineno
= (LINENO
*) buy_and_read(abfd
,
2799 asect
->line_filepos
,
2802 asect
->lineno_count
));
2804 (alent
*) bfd_alloc(abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof(alent
)));
2805 if (lineno_cache
== NULL
) {
2806 bfd_error
= no_memory
;
2809 unsigned int counter
= 0;
2810 alent
*cache_ptr
= lineno_cache
;
2811 LINENO
*src
= native_lineno
;
2813 while (counter
< asect
->lineno_count
) {
2814 struct internal_lineno dst
;
2815 coff_swap_lineno_in(abfd
, src
, &dst
);
2816 cache_ptr
->line_number
= dst
.l_lnno
;
2818 if (cache_ptr
->line_number
== 0) {
2819 coff_symbol_type
*sym
=
2820 (coff_symbol_type
*) (dst
.l_addr
.l_symndx
2821 + obj_raw_syments(abfd
))->u
.syment
._n
._n_n
._n_zeroes
;
2822 cache_ptr
->u
.sym
= (asymbol
*) sym
;
2823 sym
->lineno
= cache_ptr
;
2826 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
2827 - bfd_section_vma(abfd
, asect
);
2828 } /* If no linenumber expect a symbol index */
2834 cache_ptr
->line_number
= 0;
2837 asect
->lineno
= lineno_cache
;
2838 /* FIXME, free native_lineno here, or use alloca or something. */
2840 } /* coff_slurp_line_table() */
2842 #endif /* NO_COFF_LINENOS */
2844 #ifndef NO_COFF_LINENOS
2847 DEFUN(coff_slurp_symbol_table
,(abfd
),
2850 combined_entry_type
*native_symbols
;
2851 coff_symbol_type
*cached_area
;
2852 unsigned int *table_ptr
;
2854 unsigned int number_of_symbols
= 0;
2855 if (obj_symbols(abfd
))
2857 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
2859 /* Read in the symbol table */
2860 if ((native_symbols
= get_normalized_symtab(abfd
)) == NULL
) {
2864 /* Allocate enough room for all the symbols in cached form */
2866 (coff_symbol_type
*)
2867 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(coff_symbol_type
)));
2869 if (cached_area
== NULL
) {
2870 bfd_error
= no_memory
;
2875 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(unsigned int)));
2877 if (table_ptr
== NULL
) {
2878 bfd_error
= no_memory
;
2883 coff_symbol_type
*dst
= cached_area
;
2884 unsigned int last_native_index
= bfd_get_symcount(abfd
);
2885 unsigned int this_index
= 0;
2886 while (this_index
< last_native_index
) {
2887 combined_entry_type
*src
= native_symbols
+ this_index
;
2888 table_ptr
[this_index
] = number_of_symbols
;
2889 dst
->symbol
.the_bfd
= abfd
;
2891 dst
->symbol
.name
= (char *)(src
->u
.syment
._n
._n_n
._n_offset
);
2893 We use the native name field to point to the cached field
2895 src
->u
.syment
._n
._n_n
._n_zeroes
= (int) dst
;
2896 dst
->symbol
.section
= section_from_bfd_index(abfd
,
2897 src
->u
.syment
.n_scnum
);
2898 switch (src
->u
.syment
.n_sclass
) {
2902 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
2903 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2904 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
2906 /* Fall through to next case */
2914 if ((src
->u
.syment
.n_scnum
) == 0) {
2915 if ((src
->u
.syment
.n_value
) == 0) {
2916 dst
->symbol
.section
= &bfd_und_section
;
2917 dst
->symbol
.value
= 0;
2920 dst
->symbol
.section
= &bfd_com_section
;
2921 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2926 Base the value as an index from the base of the
2930 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2931 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
2933 if (ISFCN((src
->u
.syment
.n_type
))) {
2935 A function ext does not go at the end of a file
2937 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
2944 case C_STAT
: /* static */
2946 case C_LEAFSTAT
: /* static leaf procedure */
2948 case C_LABEL
: /* label */
2949 if (src
->u
.syment
.n_scnum
== -2)
2950 dst
->symbol
.flags
= BSF_DEBUGGING
;
2952 dst
->symbol
.flags
= BSF_LOCAL
;
2954 Base the value as an index from the base of the section, if
2957 if (dst
->symbol
.section
)
2958 dst
->symbol
.value
= (src
->u
.syment
.n_value
) -
2959 dst
->symbol
.section
->vma
;
2961 dst
->symbol
.value
= (src
->u
.syment
.n_value
) ;
2964 case C_MOS
: /* member of structure */
2965 case C_EOS
: /* end of structure */
2966 #ifdef NOTDEF /* C_AUTOARG has the same value */
2968 case C_GLBLREG
: /* A29k-specific storage class */
2971 case C_REGPARM
: /* register parameter */
2972 case C_REG
: /* register variable */
2974 case C_AUTOARG
: /* 960-specific storage class */
2976 case C_TPDEF
: /* type definition */
2978 case C_AUTO
: /* automatic variable */
2979 case C_FIELD
: /* bit field */
2980 case C_ENTAG
: /* enumeration tag */
2981 case C_MOE
: /* member of enumeration */
2982 case C_MOU
: /* member of union */
2983 case C_UNTAG
: /* union tag */
2984 dst
->symbol
.flags
= BSF_DEBUGGING
;
2985 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2988 case C_FILE
: /* file name */
2989 case C_STRTAG
: /* structure tag */
2991 case C_BINCL
: /* beginning of include file */
2992 case C_EINCL
: /* ending of include file */
3005 dst
->symbol
.flags
= BSF_DEBUGGING
;
3006 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3009 case C_BLOCK
: /* ".bb" or ".eb" */
3010 case C_FCN
: /* ".bf" or ".ef" */
3011 case C_EFCN
: /* physical end of function */
3012 dst
->symbol
.flags
= BSF_LOCAL
;
3014 Base the value as an index from the base of the section
3016 dst
->symbol
.value
= (src
->u
.syment
.n_value
) - dst
->symbol
.section
->vma
;
3020 case C_EXTDEF
: /* external definition */
3021 case C_ULABEL
: /* undefined label */
3022 case C_USTATIC
: /* undefined static */
3023 case C_LINE
: /* line # reformatted as symbol table entry */
3024 case C_ALIAS
: /* duplicate tag */
3025 case C_HIDDEN
: /* ext symbol in dmert public lib */
3028 fprintf(stderr
,"Unrecognized storage class %d\n",
3029 src
->u
.syment
.n_sclass
);
3031 dst
->symbol
.flags
= BSF_DEBUGGING
;
3032 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3036 BFD_ASSERT(dst
->symbol
.flags
!= 0);
3040 dst
->symbol
.udata
= 0;
3041 dst
->lineno
= (alent
*) NULL
;
3042 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
3044 number_of_symbols
++;
3045 } /* walk the native symtab */
3046 } /* bfdize the native symtab */
3048 obj_symbols(abfd
) = cached_area
;
3049 obj_raw_syments(abfd
) = native_symbols
;
3051 bfd_get_symcount(abfd
) = number_of_symbols
;
3052 obj_convert(abfd
) = table_ptr
;
3053 /* Slurp the line tables for each section too */
3058 coff_slurp_line_table(abfd
, p
);
3063 } /* coff_slurp_symbol_table() */
3066 coff_get_symtab_upper_bound(abfd
)
3069 if (!coff_slurp_symbol_table(abfd
))
3072 return (bfd_get_symcount(abfd
) + 1) * (sizeof(coff_symbol_type
*));
3077 DEFUN(coff_get_symtab
, (abfd
, alocation
),
3079 asymbol
**alocation
)
3081 unsigned int counter
= 0;
3082 coff_symbol_type
*symbase
;
3083 coff_symbol_type
**location
= (coff_symbol_type
**) (alocation
);
3084 if (!coff_slurp_symbol_table(abfd
))
3087 symbase
= obj_symbols(abfd
);
3088 while (counter
< bfd_get_symcount(abfd
))
3090 /* This nasty code looks at the symbol to decide whether or
3091 not it is descibes a constructor/destructor entry point. It
3092 is structured this way to (hopefully) speed non matches */
3094 if (0 && symbase
->symbol
.name
[9] == '$')
3096 bfd_constructor_entry(abfd
,
3097 (asymbol
**)location
,
3098 symbase
->symbol
.name
[10] == 'I' ?
3102 *(location
++) = symbase
++;
3106 return bfd_get_symcount(abfd
);
3109 #endif /* NO_COFF_SYMBOLS */
3112 coff_get_reloc_upper_bound(abfd
, asect
)
3116 if (bfd_get_format(abfd
) != bfd_object
) {
3117 bfd_error
= invalid_operation
;
3120 return (asect
->reloc_count
+ 1) * sizeof(arelent
*);
3127 Coff relocations are easily transformed into the internal BFD form
3130 Reading a coff relocation table is done in the following stages:
3132 o The entire coff relocation table is read into memory.
3134 o Each relocation is processed in turn, first it is swapped from the
3135 external to the internal form.
3137 o The symbol referenced in the relocation's symbol index is
3138 turned intoa pointer into the canonical symbol table. Note
3139 that this table is the same as the one returned by a call to
3140 @code{bfd_canonicalize_symtab}. The back end will call the
3141 routine and save the result if a canonicalization hasn't been done.
3143 o The reloc index is turned into a pointer to a howto
3144 structure, in a back end specific way. For instance, the 386
3145 and 960 use the @code{r_type} to directly produce an index
3146 into a howto table vector; the 88k subtracts a number from the
3147 @code{r_type} field and creates an addend field.
3153 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
3154 if (ptr && ptr->the_bfd == abfd \
3155 && ptr->section != (asection *) NULL \
3156 && ((ptr->flags & BSF_OLD_COMMON)== 0)) \
3158 cache_ptr->addend = -(ptr->section->vma + ptr->value); \
3161 cache_ptr->addend = 0; \
3166 DEFUN(coff_slurp_reloc_table
,(abfd
, asect
, symbols
),
3171 RELOC
*native_relocs
;
3172 arelent
*reloc_cache
;
3177 if (asect
->relocation
)
3179 if (asect
->reloc_count
== 0)
3181 if (asect
->flags
& SEC_CONSTRUCTOR
)
3183 #ifndef NO_COFF_SYMBOLS
3184 if (!coff_slurp_symbol_table(abfd
))
3188 (RELOC
*) buy_and_read(abfd
,
3192 asect
->reloc_count
));
3193 reloc_cache
= (arelent
*)
3194 bfd_alloc(abfd
, (size_t) (asect
->reloc_count
* sizeof(arelent
)));
3196 if (reloc_cache
== NULL
) {
3197 bfd_error
= no_memory
;
3202 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
3204 #ifdef RELOC_PROCESSING
3205 struct internal_reloc dst
;
3206 struct external_reloc
*src
;
3208 cache_ptr
= reloc_cache
+ idx
;
3209 src
= native_relocs
+ idx
;
3210 bfd_swap_reloc_in(abfd
, src
, &dst
);
3212 RELOC_PROCESSING(cache_ptr
, &dst
, symbols
, abfd
, asect
);
3214 struct internal_reloc dst
;
3216 struct external_reloc
*src
;
3218 cache_ptr
= reloc_cache
+ idx
;
3219 src
= native_relocs
+ idx
;
3221 bfd_swap_reloc_in(abfd
, src
, &dst
);
3224 cache_ptr
->address
= dst
.r_vaddr
;
3226 if (dst
.r_symndx
!= -1)
3228 cache_ptr
->sym_ptr_ptr
= symbols
+ obj_convert(abfd
)[dst
.r_symndx
];
3229 ptr
= *(cache_ptr
->sym_ptr_ptr
);
3233 cache_ptr
->sym_ptr_ptr
= 0;
3239 The symbols definitions that we have read in have been
3240 relocated as if their sections started at 0. But the offsets
3241 refering to the symbols in the raw data have not been
3242 modified, so we have to have a negative addend to compensate.
3244 Note that symbols which used to be common must be left alone */
3246 /* Calculate any reloc addend by looking at the symbol */
3247 CALC_ADDEND(abfd
, ptr
, dst
, cache_ptr
);
3249 cache_ptr
->address
-= asect
->vma
;
3250 /* !! cache_ptr->section = (asection *) NULL;*/
3252 /* Fill in the cache_ptr->howto field from dst.r_type */
3253 RTYPE2HOWTO(cache_ptr
, &dst
);
3258 asect
->relocation
= reloc_cache
;
3263 /* This is stupid. This function should be a boolean predicate */
3265 DEFUN(coff_canonicalize_reloc
, (abfd
, section
, relptr
, symbols
),
3268 arelent
**relptr AND
3271 arelent
*tblptr
= section
->relocation
;
3272 unsigned int count
= 0;
3275 if (section
->flags
& SEC_CONSTRUCTOR
)
3277 /* this section has relocs made up by us, they are not in the
3278 file, so take them out of their chain and place them into
3279 the data area provided */
3280 arelent_chain
*chain
= section
->constructor_chain
;
3281 for (count
= 0; count
< section
->reloc_count
; count
++)
3283 *relptr
++ = &chain
->relent
;
3284 chain
= chain
->next
;
3290 coff_slurp_reloc_table(abfd
, section
, symbols
);
3293 tblptr
= section
->relocation
;
3297 for (; count
++ < section
->reloc_count
;)
3298 *relptr
++ = tblptr
++;
3303 return section
->reloc_count
;
3306 #ifndef NO_COFF_SYMBOLS
3309 provided a BFD, a section and an offset into the section, calculate and
3310 return the name of the source file and the line nearest to the wanted
3315 DEFUN(coff_find_nearest_line
,(abfd
,
3323 asection
*section AND
3324 asymbol
**ignore_symbols AND
3326 CONST
char **filename_ptr AND
3327 CONST
char **functionname_ptr AND
3328 unsigned int *line_ptr
)
3330 static bfd
*cache_abfd
;
3331 static asection
*cache_section
;
3332 static bfd_vma cache_offset
;
3333 static unsigned int cache_i
;
3334 static alent
*cache_l
;
3337 coff_data_type
*cof
= coff_data(abfd
);
3338 /* Run through the raw syments if available */
3339 combined_entry_type
*p
;
3341 unsigned int line_base
= 0;
3345 *functionname_ptr
= 0;
3348 /* Don't try and find line numbers in a non coff file */
3349 if (abfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
3355 p
= cof
->raw_syments
;
3357 for (i
= 0; i
< cof
->raw_syment_count
; i
++) {
3358 if (p
->u
.syment
.n_sclass
== C_FILE
) {
3359 /* File name has been moved into symbol */
3360 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
3363 p
+= 1 + p
->u
.syment
.n_numaux
;
3365 /* Now wander though the raw linenumbers of the section */
3367 If this is the same BFD as we were previously called with and this is
3368 the same section, and the offset we want is further down then we can
3369 prime the lookup loop
3371 if (abfd
== cache_abfd
&&
3372 section
== cache_section
&&
3373 offset
>= cache_offset
) {
3379 l
= section
->lineno
;
3382 for (; i
< section
->lineno_count
; i
++) {
3383 if (l
->line_number
== 0) {
3384 /* Get the symbol this line number points at */
3385 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
3386 *functionname_ptr
= coff
->symbol
.name
;
3388 combined_entry_type
*s
= coff
->native
;
3389 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
3391 S should now point to the .bf of the function
3393 if (s
->u
.syment
.n_numaux
) {
3395 The linenumber is stored in the auxent
3397 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
3398 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
3403 if (l
->u
.offset
> offset
)
3405 *line_ptr
= l
->line_number
+ line_base
+ 1;
3411 cache_section
= section
;
3412 cache_offset
= offset
;
3421 coff_sym_filepos(abfd
)
3424 return obj_sym_filepos(abfd
);
3428 #endif /* NO_COFF_SYMBOLS */
3432 DEFUN(coff_sizeof_headers
,(abfd
, reloc
),
3438 if (reloc
== false) {
3439 size
= FILHSZ
+ AOUTSZ
;
3445 size
+= abfd
->section_count
* SCNHSZ
;
3450 #define coff_core_file_failing_command _bfd_dummy_core_file_failing_command
3451 #define coff_core_file_failing_signal _bfd_dummy_core_file_failing_signal
3452 #define coff_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
3453 #define coff_slurp_armap bfd_slurp_coff_armap
3454 #define coff_slurp_extended_name_table _bfd_slurp_extended_name_table
3455 #define coff_truncate_arname bfd_dont_truncate_arname
3456 #define coff_openr_next_archived_file bfd_generic_openr_next_archived_file
3457 #define coff_generic_stat_arch_elt bfd_generic_stat_arch_elt
3458 #define coff_get_section_contents bfd_generic_get_section_contents
3459 #define coff_close_and_cleanup bfd_generic_close_and_cleanup
3461 #define coff_bfd_debug_info_start bfd_void
3462 #define coff_bfd_debug_info_end bfd_void
3463 #define coff_bfd_debug_info_accumulate (PROTO(void,(*),(bfd*, struct sec *))) bfd_void
3464 #define coff_bfd_get_relocated_section_contents \
3465 bfd_generic_get_relocated_section_contents