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 More of the bit twiddlers are exported for @code{gas};
94 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
95 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
96 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
97 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track of all
98 the symbol table and reloc drudgery itself, thereby saving the
99 internal BFD overhead, but uses BFD to swap things on the way out,
100 making cross ports much safer. This also allows BFD (and thus the
101 linker) to use the same header files as @code{gas}, which makes one
102 avenue to disaster disappear.
104 @subsubsection Symbol Reading
105 The simple canonical form for symbols used by BFD is not rich enough
106 to keep all the information available in a coff symbol table. The back
107 end gets around this by keeping the original symbol table around,
110 When a symbol table is requested (through a call to
111 @code{bfd_canonicalize_symtab}, a request gets through to
112 @code{get_normalized_symtab}. This reads the symbol table from the
113 coff file and swaps all the structures inside into the internal form.
114 It also fixes up all the pointers in the table (represented in the file
115 by offsets from the first symbol in the table) into physical pointers
116 to elements in the new internal table. This involves some work since
117 the meanings of fields changes depending upon context; a field that is a
118 pointer to another structure in the symbol table at one moment may be
119 the size in bytes of a structure in the next.
121 Another pass is made over the table. All symbols which mark file names
122 (@code{C_FILE} symbols) are modified so that the internal string
123 points to the value in the auxent (the real filename) rather than the
124 normal text associated with the symbol (@code{".file"}).
126 At this time the symbol names are moved around. Coff stores all
127 symbols less than nine characters long physically within the symbol
128 table, longer strings are kept at the end of the file in the string
129 table. This pass moves all strings into memory, and replaces them with
130 pointers to the strings.
132 The symbol table is massaged once again, this time to create the
133 canonical table used by the BFD application. Each symbol is inspected
134 in turn, and a decision made (using the @code{sclass} field) about the
135 various flags to set in the @code{asymbol} @xref{Symbols}. The
136 generated canonical table shares strings with the hidden internal
139 Any linenumbers are read from the coff file too, and attached to the
140 symbols which own the functions the linenumbers belong to.
142 @subsubsection Symbol Writing
143 Writing a symbol to a coff file which didn't come from a coff file
144 will lose any debugging information. The @code{asymbol} structure
145 remembers the BFD from which was born, and on output the back end
146 makes sure that the same destination target as source target is
149 When the symbols have come from a coff file then all the debugging
150 information is preserved.
152 Symbol tables are provided for writing to the back end in a vector of
153 pointers to pointers. This allows applications like the linker to
154 accumulate and output large symbol tables without having to do too
157 The symbol table is not output to a writable BFD until it is closed.
158 The order of operations on the canonical symbol table at that point
161 @item coff_renumber_symbols
162 This function runs through the provided symbol table and patches each
163 symbol marked as a file place holder (@code{C_FILE}) to point to the
164 next file place holder in the list. It also marks each @code{offset}
165 field in the list with the offset from the first symbol of the current
168 Another function of this procedure is to turn the canonical value form
169 of BFD into the form used by coff. Internally, BFD expects symbol
170 values to be offsets from a section base; so a symbol physically at
171 0x120, but in a section starting at 0x100, would have the value 0x20.
172 Coff expects symbols to contain their final value, so symbols have
173 their values changed at this point to reflect their sum with their
174 owning section. Note that this transformation uses the
175 @code{output_section} field of the @code{asymbol}'s @code{asection}
177 @item coff_mangle_symbols
178 This routine runs though the provided symbol table and uses the
179 offsets generated by the previous pass and the pointers generated when
180 the symbol table was read in to create the structured hierachy
181 required by coff. It changes each pointer to a symbol to an index into
182 the symbol table of the symbol being referenced.
183 @item coff_write_symbols
184 This routine runs through the symbol table and patches up the symbols
185 from their internal form into the coff way, calls the bit twiddlers
186 and writes out the tabel to the file.
192 The hidden information for an asymbol is:
196 $ typedef struct coff_ptr_struct
199 Remembers the offset from the first symbol in the file for this
200 symbol. Generated by @code{coff_renumber_symbols}.
202 $ unsigned int offset;
204 Should the tag field of this symbol be renumbered.
205 Created by @code{coff_pointerize_aux}.
209 Should the endidx field of this symbol be renumbered.
210 Created by @code{coff_pointerize_aux}.
214 The container for the symbol structure as read and translated from the file.
217 $ union internal_auxent auxent;
218 $ struct internal_syment syment;
220 $ } combined_entry_type;
225 Each canonical asymbol really looks like this:
229 $ typedef struct coff_symbol_struct
232 The actual symbol which the rest of BFD works with
236 A pointer to the hidden information for this symbol
238 $ combined_entry_type *native;
240 A pointer to the linenumber information for this symbol
242 $ struct lineno_cache_entry *lineno;
243 $ } coff_symbol_type;
250 /* Most of this hacked by Steve Chamberlain, steve@cygnus.com */
252 /* Align an address upward to a boundary, expressed as a number of bytes.
253 E.g. align to an 8-byte boundary with argument of 8. */
254 #define ALIGN(this, boundary) \
255 ((( (this) + ((boundary) -1)) & (~((boundary)-1))))
257 /* Align an address upward to a power of two. Argument is the power
258 of two, e.g. 8-byte alignment uses argument of 3 (8 == 2^3). */
259 #define i960_align(addr, align) \
260 ( ((addr) + ((1<<(align))-1)) & (-1 << (align)))
263 #define PUTWORD bfd_h_put_32
264 #define PUTHALF bfd_h_put_16
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)
313 /* void warning(); */
316 * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the
317 * incoming SEC_* flags. The inverse of this function is styp_to_sec_flags().
318 * NOTE: If you add to/change this routine, you should mirror the changes
319 * in styp_to_sec_flags().
322 DEFUN(sec_to_styp_flags
, (sec_name
, sec_flags
),
323 CONST
char * sec_name AND
328 if (!strcmp(sec_name
, _TEXT
)) {
329 return((long)STYP_TEXT
);
330 } else if (!strcmp(sec_name
, _DATA
)) {
331 return((long)STYP_DATA
);
332 } else if (!strcmp(sec_name
, _BSS
)) {
333 return((long)STYP_BSS
);
336 /* Try and figure out what it should be */
337 if (sec_flags
& SEC_CODE
) styp_flags
= STYP_TEXT
;
338 if (sec_flags
& SEC_DATA
) styp_flags
= STYP_DATA
;
339 else if (sec_flags
& SEC_READONLY
)
340 #ifdef STYP_LIT /* 29k readonly text/data section */
341 styp_flags
= STYP_LIT
;
343 styp_flags
= STYP_TEXT
;
344 #endif /* STYP_LIT */
345 else if (sec_flags
& SEC_LOAD
) styp_flags
= STYP_TEXT
;
347 if (styp_flags
== 0) styp_flags
= STYP_BSS
;
352 * Return a word with SEC_* flags set to represent the incoming
353 * STYP_* flags (from scnhdr.s_flags). The inverse of this
354 * function is sec_to_styp_flags().
355 * NOTE: If you add to/change this routine, you should mirror the changes
356 * in sec_to_styp_flags().
359 DEFUN(styp_to_sec_flags
, (styp_flags
),
362 flagword sec_flags
=0;
364 if ((styp_flags
& STYP_TEXT
) || (styp_flags
& STYP_DATA
))
365 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
366 else if (styp_flags
& STYP_BSS
)
367 sec_flags
= SEC_ALLOC
;
369 #ifdef STYP_LIT /* A29k readonly text/data section type */
370 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
371 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
372 #endif /* STYP_LIT */
377 #define get_index(symbol) ((int) (symbol)->value)
378 #define set_index(symbol, idx) ((symbol)->value = (idx))
380 /* **********************************************************************
381 Here are all the routines for swapping the structures seen in the
382 outside world into the internal forms.
387 DEFUN(bfd_swap_reloc_in
,(abfd
, reloc_src
, reloc_dst
),
390 struct internal_reloc
*reloc_dst
)
392 reloc_dst
->r_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*)reloc_src
->r_vaddr
);
393 reloc_dst
->r_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) reloc_src
->r_symndx
);
394 reloc_dst
->r_type
= bfd_h_get_16(abfd
, (bfd_byte
*) reloc_src
->r_type
);
396 reloc_dst
->r_offset
= bfd_h_get_16(abfd
, (bfd_byte
*) reloc_src
->r_offset
);
402 DEFUN(coff_swap_reloc_out
,(abfd
, src
, dst
),
407 struct internal_reloc
*reloc_src
= (struct internal_reloc
*)src
;
408 struct external_reloc
*reloc_dst
= (struct external_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
);
415 return sizeof(struct external_reloc
);
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(coff_swap_filehdr_out
,(abfd
, in
, out
),
439 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*)in
;
440 FILHDR
*filehdr_out
= (FILHDR
*)out
;
441 bfd_h_put_16(abfd
, filehdr_in
->f_magic
, (bfd_byte
*) filehdr_out
->f_magic
);
442 bfd_h_put_16(abfd
, filehdr_in
->f_nscns
, (bfd_byte
*) filehdr_out
->f_nscns
);
443 bfd_h_put_32(abfd
, filehdr_in
->f_timdat
, (bfd_byte
*) filehdr_out
->f_timdat
);
444 bfd_h_put_32(abfd
, filehdr_in
->f_symptr
, (bfd_byte
*) filehdr_out
->f_symptr
);
445 bfd_h_put_32(abfd
, filehdr_in
->f_nsyms
, (bfd_byte
*) filehdr_out
->f_nsyms
);
446 bfd_h_put_16(abfd
, filehdr_in
->f_opthdr
, (bfd_byte
*) filehdr_out
->f_opthdr
);
447 bfd_h_put_16(abfd
, filehdr_in
->f_flags
, (bfd_byte
*) filehdr_out
->f_flags
);
448 return sizeof(FILHDR
);
452 #ifndef NO_COFF_SYMBOLS
455 DEFUN(coff_swap_sym_in
,(abfd
, ext1
, in1
),
460 SYMENT
*ext
= (SYMENT
*)ext1
;
461 struct internal_syment
*in
= (struct internal_syment
*)in1
;
463 if( ext
->e
.e_name
[0] == 0) {
464 in
->_n
._n_n
._n_zeroes
= 0;
465 in
->_n
._n_n
._n_offset
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e
.e
.e_offset
);
468 #if SYMNMLEN != E_SYMNMLEN
469 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
471 memcpy(in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
474 in
->n_value
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_value
);
475 in
->n_scnum
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_scnum
);
476 if (sizeof(ext
->e_type
) == 2){
477 in
->n_type
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_type
);
480 in
->n_type
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_type
);
482 in
->n_sclass
= bfd_h_get_8(abfd
, ext
->e_sclass
);
483 in
->n_numaux
= bfd_h_get_8(abfd
, ext
->e_numaux
);
487 DEFUN(coff_swap_sym_out
,(abfd
, inp
, extp
),
492 struct internal_syment
*in
= (struct internal_syment
*)inp
;
493 SYMENT
*ext
=(SYMENT
*)extp
;
494 if(in
->_n
._n_name
[0] == 0) {
495 bfd_h_put_32(abfd
, 0, (bfd_byte
*) ext
->e
.e
.e_zeroes
);
496 bfd_h_put_32(abfd
, in
->_n
._n_n
._n_offset
, (bfd_byte
*) ext
->e
.e
.e_offset
);
499 #if SYMNMLEN != E_SYMNMLEN
500 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
502 memcpy(ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
505 bfd_h_put_32(abfd
, in
->n_value
, (bfd_byte
*) ext
->e_value
);
506 bfd_h_put_16(abfd
, in
->n_scnum
, (bfd_byte
*) ext
->e_scnum
);
507 if (sizeof(ext
->e_type
) == 2)
509 bfd_h_put_16(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
513 bfd_h_put_32(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
515 bfd_h_put_8(abfd
, in
->n_sclass
, ext
->e_sclass
);
516 bfd_h_put_8(abfd
, in
->n_numaux
, ext
->e_numaux
);
517 return sizeof(SYMENT
);
521 DEFUN(coff_swap_aux_in
,(abfd
, ext1
, type
, class, in1
),
528 AUXENT
*ext
= (AUXENT
*)ext1
;
529 union internal_auxent
*in
= (union internal_auxent
*)in1
;
532 if (ext
->x_file
.x_fname
[0] == 0) {
533 in
->x_file
.x_n
.x_zeroes
= 0;
534 in
->x_file
.x_n
.x_offset
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
536 #if FILNMLEN != E_FILNMLEN
537 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
539 memcpy (in
->x_file
.x_fname
, ext
->x_file
.x_fname
, FILNMLEN
);
549 if (type
== T_NULL
) {
550 in
->x_scn
.x_scnlen
= GET_SCN_SCNLEN(abfd
, ext
);
551 in
->x_scn
.x_nreloc
= GET_SCN_NRELOC(abfd
, ext
);
552 in
->x_scn
.x_nlinno
= GET_SCN_NLINNO(abfd
, ext
);
556 in
->x_sym
.x_tagndx
.l
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
558 in
->x_sym
.x_tvndx
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
561 if (ISARY(type
) || class == C_BLOCK
) {
562 #if DIMNUM != E_DIMNUM
563 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
565 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]);
566 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]);
567 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]);
568 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]);
571 in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= GET_FCN_LNNOPTR(abfd
, ext
);
572 in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= GET_FCN_ENDNDX(abfd
, ext
);
575 in
->x_sym
.x_misc
.x_fsize
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
578 in
->x_sym
.x_misc
.x_lnsz
.x_lnno
= GET_LNSZ_LNNO(abfd
, ext
);
579 in
->x_sym
.x_misc
.x_lnsz
.x_size
= GET_LNSZ_SIZE(abfd
, ext
);
585 DEFUN(coff_swap_aux_out
,(abfd
, inp
, type
, class, extp
),
592 union internal_auxent
*in
= (union internal_auxent
*)inp
;
593 AUXENT
*ext
= (AUXENT
*)extp
;
596 if (in
->x_file
.x_fname
[0] == 0) {
597 PUTWORD(abfd
, 0, (bfd_byte
*) ext
->x_file
.x_n
.x_zeroes
);
599 in
->x_file
.x_n
.x_offset
,
600 (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
603 #if FILNMLEN != E_FILNMLEN
604 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
606 memcpy (ext
->x_file
.x_fname
, in
->x_file
.x_fname
, FILNMLEN
);
615 if (type
== T_NULL
) {
617 PUT_SCN_SCNLEN(abfd
, in
->x_scn
.x_scnlen
, ext
);
618 PUT_SCN_NRELOC(abfd
, in
->x_scn
.x_nreloc
, ext
);
619 PUT_SCN_NLINNO(abfd
, in
->x_scn
.x_nlinno
, ext
);
623 PUTWORD(abfd
, in
->x_sym
.x_tagndx
.l
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
625 PUTWORD(abfd
, in
->x_sym
.x_tvndx
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
629 PUTWORD(abfd
, in
->x_sym
.x_misc
.x_fsize
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
630 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
631 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
635 if (ISARY(type
) || class == C_BLOCK
) {
636 #if DIMNUM != E_DIMNUM
637 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
639 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]);
640 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]);
641 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]);
642 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]);
645 PUT_LNSZ_LNNO(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
646 PUT_LNSZ_SIZE(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
648 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
649 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
654 return sizeof(AUXENT
);
657 #endif /* NO_COFF_SYMBOLS */
659 #ifndef NO_COFF_LINENOS
662 DEFUN(coff_swap_lineno_in
,(abfd
, ext1
, in1
),
667 LINENO
*ext
= (LINENO
*)ext1
;
668 struct internal_lineno
*in
= (struct internal_lineno
*)in1
;
670 in
->l_addr
.l_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->l_addr
.l_symndx
);
672 in
->l_lnno
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->l_lnno
);
674 in
->l_lnno
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->l_lnno
);
679 DEFUN(coff_swap_lineno_out
,(abfd
, inp
, outp
),
684 struct internal_lineno
*in
= (struct internal_lineno
*)inp
;
685 struct external_lineno
*ext
= (struct external_lineno
*)outp
;
686 PUTWORD(abfd
, in
->l_addr
.l_symndx
, (bfd_byte
*) ext
->l_addr
.l_symndx
);
688 PUTWORD(abfd
, in
->l_lnno
, (bfd_byte
*) ext
->l_lnno
);
690 PUTHALF(abfd
, in
->l_lnno
, (bfd_byte
*) ext
->l_lnno
);
692 return sizeof(struct external_lineno
);
695 #endif /* NO_COFF_LINENOS */
699 DEFUN(bfd_swap_aouthdr_in
,(abfd
, aouthdr_ext1
, aouthdr_int1
),
704 AOUTHDR
*aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
705 struct internal_aouthdr
*aouthdr_int
= (struct internal_aouthdr
*)aouthdr_int1
;
707 aouthdr_int
->magic
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->magic
);
708 aouthdr_int
->vstamp
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->vstamp
);
709 aouthdr_int
->tsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tsize
);
710 aouthdr_int
->dsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->dsize
);
711 aouthdr_int
->bsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->bsize
);
712 aouthdr_int
->entry
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->entry
);
713 aouthdr_int
->text_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->text_start
);
714 aouthdr_int
->data_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->data_start
);
716 aouthdr_int
->tagentries
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tagentries
);
721 DEFUN(coff_swap_aouthdr_out
,(abfd
, in
, out
),
726 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*)in
;
727 AOUTHDR
*aouthdr_out
= (AOUTHDR
*)out
;
728 bfd_h_put_16(abfd
, aouthdr_in
->magic
, (bfd_byte
*) aouthdr_out
->magic
);
729 bfd_h_put_16(abfd
, aouthdr_in
->vstamp
, (bfd_byte
*) aouthdr_out
->vstamp
);
730 bfd_h_put_32(abfd
, aouthdr_in
->tsize
, (bfd_byte
*) aouthdr_out
->tsize
);
731 bfd_h_put_32(abfd
, aouthdr_in
->dsize
, (bfd_byte
*) aouthdr_out
->dsize
);
732 bfd_h_put_32(abfd
, aouthdr_in
->bsize
, (bfd_byte
*) aouthdr_out
->bsize
);
733 bfd_h_put_32(abfd
, aouthdr_in
->entry
, (bfd_byte
*) aouthdr_out
->entry
);
734 bfd_h_put_32(abfd
, aouthdr_in
->text_start
,
735 (bfd_byte
*) aouthdr_out
->text_start
);
736 bfd_h_put_32(abfd
, aouthdr_in
->data_start
, (bfd_byte
*) aouthdr_out
->data_start
);
738 bfd_h_put_32(abfd
, aouthdr_in
->tagentries
, (bfd_byte
*) aouthdr_out
->tagentries
);
740 return sizeof(AOUTHDR
);
744 DEFUN(coff_swap_scnhdr_in
,(abfd
, scnhdr_ext
, scnhdr_int
),
746 SCNHDR
*scnhdr_ext AND
747 struct internal_scnhdr
*scnhdr_int
)
749 memcpy(scnhdr_int
->s_name
, scnhdr_ext
->s_name
, sizeof(scnhdr_int
->s_name
));
750 scnhdr_int
->s_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
751 scnhdr_int
->s_paddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
752 scnhdr_int
->s_size
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_size
);
753 scnhdr_int
->s_scnptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
754 scnhdr_int
->s_relptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
755 scnhdr_int
->s_lnnoptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
756 scnhdr_int
->s_flags
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_flags
);
758 scnhdr_int
->s_nreloc
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
759 scnhdr_int
->s_nlnno
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
761 scnhdr_int
->s_nreloc
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
762 scnhdr_int
->s_nlnno
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
765 scnhdr_int
->s_align
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_align
);
770 DEFUN(coff_swap_scnhdr_out
,(abfd
, in
, out
),
775 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*)in
;
776 SCNHDR
*scnhdr_ext
= (SCNHDR
*)out
;
777 memcpy(scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof(scnhdr_int
->s_name
));
778 PUTWORD(abfd
, scnhdr_int
->s_vaddr
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
779 PUTWORD(abfd
, scnhdr_int
->s_paddr
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
780 PUTWORD(abfd
, scnhdr_int
->s_size
, (bfd_byte
*) scnhdr_ext
->s_size
);
781 PUTWORD(abfd
, scnhdr_int
->s_scnptr
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
782 PUTWORD(abfd
, scnhdr_int
->s_relptr
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
783 PUTWORD(abfd
, scnhdr_int
->s_lnnoptr
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
784 PUTWORD(abfd
, scnhdr_int
->s_flags
, (bfd_byte
*) scnhdr_ext
->s_flags
);
786 PUTWORD(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
787 PUTWORD(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
789 PUTHALF(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
790 PUTHALF(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
794 PUTWORD(abfd
, scnhdr_int
->s_align
, (bfd_byte
*) scnhdr_ext
->s_align
);
796 return sizeof(SCNHDR
);
801 initialize a section structure with information peculiar to this
802 particular implementation of coff
806 DEFUN(coff_new_section_hook
,(abfd_ignore
, section_ignore
),
808 asection
*section_ignore
)
810 section_ignore
->alignment_power
= abfd_ignore
->xvec
->align_power_min
;
814 /* Take a section header read from a coff file (in HOST byte order),
815 and make a BFD "section" out of it. */
817 DEFUN(make_a_section_from_file
,(abfd
, hdr
),
819 struct internal_scnhdr
*hdr
)
821 asection
*return_section
;
824 /* Assorted wastage to null-terminate the name, thanks AT&T! */
825 char *name
= bfd_alloc(abfd
, sizeof (hdr
->s_name
)+1);
827 bfd_error
= no_memory
;
830 strncpy(name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
831 name
[sizeof (hdr
->s_name
)] = 0;
833 return_section
= bfd_make_section(abfd
, name
);
836 /* s_paddr is presumed to be = to s_vaddr */
837 #define assign(to, from) return_section->to = hdr->from
838 assign(vma
, s_vaddr
);
839 /* assign (vma, s_vaddr); */
840 assign(size
, s_size
);
841 assign(filepos
, s_scnptr
);
842 assign(rel_filepos
, s_relptr
);
843 assign(reloc_count
, s_nreloc
);
846 /* FIXME, use a temp var rather than alignment_power */
847 assign(alignment_power
, s_align
);
850 for (i
= 0; i
< 32; i
++) {
851 if ((1 << i
) >= (int) (return_section
->alignment_power
)) {
852 return_section
->alignment_power
= i
;
859 assign(line_filepos
, s_lnnoptr
);
861 return_section->linesize = hdr->s_nlnno * sizeof (struct lineno);
864 return_section
->lineno_count
= hdr
->s_nlnno
;
865 return_section
->userdata
= NULL
;
866 return_section
->next
= (asection
*) NULL
;
867 return_section
->flags
= styp_to_sec_flags(hdr
->s_flags
);
870 if (hdr
->s_nreloc
!= 0)
871 return_section
->flags
|= SEC_RELOC
;
872 /* FIXME: should this check 'hdr->s_size > 0' */
873 if (hdr
->s_scnptr
!= 0)
874 return_section
->flags
|= SEC_HAS_CONTENTS
;
878 DEFUN(coff_mkobject
,(abfd
),
881 set_tdata (abfd
, bfd_zalloc (abfd
,sizeof(coff_data_type
)));
882 if (coff_data(abfd
) == 0) {
883 bfd_error
= no_memory
;
886 coff_data(abfd
)->relocbase
= 0;
892 DEFUN(coff_real_object_p
,(abfd
, nscns
, internal_f
, internal_a
),
895 struct internal_filehdr
*internal_f AND
896 struct internal_aouthdr
*internal_a
)
898 coff_data_type
*coff
;
899 enum bfd_architecture arch
;
901 size_t readsize
; /* length of file_info */
902 SCNHDR
*external_sections
;
904 /* Build a play area */
905 if (coff_mkobject(abfd
) != true)
907 coff
= coff_data(abfd
);
910 external_sections
= (SCNHDR
*)bfd_alloc(abfd
, readsize
= (nscns
* SCNHSZ
));
912 if (bfd_read((PTR
)external_sections
, 1, readsize
, abfd
) != readsize
) {
917 /* Now copy data as required; construct all asections etc */
918 coff
->symbol_index_slew
= 0;
920 coff
->raw_syment_count
= 0;
921 coff
->raw_linenos
= 0;
922 coff
->raw_syments
= 0;
923 coff
->sym_filepos
=0;
924 coff
->flags
= internal_f
->f_flags
;
927 for (i
= 0; i
< nscns
; i
++) {
928 struct internal_scnhdr tmp
;
929 coff_swap_scnhdr_in(abfd
, external_sections
+ i
, &tmp
);
930 make_a_section_from_file(abfd
,&tmp
);
933 /* Determine the machine architecture and type. */
935 switch (internal_f
->f_magic
) {
938 arch
= bfd_arch_i386
;
943 #ifdef A29K_MAGIC_BIG
945 case A29K_MAGIC_LITTLE
:
946 arch
= bfd_arch_a29k
;
955 arch
= bfd_arch_mips
;
963 arch
= bfd_arch_m68k
;
971 arch
= bfd_arch_m88k
;
979 arch
= bfd_arch_i960
;
980 switch (F_I960TYPE
& internal_f
->f_flags
)
984 machine
= bfd_mach_i960_core
;
987 machine
= bfd_mach_i960_kb_sb
;
990 machine
= bfd_mach_i960_mc
;
993 machine
= bfd_mach_i960_xa
;
996 machine
= bfd_mach_i960_ca
;
999 machine
= bfd_mach_i960_ka_sa
;
1007 default: /* Unreadable input file type */
1008 arch
= bfd_arch_obscure
;
1012 bfd_default_set_arch_mach(abfd
, arch
, machine
);
1013 if (!(internal_f
->f_flags
& F_RELFLG
))
1014 abfd
->flags
|= HAS_RELOC
;
1015 if ((internal_f
->f_flags
& F_EXEC
))
1016 abfd
->flags
|= EXEC_P
;
1017 if (!(internal_f
->f_flags
& F_LNNO
))
1018 abfd
->flags
|= HAS_LINENO
;
1019 if (!(internal_f
->f_flags
& F_LSYMS
))
1020 abfd
->flags
|= HAS_LOCALS
;
1023 bfd_get_symcount(abfd
) = internal_f
->f_nsyms
;
1024 if (internal_f
->f_nsyms
)
1025 abfd
->flags
|= HAS_SYMS
;
1027 coff
->sym_filepos
= internal_f
->f_symptr
;
1029 /* These members communicate important constants about the symbol table
1030 to GDB's symbol-reading code. These `constants' unfortunately vary
1031 from coff implementation to implementation... */
1032 #ifndef NO_COFF_SYMBOLS
1033 coff
->local_n_btmask
= N_BTMASK
;
1034 coff
->local_n_btshft
= N_BTSHFT
;
1035 coff
->local_n_tmask
= N_TMASK
;
1036 coff
->local_n_tshift
= N_TSHIFT
;
1037 coff
->local_symesz
= SYMESZ
;
1038 coff
->local_auxesz
= AUXESZ
;
1039 coff
->local_linesz
= LINESZ
;
1042 coff
->symbols
= (coff_symbol_type
*) NULL
;
1043 bfd_get_start_address(abfd
) = internal_f
->f_opthdr
? internal_a
->entry
: 0;
1047 bfd_release(abfd
, coff
);
1048 return (bfd_target
*)NULL
;
1052 DEFUN(coff_object_p
,(abfd
),
1058 struct internal_filehdr internal_f
;
1059 struct internal_aouthdr internal_a
;
1061 bfd_error
= system_call_error
;
1063 /* figure out how much to read */
1064 if (bfd_read((PTR
) &filehdr
, 1, FILHSZ
, abfd
) != FILHSZ
)
1067 bfd_swap_filehdr_in(abfd
, &filehdr
, &internal_f
);
1069 if (BADMAG(internal_f
)) {
1070 bfd_error
= wrong_format
;
1073 nscns
=internal_f
.f_nscns
;
1075 if (internal_f
.f_opthdr
) {
1076 if (bfd_read((PTR
) &opthdr
, 1,AOUTSZ
, abfd
) != AOUTSZ
) {
1079 bfd_swap_aouthdr_in(abfd
, (char *)&opthdr
, (char *)&internal_a
);
1082 /* Seek past the opt hdr stuff */
1083 bfd_seek(abfd
, internal_f
.f_opthdr
+ FILHSZ
, SEEK_SET
);
1085 /* if the optional header is NULL or not the correct size then
1086 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1087 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1088 optional header is of a different size.
1090 But the mips keeps extra stuff in it's opthdr, so dont check
1094 #if defined(M88) || defined(I960)
1095 if (internal_f
.f_opthdr
!= 0 && AOUTSZ
!= internal_f
.f_opthdr
)
1096 return (bfd_target
*)NULL
;
1099 return coff_real_object_p(abfd
, nscns
, &internal_f
, &internal_a
);
1104 #ifndef NO_COFF_LINENOS
1107 DEFUN(coff_count_linenumbers
,(abfd
),
1110 unsigned int limit
= bfd_get_symcount(abfd
);
1114 asection
*s
= abfd
->sections
->output_section
;
1116 BFD_ASSERT(s
->lineno_count
== 0);
1122 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++) {
1123 asymbol
*q_maybe
= *p
;
1124 if (q_maybe
->the_bfd
->xvec
->flavour
== bfd_target_coff_flavour
) {
1125 coff_symbol_type
*q
= coffsymbol(q_maybe
);
1128 This symbol has a linenumber, increment the owning
1129 section's linenumber count
1131 alent
*l
= q
->lineno
;
1132 q
->symbol
.section
->output_section
->lineno_count
++;
1134 while (l
->line_number
) {
1135 q
->symbol
.section
->output_section
->lineno_count
++;
1143 #endif /* NO_COFF_LINENOS */
1145 #ifndef NO_COFF_SYMBOLS
1148 Takes a bfd and a symbol, returns a pointer to the coff specific area
1149 of the symbol if there is one.
1151 static coff_symbol_type
*
1152 DEFUN(coff_symbol_from
,(ignore_abfd
, symbol
),
1153 bfd
*ignore_abfd AND
1156 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
1157 return (coff_symbol_type
*)NULL
;
1159 if (symbol
->the_bfd
->tdata
== (PTR
)NULL
)
1160 return (coff_symbol_type
*)NULL
;
1162 return (coff_symbol_type
*) symbol
;
1168 DEFUN(fixup_symbol_value
,(coff_symbol_ptr
, syment
),
1169 coff_symbol_type
*coff_symbol_ptr AND
1170 struct internal_syment
*syment
)
1173 /* Normalize the symbol flags */
1174 if (coff_symbol_ptr
->symbol
.flags
& BSF_FORT_COMM
) {
1175 /* a common symbol is undefined with a value */
1176 syment
->n_scnum
= N_UNDEF
;
1177 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1179 else if (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) {
1180 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1182 else if (coff_symbol_ptr
->symbol
.flags
& BSF_UNDEFINED
) {
1183 syment
->n_scnum
= N_UNDEF
;
1184 syment
->n_value
= 0;
1186 else if (coff_symbol_ptr
->symbol
.flags
& BSF_ABSOLUTE
) {
1187 syment
->n_scnum
= N_ABS
;
1188 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1192 coff_symbol_ptr
->symbol
.section
->output_section
->index
+1;
1195 coff_symbol_ptr
->symbol
.value
+
1196 coff_symbol_ptr
->symbol
.section
->output_offset
+
1197 coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
1201 /* run through all the symbols in the symbol table and work out what
1202 their indexes into the symbol table will be when output
1204 Coff requires that each C_FILE symbol points to the next one in the
1205 chain, and that the last one points to the first external symbol. We
1210 DEFUN(coff_renumber_symbols
,(bfd_ptr
),
1213 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1214 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1215 unsigned int native_index
= 0;
1216 struct internal_syment
*last_file
= (struct internal_syment
*)NULL
;
1217 unsigned int symbol_index
;
1218 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1220 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1221 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1222 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1225 if (s
->u
.syment
.n_sclass
== C_FILE
)
1227 if (last_file
!= (struct internal_syment
*)NULL
) {
1228 last_file
->n_value
= native_index
;
1230 last_file
= &(s
->u
.syment
);
1234 /* Modify the symbol values according to their section and
1237 fixup_symbol_value(coff_symbol_ptr
, &(s
->u
.syment
));
1239 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++) {
1240 s
[i
].offset
= native_index
++;
1251 Run thorough the symbol table again, and fix it so that all pointers to
1252 entries are changed to the entries' index in the output symbol table.
1256 DEFUN(coff_mangle_symbols
,(bfd_ptr
),
1259 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1260 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1262 unsigned int symbol_index
;
1265 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1267 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1268 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1270 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1276 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++) {
1277 combined_entry_type
*a
= s
+ i
+ 1;
1279 a
->u
.auxent
.x_sym
.x_tagndx
.l
= a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
1282 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
1283 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
1292 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1293 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1294 struct internal_syment
*last_tagndx
= (struct internal_syment
*)NULL
;
1295 struct internal_syment
*last_file
= (struct internal_syment
*)NULL
;
1296 struct internal_syment
*last_fcn
= (struct internal_syment
*)NULL
;
1297 struct internal_syment
*block_stack
[50];
1298 struct internal_syment
**last_block
= &block_stack
[0];
1299 boolean first_time
= true;
1300 unsigned int symbol_index
;
1301 unsigned int native_index
= 0;
1303 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++) {
1304 coff_symbol_type
*coff_symbol_ptr
=
1305 coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1306 if (coff_symbol_ptr
== (coff_symbol_type
*)NULL
) {
1308 This symbol has no coff information in it, it will take up
1309 only one slot in the output symbol table
1314 struct internal_syment
*syment
= coff_symbol_ptr
->native
;
1315 if (syment
== (struct internal_syment
*)NULL
) {
1319 /* Normalize the symbol flags */
1320 if (coff_symbol_ptr
->symbol
.flags
& BSF_FORT_COMM
) {
1321 /* a common symbol is undefined with a value */
1322 syment
->n_scnum
= N_UNDEF
;
1323 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1325 else if (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) {
1326 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1328 else if (coff_symbol_ptr
->symbol
.flags
& BSF_UNDEFINED
) {
1329 syment
->n_scnum
= N_UNDEF
;
1330 syment
->n_value
= 0;
1332 else if (coff_symbol_ptr
->symbol
.flags
& BSF_ABSOLUTE
) {
1333 syment
->n_scnum
= N_ABS
;
1334 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1338 coff_symbol_ptr
->symbol
.section
->output_section
->index
+1;
1341 coff_symbol_ptr
->symbol
.value
+
1342 coff_symbol_ptr
->symbol
.section
->output_offset
+
1343 coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
1347 /* If this symbol ties up something then do it */
1349 if (syment
->n_sclass
== C_FILE
&& last_file
!= (struct internal_syment
*)NULL
)
1351 last_file
->n_value
= native_index
;
1353 else if ((syment
->n_sclass
== C_EXT
1354 || syment
->n_sclass
== C_STAT
1356 || syment
->n_sclass
== C_LEAFEXT
1357 || syment
->n_sclass
== C_LEAFSTAT
1360 && last_fcn
!= (struct internal_syment
*)NULL
)
1362 union internal_auxent
*auxent
= (union internal_auxent
*)(last_fcn
+1);
1363 auxent
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= native_index
;
1364 last_fcn
= (struct internal_syment
*)NULL
;
1367 else if (syment
->n_sclass
== C_EOS
&& last_tagndx
!= (struct internal_syment
*)NULL
)
1369 union internal_auxent
*auxent
= (union internal_auxent
*)(last_tagndx
+1);
1370 /* Remember that we keep the native index in the offset
1371 so patch the beginning of the struct to point to this
1374 auxent->x_sym.x_tagndx = last_tagndx->_n._n_n._n_offset;*/
1375 auxent
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= syment
->n_numaux
+ 1 + native_index
;
1376 /* Now point the eos to the structure */
1377 auxent
= (union internal_auxent
*)(syment
+1);
1378 auxent
->x_sym
.x_tagndx
.l
= last_tagndx
->_n
._n_n
._n_offset
;
1380 else if (syment
->n_sclass
== C_BLOCK
1381 && coff_symbol_ptr
->symbol
.name
[1] == 'e')
1383 union internal_auxent
*auxent
= (union internal_auxent
*)((*(--last_block
))+1);
1384 auxent
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= native_index
+ syment
->n_numaux
+ 1;
1386 if (syment
->n_sclass
== C_EXT
1387 && !ISFCN(syment
->n_type
)
1388 && first_time
== true
1389 && last_file
!= (struct internal_syment
*)NULL
) {
1390 /* This is the first external symbol seen which isn't a
1391 function place it in the last .file entry */
1392 last_file
->n_value
= native_index
;
1396 if (syment
->n_sclass
== C_LEAFPROC
&&
1397 syment
->n_numaux
== 2) {
1398 union internal_auxent
*auxent
= (union internal_auxent
*)(syment
+2);
1399 /* This is the definition of a leaf proc, we'll relocate the
1401 auxent
->x_bal
.x_balntry
=
1402 coff_symbol_ptr
->symbol
.section
->output_offset
+
1403 coff_symbol_ptr
->symbol
.section
->output_section
->vma
+
1404 auxent
->x_bal
.x_balntry
;
1407 /* If this symbol needs to be tied up then remember some facts */
1408 if (syment
->n_sclass
== C_FILE
)
1412 if (syment
->n_numaux
!= 0) {
1414 If this symbol would like to point to something in the
1415 future then remember where it is
1417 if (uses_x_sym_x_tagndx_p(bfd_ptr
, syment
)) {
1419 If this is a ref to a structure then we'll tie it up
1420 now - there are never any forward refs for one
1422 if (syment
->n_sclass
== C_STRTAG
||
1423 syment
->n_sclass
== C_ENTAG
||
1424 syment
->n_sclass
== C_UNTAG
) {
1425 last_tagndx
= syment
;
1429 This is a ref to a structure - the structure must
1430 have been defined within the same file, and previous
1431 to this point, so we can deduce the new tagndx
1434 union internal_auxent
*auxent
= (union internal_auxent
*)(syment
+1);
1435 bfd
*bfd_ptr
= coff_symbol_ptr
->symbol
.the_bfd
;
1436 struct internal_syment
*base
= obj_raw_syments(bfd_ptr
);
1437 /* auxent->x_sym.x_tagndx = base[auxent->x_sym.x_tagndx]._n._n_n._n_offset;*/
1442 if (ISFCN(syment
->n_type
)) {
1445 if (syment
->n_sclass
== C_BLOCK
1446 && coff_symbol_ptr
->symbol
.name
[1] == 'b')
1448 *last_block
++ = syment
;
1451 syment
->_n
._n_n
._n_offset
= native_index
;
1452 native_index
= native_index
+ 1 + syment
->n_numaux
;
1460 static int string_size
;
1462 DEFUN(coff_fix_symbol_name
,(ignore_abfd
, symbol
, native
),
1463 bfd
*ignore_abfd AND
1465 combined_entry_type
*native
)
1467 unsigned int name_length
;
1468 union internal_auxent
*auxent
;
1469 char * name
= ( char *)(symbol
->name
);
1471 if (name
== (char *) NULL
) {
1472 /* coff symbols always have names, so we'll make one up */
1473 symbol
->name
= "strange";
1474 name
= (char *)symbol
->name
;
1476 name_length
= strlen(name
);
1478 if (native
->u
.syment
.n_sclass
== C_FILE
) {
1479 strncpy(native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
1480 auxent
= &(native
+1)->u
.auxent
;
1482 #ifdef COFF_LONG_FILENAMES
1483 if (name_length
<= FILNMLEN
) {
1484 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1487 auxent
->x_file
.x_n
.x_offset
= string_size
+ 4;
1488 auxent
->x_file
.x_n
.x_zeroes
= 0;
1489 string_size
+= name_length
+ 1;
1492 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1493 if (name_length
> FILNMLEN
) {
1494 name
[FILNMLEN
] = '\0';
1499 { /* NOT A C_FILE SYMBOL */
1500 if (name_length
<= SYMNMLEN
) {
1501 /* This name will fit into the symbol neatly */
1502 strncpy(native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
1505 native
->u
.syment
._n
._n_n
._n_offset
= string_size
+ 4;
1506 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1507 string_size
+= name_length
+ 1;
1515 DEFUN(coff_write_symbol
,(abfd
, symbol
, native
, written
),
1518 combined_entry_type
*native AND
1519 unsigned int written
)
1521 unsigned int numaux
= native
->u
.syment
.n_numaux
;
1522 int type
= native
->u
.syment
.n_type
;
1523 int class = native
->u
.syment
.n_sclass
;
1527 coff_fix_symbol_name(abfd
, symbol
, native
);
1528 coff_swap_sym_out(abfd
, &native
->u
.syment
, &buf
);
1529 bfd_write((PTR
)& buf
, 1, SYMESZ
, abfd
);
1530 for (j
= 0; j
!= native
->u
.syment
.n_numaux
; j
++)
1533 coff_swap_aux_out(abfd
,
1534 &( (native
+ j
+ 1)->u
.auxent
), type
, class, &buf1
);
1535 bfd_write((PTR
) (&buf1
), 1, AUXESZ
, abfd
);
1538 Reuse somewhere in the symbol to keep the index
1540 set_index(symbol
, written
);
1541 return written
+ 1 + numaux
;
1546 DEFUN(coff_write_alien_symbol
,(abfd
, symbol
, written
),
1549 unsigned int written
)
1552 This symbol has been created by the loader, or come from a non
1553 coff format. It has no native element to inherit, make our
1556 combined_entry_type
*native
;
1557 combined_entry_type dummy
;
1559 native
->u
.syment
.n_type
= T_NULL
;
1561 native
->u
.syment
.n_flags
= 0;
1563 if (symbol
->flags
& BSF_ABSOLUTE
) {
1564 native
->u
.syment
.n_scnum
= N_ABS
;
1565 native
->u
.syment
.n_value
= symbol
->value
;
1567 else if (symbol
->flags
& (BSF_UNDEFINED
| BSF_FORT_COMM
)) {
1568 native
->u
.syment
.n_scnum
= N_UNDEF
;
1569 native
->u
.syment
.n_value
= symbol
->value
;
1571 else if (symbol
->flags
& BSF_DEBUGGING
) {
1573 remove name so it doesn't take up any space
1578 native
->u
.syment
.n_scnum
= symbol
->section
->output_section
->index
+
1580 native
->u
.syment
.n_value
= symbol
->value
+
1581 symbol
->section
->output_section
->vma
+
1582 symbol
->section
->output_offset
;
1584 /* Copy the any flags from the the file hdr into the symbol */
1586 coff_symbol_type
*c
= coff_symbol_from(abfd
, symbol
);
1587 if (c
!= (coff_symbol_type
*)NULL
) {
1588 native
->u
.syment
.n_flags
= c
->symbol
.the_bfd
->flags
;
1595 native
->u
.syment
.pad1
[0] = 0;
1596 native
->u
.syment
.pad1
[0] = 0;
1599 native
->u
.syment
.n_type
= 0;
1600 if (symbol
->flags
& BSF_LOCAL
)
1601 native
->u
.syment
.n_sclass
= C_STAT
;
1603 native
->u
.syment
.n_sclass
= C_EXT
;
1604 native
->u
.syment
.n_numaux
= 0;
1606 return coff_write_symbol(abfd
, symbol
, native
, written
);
1610 DEFUN(coff_write_native_symbol
,(abfd
, symbol
, written
),
1612 coff_symbol_type
*symbol AND
1613 unsigned int written
)
1616 Does this symbol have an ascociated line number - if so then
1617 make it remember this symbol index. Also tag the auxent of
1618 this symbol to point to the right place in the lineno table
1620 combined_entry_type
*native
= symbol
->native
;
1622 alent
*lineno
= symbol
->lineno
;
1625 unsigned int count
= 0;
1626 lineno
[count
].u
.offset
= written
;
1627 if (native
->u
.syment
.n_numaux
) {
1628 union internal_auxent
*a
= &((native
+1)->u
.auxent
);
1630 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1631 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1634 And count and relocate all other linenumbers
1637 while (lineno
[count
].line_number
) {
1638 lineno
[count
].u
.offset
+=
1639 symbol
->symbol
.section
->output_section
->vma
+
1640 symbol
->symbol
.section
->output_offset
;
1643 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1647 return coff_write_symbol(abfd
, &( symbol
->symbol
), native
,written
);
1651 DEFUN(coff_write_symbols
,(abfd
),
1655 unsigned int limit
= bfd_get_symcount(abfd
);
1656 unsigned int written
= 0;
1663 /* Seek to the right place */
1664 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
1666 /* Output all the symbols we have */
1669 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1671 asymbol
*symbol
= *p
;
1672 coff_symbol_type
*c_symbol
= coff_symbol_from(abfd
, symbol
);
1676 if (c_symbol
== (coff_symbol_type
*) NULL
||
1677 c_symbol
->native
== (combined_entry_type
*)NULL
)
1679 written
= coff_write_alien_symbol(abfd
, symbol
, written
);
1683 written
= coff_write_native_symbol(abfd
, c_symbol
, written
);
1688 bfd_get_symcount(abfd
) = written
;
1690 /* Now write out strings */
1692 if (string_size
!= 0)
1694 unsigned int size
= string_size
+ 4;
1697 bfd_h_put_32(abfd
, size
, buffer
);
1698 bfd_write((PTR
) buffer
, 1, sizeof(buffer
), abfd
);
1699 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1702 size_t name_length
= strlen(q
->name
);
1704 coff_symbol_type
* c_symbol
= coff_symbol_from(abfd
, q
);
1705 maxlen
= ((c_symbol
!= NULL
&& c_symbol
->native
!= NULL
) &&
1706 (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
)) ?
1707 FILNMLEN
: SYMNMLEN
;
1709 if (name_length
> maxlen
) {
1710 bfd_write((PTR
) (q
->name
), 1, name_length
+ 1, abfd
);
1715 /* We would normally not write anything here, but we'll write
1716 out 4 so that any stupid coff reader which tries to read
1717 the string table even when there isn't one won't croak.
1720 uint32e_type size
= 4;
1722 bfd_write((PTR
)&size
, 1, sizeof(size
), abfd
);
1728 @subsubsection Writing Relocations
1729 To write a relocations, all the back end does is step though the
1730 canonical relocation table, and create an @code{internal_reloc}. The
1731 symbol index to use is removed from the @code{offset} field in the
1732 symbol table supplied, the address comes directly from the sum of the
1733 section base address and the relocation offset and the type is dug
1734 directly from the howto field.
1736 Then the @code{internal_reloc} is swapped into the shape of an
1737 @code{external_reloc} and written out to disk.
1741 DEFUN(coff_write_relocs
,(abfd
),
1745 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1747 struct external_reloc dst
;
1749 arelent
**p
= s
->orelocation
;
1750 bfd_seek(abfd
, s
->rel_filepos
, SEEK_SET
);
1751 for (i
= 0; i
< s
->reloc_count
; i
++) {
1752 struct internal_reloc n
;
1754 memset((PTR
)&n
, 0, sizeof(n
));
1755 n
.r_vaddr
= q
->address
+ s
->vma
;
1756 if (q
->sym_ptr_ptr
) {
1757 n
.r_symndx
= get_index((*(q
->sym_ptr_ptr
)));
1760 /* Work out reloc type from what is required */
1761 SELECT_RELOC(n
.r_type
, q
->howto
);
1763 n
.r_type
= q
->howto
->type
;
1765 coff_swap_reloc_out(abfd
, &n
, &dst
);
1766 bfd_write((PTR
) &n
, 1, RELSZ
, abfd
);
1770 #endif /* NO_COFF_SYMBOLS */
1772 #ifndef NO_COFF_LINENOS
1775 DEFUN(coff_write_linenumbers
,(abfd
),
1779 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1780 if (s
->lineno_count
) {
1781 asymbol
**q
= abfd
->outsymbols
;
1782 bfd_seek(abfd
, s
->line_filepos
, SEEK_SET
);
1783 /* Find all the linenumbers in this section */
1786 alent
*l
= BFD_SEND(p
->the_bfd
, _get_lineno
, (p
->the_bfd
, p
));
1788 /* Found a linenumber entry, output */
1789 struct internal_lineno out
;
1791 memset( (PTR
)&out
, 0, sizeof(out
));
1793 out
.l_addr
.l_symndx
= l
->u
.offset
;
1794 coff_swap_lineno_out(abfd
, &out
, &buff
);
1795 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1797 while (l
->line_number
) {
1798 out
.l_lnno
= l
->line_number
;
1799 out
.l_addr
.l_symndx
= l
->u
.offset
;
1800 coff_swap_lineno_out(abfd
, &out
, &buff
);
1801 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1812 DEFUN(coff_get_lineno
,(ignore_abfd
, symbol
),
1813 bfd
*ignore_abfd AND
1816 return coffsymbol(symbol
)->lineno
;
1819 #endif /* NO_COFF_LINENOS */
1822 coff_make_empty_symbol(abfd
)
1825 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc(abfd
, sizeof(coff_symbol_type
));
1827 bfd_error
= no_memory
;
1831 new->lineno
= (alent
*) NULL
;
1832 new->symbol
.the_bfd
= abfd
;
1833 return &new->symbol
;
1836 #ifndef NO_COFF_SYMBOLS
1839 DEFUN(coff_print_symbol
,(ignore_abfd
, filep
, symbol
, how
),
1840 bfd
*ignore_abfd AND
1843 bfd_print_symbol_type how
)
1845 FILE *file
= (FILE *)filep
;
1847 case bfd_print_symbol_name
:
1848 fprintf(file
, "%s", symbol
->name
);
1850 case bfd_print_symbol_more
:
1851 fprintf(file
, "coff %lx %lx", (unsigned long) coffsymbol(symbol
)->native
,
1852 (unsigned long) coffsymbol(symbol
)->lineno
);
1854 case bfd_print_symbol_all
:
1856 CONST
char *section_name
= symbol
->section
== (asection
*) NULL
?
1857 "*abs" : symbol
->section
->name
;
1858 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 #ifdef A29K_MAGIC_BIG
1949 if (abfd
->xvec
->byteorder_big_p
)
1950 *magicp
= A29K_MAGIC_BIG
;
1952 *magicp
= A29K_MAGIC_LITTLE
;
1957 default: /* Unknown architecture */
1958 /* return false; -- fall through to "return false" below, to avoid
1959 "statement never reached" errors on the one below. */
1968 DEFUN(coff_set_arch_mach
,(abfd
, arch
, machine
),
1970 enum bfd_architecture arch AND
1971 unsigned long machine
)
1974 unsigned short dummy2
;
1975 bfd_default_set_arch_mach(abfd
, arch
, machine
);
1977 if (arch
!= bfd_arch_unknown
&&
1978 coff_set_flags(abfd
, &dummy1
, &dummy2
) != true)
1979 return false; /* We can't represent this type */
1980 return true; /* We're easy ... */
1984 /* Calculate the file position for each section. */
1987 DEFUN(coff_compute_section_file_positions
,(abfd
),
1991 file_ptr sofar
= FILHSZ
;
1992 if (bfd_get_start_address(abfd
)) {
1994 A start address may have been added to the original file. In this
1995 case it will need an optional header to record it.
1997 abfd
->flags
|= EXEC_P
;
1999 if (abfd
->flags
& EXEC_P
)
2003 sofar
+= abfd
->section_count
* SCNHSZ
;
2004 for (current
= abfd
->sections
;
2005 current
!= (asection
*)NULL
;
2006 current
= current
->next
) {
2007 /* Only deal with sections which have contents */
2008 if (!(current
->flags
& SEC_HAS_CONTENTS
))
2011 /* Align the sections in the file to the same boundary on
2012 which they are aligned in virtual memory. I960 doesn't
2013 do this (FIXME) so we can stay in sync with Intel. 960
2014 doesn't yet page from files... */
2016 sofar
= ALIGN(sofar
, 1 << current
->alignment_power
);
2018 /* FIXME, in demand paged files, the low order bits of the file
2019 offset must match the low order bits of the virtual address.
2020 "Low order" is apparently implementation defined. Add code
2021 here to round sofar up to match the virtual address. */
2023 current
->filepos
= sofar
;
2024 sofar
+= current
->size
;
2026 obj_relocbase(abfd
) = sofar
;
2035 DEFUN(coff_write_object_contents
,(abfd
),
2039 boolean hasrelocs
= false;
2040 boolean haslinno
= false;
2041 file_ptr reloc_base
;
2042 file_ptr lineno_base
;
2046 unsigned long reloc_size
= 0;
2047 unsigned long lnno_size
= 0;
2048 asection
*text_sec
= NULL
;
2049 asection
*data_sec
= NULL
;
2050 asection
*bss_sec
= NULL
;
2052 struct internal_filehdr internal_f
;
2053 struct internal_aouthdr internal_a
;
2056 bfd_error
= system_call_error
;
2059 if(abfd
->output_has_begun
== false) {
2060 coff_compute_section_file_positions(abfd
);
2063 if (abfd
->sections
!= (asection
*)NULL
) {
2064 scn_base
= abfd
->sections
->filepos
;
2069 if (bfd_seek(abfd
, scn_base
, SEEK_SET
) != 0)
2071 reloc_base
= obj_relocbase(abfd
);
2073 /* Make a pass through the symbol table to count line number entries and
2074 put them into the correct asections */
2076 #ifndef NO_COFF_LINENOS
2077 coff_count_linenumbers(abfd
);
2079 data_base
= scn_base
;
2081 /* Work out the size of the reloc and linno areas */
2083 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
) {
2084 reloc_size
+= current
->reloc_count
* RELSZ
;
2085 #ifndef NO_COFF_LINENOS
2086 lnno_size
+= current
->lineno_count
* LINESZ
;
2088 data_base
+= SCNHSZ
;
2091 lineno_base
= reloc_base
+ reloc_size
;
2092 sym_base
= lineno_base
+ lnno_size
;
2094 /* Indicate in each section->line_filepos its actual file address */
2095 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
) {
2096 if (current
->lineno_count
) {
2097 current
->line_filepos
= lineno_base
;
2098 current
->moving_line_filepos
= lineno_base
;
2099 #ifndef NO_COFF_LINENOS
2100 lineno_base
+= current
->lineno_count
* LINESZ
;
2104 current
->line_filepos
= 0;
2106 if (current
->reloc_count
) {
2107 current
->rel_filepos
= reloc_base
;
2108 reloc_base
+= current
->reloc_count
* sizeof(struct internal_reloc
);
2111 current
->rel_filepos
= 0;
2115 /* Write section headers to the file. */
2118 (file_ptr
) ((abfd
->flags
& EXEC_P
) ?
2119 (FILHSZ
+ AOUTSZ
) : FILHSZ
),
2124 unsigned int pad
= abfd
->flags
& D_PAGED
? data_base
: 0;
2126 unsigned int pad
= 0;
2128 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
) {
2129 struct internal_scnhdr section
;
2130 strncpy(&(section
.s_name
[0]), current
->name
, 8);
2131 section
.s_vaddr
= current
->vma
+ pad
;
2132 section
.s_paddr
= current
->vma
+ pad
;
2133 section
.s_size
= current
->size
- pad
;
2135 If this section has no size or is unloadable then the scnptr
2138 if (current
->size
- pad
== 0 ||
2139 (current
->flags
& SEC_LOAD
) == 0) {
2140 section
.s_scnptr
= 0;
2144 section
.s_scnptr
= current
->filepos
;
2146 section
.s_relptr
= current
->rel_filepos
;
2147 section
.s_lnnoptr
= current
->line_filepos
;
2148 section
.s_nreloc
= current
->reloc_count
;
2149 section
.s_nlnno
= current
->lineno_count
;
2150 if (current
->reloc_count
!= 0)
2152 if (current
->lineno_count
!= 0)
2155 section
.s_flags
= sec_to_styp_flags(current
->name
,current
->flags
);
2157 if (!strcmp(current
->name
, _TEXT
)) {
2159 } else if (!strcmp(current
->name
, _DATA
)) {
2161 } else if (!strcmp(current
->name
, _BSS
)) {
2166 section
.s_align
= (current
->alignment_power
2167 ? 1 << current
->alignment_power
2174 coff_swap_scnhdr_out(abfd
, §ion
, &buff
);
2175 bfd_write((PTR
) (&buff
), 1, SCNHSZ
, abfd
);
2182 /* OK, now set up the filehdr... */
2183 internal_f
.f_nscns
= abfd
->section_count
;
2185 We will NOT put a fucking timestamp in the header here. Every time you
2186 put it back, I will come in and take it out again. I'm sorry. This
2187 field does not belong here. We fill it with a 0 so it compares the
2188 same but is not a reasonable time. -- gnu@cygnus.com
2191 Well, I like it, so I'm conditionally compiling it in.
2194 #ifdef COFF_TIMESTAMP
2195 internal_f
.f_timdat
= time(0);
2197 internal_f
.f_timdat
= 0;
2200 if (bfd_get_symcount(abfd
) != 0)
2201 internal_f
.f_symptr
= sym_base
;
2203 internal_f
.f_symptr
= 0;
2205 internal_f
.f_flags
= 0;
2207 if (abfd
->flags
& EXEC_P
)
2208 internal_f
.f_opthdr
= AOUTSZ
;
2210 internal_f
.f_opthdr
= 0;
2213 internal_f
.f_flags
|= F_RELFLG
;
2215 internal_f
.f_flags
|= F_LNNO
;
2216 if (0 == bfd_get_symcount(abfd
))
2217 internal_f
.f_flags
|= F_LSYMS
;
2218 if (abfd
->flags
& EXEC_P
)
2219 internal_f
.f_flags
|= F_EXEC
;
2221 internal_f
.f_flags
|= F_AR32W
;
2223 if (!abfd
->xvec
->byteorder_big_p
)
2224 internal_f
.f_flags
|= F_AR32WR
;
2227 FIXME, should do something about the other byte orders and
2231 /* Set up architecture-dependent stuff */
2233 { unsigned int magic
= 0;
2234 unsigned short flags
= 0;
2235 coff_set_flags(abfd
, &magic
, &flags
);
2236 internal_f
.f_magic
= magic
;
2237 internal_f
.f_flags
|= flags
;
2238 /* ...and the "opt"hdr... */
2241 # ifdef ULTRA3 /* NYU's machine */
2242 /* FIXME: This is a bogus check. I really want to see if there
2243 * is a .shbss or a .shdata section, if so then set the magic
2244 * number to indicate a shared data executable.
2246 if (internal_f
.f_nscns
>= 7)
2247 internal_a
.magic
= SHMAGIC
; /* Shared magic */
2249 # endif /* ULTRA3 */
2250 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
2251 #define __A_MAGIC_SET__
2254 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
2255 #define __A_MAGIC_SET__
2258 #define __A_MAGIC_SET__
2259 internal_a
.magic
= PAGEMAGICBCS
;
2262 #if M68 || I386 || MIPS
2263 #define __A_MAGIC_SET__
2264 /* Never was anything here for the 68k */
2267 #ifndef __A_MAGIC_SET__
2268 # include "Your aouthdr magic number is not being set!"
2270 # undef __A_MAGIC_SET__
2273 /* Now should write relocs, strings, syms */
2274 obj_sym_filepos(abfd
) = sym_base
;
2276 #ifndef NO_COFF_SYMBOLS
2277 if (bfd_get_symcount(abfd
) != 0) {
2278 coff_renumber_symbols(abfd
);
2279 coff_mangle_symbols(abfd
);
2280 coff_write_symbols(abfd
);
2281 coff_write_linenumbers(abfd
);
2282 coff_write_relocs(abfd
);
2284 #endif /* NO_COFF_SYMBOLS */
2286 internal_a
.tsize
= text_sec
->size
;
2287 internal_a
.text_start
=text_sec
->size
? text_sec
->vma
: 0;
2290 internal_a
.dsize
= data_sec
->size
;
2291 internal_a
.data_start
= data_sec
->size
? data_sec
->vma
: 0;
2294 internal_a
.bsize
= bss_sec
->size
;
2297 internal_a
.entry
= bfd_get_start_address(abfd
);
2298 internal_f
.f_nsyms
= bfd_get_symcount(abfd
);
2300 /* now write them */
2301 if (bfd_seek(abfd
, 0L, SEEK_SET
) != 0)
2305 coff_swap_filehdr_out(abfd
, &internal_f
, &buff
);
2306 bfd_write((PTR
) &buff
, 1, FILHSZ
, abfd
);
2308 if (abfd
->flags
& EXEC_P
) {
2310 coff_swap_aouthdr_out(abfd
, &internal_a
, &buff
);
2311 bfd_write((PTR
) &buff
, 1, AOUTSZ
, abfd
);
2316 #ifndef NO_COFF_SYMBOLS
2319 this function transforms the offsets into the symbol table into
2320 pointers to syments.
2325 DEFUN(coff_pointerize_aux
,(ignore_abfd
, table_base
, type
, class, auxent
),
2326 bfd
*ignore_abfd AND
2327 combined_entry_type
*table_base AND
2330 combined_entry_type
*auxent
)
2332 /* Don't bother if this is a file or a section */
2333 if (class == C_STAT
&& type
== T_NULL
) return;
2334 if (class == C_FILE
) return;
2336 /* Otherwise patch up */
2337 if (ISFCN(type
) || ISTAG(class) || class == C_BLOCK
) {
2338 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
= table_base
+
2339 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2340 auxent
->fix_end
= 1;
2342 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
!= 0) {
2343 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
= table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
2344 auxent
->fix_tag
= 1;
2348 #endif /* NO_COFF_SYMBOLS */
2351 DEFUN(coff_set_section_contents
,(abfd
, section
, location
, offset
, count
),
2356 bfd_size_type count
)
2358 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
2359 coff_compute_section_file_positions(abfd
);
2361 bfd_seek(abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
);
2364 return (bfd_write(location
, 1, count
, abfd
) == count
) ? true : false;
2370 coff_close_and_cleanup(abfd
)
2373 if (!bfd_read_p(abfd
))
2374 switch (abfd
->format
) {
2376 if (!_bfd_write_archive_contents(abfd
))
2380 if (!coff_write_object_contents(abfd
))
2384 bfd_error
= invalid_operation
;
2388 /* We depend on bfd_close to free all the memory on the obstack. */
2389 /* FIXME if bfd_release is not using obstacks! */
2395 buy_and_read(abfd
, where
, seek_direction
, size
)
2401 PTR area
= (PTR
) bfd_alloc(abfd
, size
);
2403 bfd_error
= no_memory
;
2406 bfd_seek(abfd
, where
, seek_direction
);
2407 if (bfd_read(area
, 1, size
, abfd
) != size
) {
2408 bfd_error
= system_call_error
;
2412 } /* buy_and_read() */
2415 #ifndef NO_COFF_SYMBOLS
2418 DEFUN(build_string_table
,(abfd
),
2421 char string_table_size_buffer
[4];
2422 unsigned int string_table_size
;
2425 At this point we should be "seek"'d to the end of the
2426 symbols === the symbol table size.
2429 if (bfd_read((char *) string_table_size_buffer
,
2430 sizeof(string_table_size_buffer
),
2431 1, abfd
) != sizeof(string_table_size
)) {
2432 bfd_error
= system_call_error
;
2436 string_table_size
= bfd_h_get_32(abfd
, (bfd_byte
*) string_table_size_buffer
);
2438 if ((string_table
= (PTR
) bfd_alloc(abfd
, string_table_size
-= 4)) == NULL
) {
2439 bfd_error
= no_memory
;
2441 } /* on mallocation error */
2442 if (bfd_read(string_table
, string_table_size
, 1, abfd
) != string_table_size
) {
2443 bfd_error
= system_call_error
;
2446 return string_table
;
2449 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
2450 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
2451 be \0-terminated. */
2453 DEFUN(copy_name
,(abfd
, name
, maxlen
),
2461 for (len
= 0; len
< maxlen
; ++len
) {
2462 if (name
[len
] == '\0') {
2467 if ((newname
= (PTR
) bfd_alloc(abfd
, len
+1)) == NULL
) {
2468 bfd_error
= no_memory
;
2471 strncpy(newname
, name
, len
);
2472 newname
[len
] = '\0';
2478 read a symbol table into freshly mallocated memory, swap it, and knit the
2479 symbol names into a normalized form. By normalized here I mean that all
2480 symbols have an n_offset pointer that points to a NULL terminated string.
2481 Oh, and the first symbol MUST be a C_FILE. If there wasn't one there
2482 before, put one there.
2485 static combined_entry_type
*
2486 DEFUN(get_normalized_symtab
,(abfd
),
2490 combined_entry_type
*internal
;
2491 combined_entry_type
*internal_ptr
;
2492 combined_entry_type
*internal_end
;
2496 char *string_table
= NULL
;
2500 unsigned int raw_size
;
2501 if (obj_raw_syments(abfd
) != (combined_entry_type
*)NULL
) {
2502 return obj_raw_syments(abfd
);
2504 if ((size
= bfd_get_symcount(abfd
) * sizeof(combined_entry_type
)) == 0) {
2505 bfd_error
= no_symbols
;
2509 internal
= (combined_entry_type
*)bfd_alloc(abfd
, size
);
2510 internal_end
= internal
+ bfd_get_symcount(abfd
);
2512 raw_size
= bfd_get_symcount(abfd
) * SYMESZ
;
2513 raw
= (SYMENT
*)bfd_alloc(abfd
,raw_size
);
2515 if (bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
) == -1
2516 || bfd_read((PTR
)raw
, raw_size
, 1, abfd
) != raw_size
) {
2517 bfd_error
= system_call_error
;
2520 /* mark the end of the symbols */
2521 raw_end
= raw
+ bfd_get_symcount(abfd
);
2523 FIXME SOMEDAY. A string table size of zero is very weird, but
2524 probably possible. If one shows up, it will probably kill us.
2527 /* Swap all the raw entries */
2528 for (raw_src
= raw
, internal_ptr
= internal
; raw_src
< raw_end
; raw_src
++, internal_ptr
++) {
2530 coff_swap_sym_in(abfd
, (char *)raw_src
, (char *)&internal_ptr
->u
.syment
);
2531 internal_ptr
->fix_tag
= 0;
2532 internal_ptr
->fix_end
= 0;
2534 for (i
= internal_ptr
->u
.syment
.n_numaux
; i
; --i
, raw_src
++, internal_ptr
++) {
2535 (internal_ptr
+1)->fix_tag
= 0;
2536 (internal_ptr
+1)->fix_end
= 0;
2538 coff_swap_aux_in(abfd
, (char *)(raw_src
+1), internal_ptr
->u
.syment
.n_type
,
2539 internal_ptr
->u
.syment
.n_sclass
, & (internal_ptr
+1)->u
.auxent
);
2541 coff_pointerize_aux(abfd
,
2543 internal_ptr
->u
.syment
.n_type
,
2544 internal_ptr
->u
.syment
.n_sclass
,
2549 /* Free all the raw stuff */
2550 bfd_release(abfd
, raw
);
2552 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
2555 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
) {
2556 /* make a file symbol point to the name in the auxent, since
2557 the text ".file" is redundant */
2558 if ((internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_zeroes
== 0) {
2559 /* the filename is a long one, point into the string table
2561 if (string_table
== NULL
) {
2562 string_table
= build_string_table(abfd
);
2565 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
2566 (int) (string_table
- 4 +
2567 (internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_offset
);
2570 /* ordinary short filename, put into memory anyway */
2571 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2572 copy_name(abfd
, (internal_ptr
+1)->u
.auxent
.x_file
.x_fname
, FILNMLEN
);
2577 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0) {
2579 This is a "short" name. Make it long.
2581 unsigned long i
= 0;
2582 char *newstring
= NULL
;
2584 find the length of this string without walking into memory
2588 for (i
= 0; i
< 8; ++i
) {
2589 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0') {
2591 } /* if end of string */
2592 } /* possible lengths of this string. */
2594 if ((newstring
= (PTR
) bfd_alloc(abfd
, ++i
)) == NULL
) {
2595 bfd_error
= no_memory
;
2598 bzero(newstring
, i
);
2599 strncpy(newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
-1);
2600 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int) newstring
;
2601 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
2605 /* This is a long name already. Just point it at the string in memory. */
2606 if (string_table
== NULL
) {
2607 string_table
= build_string_table(abfd
);
2609 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
2610 (int) (string_table
- 4 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
2613 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
2616 obj_raw_syments(abfd
) = internal
;
2617 obj_string_table(abfd
) = string_table
;
2620 } /* get_normalized_symtab() */
2622 #endif /* NO_COFF_SYMBOLS */
2626 DEFUN(section_from_bfd_index
,(abfd
, index
),
2631 struct sec
*answer
= abfd
->sections
;
2633 answer
= answer
->next
;
2640 #ifndef NO_COFF_LINENOS
2643 @subsubsection Reading Linenumbers
2644 Createing the linenumber table is done by reading in the entire coff
2645 linenumber table, and creating another table for internal use.
2647 A coff line number table is structured so that each
2648 function is marked as having a line number of 0. Each line within the
2649 function is an offset from the first line in the function. The base of
2650 the line number information for the table is stored in the symbol
2651 associated with the function.
2653 The information is copied from the external to the internal table, and
2654 each symbol which marks a function is marked by pointing its...
2656 **How does this work ?**
2661 coff_slurp_line_table(abfd
, asect
)
2665 LINENO
*native_lineno
;
2666 alent
*lineno_cache
;
2668 BFD_ASSERT(asect
->lineno
== (alent
*) NULL
);
2670 native_lineno
= (LINENO
*) buy_and_read(abfd
,
2671 asect
->line_filepos
,
2674 asect
->lineno_count
));
2676 (alent
*) bfd_alloc(abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof(alent
)));
2677 if (lineno_cache
== NULL
) {
2678 bfd_error
= no_memory
;
2681 unsigned int counter
= 0;
2682 alent
*cache_ptr
= lineno_cache
;
2683 LINENO
*src
= native_lineno
;
2685 while (counter
< asect
->lineno_count
) {
2686 struct internal_lineno dst
;
2687 coff_swap_lineno_in(abfd
, src
, &dst
);
2688 cache_ptr
->line_number
= dst
.l_lnno
;
2690 if (cache_ptr
->line_number
== 0) {
2691 coff_symbol_type
*sym
=
2692 (coff_symbol_type
*) (dst
.l_addr
.l_symndx
2693 + obj_symbol_slew(abfd
)
2694 + obj_raw_syments(abfd
))->u
.syment
._n
._n_n
._n_zeroes
;
2695 cache_ptr
->u
.sym
= (asymbol
*) sym
;
2696 sym
->lineno
= cache_ptr
;
2699 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
2700 - bfd_section_vma(abfd
, asect
);
2701 } /* If no linenumber expect a symbol index */
2707 cache_ptr
->line_number
= 0;
2710 asect
->lineno
= lineno_cache
;
2711 /* FIXME, free native_lineno here, or use alloca or something. */
2713 } /* coff_slurp_line_table() */
2715 #endif /* NO_COFF_LINENOS */
2717 #ifndef NO_COFF_LINENOS
2720 DEFUN(coff_slurp_symbol_table
,(abfd
),
2723 combined_entry_type
*native_symbols
;
2724 coff_symbol_type
*cached_area
;
2725 unsigned int *table_ptr
;
2727 unsigned int number_of_symbols
= 0;
2728 if (obj_symbols(abfd
))
2730 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
2732 /* Read in the symbol table */
2733 if ((native_symbols
= get_normalized_symtab(abfd
)) == NULL
) {
2738 /* Allocate enough room for all the symbols in cached form */
2740 (coff_symbol_type
*)
2741 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(coff_symbol_type
)));
2743 if (cached_area
== NULL
) {
2744 bfd_error
= no_memory
;
2749 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(unsigned int)));
2751 if (table_ptr
== NULL
) {
2752 bfd_error
= no_memory
;
2755 coff_symbol_type
*dst
= cached_area
;
2756 unsigned int last_native_index
= bfd_get_symcount(abfd
);
2757 unsigned int this_index
= 0;
2758 while (this_index
< last_native_index
) {
2759 combined_entry_type
*src
= native_symbols
+ this_index
;
2760 table_ptr
[this_index
] = number_of_symbols
;
2761 dst
->symbol
.the_bfd
= abfd
;
2763 dst
->symbol
.name
= (char *)(src
->u
.syment
._n
._n_n
._n_offset
);
2765 We use the native name field to point to the cached field
2767 src
->u
.syment
._n
._n_n
._n_zeroes
= (int) dst
;
2768 dst
->symbol
.section
= section_from_bfd_index(abfd
,
2769 src
->u
.syment
.n_scnum
);
2770 switch (src
->u
.syment
.n_sclass
) {
2774 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
2775 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2776 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
2778 /* Fall through to next case */
2783 if ((src
->u
.syment
.n_scnum
) == 0) {
2784 if ((src
->u
.syment
.n_value
) == 0) {
2785 dst
->symbol
.flags
= BSF_UNDEFINED
;
2786 dst
->symbol
.value
= 0;
2789 dst
->symbol
.flags
= BSF_FORT_COMM
;
2790 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2795 Base the value as an index from the base of the
2798 if (dst
->symbol
.section
== (asection
*) NULL
) {
2799 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
| BSF_ABSOLUTE
;
2800 dst
->symbol
.value
= src
->u
.syment
.n_value
;
2803 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2804 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
2806 if (ISFCN((src
->u
.syment
.n_type
))) {
2808 A function ext does not go at the end of a file
2810 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
2815 case C_STAT
: /* static */
2817 case C_LEAFSTAT
: /* static leaf procedure */
2819 case C_LABEL
: /* label */
2820 if (src
->u
.syment
.n_scnum
== -2)
2821 dst
->symbol
.flags
= BSF_DEBUGGING
;
2823 dst
->symbol
.flags
= BSF_LOCAL
;
2825 Base the value as an index from the base of the section, if
2828 if (dst
->symbol
.section
)
2829 dst
->symbol
.value
= (src
->u
.syment
.n_value
) -
2830 dst
->symbol
.section
->vma
;
2832 dst
->symbol
.value
= (src
->u
.syment
.n_value
) ;
2835 case C_MOS
: /* member of structure */
2836 case C_EOS
: /* end of structure */
2837 #ifdef NOTDEF /* C_AUTOARG has the same value */
2839 case C_GLBLREG
: /* A29k-specific storage class */
2842 case C_REGPARM
: /* register parameter */
2843 case C_REG
: /* register variable */
2845 case C_AUTOARG
: /* 960-specific storage class */
2847 case C_TPDEF
: /* type definition */
2850 case C_AUTO
: /* automatic variable */
2851 case C_FIELD
: /* bit field */
2852 case C_ENTAG
: /* enumeration tag */
2853 case C_MOE
: /* member of enumeration */
2854 case C_MOU
: /* member of union */
2855 case C_UNTAG
: /* union tag */
2857 dst
->symbol
.flags
= BSF_DEBUGGING
;
2858 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2861 case C_FILE
: /* file name */
2862 case C_STRTAG
: /* structure tag */
2863 dst
->symbol
.flags
= BSF_DEBUGGING
;
2864 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2867 case C_BLOCK
: /* ".bb" or ".eb" */
2868 case C_FCN
: /* ".bf" or ".ef" */
2869 case C_EFCN
: /* physical end of function */
2870 dst
->symbol
.flags
= BSF_LOCAL
;
2872 Base the value as an index from the base of the section
2874 dst
->symbol
.value
= (src
->u
.syment
.n_value
) - dst
->symbol
.section
->vma
;
2878 case C_EXTDEF
: /* external definition */
2879 case C_ULABEL
: /* undefined label */
2880 case C_USTATIC
: /* undefined static */
2881 case C_LINE
: /* line # reformatted as symbol table entry */
2882 case C_ALIAS
: /* duplicate tag */
2883 case C_HIDDEN
: /* ext symbol in dmert public lib */
2887 fprintf(stderr
,"Unrecognized storage class %d\n",
2888 src
->u
.syment
.n_sclass
);
2890 dst
->symbol
.flags
= BSF_DEBUGGING
;
2891 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2896 BFD_ASSERT(dst
->symbol
.flags
!= 0);
2900 dst
->symbol
.udata
= 0;
2901 dst
->lineno
= (alent
*) NULL
;
2902 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
2904 number_of_symbols
++;
2905 } /* walk the native symtab */
2906 } /* bfdize the native symtab */
2908 obj_symbols(abfd
) = cached_area
;
2909 obj_raw_syments(abfd
) = native_symbols
;
2911 bfd_get_symcount(abfd
) = number_of_symbols
;
2912 obj_convert(abfd
) = table_ptr
;
2913 /* Slurp the line tables for each section too */
2918 coff_slurp_line_table(abfd
, p
);
2923 } /* coff_slurp_symbol_table() */
2926 coff_get_symtab_upper_bound(abfd
)
2929 if (!coff_slurp_symbol_table(abfd
))
2932 return (bfd_get_symcount(abfd
) + 1) * (sizeof(coff_symbol_type
*));
2937 coff_get_symtab(abfd
, alocation
)
2939 asymbol
**alocation
;
2941 unsigned int counter
= 0;
2942 coff_symbol_type
*symbase
;
2943 coff_symbol_type
**location
= (coff_symbol_type
**) (alocation
);
2944 if (!coff_slurp_symbol_table(abfd
))
2947 for (symbase
= obj_symbols(abfd
); counter
++ < bfd_get_symcount(abfd
);)
2948 *(location
++) = symbase
++;
2950 return bfd_get_symcount(abfd
);
2953 #endif /* NO_COFF_SYMBOLS */
2956 coff_get_reloc_upper_bound(abfd
, asect
)
2960 if (bfd_get_format(abfd
) != bfd_object
) {
2961 bfd_error
= invalid_operation
;
2964 return (asect
->reloc_count
+ 1) * sizeof(arelent
*);
2968 @subsubsection Reading Relocations
2969 Coff relocations are easily transformed into the internal BFD form
2972 Reading a coff relocation table is done in the following stages:
2975 The entire coff relocation table is read into memory.
2977 Each relocation is processed in turn, first it is swapped from the
2978 external to the internal form.
2980 The symbol referenced in the relocation's symbol index is turned into
2981 a pointer into the canonical symbol table. Note that this table is the
2982 same as the one returned by a call to @code{bfd_canonicalize_symtab}.
2983 The back end will call the routine and save the result if a
2984 canonicalization hasn't been done.
2986 The reloc index is turned into a pointer to a howto structure, in a
2987 back end specific way. For instance, the 386 and 960 use the
2988 @code{r_type} to directly produce an index into a howto table vector;
2989 the 88k subtracts a number from the @code{r_type} field and creates an
2995 DEFUN(coff_slurp_reloc_table
,(abfd
, asect
, symbols
),
3000 RELOC
*native_relocs
;
3001 arelent
*reloc_cache
;
3002 if (asect
->relocation
)
3004 if (asect
->reloc_count
== 0)
3006 #ifndef NO_COFF_SYMBOLS
3007 if (!coff_slurp_symbol_table(abfd
))
3011 (RELOC
*) buy_and_read(abfd
,
3015 asect
->reloc_count
));
3016 reloc_cache
= (arelent
*)
3017 bfd_alloc(abfd
, (size_t) (asect
->reloc_count
* sizeof(arelent
)));
3019 if (reloc_cache
== NULL
) {
3020 bfd_error
= no_memory
;
3025 for (cache_ptr
= reloc_cache
,
3026 src
= native_relocs
;
3027 cache_ptr
< reloc_cache
+ asect
->reloc_count
;
3030 struct internal_reloc dst
;
3032 bfd_swap_reloc_in(abfd
, src
, &dst
);
3034 dst
.r_symndx
+= obj_symbol_slew(abfd
);
3035 cache_ptr
->sym_ptr_ptr
= symbols
+ obj_convert(abfd
)[dst
.r_symndx
];
3037 /* AMD has two relocation entries for the 'consth' instruction.
3038 * The first is R_IHIHALF (part 1), the second is R_IHCONST
3039 * (part 2). The second entry's r_symndx does not contain
3040 * an index to a symbol but rather a value (apparently).
3041 * Also, see the ifdef below for saving the r_symndx value in addend.
3043 if (dst
.r_type
== R_IHCONST
) {
3047 ptr
= *(cache_ptr
->sym_ptr_ptr
);
3048 cache_ptr
->address
= dst
.r_vaddr
;
3050 The symbols definitions that we have read in have been
3051 relocated as if their sections started at 0. But the offsets
3052 refering to the symbols in the raw data have not been
3053 modified, so we have to have a negative addend to compensate.
3055 Note that symbols which used to be common must be left alone
3058 if (ptr
&& ptr
->the_bfd
== abfd
3059 && ptr
->section
!= (asection
*) NULL
3060 && ((ptr
->flags
& BSF_OLD_COMMON
)== 0))
3063 cache_ptr
->addend
= -(ptr
->section
->vma
+ ptr
->value
);
3065 cache_ptr
->addend
= 0;
3070 cache_ptr
->addend
= 0;
3073 cache_ptr
->address
-= asect
->vma
;
3075 cache_ptr
->section
= (asection
*) NULL
;
3078 if (dst
.r_type
== R_IHCONST
) {
3079 /* Add in the value which was stored in the symbol index */
3080 /* See above comment */
3081 cache_ptr
->addend
+= dst
.r_symndx
;
3082 /* Throw away the bogus symbol pointer */
3083 cache_ptr
->sym_ptr_ptr
= 0;
3085 cache_ptr
->howto
= howto_table
+ dst
.r_type
;
3088 cache_ptr
->howto
= howto_table
+ dst
.r_type
;
3091 cache_ptr
->howto
= howto_table
+ dst
.r_type
;
3094 cache_ptr
->howto
= howto_table
+ dst
.r_type
- R_RELBYTE
;
3097 if (dst
.r_type
>= R_PCR16L
&& dst
.r_type
<= R_VRT32
) {
3098 cache_ptr
->howto
= howto_table
+ dst
.r_type
- R_PCR16L
;
3099 cache_ptr
->addend
+= dst
.r_offset
<< 16;
3110 asect
->relocation
= reloc_cache
;
3115 /* This is stupid. This function should be a boolean predicate */
3117 coff_canonicalize_reloc(abfd
, section
, relptr
, symbols
)
3123 arelent
*tblptr
= section
->relocation
;
3124 unsigned int count
= 0;
3125 if (!(tblptr
|| coff_slurp_reloc_table(abfd
, section
, symbols
)))
3127 tblptr
= section
->relocation
;
3131 for (; count
++ < section
->reloc_count
;)
3132 *relptr
++ = tblptr
++;
3136 return section
->reloc_count
;
3139 #ifndef NO_COFF_SYMBOLS
3142 provided a BFD, a section and an offset into the section, calculate and
3143 return the name of the source file and the line nearest to the wanted
3148 DEFUN(coff_find_nearest_line
,(abfd
,
3156 asection
*section AND
3157 asymbol
**ignore_symbols AND
3159 CONST
char **filename_ptr AND
3160 CONST
char **functionname_ptr AND
3161 unsigned int *line_ptr
)
3163 static bfd
*cache_abfd
;
3164 static asection
*cache_section
;
3165 static bfd_vma cache_offset
;
3166 static unsigned int cache_i
;
3167 static alent
*cache_l
;
3170 coff_data_type
*cof
= coff_data(abfd
);
3171 /* Run through the raw syments if available */
3172 combined_entry_type
*p
;
3174 unsigned int line_base
= 0;
3178 *functionname_ptr
= 0;
3181 /* Don't try and find line numbers in a non coff file */
3182 if (abfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
3188 p
= cof
->raw_syments
;
3190 for (i
= 0; i
< cof
->raw_syment_count
; i
++) {
3191 if (p
->u
.syment
.n_sclass
== C_FILE
) {
3192 /* File name has been moved into symbol */
3193 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
3196 p
+= 1 + p
->u
.syment
.n_numaux
;
3198 /* Now wander though the raw linenumbers of the section */
3200 If this is the same BFD as we were previously called with and this is
3201 the same section, and the offset we want is further down then we can
3202 prime the lookup loop
3204 if (abfd
== cache_abfd
&&
3205 section
== cache_section
&&
3206 offset
>= cache_offset
) {
3212 l
= section
->lineno
;
3215 for (; i
< section
->lineno_count
; i
++) {
3216 if (l
->line_number
== 0) {
3217 /* Get the symbol this line number points at */
3218 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
3219 *functionname_ptr
= coff
->symbol
.name
;
3221 combined_entry_type
*s
= coff
->native
;
3222 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
3224 S should now point to the .bf of the function
3226 if (s
->u
.syment
.n_numaux
) {
3228 The linenumber is stored in the auxent
3230 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
3231 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
3236 if (l
->u
.offset
> offset
)
3238 *line_ptr
= l
->line_number
+ line_base
+ 1;
3244 cache_section
= section
;
3245 cache_offset
= offset
;
3254 coff_sym_filepos(abfd
)
3257 return obj_sym_filepos(abfd
);
3261 #endif /* NO_COFF_SYMBOLS */
3265 DEFUN(coff_sizeof_headers
,(abfd
, reloc
),
3271 if (reloc
== false) {
3272 size
= FILHSZ
+ AOUTSZ
;
3278 size
+= abfd
->section_count
* SCNHSZ
;
3283 #define coff_core_file_failing_command _bfd_dummy_core_file_failing_command
3284 #define coff_core_file_failing_signal _bfd_dummy_core_file_failing_signal
3285 #define coff_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
3286 #define coff_slurp_armap bfd_slurp_coff_armap
3287 #define coff_slurp_extended_name_table _bfd_slurp_extended_name_table
3288 #define coff_truncate_arname bfd_dont_truncate_arname
3289 #define coff_openr_next_archived_file bfd_generic_openr_next_archived_file
3290 #define coff_generic_stat_arch_elt bfd_generic_stat_arch_elt
3291 #define coff_get_section_contents bfd_generic_get_section_contents
3292 #define coff_close_and_cleanup bfd_generic_close_and_cleanup
3294 #define coff_bfd_debug_info_start bfd_void
3295 #define coff_bfd_debug_info_end bfd_void
3296 #define coff_bfd_debug_info_accumulate (PROTO(void,(*),(bfd*, struct sec *))) bfd_void