1 /* Support for Intel 960 COFF and Motorola 88k BCS COFF (and maybe others)
2 Copyright (C) 1990-1991 Free Software Foundation, Inc.
3 Written by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
22 @section coff backends
24 BFD supports a number of different flavours of coff format. The major
25 difference between formats are the sizes and alignments of fields in
26 structures on disk, and the occasional extra field.
28 Coff in all its varieties is implimented with a few common files and a
29 number of implementation specific files. For example, The 88k bcs coff
30 format is implemented in the file @code{m88k-bcs.c}. This file
31 @code{#include}s @code{m88k-bcs.h} which defines the external
32 structure of the coff format for the 88k, and @code{internalcoff.h}
33 which defines the internal structure. @code{m88k-bcs.c} also defines
34 the relocations used by the 88k format @xref{Relocations}. Then the
35 major portion of coff code is included (@code{coffcode.h}) which
36 defines the methods used to act upon the types defined in
37 @code{m88k-bcs.h} and @code{internalcoff.h}.
39 The Intel i960 processor version of coff is implemented in
40 @code{icoff.c}. This file has the same structure as
41 @code{m88k-bcs.c}, except that it includes @code{intel-coff.h} rather
42 than @code{m88k-bcs.h}.
44 @subsection Porting To A New Version of Coff
46 The recommended method is to select from the existing implimentations
47 the version of coff which is most like the one you want to use, for
48 our purposes, we'll say that i386 coff is the one you select, and that
49 your coff flavour is called foo. Copy the @code{i386coff.c} to @code{foocoff.c},
50 copy @code{../include/i386coff.h} to @code{../include/foocoff.h} and
51 add the lines to @code{targets.c} and @code{Makefile.in} so that your
54 Alter the shapes of the structures in @code{../include/foocoff.h} so
55 that they match what you need. You will probably also have to add
56 @code{#ifdef}s to the code in @code{internalcoff.h} and
57 @code{coffcode.h} if your version of coff is too wild.
59 You can verify that your new BFD backend works quite simply by
60 building @code{objdump} from the @code{binutils} directory, and
61 making sure that its version of what's going on at your host systems
62 idea (assuming it has the pretty standard coff dump utility (usually
63 called @code{att-dump} or just @code{dump})) are the same.
65 Then clean up your code, and send what you've done to Cygnus. Then your stuff
66 will be in the next release, and you won't have to keep integrating
69 @subsection How The Coff Backend Works
71 @subsubsection Bit Twiddling
72 Each flavour of coff supported in BFD has its own header file
73 descibing the external layout of the structures. There is also an
74 internal description of the coff layout (in @code{internalcoff.h})
75 file (@code{}). A major function of the coff backend is swapping the
76 bytes and twiddling the bits to translate the external form of the
77 structures into the normal internal form. This is all performed in the
78 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some elements are
79 different sizes between different versions of coff, it is the duty of
80 the coff version specific include file to override the definitions of
81 various packing routines in @code{coffcode.h}. Eg the size of line
82 number entry in coff is sometimes 16 bits, and sometimes 32 bits.
83 @code{#define}ing @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will
84 select the correct one. No doubt, some day someone will find a version
85 of coff which has a varying field size not catered for at the moment.
86 To port BFD, that person will have to add more @code{#defines}.
88 Three of the bit twiddling routines are exported to @code{gdb};
89 @code{coff_swap_aux_in}, @code{coff_swap_sym_in} and
90 @code{coff_swap_linno_in}. @code{GDB} reads the symbol table on its
91 own, but uses BFD to fix things up.
93 @subsubsection Symbol Reading
94 The simple canonical form for symbols used by BFD is not rich enough
95 to keep all the information available in a coff symbol table. The back
96 end gets around this by keeping the original symbol table around,
99 When a symbol table is requested (through a call to
100 @code{bfd_canonicalize_symtab}, a request gets through to
101 @code{get_normalized_symtab}. This reads the symbol table from the
102 coff file and swaps all the structures inside into the internal form.
103 It also fixes up all the pointers in the table (represented in the file
104 by offsets from the first symbol in the table) into physical pointers
105 to elements in the new internal table. This involves some work since
106 the meanings of fields changes depending upon context; a field that is a
107 pointer to another structure in the symbol table at one moment may be
108 the size in bytes of a structure in the next.
110 Another pass is made over the table. All symbols which mark file names
111 (@code{C_FILE} symbols) are modified so that the internal string
112 points to the value in the auxent (the real filename) rather than the
113 normal text associated with the symbol (@code{".file"}).
115 At this time the symbol names are moved around. Coff stores all
116 symbols less than nine characters long physically within the symbol
117 table, longer strings are kept at the end of the file in the string
118 table. This pass moves all strings into memory, and replaces them with
119 pointers to the strings.
121 The symbol table is massaged once again, this time to create the
122 canonical table used by the BFD application. Each symbol is inspected
123 in turn, and a decision made (using the @code{sclass} field) about the
124 various flags to set in the @code{asymbol} @xref{Symbols}. The
125 generated canonical table shares strings with the hidden internal
128 Any linenumbers are read from the coff file too, and attatched to the
129 symbols which own the functions the linenumbers belong to.
131 @subsubsection Symbol Writing
132 Writing a symbol to a coff file which didn't come from a coff file
133 will lose any debugging information. The @code{asymbol} structure
134 remembers the BFD from which was born, and on output the back end
135 makes sure that the same destination target as source target is
138 When the symbols have come from a coff file then all the debugging
139 information is preserved.
141 Symbol tables are provided for writing to the back end in a vector of
142 pointers to pointers. This allows applications like the linker to
143 accumulate and output large symbol tables without having to do too
146 The symbol table is not output to a writable BFD until it is closed.
147 The order of operations on the canonical symbol table at that point
150 @item coff_renumber_symbols
151 This function runs through the provided symbol table and patches each
152 symbol marked as a file place holder (@code{C_FILE}) to point to the
153 next file place holder in the list. It also marks each @code{offset}
154 field in the list with the offset from the first symbol of the current
157 Another function of this procedure is to turn the canonical value form
158 of BFD into the form used by coff. Internally, BFD expects symbol
159 values to be offsets from a section base; so a symbol physically at
160 0x120, but in a section starting at 0x100, would have the value 0x20.
161 Coff expects symbols to contain their final value, so symbols have
162 their values changed at this point to reflect their sum with their
163 owning section. Note that this transformation uses the
164 @code{output_section} field of the @code{asymbol}'s @code{asection}
166 @item coff_mangle_symbols
167 This routine runs though the provided symbol table and uses the
168 offsets generated by the previous pass and the pointers generated when
169 the symbol table was read in to create the structured hierachy
170 required by coff. It changes each pointer to a symbol to an index into
171 the symbol table of the symbol being referenced.
172 @item coff_write_symbols
173 This routine runs through the symbol table and patches up the symbols
174 from their internal form into the coff way, calls the bit twiddlers
175 and writes out the tabel to the file.
181 The hidden information for an asymbol is:
185 $ typedef struct coff_ptr_struct
188 Remembers the offset from the first symbol in the file for this
189 symbol. Generated by @code{coff_renumber_symbols}.
191 $ unsigned int offset;
193 Should the tag field of this symbol be renumbered.
194 Created by @code{coff_pointerize_aux}.
198 Should the endidx field of this symbol be renumbered.
199 Created by @code{coff_pointerize_aux}.
203 The container for the symbol structure as read and translated from the file.
206 $ union internal_auxent auxent;
207 $ struct internal_syment syment;
209 $ } combined_entry_type;
214 Each canonical asymbol really looks like this:
218 $ typedef struct coff_symbol_struct
221 The actual symbol which the rest of BFD works with
225 A pointer to the hidden information for this symbol
227 $ combined_entry_type *native;
229 A pointer to the linenumber information for this symbol
231 $ struct lineno_cache_entry *lineno;
232 $ } coff_symbol_type;
239 /* Most of this hacked by Steve Chamberlain, steve@cygnus.com */
241 /* Align an address upward to a boundary, expressed as a number of bytes.
242 E.g. align to an 8-byte boundary with argument of 8. */
243 #define ALIGN(this, boundary) \
244 ((( (this) + ((boundary) -1)) & (~((boundary)-1))))
246 /* Align an address upward to a power of two. Argument is the power
247 of two, e.g. 8-byte alignment uses argument of 3 (8 == 2^3). */
248 #define i960_align(addr, align) \
249 ( ((addr) + ((1<<(align))-1)) & (-1 << (align)))
252 #define PUTWORD bfd_h_put_32
253 #define PUTHALF bfd_h_put_16
255 #ifndef GET_FCN_LNNOPTR
256 #define GET_FCN_LNNOPTR(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
259 #ifndef GET_FCN_ENDNDX
260 #define GET_FCN_ENDNDX(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
263 #ifndef PUT_FCN_LNNOPTR
264 #define PUT_FCN_LNNOPTR(abfd, in, ext) PUTWORD(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
266 #ifndef PUT_FCN_ENDNDX
267 #define PUT_FCN_ENDNDX(abfd, in, ext) PUTWORD(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
269 #ifndef GET_LNSZ_LNNO
270 #define GET_LNSZ_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_lnno)
272 #ifndef GET_LNSZ_SIZE
273 #define GET_LNSZ_SIZE(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_size)
275 #ifndef PUT_LNSZ_LNNO
276 #define PUT_LNSZ_LNNO(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_sym.x_misc.x_lnsz.x_lnno)
278 #ifndef PUT_LNSZ_SIZE
279 #define PUT_LNSZ_SIZE(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte*) ext->x_sym.x_misc.x_lnsz.x_size)
281 #ifndef GET_SCN_SCNLEN
282 #define GET_SCN_SCNLEN(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_scn.x_scnlen)
284 #ifndef GET_SCN_NRELOC
285 #define GET_SCN_NRELOC(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nreloc)
287 #ifndef GET_SCN_NLINNO
288 #define GET_SCN_NLINNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nlinno)
290 #ifndef PUT_SCN_SCNLEN
291 #define PUT_SCN_SCNLEN(abfd,in, ext) bfd_h_put_32(abfd, in, (bfd_byte *) ext->x_scn.x_scnlen)
293 #ifndef PUT_SCN_NRELOC
294 #define PUT_SCN_NRELOC(abfd,in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_scn.x_nreloc)
296 #ifndef PUT_SCN_NLINNO
297 #define PUT_SCN_NLINNO(abfd,in, ext) bfd_h_put_16(abfd,in, (bfd_byte *) ext->x_scn.x_nlinno)
302 /* void warning(); */
305 * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the
306 * incoming SEC_* flags. The inverse of this function is styp_to_sec_flags().
307 * NOTE: If you add to/change this routine, you should mirror the changes
308 * in styp_to_sec_flags().
311 DEFUN(sec_to_styp_flags
, (sec_name
, sec_flags
),
312 CONST
char * sec_name AND
317 if (!strcmp(sec_name
, _TEXT
)) {
318 return((long)STYP_TEXT
);
319 } else if (!strcmp(sec_name
, _DATA
)) {
320 return((long)STYP_DATA
);
321 } else if (!strcmp(sec_name
, _BSS
)) {
322 return((long)STYP_BSS
);
325 /* Try and figure out what it should be */
326 if (sec_flags
& SEC_CODE
) styp_flags
= STYP_TEXT
;
327 if (sec_flags
& SEC_DATA
) styp_flags
= STYP_DATA
;
328 else if (sec_flags
& SEC_READONLY
)
329 #ifdef STYP_LIT /* 29k readonly text/data section */
330 styp_flags
= STYP_LIT
;
332 styp_flags
= STYP_TEXT
;
333 #endif /* STYP_LIT */
334 else if (sec_flags
& SEC_LOAD
) styp_flags
= STYP_TEXT
;
336 if (styp_flags
== 0) styp_flags
= STYP_BSS
;
341 * Return a word with SEC_* flags set to represent the incoming
342 * STYP_* flags (from scnhdr.s_flags). The inverse of this
343 * function is sec_to_styp_flags().
344 * NOTE: If you add to/change this routine, you should mirror the changes
345 * in sec_to_styp_flags().
348 DEFUN(styp_to_sec_flags
, (styp_flags
),
351 flagword sec_flags
=0;
353 if ((styp_flags
& STYP_TEXT
) || (styp_flags
& STYP_DATA
))
354 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
355 else if (styp_flags
& STYP_BSS
)
356 sec_flags
= SEC_ALLOC
;
358 #ifdef STYP_LIT /* A29k readonly text/data section type */
359 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
360 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
361 #endif /* STYP_LIT */
367 DEFUN(get_index
,(symbol
),
370 return (int) symbol
->value
;
374 DEFUN(set_index
,(symbol
, idx
),
382 /* **********************************************************************
383 Here are all the routines for swapping the structures seen in the
384 outside world into the internal forms.
389 DEFUN(bfd_swap_reloc_in
,(abfd
, reloc_src
, reloc_dst
),
392 struct internal_reloc
*reloc_dst
)
394 reloc_dst
->r_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*)reloc_src
->r_vaddr
);
395 reloc_dst
->r_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) reloc_src
->r_symndx
);
396 reloc_dst
->r_type
= bfd_h_get_16(abfd
, (bfd_byte
*) reloc_src
->r_type
);
398 reloc_dst
->r_offset
= bfd_h_get_16(abfd
, (bfd_byte
*) reloc_src
->r_offset
);
404 DEFUN(bfd_swap_reloc_out
,(abfd
, reloc_src
, reloc_dst
),
406 struct internal_reloc
*reloc_src AND
407 struct external_reloc
*reloc_dst
)
409 bfd_h_put_32(abfd
, reloc_src
->r_vaddr
, (bfd_byte
*) reloc_dst
->r_vaddr
);
410 bfd_h_put_32(abfd
, reloc_src
->r_symndx
, (bfd_byte
*) reloc_dst
->r_symndx
);
411 bfd_h_put_16(abfd
, reloc_src
->r_type
, (bfd_byte
*) reloc_dst
->r_type
);
413 bfd_h_put_16(abfd
, reloc_src
->r_offset
, (bfd_byte
*) reloc_dst
->r_offset
);
419 DEFUN(bfd_swap_filehdr_in
,(abfd
, filehdr_src
, filehdr_dst
),
421 FILHDR
*filehdr_src AND
422 struct internal_filehdr
*filehdr_dst
)
424 filehdr_dst
->f_magic
= bfd_h_get_16(abfd
, (bfd_byte
*) filehdr_src
->f_magic
);
425 filehdr_dst
->f_nscns
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_nscns
);
426 filehdr_dst
->f_timdat
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_timdat
);
427 filehdr_dst
->f_symptr
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_symptr
);
428 filehdr_dst
->f_nsyms
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_nsyms
);
429 filehdr_dst
->f_opthdr
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_opthdr
);
430 filehdr_dst
->f_flags
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_flags
);
434 DEFUN(bfd_swap_filehdr_out
,(abfd
, filehdr_in
, filehdr_out
),
436 struct internal_filehdr
*filehdr_in AND
439 bfd_h_put_16(abfd
, filehdr_in
->f_magic
, (bfd_byte
*) filehdr_out
->f_magic
);
440 bfd_h_put_16(abfd
, filehdr_in
->f_nscns
, (bfd_byte
*) filehdr_out
->f_nscns
);
441 bfd_h_put_32(abfd
, filehdr_in
->f_timdat
, (bfd_byte
*) filehdr_out
->f_timdat
);
442 bfd_h_put_32(abfd
, filehdr_in
->f_symptr
, (bfd_byte
*) filehdr_out
->f_symptr
);
443 bfd_h_put_32(abfd
, filehdr_in
->f_nsyms
, (bfd_byte
*) filehdr_out
->f_nsyms
);
444 bfd_h_put_16(abfd
, filehdr_in
->f_opthdr
, (bfd_byte
*) filehdr_out
->f_opthdr
);
445 bfd_h_put_16(abfd
, filehdr_in
->f_flags
, (bfd_byte
*) filehdr_out
->f_flags
);
449 #ifndef NO_COFF_SYMBOLS
452 DEFUN(coff_swap_sym_in
,(abfd
, ext1
, in1
),
457 SYMENT
*ext
= (SYMENT
*)ext1
;
458 struct internal_syment
*in
= (struct internal_syment
*)in1
;
460 if( ext
->e
.e_name
[0] == 0) {
461 in
->_n
._n_n
._n_zeroes
= 0;
462 in
->_n
._n_n
._n_offset
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e
.e
.e_offset
);
465 memcpy(in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
467 in
->n_value
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_value
);
468 in
->n_scnum
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_scnum
);
469 if (sizeof(ext
->e_type
) == 2){
470 in
->n_type
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_type
);
473 in
->n_type
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_type
);
475 in
->n_sclass
= bfd_h_get_8(abfd
, ext
->e_sclass
);
476 in
->n_numaux
= bfd_h_get_8(abfd
, ext
->e_numaux
);
480 DEFUN(coff_swap_sym_out
,(abfd
,in
, ext
),
482 struct internal_syment
*in AND
485 if(in
->_n
._n_name
[0] == 0) {
486 bfd_h_put_32(abfd
, 0, (bfd_byte
*) ext
->e
.e
.e_zeroes
);
487 bfd_h_put_32(abfd
, in
->_n
._n_n
._n_offset
, (bfd_byte
*) ext
->e
.e
.e_offset
);
490 memcpy(ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
492 bfd_h_put_32(abfd
, in
->n_value
, (bfd_byte
*) ext
->e_value
);
493 bfd_h_put_16(abfd
, in
->n_scnum
, (bfd_byte
*) ext
->e_scnum
);
494 if (sizeof(ext
->e_type
) == 2)
496 bfd_h_put_16(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
500 bfd_h_put_32(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
502 bfd_h_put_8(abfd
, in
->n_sclass
, ext
->e_sclass
);
503 bfd_h_put_8(abfd
, in
->n_numaux
, ext
->e_numaux
);
507 DEFUN(coff_swap_aux_in
,(abfd
, ext1
, type
, class, in1
),
514 AUXENT
*ext
= (AUXENT
*)ext1
;
515 union internal_auxent
*in
= (union internal_auxent
*)in1
;
518 if (ext
->x_file
.x_fname
[0] == 0) {
519 in
->x_file
.x_n
.x_zeroes
= 0;
520 in
->x_file
.x_n
.x_offset
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
522 memcpy (in
->x_file
.x_fname
, ext
->x_file
.x_fname
,
523 sizeof (in
->x_file
.x_fname
));
532 if (type
== T_NULL
) {
533 in
->x_scn
.x_scnlen
= GET_SCN_SCNLEN(abfd
, ext
);
534 in
->x_scn
.x_nreloc
= GET_SCN_NRELOC(abfd
, ext
);
535 in
->x_scn
.x_nlinno
= GET_SCN_NLINNO(abfd
, ext
);
539 in
->x_sym
.x_tagndx
.l
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
541 in
->x_sym
.x_tvndx
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
544 if (ISARY(type
) || class == C_BLOCK
) {
545 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]);
546 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]);
547 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]);
548 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]);
550 in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= GET_FCN_LNNOPTR(abfd
, ext
);
551 in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= GET_FCN_ENDNDX(abfd
, ext
);
554 in
->x_sym
.x_misc
.x_fsize
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
557 in
->x_sym
.x_misc
.x_lnsz
.x_lnno
= GET_LNSZ_LNNO(abfd
, ext
);
558 in
->x_sym
.x_misc
.x_lnsz
.x_size
= GET_LNSZ_SIZE(abfd
, ext
);
564 DEFUN(coff_swap_aux_out
,(abfd
, in
, type
, class, ext
),
566 union internal_auxent
*in AND
573 if (in
->x_file
.x_fname
[0] == 0) {
574 PUTWORD(abfd
, 0, (bfd_byte
*) ext
->x_file
.x_n
.x_zeroes
);
575 PUTWORD(abfd
, in
->x_file
.x_n
.x_offset
, (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
578 memcpy ( ext
->x_file
.x_fname
,in
->x_file
.x_fname
,
579 sizeof (in
->x_file
.x_fname
));
587 if (type
== T_NULL
) {
589 PUT_SCN_SCNLEN(abfd
, in
->x_scn
.x_scnlen
, ext
);
590 PUT_SCN_NRELOC(abfd
, in
->x_scn
.x_nreloc
, ext
);
591 PUT_SCN_NLINNO(abfd
, in
->x_scn
.x_nlinno
, ext
);
595 PUTWORD(abfd
, in
->x_sym
.x_tagndx
.l
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
597 PUTWORD(abfd
, in
->x_sym
.x_tvndx
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
601 PUTWORD(abfd
, in
->x_sym
.x_misc
.x_fsize
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
602 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
603 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
607 if (ISARY(type
) || class == C_BLOCK
) {
608 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]);
609 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]);
610 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]);
611 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]);
614 PUT_LNSZ_LNNO(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
615 PUT_LNSZ_SIZE(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
617 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
618 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
625 #endif /* NO_COFF_SYMBOLS */
627 #ifndef NO_COFF_LINENOS
630 DEFUN(coff_swap_lineno_in
,(abfd
, ext1
, in1
),
635 LINENO
*ext
= (LINENO
*)ext1
;
636 struct internal_lineno
*in
= (struct internal_lineno
*)in1
;
638 in
->l_addr
.l_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->l_addr
.l_symndx
);
640 in
->l_lnno
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->l_lnno
);
642 in
->l_lnno
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->l_lnno
);
647 DEFUN(coff_swap_lineno_out
,(abfd
, in
, ext
),
649 struct internal_lineno
*in AND
650 struct external_lineno
*ext
)
652 PUTWORD(abfd
, in
->l_addr
.l_symndx
, (bfd_byte
*) ext
->l_addr
.l_symndx
);
654 PUTWORD(abfd
, in
->l_lnno
, (bfd_byte
*) ext
->l_lnno
);
656 PUTHALF(abfd
, in
->l_lnno
, (bfd_byte
*) ext
->l_lnno
);
660 #endif /* NO_COFF_LINENOS */
664 DEFUN(bfd_swap_aouthdr_in
,(abfd
, aouthdr_ext1
, aouthdr_int1
),
669 AOUTHDR
*aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
670 struct internal_aouthdr
*aouthdr_int
= (struct internal_aouthdr
*)aouthdr_int1
;
672 aouthdr_int
->magic
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->magic
);
673 aouthdr_int
->vstamp
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->vstamp
);
674 aouthdr_int
->tsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tsize
);
675 aouthdr_int
->dsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->dsize
);
676 aouthdr_int
->bsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->bsize
);
677 aouthdr_int
->entry
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->entry
);
678 aouthdr_int
->text_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->text_start
);
679 aouthdr_int
->data_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->data_start
);
681 aouthdr_int
->tagentries
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tagentries
);
686 DEFUN(bfd_swap_aouthdr_out
,(abfd
, aouthdr_in
, aouthdr_out
),
688 struct internal_aouthdr
*aouthdr_in AND
689 AOUTHDR
*aouthdr_out
)
691 bfd_h_put_16(abfd
, aouthdr_in
->magic
, (bfd_byte
*) aouthdr_out
->magic
);
692 bfd_h_put_16(abfd
, aouthdr_in
->vstamp
, (bfd_byte
*) aouthdr_out
->vstamp
);
693 bfd_h_put_32(abfd
, aouthdr_in
->tsize
, (bfd_byte
*) aouthdr_out
->tsize
);
694 bfd_h_put_32(abfd
, aouthdr_in
->dsize
, (bfd_byte
*) aouthdr_out
->dsize
);
695 bfd_h_put_32(abfd
, aouthdr_in
->bsize
, (bfd_byte
*) aouthdr_out
->bsize
);
696 bfd_h_put_32(abfd
, aouthdr_in
->entry
, (bfd_byte
*) aouthdr_out
->entry
);
697 bfd_h_put_32(abfd
, aouthdr_in
->text_start
, (bfd_byte
*) aouthdr_out
->text_start
);
698 bfd_h_put_32(abfd
, aouthdr_in
->data_start
, (bfd_byte
*) aouthdr_out
->data_start
);
700 bfd_h_put_32(abfd
, aouthdr_in
->tagentries
, (bfd_byte
*) aouthdr_out
->tagentries
);
705 DEFUN(coff_swap_scnhdr_in
,(abfd
, scnhdr_ext
, scnhdr_int
),
707 SCNHDR
*scnhdr_ext AND
708 struct internal_scnhdr
*scnhdr_int
)
710 memcpy(scnhdr_int
->s_name
, scnhdr_ext
->s_name
, sizeof(scnhdr_int
->s_name
));
711 scnhdr_int
->s_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
712 scnhdr_int
->s_paddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
713 scnhdr_int
->s_size
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_size
);
714 scnhdr_int
->s_scnptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
715 scnhdr_int
->s_relptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
716 scnhdr_int
->s_lnnoptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
717 scnhdr_int
->s_flags
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_flags
);
719 scnhdr_int
->s_nreloc
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
720 scnhdr_int
->s_nlnno
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
722 scnhdr_int
->s_nreloc
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
723 scnhdr_int
->s_nlnno
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
726 scnhdr_int
->s_align
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_align
);
731 DEFUN(swap_scnhdr_out
,(abfd
, scnhdr_int
, scnhdr_ext
),
733 struct internal_scnhdr
*scnhdr_int AND
736 memcpy(scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof(scnhdr_int
->s_name
));
737 PUTWORD(abfd
, scnhdr_int
->s_vaddr
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
738 PUTWORD(abfd
, scnhdr_int
->s_paddr
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
739 PUTWORD(abfd
, scnhdr_int
->s_size
, (bfd_byte
*) scnhdr_ext
->s_size
);
740 PUTWORD(abfd
, scnhdr_int
->s_scnptr
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
741 PUTWORD(abfd
, scnhdr_int
->s_relptr
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
742 PUTWORD(abfd
, scnhdr_int
->s_lnnoptr
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
743 PUTWORD(abfd
, scnhdr_int
->s_flags
, (bfd_byte
*) scnhdr_ext
->s_flags
);
745 PUTWORD(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
746 PUTWORD(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
748 PUTHALF(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
749 PUTHALF(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
753 PUTWORD(abfd
, scnhdr_int
->s_align
, (bfd_byte
*) scnhdr_ext
->s_align
);
758 /* **********************************************************************/
759 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
760 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
764 DEFUN(copy_name
,(abfd
, name
, maxlen
),
772 for (len
= 0; len
< maxlen
; ++len
) {
773 if (name
[len
] == '\0') {
778 if ((newname
= (PTR
) bfd_alloc(abfd
, len
+1)) == NULL
) {
779 bfd_error
= no_memory
;
782 strncpy(newname
, name
, len
);
788 initialize a section structure with information peculiar to this
789 particular implementation of coff
793 DEFUN(coff_new_section_hook
,(abfd_ignore
, section_ignore
),
795 asection
*section_ignore
)
797 section_ignore
->alignment_power
= abfd_ignore
->xvec
->align_power_min
;
801 /* Take a section header read from a coff file (in HOST byte order),
802 and make a BFD "section" out of it. */
804 DEFUN(make_a_section_from_file
,(abfd
, hdr
),
806 struct internal_scnhdr
*hdr
)
808 asection
*return_section
;
811 /* Assorted wastage to null-terminate the name, thanks AT&T! */
812 char *name
= bfd_alloc(abfd
, sizeof (hdr
->s_name
)+1);
814 bfd_error
= no_memory
;
817 strncpy(name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
818 name
[sizeof (hdr
->s_name
)] = 0;
820 return_section
= bfd_make_section(abfd
, name
);
823 /* s_paddr is presumed to be = to s_vaddr */
824 #define assign(to, from) return_section->to = hdr->from
825 assign(vma
, s_vaddr
);
826 /* assign (vma, s_vaddr); */
827 assign(size
, s_size
);
828 assign(filepos
, s_scnptr
);
829 assign(rel_filepos
, s_relptr
);
830 assign(reloc_count
, s_nreloc
);
833 /* FIXME, use a temp var rather than alignment_power */
834 assign(alignment_power
, s_align
);
837 for (i
= 0; i
< 32; i
++) {
838 if ((1 << i
) >= (int) (return_section
->alignment_power
)) {
839 return_section
->alignment_power
= i
;
846 assign(line_filepos
, s_lnnoptr
);
848 return_section->linesize = hdr->s_nlnno * sizeof (struct lineno);
851 return_section
->lineno_count
= hdr
->s_nlnno
;
852 return_section
->userdata
= NULL
;
853 return_section
->next
= (asection
*) NULL
;
854 return_section
->flags
= styp_to_sec_flags(hdr
->s_flags
);
857 if (hdr
->s_nreloc
!= 0)
858 return_section
->flags
|= SEC_RELOC
;
859 /* FIXME: should this check 'hdr->s_size > 0' */
860 if (hdr
->s_scnptr
!= 0)
861 return_section
->flags
|= SEC_HAS_CONTENTS
;
865 DEFUN(coff_mkobject
,(abfd
),
868 set_tdata (abfd
, bfd_zalloc (abfd
,sizeof(coff_data_type
)));
869 if (coff_data(abfd
) == 0) {
870 bfd_error
= no_memory
;
873 coff_data(abfd
)->relocbase
= 0;
879 DEFUN(coff_real_object_p
,(abfd
, nscns
, internal_f
, internal_a
),
882 struct internal_filehdr
*internal_f AND
883 struct internal_aouthdr
*internal_a
)
885 coff_data_type
*coff
;
887 size_t readsize
; /* length of file_info */
888 SCNHDR
*external_sections
;
890 /* Build a play area */
891 if (coff_mkobject(abfd
) != true)
893 coff
= coff_data(abfd
);
896 external_sections
= (SCNHDR
*)bfd_alloc(abfd
, readsize
= (nscns
* SCNHSZ
));
898 if (bfd_read((PTR
)external_sections
, 1, readsize
, abfd
) != readsize
) {
903 /* Now copy data as required; construct all asections etc */
904 coff
->symbol_index_slew
= 0;
906 coff
->raw_syment_count
= 0;
907 coff
->raw_linenos
= 0;
908 coff
->raw_syments
= 0;
909 coff
->sym_filepos
=0;
910 coff
->flags
= internal_f
->f_flags
;
913 for (i
= 0; i
< nscns
; i
++) {
914 struct internal_scnhdr tmp
;
915 coff_swap_scnhdr_in(abfd
, external_sections
+ i
, &tmp
);
916 make_a_section_from_file(abfd
,&tmp
);
919 /* Determine the machine architecture and type. */
920 abfd
->obj_machine
= 0;
921 switch (internal_f
->f_magic
) {
924 abfd
->obj_arch
= bfd_arch_i386
;
925 abfd
->obj_machine
= 0;
929 #ifdef A29K_MAGIC_BIG
931 case A29K_MAGIC_LITTLE
:
932 abfd
->obj_arch
= bfd_arch_a29k
;
933 abfd
->obj_machine
= 0;
941 abfd
->obj_arch
= bfd_arch_mips
;
942 abfd
->obj_machine
= 0;
949 abfd
->obj_arch
= bfd_arch_m68k
;
950 abfd
->obj_machine
= 68020;
957 abfd
->obj_arch
= bfd_arch_m88k
;
958 abfd
->obj_machine
= 88100;
965 abfd
->obj_arch
= bfd_arch_i960
;
966 switch (F_I960TYPE
& internal_f
->f_flags
)
970 abfd
->obj_machine
= bfd_mach_i960_core
;
973 abfd
->obj_machine
= bfd_mach_i960_kb_sb
;
976 abfd
->obj_machine
= bfd_mach_i960_mc
;
979 abfd
->obj_machine
= bfd_mach_i960_xa
;
982 abfd
->obj_machine
= bfd_mach_i960_ca
;
985 abfd
->obj_machine
= bfd_mach_i960_ka_sa
;
993 default: /* Unreadable input file type */
994 abfd
->obj_arch
= bfd_arch_obscure
;
998 if (!(internal_f
->f_flags
& F_RELFLG
))
999 abfd
->flags
|= HAS_RELOC
;
1000 if ((internal_f
->f_flags
& F_EXEC
))
1001 abfd
->flags
|= EXEC_P
;
1002 if (!(internal_f
->f_flags
& F_LNNO
))
1003 abfd
->flags
|= HAS_LINENO
;
1004 if (!(internal_f
->f_flags
& F_LSYMS
))
1005 abfd
->flags
|= HAS_LOCALS
;
1008 bfd_get_symcount(abfd
) = internal_f
->f_nsyms
;
1009 if (internal_f
->f_nsyms
)
1010 abfd
->flags
|= HAS_SYMS
;
1012 coff
->sym_filepos
= internal_f
->f_symptr
;
1016 coff
->symbols
= (coff_symbol_type
*) NULL
;
1017 bfd_get_start_address(abfd
) = internal_f
->f_opthdr
? internal_a
->entry
: 0;
1021 bfd_release(abfd
, coff
);
1022 return (bfd_target
*)NULL
;
1026 DEFUN(coff_object_p
,(abfd
),
1032 struct internal_filehdr internal_f
;
1033 struct internal_aouthdr internal_a
;
1035 bfd_error
= system_call_error
;
1037 /* figure out how much to read */
1038 if (bfd_read((PTR
) &filehdr
, 1, FILHSZ
, abfd
) != FILHSZ
)
1041 bfd_swap_filehdr_in(abfd
, &filehdr
, &internal_f
);
1043 if (BADMAG(internal_f
)) {
1044 bfd_error
= wrong_format
;
1047 nscns
=internal_f
.f_nscns
;
1049 if (internal_f
.f_opthdr
) {
1050 if (bfd_read((PTR
) &opthdr
, 1,AOUTSZ
, abfd
) != AOUTSZ
) {
1053 bfd_swap_aouthdr_in(abfd
, &opthdr
, &internal_a
);
1056 /* Seek past the opt hdr stuff */
1057 bfd_seek(abfd
, internal_f
.f_opthdr
+ FILHSZ
, SEEK_SET
);
1059 /* if the optional header is NULL or not the correct size then
1060 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1061 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1062 optional header is of a different size.
1064 But the mips keeps extra stuff in it's opthdr, so dont check
1069 if (internal_f
.f_opthdr
!= 0 && AOUTSZ
!= internal_f
.f_opthdr
)
1070 return (bfd_target
*)NULL
;
1073 return coff_real_object_p(abfd
, nscns
, &internal_f
, &internal_a
);
1078 #ifndef NO_COFF_LINENOS
1081 DEFUN(coff_count_linenumbers
,(abfd
),
1084 unsigned int limit
= bfd_get_symcount(abfd
);
1088 asection
*s
= abfd
->sections
->output_section
;
1090 BFD_ASSERT(s
->lineno_count
== 0);
1096 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++) {
1097 asymbol
*q_maybe
= *p
;
1098 if (q_maybe
->the_bfd
->xvec
->flavour
== bfd_target_coff_flavour_enum
) {
1099 coff_symbol_type
*q
= coffsymbol(q_maybe
);
1102 This symbol has a linenumber, increment the owning
1103 section's linenumber count
1105 alent
*l
= q
->lineno
;
1106 q
->symbol
.section
->output_section
->lineno_count
++;
1108 while (l
->line_number
) {
1109 q
->symbol
.section
->output_section
->lineno_count
++;
1117 #endif /* NO_COFF_LINENOS */
1119 #ifndef NO_COFF_SYMBOLS
1122 Takes a bfd and a symbol, returns a pointer to the coff specific area
1123 of the symbol if there is one.
1125 static coff_symbol_type
*
1126 DEFUN(coff_symbol_from
,(abfd
, symbol
),
1130 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_coff_flavour_enum
)
1131 return (coff_symbol_type
*)NULL
;
1133 if (symbol
->the_bfd
->tdata
== (PTR
)NULL
)
1134 return (coff_symbol_type
*)NULL
;
1136 return (coff_symbol_type
*) symbol
;
1142 DEFUN(fixup_symbol_value
,(coff_symbol_ptr
, syment
),
1143 coff_symbol_type
*coff_symbol_ptr AND
1144 struct internal_syment
*syment
)
1147 /* Normalize the symbol flags */
1148 if (coff_symbol_ptr
->symbol
.flags
& BSF_FORT_COMM
) {
1149 /* a common symbol is undefined with a value */
1150 syment
->n_scnum
= N_UNDEF
;
1151 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1153 else if (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) {
1154 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1156 else if (coff_symbol_ptr
->symbol
.flags
& BSF_UNDEFINED
) {
1157 syment
->n_scnum
= N_UNDEF
;
1158 syment
->n_value
= 0;
1160 else if (coff_symbol_ptr
->symbol
.flags
& BSF_ABSOLUTE
) {
1161 syment
->n_scnum
= N_ABS
;
1162 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1166 coff_symbol_ptr
->symbol
.section
->output_section
->index
+1;
1169 coff_symbol_ptr
->symbol
.value
+
1170 coff_symbol_ptr
->symbol
.section
->output_offset
+
1171 coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
1175 /* run through all the symbols in the symbol table and work out what
1176 their indexes into the symbol table will be when output
1178 Coff requires that each C_FILE symbol points to the next one in the
1179 chain, and that the last one points to the first external symbol. We
1184 DEFUN(coff_renumber_symbols
,(bfd_ptr
),
1187 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1188 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1189 unsigned int native_index
= 0;
1190 struct internal_syment
*last_file
= (struct internal_syment
*)NULL
;
1191 unsigned int symbol_index
;
1192 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1194 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1195 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1196 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1199 if (s
->u
.syment
.n_sclass
== C_FILE
)
1201 if (last_file
!= (struct internal_syment
*)NULL
) {
1202 last_file
->n_value
= native_index
;
1204 last_file
= &(s
->u
.syment
);
1208 /* Modify the symbol values according to their section and
1211 fixup_symbol_value(coff_symbol_ptr
, &(s
->u
.syment
));
1213 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++) {
1214 s
[i
].offset
= native_index
++;
1225 Run thorough the symbol table again, and fix it so that all pointers to
1226 entries are changed to the entries' index in the output symbol table.
1230 DEFUN(coff_mangle_symbols
,(bfd_ptr
),
1233 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1234 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1236 unsigned int symbol_index
;
1239 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1241 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1242 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1244 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1250 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++) {
1251 combined_entry_type
*a
= s
+ i
+ 1;
1253 a
->u
.auxent
.x_sym
.x_tagndx
.l
= a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
1256 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
1257 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
1266 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1267 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1268 struct internal_syment
*last_tagndx
= (struct internal_syment
*)NULL
;
1269 struct internal_syment
*last_file
= (struct internal_syment
*)NULL
;
1270 struct internal_syment
*last_fcn
= (struct internal_syment
*)NULL
;
1271 struct internal_syment
*block_stack
[50];
1272 struct internal_syment
**last_block
= &block_stack
[0];
1273 boolean first_time
= true;
1274 unsigned int symbol_index
;
1275 unsigned int native_index
= 0;
1277 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++) {
1278 coff_symbol_type
*coff_symbol_ptr
=
1279 coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1280 if (coff_symbol_ptr
== (coff_symbol_type
*)NULL
) {
1282 This symbol has no coff information in it, it will take up
1283 only one slot in the output symbol table
1288 struct internal_syment
*syment
= coff_symbol_ptr
->native
;
1289 if (syment
== (struct internal_syment
*)NULL
) {
1293 /* Normalize the symbol flags */
1294 if (coff_symbol_ptr
->symbol
.flags
& BSF_FORT_COMM
) {
1295 /* a common symbol is undefined with a value */
1296 syment
->n_scnum
= N_UNDEF
;
1297 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1299 else if (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) {
1300 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1302 else if (coff_symbol_ptr
->symbol
.flags
& BSF_UNDEFINED
) {
1303 syment
->n_scnum
= N_UNDEF
;
1304 syment
->n_value
= 0;
1306 else if (coff_symbol_ptr
->symbol
.flags
& BSF_ABSOLUTE
) {
1307 syment
->n_scnum
= N_ABS
;
1308 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1312 coff_symbol_ptr
->symbol
.section
->output_section
->index
+1;
1315 coff_symbol_ptr
->symbol
.value
+
1316 coff_symbol_ptr
->symbol
.section
->output_offset
+
1317 coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
1321 /* If this symbol ties up something then do it */
1323 if (syment
->n_sclass
== C_FILE
&& last_file
!= (struct internal_syment
*)NULL
)
1325 last_file
->n_value
= native_index
;
1327 else if ((syment
->n_sclass
== C_EXT
1328 || syment
->n_sclass
== C_STAT
1330 || syment
->n_sclass
== C_LEAFEXT
1331 || syment
->n_sclass
== C_LEAFSTAT
1334 && last_fcn
!= (struct internal_syment
*)NULL
)
1336 union internal_auxent
*auxent
= (union internal_auxent
*)(last_fcn
+1);
1337 auxent
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= native_index
;
1338 last_fcn
= (struct internal_syment
*)NULL
;
1341 else if (syment
->n_sclass
== C_EOS
&& last_tagndx
!= (struct internal_syment
*)NULL
)
1343 union internal_auxent
*auxent
= (union internal_auxent
*)(last_tagndx
+1);
1344 /* Remember that we keep the native index in the offset
1345 so patch the beginning of the struct to point to this
1348 auxent->x_sym.x_tagndx = last_tagndx->_n._n_n._n_offset;*/
1349 auxent
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= syment
->n_numaux
+ 1 + native_index
;
1350 /* Now point the eos to the structure */
1351 auxent
= (union internal_auxent
*)(syment
+1);
1352 auxent
->x_sym
.x_tagndx
.l
= last_tagndx
->_n
._n_n
._n_offset
;
1354 else if (syment
->n_sclass
== C_BLOCK
1355 && coff_symbol_ptr
->symbol
.name
[1] == 'e')
1357 union internal_auxent
*auxent
= (union internal_auxent
*)((*(--last_block
))+1);
1358 auxent
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= native_index
+ syment
->n_numaux
+ 1;
1360 if (syment
->n_sclass
== C_EXT
1361 && !ISFCN(syment
->n_type
)
1362 && first_time
== true
1363 && last_file
!= (struct internal_syment
*)NULL
) {
1364 /* This is the first external symbol seen which isn't a
1365 function place it in the last .file entry */
1366 last_file
->n_value
= native_index
;
1370 if (syment
->n_sclass
== C_LEAFPROC
&&
1371 syment
->n_numaux
== 2) {
1372 union internal_auxent
*auxent
= (union internal_auxent
*)(syment
+2);
1373 /* This is the definition of a leaf proc, we'll relocate the
1375 auxent
->x_bal
.x_balntry
=
1376 coff_symbol_ptr
->symbol
.section
->output_offset
+
1377 coff_symbol_ptr
->symbol
.section
->output_section
->vma
+
1378 auxent
->x_bal
.x_balntry
;
1381 /* If this symbol needs to be tied up then remember some facts */
1382 if (syment
->n_sclass
== C_FILE
)
1386 if (syment
->n_numaux
!= 0) {
1388 If this symbol would like to point to something in the
1389 future then remember where it is
1391 if (uses_x_sym_x_tagndx_p(bfd_ptr
, syment
)) {
1393 If this is a ref to a structure then we'll tie it up
1394 now - there are never any forward refs for one
1396 if (syment
->n_sclass
== C_STRTAG
||
1397 syment
->n_sclass
== C_ENTAG
||
1398 syment
->n_sclass
== C_UNTAG
) {
1399 last_tagndx
= syment
;
1403 This is a ref to a structure - the structure must
1404 have been defined within the same file, and previous
1405 to this point, so we can deduce the new tagndx
1408 union internal_auxent
*auxent
= (union internal_auxent
*)(syment
+1);
1409 bfd
*bfd_ptr
= coff_symbol_ptr
->symbol
.the_bfd
;
1410 struct internal_syment
*base
= obj_raw_syments(bfd_ptr
);
1411 /* auxent->x_sym.x_tagndx = base[auxent->x_sym.x_tagndx]._n._n_n._n_offset;*/
1416 if (ISFCN(syment
->n_type
)) {
1419 if (syment
->n_sclass
== C_BLOCK
1420 && coff_symbol_ptr
->symbol
.name
[1] == 'b')
1422 *last_block
++ = syment
;
1425 syment
->_n
._n_n
._n_offset
= native_index
;
1426 native_index
= native_index
+ 1 + syment
->n_numaux
;
1434 static int string_size
;
1436 DEFUN(coff_fix_symbol_name
,(abfd
, symbol
, native
),
1439 combined_entry_type
*native
)
1441 unsigned int name_length
;
1442 union internal_auxent
*auxent
;
1443 char * name
= ( char *)(symbol
->name
);
1445 if (name
== (char *) NULL
) {
1447 coff symbols always have names, so we'll make one up
1449 symbol
->name
= "strange";
1450 name
= (char *)symbol
->name
;
1452 name_length
= strlen(name
);
1454 if (native
->u
.syment
.n_sclass
== C_FILE
) {
1455 strncpy(native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
1456 auxent
= &(native
+1)->u
.auxent
;
1458 #ifdef COFF_LONG_FILENAMES
1459 if (name_length
<= FILNMLEN
) {
1460 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1463 auxent
->x_file
.x_n
.x_offset
= string_size
+ 4;
1464 auxent
->x_file
.x_n
.x_zeroes
= 0;
1465 string_size
+= name_length
+ 1;
1468 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1469 if (name_length
> FILNMLEN
) {
1470 name
[FILNMLEN
] = '\0';
1475 { /* NOT A C_FILE SYMBOL */
1476 if (name_length
<= SYMNMLEN
) {
1477 /* This name will fit into the symbol neatly */
1478 strncpy(native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
1481 native
->u
.syment
._n
._n_n
._n_offset
= string_size
+ 4;
1482 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1483 string_size
+= name_length
+ 1;
1491 DEFUN(coff_write_symbol
,(abfd
, symbol
, native
, written
),
1494 combined_entry_type
*native AND
1495 unsigned int written
)
1497 unsigned int numaux
= native
->u
.syment
.n_numaux
;
1498 int type
= native
->u
.syment
.n_type
;
1499 int class = native
->u
.syment
.n_sclass
;
1503 coff_fix_symbol_name(abfd
, symbol
, native
);
1504 coff_swap_sym_out(abfd
, &native
->u
.syment
, &buf
);
1505 bfd_write((PTR
)& buf
, 1, SYMESZ
, abfd
);
1506 for (j
= 0; j
!= native
->u
.syment
.n_numaux
; j
++)
1509 coff_swap_aux_out(abfd
,
1510 &( (native
+ j
+ 1)->u
.auxent
), type
, class, &buf1
);
1511 bfd_write((PTR
) (&buf1
), 1, AUXESZ
, abfd
);
1514 Reuse somewhere in the symbol to keep the index
1516 set_index(symbol
, written
);
1517 return written
+ 1 + numaux
;
1522 DEFUN(coff_write_alien_symbol
,(abfd
, symbol
, written
),
1525 unsigned int written
)
1528 This symbol has been created by the loader, or come from a non
1529 coff format. It has no native element to inherit, make our
1532 combined_entry_type
*native
;
1533 combined_entry_type dummy
;
1535 native
->u
.syment
.n_type
= T_NULL
;
1537 native
->u
.syment
.n_flags
= 0;
1539 if (symbol
->flags
& BSF_ABSOLUTE
) {
1540 native
->u
.syment
.n_scnum
= N_ABS
;
1541 native
->u
.syment
.n_value
= symbol
->value
;
1543 else if (symbol
->flags
& (BSF_UNDEFINED
| BSF_FORT_COMM
)) {
1544 native
->u
.syment
.n_scnum
= N_UNDEF
;
1545 native
->u
.syment
.n_value
= symbol
->value
;
1547 else if (symbol
->flags
& BSF_DEBUGGING
) {
1549 remove name so it doesn't take up any space
1554 native
->u
.syment
.n_scnum
= symbol
->section
->output_section
->index
+
1556 native
->u
.syment
.n_value
= symbol
->value
+
1557 symbol
->section
->output_section
->vma
+
1558 symbol
->section
->output_offset
;
1560 /* Copy the any flags from the the file hdr into the symbol */
1562 coff_symbol_type
*c
= coff_symbol_from(abfd
, symbol
);
1563 if (c
!= (coff_symbol_type
*)NULL
) {
1564 native
->u
.syment
.n_flags
= c
->symbol
.the_bfd
->flags
;
1571 native
->u
.syment
.pad1
[0] = 0;
1572 native
->u
.syment
.pad1
[0] = 0;
1575 native
->u
.syment
.n_type
= 0;
1576 if (symbol
->flags
& BSF_LOCAL
)
1577 native
->u
.syment
.n_sclass
= C_STAT
;
1579 native
->u
.syment
.n_sclass
= C_EXT
;
1580 native
->u
.syment
.n_numaux
= 0;
1582 return coff_write_symbol(abfd
, symbol
, native
, written
);
1586 DEFUN(coff_write_native_symbol
,(abfd
, symbol
, written
),
1588 coff_symbol_type
*symbol AND
1589 unsigned int written
)
1592 Does this symbol have an ascociated line number - if so then
1593 make it remember this symbol index. Also tag the auxent of
1594 this symbol to point to the right place in the lineno table
1596 combined_entry_type
*native
= symbol
->native
;
1598 alent
*lineno
= symbol
->lineno
;
1601 unsigned int count
= 0;
1602 lineno
[count
].u
.offset
= written
;
1603 if (native
->u
.syment
.n_numaux
) {
1604 union internal_auxent
*a
= &((native
+1)->u
.auxent
);
1606 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1607 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1610 And count and relocate all other linenumbers
1613 while (lineno
[count
].line_number
) {
1614 lineno
[count
].u
.offset
+=
1615 symbol
->symbol
.section
->output_section
->vma
+
1616 symbol
->symbol
.section
->output_offset
;
1619 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1623 return coff_write_symbol(abfd
, &( symbol
->symbol
), native
,written
);
1627 DEFUN(coff_write_symbols
,(abfd
),
1631 unsigned int limit
= bfd_get_symcount(abfd
);
1632 unsigned int written
= 0;
1639 /* Seek to the right place */
1640 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
1642 /* Output all the symbols we have */
1645 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1647 asymbol
*symbol
= *p
;
1648 coff_symbol_type
*c_symbol
= coff_symbol_from(abfd
, symbol
);
1652 if (c_symbol
== (coff_symbol_type
*) NULL
||
1653 c_symbol
->native
== (combined_entry_type
*)NULL
)
1655 written
= coff_write_alien_symbol(abfd
, symbol
, written
);
1659 written
= coff_write_native_symbol(abfd
, c_symbol
, written
);
1664 bfd_get_symcount(abfd
) = written
;
1666 /* Now write out strings */
1668 if (string_size
!= 0)
1670 unsigned int size
= string_size
+ 4;
1672 bfd_h_put_32(abfd
, size
, buffer
);
1673 bfd_write((PTR
) buffer
, 1, sizeof(buffer
), abfd
);
1674 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1677 size_t name_length
= strlen(q
->name
);
1679 coff_symbol_type
* c_symbol
= coff_symbol_from(abfd
, q
);
1680 maxlen
= ((c_symbol
!= NULL
&& c_symbol
->native
!= NULL
) &&
1681 (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
)) ?
1682 FILNMLEN
: SYMNMLEN
;
1684 if (name_length
> maxlen
) {
1685 bfd_write((PTR
) (q
->name
), 1, name_length
+ 1, abfd
);
1690 /* We would normally not write anything here, but we'll write
1691 out 4 so that any stupid coff reader which tries to read
1692 the string table even when there isn't one won't croak.
1695 uint32e_type size
= 4;
1697 bfd_write((PTR
)&size
, 1, sizeof(size
), abfd
);
1701 #endif /* NO_COFF_SYMBOLS */
1704 @subsubsection Writing Relocations
1705 To write a relocations, all the back end does is step though the
1706 canonical relocation table, and create an @code{internal_reloc}. The
1707 symbol index to use is removed from the @code{offset} field in the
1708 symbol table supplied, the address comes directly from the sum of the
1709 section base address and the relocation offset and the type is dug
1710 directly from the howto field.
1712 Then the @code{internal_reloc} is swapped into the shape of an
1713 @code{external_reloc} and written out to disk.
1717 DEFUN(coff_write_relocs
,(abfd
),
1721 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1723 struct external_reloc dst
;
1725 arelent
**p
= s
->orelocation
;
1726 bfd_seek(abfd
, s
->rel_filepos
, SEEK_SET
);
1727 for (i
= 0; i
< s
->reloc_count
; i
++) {
1728 struct internal_reloc n
;
1730 memset((PTR
)&n
, 0, sizeof(n
));
1731 n
.r_vaddr
= q
->address
+ s
->vma
;
1732 if (q
->sym_ptr_ptr
) {
1733 n
.r_symndx
= get_index((*(q
->sym_ptr_ptr
)));
1736 /* Work out reloc type from what is required */
1737 SELECT_RELOC(n
.r_type
, q
->howto
);
1739 n
.r_type
= q
->howto
->type
;
1741 bfd_swap_reloc_out(abfd
, &n
, &dst
);
1742 bfd_write((PTR
) &n
, 1, RELSZ
, abfd
);
1747 #ifndef NO_COFF_LINENOS
1750 DEFUN(coff_write_linenumbers
,(abfd
),
1754 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1755 if (s
->lineno_count
) {
1756 asymbol
**q
= abfd
->outsymbols
;
1757 bfd_seek(abfd
, s
->line_filepos
, SEEK_SET
);
1758 /* Find all the linenumbers in this section */
1761 alent
*l
= BFD_SEND(p
->the_bfd
, _get_lineno
, (p
->the_bfd
, p
));
1763 /* Found a linenumber entry, output */
1764 struct internal_lineno out
;
1766 memset( (PTR
)&out
, 0, sizeof(out
));
1768 out
.l_addr
.l_symndx
= l
->u
.offset
;
1769 coff_swap_lineno_out(abfd
, &out
, &buff
);
1770 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1772 while (l
->line_number
) {
1773 out
.l_lnno
= l
->line_number
;
1774 out
.l_addr
.l_symndx
= l
->u
.offset
;
1775 coff_swap_lineno_out(abfd
, &out
, &buff
);
1776 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1787 DEFUN(coff_get_lineno
,(ignore_abfd
, symbol
),
1788 bfd
*ignore_abfd AND
1791 return coffsymbol(symbol
)->lineno
;
1794 #endif /* NO_COFF_LINENOS */
1797 coff_make_empty_symbol(abfd
)
1800 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc(abfd
, sizeof(coff_symbol_type
));
1802 bfd_error
= no_memory
;
1806 new->lineno
= (alent
*) NULL
;
1807 new->symbol
.the_bfd
= abfd
;
1808 return &new->symbol
;
1811 #ifndef NO_COFF_SYMBOLS
1814 DEFUN(coff_print_symbol
,(ignore_abfd
, filep
, symbol
, how
),
1815 bfd
*ignore_abfd AND
1818 bfd_print_symbol_enum_type how
)
1820 FILE *file
= (FILE *)filep
;
1822 case bfd_print_symbol_name_enum
:
1823 fprintf(file
, "%s", symbol
->name
);
1825 case bfd_print_symbol_type_enum
:
1826 fprintf(file
, "coff %lx %lx", (unsigned long) coffsymbol(symbol
)->native
,
1827 (unsigned long) coffsymbol(symbol
)->lineno
);
1829 case bfd_print_symbol_all_enum
:
1831 CONST
char *section_name
= symbol
->section
== (asection
*) NULL
?
1832 "*abs" : symbol
->section
->name
;
1833 bfd_print_symbol_vandf((PTR
) file
, symbol
);
1835 fprintf(file
, " %-5s %s %s %s",
1837 coffsymbol(symbol
)->native
? "n" : "g",
1838 coffsymbol(symbol
)->lineno
? "l" : " ",
1847 #endif /* NO_COFF_SYMBOLS */
1849 /* Set flags and magic number of a coff file from architecture and machine
1850 type. Result is true if we can represent the arch&type, false if not. */
1853 DEFUN(coff_set_flags
,(abfd
, magicp
, flagsp
),
1855 unsigned *magicp AND
1856 unsigned short *flagsp
)
1859 switch (abfd
->obj_arch
) {
1867 *magicp
= I960ROMAGIC
;
1869 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1870 I960RWMAGIC); FIXME???
1872 switch (abfd
->obj_machine
) {
1873 case bfd_mach_i960_core
:
1876 case bfd_mach_i960_kb_sb
:
1879 case bfd_mach_i960_mc
:
1882 case bfd_mach_i960_xa
:
1885 case bfd_mach_i960_ca
:
1888 case bfd_mach_i960_ka_sa
:
1901 *magicp
= MIPS_MAGIC_2
;
1907 *magicp
= I386MAGIC
;
1912 *magicp
= MC68MAGIC
;
1918 *magicp
= MC88OMAGIC
;
1923 #ifdef A29K_MAGIC_BIG
1925 if (abfd
->xvec
->byteorder_big_p
)
1926 *magicp
= A29K_MAGIC_BIG
;
1928 *magicp
= A29K_MAGIC_LITTLE
;
1933 default: /* Unknown architecture */
1934 /* return false; -- fall through to "return false" below, to avoid
1935 "statement never reached" errors on the one below. */
1944 DEFUN(coff_set_arch_mach
,(abfd
, arch
, machine
),
1946 enum bfd_architecture arch AND
1947 unsigned long machine
)
1950 unsigned short dummy2
;
1951 abfd
->obj_arch
= arch
;
1952 abfd
->obj_machine
= machine
;
1953 if (arch
!= bfd_arch_unknown
&&
1954 coff_set_flags(abfd
, &dummy1
, &dummy2
) != true)
1955 return false; /* We can't represent this type */
1956 return true; /* We're easy ... */
1960 /* Calculate the file position for each section. */
1963 DEFUN(coff_compute_section_file_positions
,(abfd
),
1967 file_ptr sofar
= FILHSZ
;
1968 if (bfd_get_start_address(abfd
)) {
1970 A start address may have been added to the original file. In this
1971 case it will need an optional header to record it.
1973 abfd
->flags
|= EXEC_P
;
1975 if (abfd
->flags
& EXEC_P
)
1979 sofar
+= abfd
->section_count
* SCNHSZ
;
1980 for (current
= abfd
->sections
;
1981 current
!= (asection
*)NULL
;
1982 current
= current
->next
) {
1983 /* Only deal with sections which have contents */
1984 if (!(current
->flags
& SEC_HAS_CONTENTS
))
1987 /* Align the sections in the file to the same boundary on
1988 which they are aligned in virtual memory. I960 doesn't
1989 do this (FIXME) so we can stay in sync with Intel. 960
1990 doesn't yet page from files... */
1992 sofar
= ALIGN(sofar
, 1 << current
->alignment_power
);
1994 /* FIXME, in demand paged files, the low order bits of the file
1995 offset must match the low order bits of the virtual address.
1996 "Low order" is apparently implementation defined. Add code
1997 here to round sofar up to match the virtual address. */
1999 current
->filepos
= sofar
;
2000 sofar
+= current
->size
;
2002 obj_relocbase(abfd
) = sofar
;
2011 DEFUN(coff_write_object_contents
,(abfd
),
2015 boolean hasrelocs
= false;
2016 boolean haslinno
= false;
2017 file_ptr reloc_base
;
2018 file_ptr lineno_base
;
2022 unsigned long reloc_size
= 0;
2023 unsigned long lnno_size
= 0;
2024 asection
*text_sec
= NULL
;
2025 asection
*data_sec
= NULL
;
2026 asection
*bss_sec
= NULL
;
2028 struct internal_filehdr internal_f
;
2029 struct internal_aouthdr internal_a
;
2032 bfd_error
= system_call_error
;
2035 if(abfd
->output_has_begun
== false) {
2036 coff_compute_section_file_positions(abfd
);
2039 if (abfd
->sections
!= (asection
*)NULL
) {
2040 scn_base
= abfd
->sections
->filepos
;
2045 if (bfd_seek(abfd
, scn_base
, SEEK_SET
) != 0)
2047 reloc_base
= obj_relocbase(abfd
);
2049 /* Make a pass through the symbol table to count line number entries and
2050 put them into the correct asections */
2052 #ifndef NO_COFF_LINENOS
2053 coff_count_linenumbers(abfd
);
2055 data_base
= scn_base
;
2057 /* Work out the size of the reloc and linno areas */
2059 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
) {
2060 reloc_size
+= current
->reloc_count
* RELSZ
;
2061 #ifndef NO_COFF_LINENOS
2062 lnno_size
+= current
->lineno_count
* LINESZ
;
2064 data_base
+= SCNHSZ
;
2067 lineno_base
= reloc_base
+ reloc_size
;
2068 sym_base
= lineno_base
+ lnno_size
;
2070 /* Indicate in each section->line_filepos its actual file address */
2071 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
) {
2072 if (current
->lineno_count
) {
2073 current
->line_filepos
= lineno_base
;
2074 current
->moving_line_filepos
= lineno_base
;
2075 #ifndef NO_COFF_LINENOS
2076 lineno_base
+= current
->lineno_count
* LINESZ
;
2080 current
->line_filepos
= 0;
2082 if (current
->reloc_count
) {
2083 current
->rel_filepos
= reloc_base
;
2084 reloc_base
+= current
->reloc_count
* sizeof(struct internal_reloc
);
2087 current
->rel_filepos
= 0;
2091 /* Write section headers to the file. */
2094 (file_ptr
) ((abfd
->flags
& EXEC_P
) ?
2095 (FILHSZ
+ AOUTSZ
) : FILHSZ
),
2100 unsigned int pad
= abfd
->flags
& D_PAGED
? data_base
: 0;
2102 unsigned int pad
= 0;
2104 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
) {
2105 struct internal_scnhdr section
;
2106 strncpy(&(section
.s_name
[0]), current
->name
, 8);
2107 section
.s_vaddr
= current
->vma
+ pad
;
2108 section
.s_paddr
= current
->vma
+ pad
;
2109 section
.s_size
= current
->size
- pad
;
2111 If this section has no size or is unloadable then the scnptr
2114 if (current
->size
- pad
== 0 ||
2115 (current
->flags
& SEC_LOAD
) == 0) {
2116 section
.s_scnptr
= 0;
2120 section
.s_scnptr
= current
->filepos
;
2122 section
.s_relptr
= current
->rel_filepos
;
2123 section
.s_lnnoptr
= current
->line_filepos
;
2124 section
.s_nreloc
= current
->reloc_count
;
2125 section
.s_nlnno
= current
->lineno_count
;
2126 if (current
->reloc_count
!= 0)
2128 if (current
->lineno_count
!= 0)
2131 section
.s_flags
= sec_to_styp_flags(current
->name
,current
->flags
);
2133 if (!strcmp(current
->name
, _TEXT
)) {
2135 } else if (!strcmp(current
->name
, _DATA
)) {
2137 } else if (!strcmp(current
->name
, _BSS
)) {
2142 section
.s_align
= (current
->alignment_power
2143 ? 1 << current
->alignment_power
2150 swap_scnhdr_out(abfd
, §ion
, &buff
);
2151 bfd_write((PTR
) (&buff
), 1, SCNHSZ
, abfd
);
2158 /* OK, now set up the filehdr... */
2159 internal_f
.f_nscns
= abfd
->section_count
;
2161 We will NOT put a fucking timestamp in the header here. Every time you
2162 put it back, I will come in and take it out again. I'm sorry. This
2163 field does not belong here. We fill it with a 0 so it compares the
2164 same but is not a reasonable time. -- gnu@cygnus.com
2167 Well, I like it, so I'm conditionally compiling it in.
2170 #ifdef COFF_TIMESTAMP
2171 internal_f
.f_timdat
= time(0);
2173 internal_f
.f_timdat
= 0;
2176 if (bfd_get_symcount(abfd
) != 0)
2177 internal_f
.f_symptr
= sym_base
;
2179 internal_f
.f_symptr
= 0;
2181 internal_f
.f_flags
= 0;
2183 if (abfd
->flags
& EXEC_P
)
2184 internal_f
.f_opthdr
= AOUTSZ
;
2186 internal_f
.f_opthdr
= 0;
2189 internal_f
.f_flags
|= F_RELFLG
;
2191 internal_f
.f_flags
|= F_LNNO
;
2192 if (0 == bfd_get_symcount(abfd
))
2193 internal_f
.f_flags
|= F_LSYMS
;
2194 if (abfd
->flags
& EXEC_P
)
2195 internal_f
.f_flags
|= F_EXEC
;
2197 internal_f
.f_flags
|= F_AR32W
;
2199 if (!abfd
->xvec
->byteorder_big_p
)
2200 internal_f
.f_flags
|= F_AR32WR
;
2203 FIXME, should do something about the other byte orders and
2207 /* Set up architecture-dependent stuff */
2209 { unsigned int magic
= 0;
2210 unsigned short flags
= 0;
2211 coff_set_flags(abfd
, &magic
, &flags
);
2212 internal_f
.f_magic
= magic
;
2213 internal_f
.f_flags
|= flags
;
2214 /* ...and the "opt"hdr... */
2217 # ifdef ULTRA3 /* NYU's machine */
2218 /* FIXME: This is a bogus check. I really want to see if there
2219 * is a .shbss or a .shdata section, if so then set the magic
2220 * number to indicate a shared data executable.
2222 if (internal_f
.f_nscns
>= 7)
2223 internal_a
.magic
= SHMAGIC
; /* Shared magic */
2225 # endif /* ULTRA3 */
2226 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
2227 #define __A_MAGIC_SET__
2230 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
2231 #define __A_MAGIC_SET__
2234 #define __A_MAGIC_SET__
2235 internal_a
.magic
= PAGEMAGICBCS
;
2238 #if M68 || I386 || MIPS
2239 #define __A_MAGIC_SET__
2240 /* Never was anything here for the 68k */
2243 #ifndef __A_MAGIC_SET__
2244 # include "Your aouthdr magic number is not being set!"
2246 # undef __A_MAGIC_SET__
2249 /* Now should write relocs, strings, syms */
2250 obj_sym_filepos(abfd
) = sym_base
;
2252 #ifndef NO_COFF_SYMBOLS
2253 if (bfd_get_symcount(abfd
) != 0) {
2254 coff_renumber_symbols(abfd
);
2255 coff_mangle_symbols(abfd
);
2256 coff_write_symbols(abfd
);
2257 coff_write_linenumbers(abfd
);
2258 coff_write_relocs(abfd
);
2260 #endif /* NO_COFF_SYMBOLS */
2262 internal_a
.tsize
= text_sec
->size
;
2263 internal_a
.text_start
=text_sec
->size
? text_sec
->vma
: 0;
2266 internal_a
.dsize
= data_sec
->size
;
2267 internal_a
.data_start
= data_sec
->size
? data_sec
->vma
: 0;
2270 internal_a
.bsize
= bss_sec
->size
;
2273 internal_a
.entry
= bfd_get_start_address(abfd
);
2274 internal_f
.f_nsyms
= bfd_get_symcount(abfd
);
2276 /* now write them */
2277 if (bfd_seek(abfd
, 0L, SEEK_SET
) != 0)
2281 bfd_swap_filehdr_out(abfd
, &internal_f
, &buff
);
2282 bfd_write((PTR
) &buff
, 1, FILHSZ
, abfd
);
2284 if (abfd
->flags
& EXEC_P
) {
2286 bfd_swap_aouthdr_out(abfd
, &internal_a
, &buff
);
2287 bfd_write((PTR
) &buff
, 1, AOUTSZ
, abfd
);
2292 #ifndef NO_COFF_SYMBOLS
2295 this function transforms the offsets into the symbol table into
2296 pointers to syments.
2301 DEFUN(coff_pointerize_aux
,(abfd
, table_base
, type
, class, auxent
),
2303 combined_entry_type
*table_base AND
2306 combined_entry_type
*auxent
)
2308 /* Don't bother if this is a file or a section */
2309 if (class == C_STAT
&& type
== T_NULL
) return;
2310 if (class == C_FILE
) return;
2312 /* Otherwise patch up */
2313 if (ISFCN(type
) || ISTAG(class) || class == C_BLOCK
) {
2314 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
= table_base
+
2315 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2316 auxent
->fix_end
= 1;
2318 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
!= 0) {
2319 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
= table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
2320 auxent
->fix_tag
= 1;
2324 #endif /* NO_COFF_SYMBOLS */
2327 DEFUN(coff_set_section_contents
,(abfd
, section
, location
, offset
, count
),
2332 bfd_size_type count
)
2334 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
2335 coff_compute_section_file_positions(abfd
);
2337 bfd_seek(abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
);
2340 return (bfd_write(location
, 1, count
, abfd
) == count
) ? true : false;
2346 coff_close_and_cleanup(abfd
)
2349 if (!bfd_read_p(abfd
))
2350 switch (abfd
->format
) {
2352 if (!_bfd_write_archive_contents(abfd
))
2356 if (!coff_write_object_contents(abfd
))
2360 bfd_error
= invalid_operation
;
2364 /* We depend on bfd_close to free all the memory on the obstack. */
2365 /* FIXME if bfd_release is not using obstacks! */
2371 buy_and_read(abfd
, where
, seek_direction
, size
)
2377 PTR area
= (PTR
) bfd_alloc(abfd
, size
);
2379 bfd_error
= no_memory
;
2382 bfd_seek(abfd
, where
, seek_direction
);
2383 if (bfd_read(area
, 1, size
, abfd
) != size
) {
2384 bfd_error
= system_call_error
;
2388 } /* buy_and_read() */
2391 #ifndef NO_COFF_SYMBOLS
2394 DEFUN(build_string_table
,(abfd
),
2397 char string_table_size_buffer
[4];
2398 unsigned int string_table_size
;
2401 At this point we should be "seek"'d to the end of the
2402 symbols === the symbol table size.
2405 if (bfd_read((char *) string_table_size_buffer
,
2406 sizeof(string_table_size_buffer
),
2407 1, abfd
) != sizeof(string_table_size
)) {
2408 bfd_error
= system_call_error
;
2412 string_table_size
= bfd_h_get_32(abfd
, (bfd_byte
*) string_table_size_buffer
);
2414 if ((string_table
= (PTR
) bfd_alloc(abfd
, string_table_size
-= 4)) == NULL
) {
2415 bfd_error
= no_memory
;
2417 } /* on mallocation error */
2418 if (bfd_read(string_table
, string_table_size
, 1, abfd
) != string_table_size
) {
2419 bfd_error
= system_call_error
;
2422 return string_table
;
2426 read a symbol table into freshly mallocated memory, swap it, and knit the
2427 symbol names into a normalized form. By normalized here I mean that all
2428 symbols have an n_offset pointer that points to a NULL terminated string.
2429 Oh, and the first symbol MUST be a C_FILE. If there wasn't one there
2430 before, put one there.
2433 static combined_entry_type
*
2434 DEFUN(get_normalized_symtab
,(abfd
),
2438 combined_entry_type
*internal
;
2439 combined_entry_type
*internal_ptr
;
2440 combined_entry_type
*internal_end
;
2444 char *string_table
= NULL
;
2448 unsigned int raw_size
;
2449 if (obj_raw_syments(abfd
) != (combined_entry_type
*)NULL
) {
2450 return obj_raw_syments(abfd
);
2452 if ((size
= bfd_get_symcount(abfd
) * sizeof(combined_entry_type
)) == 0) {
2453 bfd_error
= no_symbols
;
2457 internal
= (combined_entry_type
*)bfd_alloc(abfd
, size
);
2458 internal_end
= internal
+ bfd_get_symcount(abfd
);
2460 raw_size
= bfd_get_symcount(abfd
) * SYMESZ
;
2461 raw
= (SYMENT
*)bfd_alloc(abfd
,raw_size
);
2463 if (bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
) == -1
2464 || bfd_read((PTR
)raw
, raw_size
, 1, abfd
) != raw_size
) {
2465 bfd_error
= system_call_error
;
2468 /* mark the end of the symbols */
2469 raw_end
= raw
+ bfd_get_symcount(abfd
);
2471 FIXME SOMEDAY. A string table size of zero is very weird, but
2472 probably possible. If one shows up, it will probably kill us.
2475 /* Swap all the raw entries */
2476 for (raw_src
= raw
, internal_ptr
= internal
; raw_src
< raw_end
; raw_src
++, internal_ptr
++) {
2478 coff_swap_sym_in(abfd
, raw_src
,&internal_ptr
->u
.syment
);
2479 internal_ptr
->fix_tag
= 0;
2480 internal_ptr
->fix_end
= 0;
2482 for (i
= internal_ptr
->u
.syment
.n_numaux
; i
; --i
, raw_src
++, internal_ptr
++) {
2483 (internal_ptr
+1)->fix_tag
= 0;
2484 (internal_ptr
+1)->fix_end
= 0;
2486 coff_swap_aux_in(abfd
, (AUXENT
*)(raw_src
+1), internal_ptr
->u
.syment
.n_type
,
2487 internal_ptr
->u
.syment
.n_sclass
, & (internal_ptr
+1)->u
.auxent
);
2489 coff_pointerize_aux(abfd
,
2491 internal_ptr
->u
.syment
.n_type
,
2492 internal_ptr
->u
.syment
.n_sclass
,
2497 /* Free all the raw stuff */
2498 bfd_release(abfd
, raw_src
);
2500 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
2503 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
) {
2504 /* make a file symbol point to the name in the auxent, since
2505 the text ".file" is redundant */
2506 if ((internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_zeroes
== 0) {
2507 /* the filename is a long one, point into the string table
2509 if (string_table
== NULL
) {
2510 string_table
= build_string_table(abfd
);
2513 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
2514 (int) (string_table
- 4 +
2515 (internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_offset
);
2518 /* ordinary short filename, put into memory anyway */
2519 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2520 copy_name(abfd
, (internal_ptr
+1)->u
.auxent
.x_file
.x_fname
, FILNMLEN
);
2525 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0) {
2527 This is a "short" name. Make it long.
2529 unsigned long i
= 0;
2530 char *newstring
= NULL
;
2532 find the length of this string without walking into memory
2536 for (i
= 0; i
< 8; ++i
) {
2537 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0') {
2539 } /* if end of string */
2540 } /* possible lengths of this string. */
2542 if ((newstring
= (PTR
) bfd_alloc(abfd
, ++i
)) == NULL
) {
2543 bfd_error
= no_memory
;
2546 bzero(newstring
, i
);
2547 strncpy(newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
-1);
2548 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int) newstring
;
2549 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
2553 /* This is a long name already. Just point it at the string in memory. */
2554 if (string_table
== NULL
) {
2555 string_table
= build_string_table(abfd
);
2557 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
2558 (int) (string_table
- 4 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
2561 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
2564 obj_raw_syments(abfd
) = internal
;
2565 obj_string_table(abfd
) = string_table
;
2568 } /* get_normalized_symtab() */
2570 #endif /* NO_COFF_SYMBOLS */
2574 DEFUN(section_from_bfd_index
,(abfd
, index
),
2579 struct sec
*answer
= abfd
->sections
;
2581 answer
= answer
->next
;
2588 #ifndef NO_COFF_LINENOS
2591 @subsubsection Reading Linenumbers
2592 Createing the linenumber table is done by reading in the entire coff
2593 linenumber table, and creating another table for internal use.
2595 A coff line number table is structured so that each
2596 function is marked as having a line number of 0. Each line within the
2597 function is an offset from the first line in the function. The base of
2598 the line number information for the table is stored in the symbol
2599 associated with the function.
2601 The information is copied from the external to the internal table, and
2602 each symbol which marks a function is marked by pointing its...
2604 **How does this work ?**
2609 coff_slurp_line_table(abfd
, asect
)
2613 LINENO
*native_lineno
;
2614 alent
*lineno_cache
;
2616 BFD_ASSERT(asect
->lineno
== (alent
*) NULL
);
2618 native_lineno
= (LINENO
*) buy_and_read(abfd
,
2619 asect
->line_filepos
,
2622 asect
->lineno_count
));
2624 (alent
*) bfd_alloc(abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof(alent
)));
2625 if (lineno_cache
== NULL
) {
2626 bfd_error
= no_memory
;
2629 unsigned int counter
= 0;
2630 alent
*cache_ptr
= lineno_cache
;
2631 LINENO
*src
= native_lineno
;
2633 while (counter
< asect
->lineno_count
) {
2634 struct internal_lineno dst
;
2635 coff_swap_lineno_in(abfd
, src
, &dst
);
2636 cache_ptr
->line_number
= dst
.l_lnno
;
2638 if (cache_ptr
->line_number
== 0) {
2639 coff_symbol_type
*sym
=
2640 (coff_symbol_type
*) (dst
.l_addr
.l_symndx
2641 + obj_symbol_slew(abfd
)
2642 + obj_raw_syments(abfd
))->u
.syment
._n
._n_n
._n_zeroes
;
2643 cache_ptr
->u
.sym
= (asymbol
*) sym
;
2644 sym
->lineno
= cache_ptr
;
2647 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
2648 - bfd_section_vma(abfd
, asect
);
2649 } /* If no linenumber expect a symbol index */
2655 cache_ptr
->line_number
= 0;
2658 asect
->lineno
= lineno_cache
;
2659 /* FIXME, free native_lineno here, or use alloca or something. */
2661 } /* coff_slurp_line_table() */
2663 #endif /* NO_COFF_LINENOS */
2665 #ifndef NO_COFF_LINENOS
2668 DEFUN(coff_slurp_symbol_table
,(abfd
),
2671 combined_entry_type
*native_symbols
;
2672 coff_symbol_type
*cached_area
;
2673 unsigned int *table_ptr
;
2675 unsigned int number_of_symbols
= 0;
2676 if (obj_symbols(abfd
))
2678 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
2680 /* Read in the symbol table */
2681 if ((native_symbols
= get_normalized_symtab(abfd
)) == NULL
) {
2686 /* Allocate enough room for all the symbols in cached form */
2688 (coff_symbol_type
*)
2689 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(coff_symbol_type
)));
2691 if (cached_area
== NULL
) {
2692 bfd_error
= no_memory
;
2697 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(unsigned int)));
2699 if (table_ptr
== NULL
) {
2700 bfd_error
= no_memory
;
2703 coff_symbol_type
*dst
= cached_area
;
2704 unsigned int last_native_index
= bfd_get_symcount(abfd
);
2705 unsigned int this_index
= 0;
2706 while (this_index
< last_native_index
) {
2707 combined_entry_type
*src
= native_symbols
+ this_index
;
2708 table_ptr
[this_index
] = number_of_symbols
;
2709 dst
->symbol
.the_bfd
= abfd
;
2711 dst
->symbol
.name
= (char *)(src
->u
.syment
._n
._n_n
._n_offset
);
2713 We use the native name field to point to the cached field
2715 src
->u
.syment
._n
._n_n
._n_zeroes
= (int) dst
;
2716 dst
->symbol
.section
= section_from_bfd_index(abfd
,
2717 src
->u
.syment
.n_scnum
);
2718 switch (src
->u
.syment
.n_sclass
) {
2722 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
2723 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2724 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
2726 /* Fall through to next case */
2731 if ((src
->u
.syment
.n_scnum
) == 0) {
2732 if ((src
->u
.syment
.n_value
) == 0) {
2733 dst
->symbol
.flags
= BSF_UNDEFINED
;
2734 dst
->symbol
.value
= 0;
2737 dst
->symbol
.flags
= BSF_FORT_COMM
;
2738 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2743 Base the value as an index from the base of the
2746 if (dst
->symbol
.section
== (asection
*) NULL
) {
2747 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
| BSF_ABSOLUTE
;
2748 dst
->symbol
.value
= src
->u
.syment
.n_value
;
2751 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2752 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
2754 if (ISFCN((src
->u
.syment
.n_type
))) {
2756 A function ext does not go at the end of a file
2758 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
2763 case C_STAT
: /* static */
2765 case C_LEAFSTAT
: /* static leaf procedure */
2767 case C_LABEL
: /* label */
2768 dst
->symbol
.flags
= BSF_LOCAL
;
2770 Base the value as an index from the base of the section
2772 dst
->symbol
.value
= (src
->u
.syment
.n_value
) - dst
->symbol
.section
->vma
;
2775 case C_MOS
: /* member of structure */
2776 case C_EOS
: /* end of structure */
2777 #ifdef NOTDEF /* C_AUTOARG has the same value */
2779 case C_GLBLREG
: /* A29k-specific storage class */
2782 case C_REGPARM
: /* register parameter */
2783 case C_REG
: /* register variable */
2785 case C_AUTOARG
: /* 960-specific storage class */
2787 case C_TPDEF
: /* type definition */
2790 case C_AUTO
: /* automatic variable */
2791 case C_FIELD
: /* bit field */
2792 case C_ENTAG
: /* enumeration tag */
2793 case C_MOE
: /* member of enumeration */
2794 case C_MOU
: /* member of union */
2795 case C_UNTAG
: /* union tag */
2797 dst
->symbol
.flags
= BSF_DEBUGGING
;
2798 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2801 case C_FILE
: /* file name */
2802 case C_STRTAG
: /* structure tag */
2803 dst
->symbol
.flags
= BSF_DEBUGGING
;
2804 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2807 case C_BLOCK
: /* ".bb" or ".eb" */
2808 case C_FCN
: /* ".bf" or ".ef" */
2809 case C_EFCN
: /* physical end of function */
2810 dst
->symbol
.flags
= BSF_LOCAL
;
2812 Base the value as an index from the base of the section
2814 dst
->symbol
.value
= (src
->u
.syment
.n_value
) - dst
->symbol
.section
->vma
;
2818 case C_EXTDEF
: /* external definition */
2819 case C_ULABEL
: /* undefined label */
2820 case C_USTATIC
: /* undefined static */
2821 case C_LINE
: /* line # reformatted as symbol table entry */
2822 case C_ALIAS
: /* duplicate tag */
2823 case C_HIDDEN
: /* ext symbol in dmert public lib */
2827 fprintf(stderr
,"Unrecognized storage class %d\n",
2828 src
->u
.syment
.n_sclass
);
2830 dst
->symbol
.flags
= BSF_DEBUGGING
;
2831 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2836 BFD_ASSERT(dst
->symbol
.flags
!= 0);
2840 dst
->symbol
.udata
= 0;
2841 dst
->lineno
= (alent
*) NULL
;
2842 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
2844 number_of_symbols
++;
2845 } /* walk the native symtab */
2846 } /* bfdize the native symtab */
2848 obj_symbols(abfd
) = cached_area
;
2849 obj_raw_syments(abfd
) = native_symbols
;
2851 bfd_get_symcount(abfd
) = number_of_symbols
;
2852 obj_convert(abfd
) = table_ptr
;
2853 /* Slurp the line tables for each section too */
2858 coff_slurp_line_table(abfd
, p
);
2863 } /* coff_slurp_symbol_table() */
2866 coff_get_symtab_upper_bound(abfd
)
2869 if (!coff_slurp_symbol_table(abfd
))
2872 return (bfd_get_symcount(abfd
) + 1) * (sizeof(coff_symbol_type
*));
2877 coff_get_symtab(abfd
, alocation
)
2879 asymbol
**alocation
;
2881 unsigned int counter
= 0;
2882 coff_symbol_type
*symbase
;
2883 coff_symbol_type
**location
= (coff_symbol_type
**) (alocation
);
2884 if (!coff_slurp_symbol_table(abfd
))
2887 for (symbase
= obj_symbols(abfd
); counter
++ < bfd_get_symcount(abfd
);)
2888 *(location
++) = symbase
++;
2890 return bfd_get_symcount(abfd
);
2893 #endif /* NO_COFF_SYMBOLS */
2896 coff_get_reloc_upper_bound(abfd
, asect
)
2900 if (bfd_get_format(abfd
) != bfd_object
) {
2901 bfd_error
= invalid_operation
;
2904 return (asect
->reloc_count
+ 1) * sizeof(arelent
*);
2908 @subsubsection Reading Relocations
2909 Coff relocations are easily transformed into the internal BFD form
2912 Reading a coff relocation table is done in the following stages:
2915 The entire coff relocation table is read into memory.
2917 Each relocation is processed in turn, first it is swapped from the
2918 external to the internal form.
2920 The symbol referenced in the relocation's symbol index is turned into
2921 a pointer into the canonical symbol table. Note that this table is the
2922 same as the one returned by a call to @code{bfd_canonicalize_symtab}.
2923 The back end will call the routine and save the result if a
2924 canonicalization hasn't been done.
2926 The reloc index is turned into a pointer to a howto structure, in a
2927 back end specific way. For instance, the 386 and 960 use the
2928 @code{r_type} to directly produce an index into a howto table vector;
2929 the 88k subtracts a number from the @code{r_type} field and creates an
2935 DEFUN(coff_slurp_reloc_table
,(abfd
, asect
, symbols
),
2940 RELOC
*native_relocs
;
2941 arelent
*reloc_cache
;
2942 if (asect
->relocation
)
2944 if (asect
->reloc_count
== 0)
2946 #ifndef NO_COFF_SYMBOLS
2947 if (!coff_slurp_symbol_table(abfd
))
2951 (RELOC
*) buy_and_read(abfd
,
2955 asect
->reloc_count
));
2956 reloc_cache
= (arelent
*)
2957 bfd_alloc(abfd
, (size_t) (asect
->reloc_count
* sizeof(arelent
)));
2959 if (reloc_cache
== NULL
) {
2960 bfd_error
= no_memory
;
2965 for (cache_ptr
= reloc_cache
,
2966 src
= native_relocs
;
2967 cache_ptr
< reloc_cache
+ asect
->reloc_count
;
2970 struct internal_reloc dst
;
2972 bfd_swap_reloc_in(abfd
, src
, &dst
);
2974 dst
.r_symndx
+= obj_symbol_slew(abfd
);
2975 cache_ptr
->sym_ptr_ptr
= symbols
+ obj_convert(abfd
)[dst
.r_symndx
];
2977 /* AMD has two relocation entries for the 'consth' instruction.
2978 * The first is R_IHIHALF (part 1), the second is R_IHCONST
2979 * (part 2). The second entry's r_symndx does not contain
2980 * an index to a symbol but rather a value (apparently).
2981 * Also, see the ifdef below for saving the r_symndx value in addend.
2983 if (dst
.r_type
== R_IHCONST
) {
2987 ptr
= *(cache_ptr
->sym_ptr_ptr
);
2988 cache_ptr
->address
= dst
.r_vaddr
;
2990 The symbols definitions that we have read in have been
2991 relocated as if their sections started at 0. But the offsets
2992 refering to the symbols in the raw data have not been
2993 modified, so we have to have a negative addend to compensate.
2995 Note that symbols which used to be common must be left alone
2998 if (ptr
&& ptr
->the_bfd
== abfd
2999 && ptr
->section
!= (asection
*) NULL
3000 && ((ptr
->flags
& BSF_OLD_COMMON
)== 0))
3003 cache_ptr
->addend
= -(ptr
->section
->vma
+ ptr
->value
);
3005 cache_ptr
->addend
= 0;
3010 cache_ptr
->addend
= 0;
3013 cache_ptr
->address
-= asect
->vma
;
3015 cache_ptr
->section
= (asection
*) NULL
;
3018 if (dst
.r_type
== R_IHCONST
) {
3019 /* Add in the value which was stored in the symbol index */
3020 /* See above comment */
3021 cache_ptr
->addend
+= dst
.r_symndx
;
3022 /* Throw away the bogus symbol pointer */
3023 cache_ptr
->sym_ptr_ptr
= 0;
3025 cache_ptr
->howto
= howto_table
+ dst
.r_type
;
3028 cache_ptr
->howto
= howto_table
+ dst
.r_type
;
3031 cache_ptr
->howto
= howto_table
+ dst
.r_type
;
3034 cache_ptr
->howto
= howto_table
+ dst
.r_type
- R_RELBYTE
;
3037 if (dst
.r_type
>= R_PCR16L
&& dst
.r_type
<= R_VRT32
) {
3038 cache_ptr
->howto
= howto_table
+ dst
.r_type
- R_PCR16L
;
3039 cache_ptr
->addend
+= dst
.r_offset
<< 16;
3050 asect
->relocation
= reloc_cache
;
3055 /* This is stupid. This function should be a boolean predicate */
3057 coff_canonicalize_reloc(abfd
, section
, relptr
, symbols
)
3063 arelent
*tblptr
= section
->relocation
;
3064 unsigned int count
= 0;
3065 if (!(tblptr
|| coff_slurp_reloc_table(abfd
, section
, symbols
)))
3067 tblptr
= section
->relocation
;
3071 for (; count
++ < section
->reloc_count
;)
3072 *relptr
++ = tblptr
++;
3076 return section
->reloc_count
;
3079 #ifndef NO_COFF_SYMBOLS
3082 provided a BFD, a section and an offset into the section, calculate and
3083 return the name of the source file and the line nearest to the wanted
3088 DEFUN(coff_find_nearest_line
,(abfd
,
3096 asection
*section AND
3097 asymbol
**symbols AND
3099 CONST
char **filename_ptr AND
3100 CONST
char **functionname_ptr AND
3101 unsigned int *line_ptr
)
3103 static bfd
*cache_abfd
;
3104 static asection
*cache_section
;
3105 static bfd_vma cache_offset
;
3106 static unsigned int cache_i
;
3107 static alent
*cache_l
;
3110 struct icofdata
*cof
= obj_icof(abfd
);
3111 /* Run through the raw syments if available */
3112 combined_entry_type
*p
;
3114 unsigned int line_base
= 0;
3118 *functionname_ptr
= 0;
3121 /* Don't try and find line numbers in a non coff file */
3122 if (abfd
->xvec
->flavour
!= bfd_target_coff_flavour_enum
)
3125 if (cof
== (struct icofdata
*)NULL
)
3128 p
= cof
->raw_syments
;
3130 for (i
= 0; i
< cof
->raw_syment_count
; i
++) {
3131 if (p
->u
.syment
.n_sclass
== C_FILE
) {
3132 /* File name has been moved into symbol */
3133 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
3136 p
+= 1 + p
->u
.syment
.n_numaux
;
3138 /* Now wander though the raw linenumbers of the section */
3140 If this is the same BFD as we were previously called with and this is
3141 the same section, and the offset we want is further down then we can
3142 prime the lookup loop
3144 if (abfd
== cache_abfd
&&
3145 section
== cache_section
&&
3146 offset
>= cache_offset
) {
3152 l
= section
->lineno
;
3155 for (; i
< section
->lineno_count
; i
++) {
3156 if (l
->line_number
== 0) {
3157 /* Get the symbol this line number points at */
3158 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
3159 *functionname_ptr
= coff
->symbol
.name
;
3161 combined_entry_type
*s
= coff
->native
;
3162 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
3164 S should now point to the .bf of the function
3166 if (s
->u
.syment
.n_numaux
) {
3168 The linenumber is stored in the auxent
3170 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
3171 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
3176 if (l
->u
.offset
> offset
)
3178 *line_ptr
= l
->line_number
+ line_base
+ 1;
3184 cache_section
= section
;
3185 cache_offset
= offset
;
3194 coff_sym_filepos(abfd
)
3197 return obj_sym_filepos(abfd
);
3201 #endif /* NO_COFF_SYMBOLS */
3205 DEFUN(coff_sizeof_headers
,(abfd
, reloc
),
3211 if (reloc
== false) {
3212 size
= FILHSZ
+ AOUTSZ
;
3218 size
+= abfd
->section_count
* SCNHSZ
;
3223 #define coff_core_file_failing_command _bfd_dummy_core_file_failing_command
3224 #define coff_core_file_failing_signal _bfd_dummy_core_file_failing_signal
3225 #define coff_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
3226 #define coff_slurp_armap bfd_slurp_coff_armap
3227 #define coff_slurp_extended_name_table _bfd_slurp_extended_name_table
3228 #define coff_truncate_arname bfd_dont_truncate_arname
3229 #define coff_openr_next_archived_file bfd_generic_openr_next_archived_file
3230 #define coff_generic_stat_arch_elt bfd_generic_stat_arch_elt
3231 #define coff_get_section_contents bfd_generic_get_section_contents
3232 #define coff_close_and_cleanup bfd_generic_close_and_cleanup
3234 #define coff_bfd_debug_info_start bfd_void
3235 #define coff_bfd_debug_info_end bfd_void
3236 #define coff_bfd_debug_info_accumulate (PROTO(void,(*),(bfd*, struct sec *))) bfd_void