1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright 1990, 1991, 1992 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 Most of this hacked by Steve Chamberlain,
30 BFD supports a number of different flavours of coff format.
31 The major difference between formats are the sizes and
32 alignments of fields in structures on disk, and the occasional
35 Coff in all its varieties is implimented with a few common
36 files and a number of implementation specific files. For
37 example, The 88k bcs coff format is implemented in the file
38 @code{coff-m88k.c}. This file @code{#include}s
39 @code{coff-m88k.h} which defines the external structure of the
40 coff format for the 88k, and @code{internalcoff.h} which
41 defines the internal structure. @code{coff-m88k.c} also
42 defines pthe relocations used by the 88k format
43 @xref{Relocations}. Then the major portion of coff code is
44 included (@code{coffcode.h}) which defines the methods used to
45 act upon the types defined in @code{coff-m88k.h} and
46 @code{internalcoff.h}.
49 The Intel i960 processor version of coff is implemented in
50 @code{coff-i960.c}. This file has the same structure as
51 @code{coff-m88k.c}, except that it includes @code{coff-i960.h}
52 rather than @code{coff-m88k.h}.
55 Porting To A New Version of Coff
57 The recommended method is to select from the existing
58 implimentations the version of coff which is most like the one
59 you want to use, for our purposes, we'll say that i386 coff is
60 the one you select, and that your coff flavour is called foo.
61 Copy the @code{i386coff.c} to @code{foocoff.c}, copy
62 @code{../include/i386coff.h} to @code{../include/foocoff.h}
63 and add the lines to @code{targets.c} and @code{Makefile.in}
64 so that your new back end is used. Alter the shapes of the
65 structures in @code{../include/foocoff.h} so that they match
66 what you need. You will probably also have to add
67 @code{#ifdef}s to the code in @code{internalcoff.h} and
68 @code{coffcode.h} if your version of coff is too wild.
70 You can verify that your new BFD backend works quite simply by
71 building @code{objdump} from the @code{binutils} directory,
72 and making sure that its version of what's going on at your
73 host systems idea (assuming it has the pretty standard coff
74 dump utility (usually called @code{att-dump} or just
75 @code{dump})) are the same. Then clean up your code, and send
76 what you've done to Cygnus. Then your stuff will be in the
77 next release, and you won't have to keep integrating it.
80 How The Coff Backend Works
85 Each flavour of coff supported in BFD has its own header file
86 descibing the external layout of the structures. There is also
87 an internal description of the coff layout (in
88 @code{internalcoff.h}) file (@code{}). A major function of the
89 coff backend is swapping the bytes and twiddling the bits to
90 translate the external form of the structures into the normal
91 internal form. This is all performed in the
92 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
93 elements are different sizes between different versions of
94 coff, it is the duty of the coff version specific include file
95 to override the definitions of various packing routines in
96 @code{coffcode.h}. Eg the size of line number entry in coff is
97 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
98 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
99 correct one. No doubt, some day someone will find a version of
100 coff which has a varying field size not catered for at the
101 moment. To port BFD, that person will have to add more @code{#defines}.
102 Three of the bit twiddling routines are exported to
103 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
104 and @code{coff_swap_linno_in}. @code{GDB} reads the symbol
105 table on its own, but uses BFD to fix things up. More of the
106 bit twiddlers are exported for @code{gas};
107 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
108 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
109 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
110 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
111 of all the symbol table and reloc drudgery itself, thereby
112 saving the internal BFD overhead, but uses BFD to swap things
113 on the way out, making cross ports much safer. This also
114 allows BFD (and thus the linker) to use the same header files
115 as @code{gas}, which makes one avenue to disaster disappear.
120 The simple canonical form for symbols used by BFD is not rich
121 enough to keep all the information available in a coff symbol
122 table. The back end gets around this by keeping the original
123 symbol table around, "behind the scenes".
125 When a symbol table is requested (through a call to
126 @code{bfd_canonicalize_symtab}, a request gets through to
127 @code{get_normalized_symtab}. This reads the symbol table from
128 the coff file and swaps all the structures inside into the
129 internal form. It also fixes up all the pointers in the table
130 (represented in the file by offsets from the first symbol in
131 the table) into physical pointers to elements in the new
132 internal table. This involves some work since the meanings of
133 fields changes depending upon context; a field that is a
134 pointer to another structure in the symbol table at one moment
135 may be the size in bytes of a structure in the next. Another
136 pass is made over the table. All symbols which mark file names
137 (<<C_FILE>> symbols) are modified so that the internal
138 string points to the value in the auxent (the real filename)
139 rather than the normal text associated with the symbol
142 At this time the symbol names are moved around. Coff stores
143 all symbols less than nine characters long physically
144 within the symbol table, longer strings are kept at the end of
145 the file in the string table. This pass moves all strings
146 into memory, and replaces them with pointers to the strings.
149 The symbol table is massaged once again, this time to create
150 the canonical table used by the BFD application. Each symbol
151 is inspected in turn, and a decision made (using the
152 @code{sclass} field) about the various flags to set in the
153 @code{asymbol} @xref{Symbols}. The generated canonical table
154 shares strings with the hidden internal symbol table.
156 Any linenumbers are read from the coff file too, and attached
157 to the symbols which own the functions the linenumbers belong to.
162 Writing a symbol to a coff file which didn't come from a coff
163 file will lose any debugging information. The @code{asymbol}
164 structure remembers the BFD from which was born, and on output
165 the back end makes sure that the same destination target as
166 source target is present.
168 When the symbols have come from a coff file then all the
169 debugging information is preserved.
171 Symbol tables are provided for writing to the back end in a
172 vector of pointers to pointers. This allows applications like
173 the linker to accumulate and output large symbol tables
174 without having to do too much byte copying.
176 This function runs through the provided symbol table and
177 patches each symbol marked as a file place holder
178 (@code{C_FILE}) to point to the next file place holder in the
179 list. It also marks each @code{offset} field in the list with
180 the offset from the first symbol of the current symbol.
182 Another function of this procedure is to turn the canonical
183 value form of BFD into the form used by coff. Internally, BFD
184 expects symbol values to be offsets from a section base; so a
185 symbol physically at 0x120, but in a section starting at
186 0x100, would have the value 0x20. Coff expects symbols to
187 contain their final value, so symbols have their values
188 changed at this point to reflect their sum with their owning
189 section. Note that this transformation uses the
190 <<output_section>> field of the @code{asymbol}'s
191 @code{asection} @xref{Sections}.
193 o coff_mangle_symbols
195 This routine runs though the provided symbol table and uses
196 the offsets generated by the previous pass and the pointers
197 generated when the symbol table was read in to create the
198 structured hierachy required by coff. It changes each pointer
199 to a symbol to an index into the symbol table of the symbol
204 This routine runs through the symbol table and patches up the
205 symbols from their internal form into the coff way, calls the
206 bit twiddlers and writes out the tabel to the file.
215 The hidden information for an asymbol is described in a
216 coff_ptr_struct, which is typedefed to a combined_entry_type
220 .typedef struct coff_ptr_struct
223 . {* Remembers the offset from the first symbol in the file for
224 . this symbol. Generated by coff_renumber_symbols. *}
225 .unsigned int offset;
227 . {* Should the tag field of this symbol be renumbered.
228 . Created by coff_pointerize_aux. *}
231 . {* Should the endidx field of this symbol be renumbered.
232 . Created by coff_pointerize_aux. *}
235 . {* The container for the symbol structure as read and translated
239 . union internal_auxent auxent;
240 . struct internal_syment syment;
242 .} combined_entry_type;
245 .{* Each canonical asymbol really looks like this: *}
247 .typedef struct coff_symbol_struct
249 . {* The actual symbol which the rest of BFD works with *}
252 . {* A pointer to the hidden information for this symbol *}
253 .combined_entry_type *native;
255 . {* A pointer to the linenumber information for this symbol *}
256 .struct lineno_cache_entry *lineno;
258 . {* Have the line numbers been relocated yet ? *}
259 .boolean done_lineno;
266 extern bfd_error_vector_type bfd_error_vector
;
271 #define PUTWORD bfd_h_put_32
272 #define PUTHALF bfd_h_put_16
273 #define PUTBYTE bfd_h_put_8
275 #ifndef GET_FCN_LNNOPTR
276 #define GET_FCN_LNNOPTR(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
279 #ifndef GET_FCN_ENDNDX
280 #define GET_FCN_ENDNDX(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
283 #ifndef PUT_FCN_LNNOPTR
284 #define PUT_FCN_LNNOPTR(abfd, in, ext) PUTWORD(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
286 #ifndef PUT_FCN_ENDNDX
287 #define PUT_FCN_ENDNDX(abfd, in, ext) PUTWORD(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
289 #ifndef GET_LNSZ_LNNO
290 #define GET_LNSZ_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_lnno)
292 #ifndef GET_LNSZ_SIZE
293 #define GET_LNSZ_SIZE(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_size)
295 #ifndef PUT_LNSZ_LNNO
296 #define PUT_LNSZ_LNNO(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_sym.x_misc.x_lnsz.x_lnno)
298 #ifndef PUT_LNSZ_SIZE
299 #define PUT_LNSZ_SIZE(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte*) ext->x_sym.x_misc.x_lnsz.x_size)
301 #ifndef GET_SCN_SCNLEN
302 #define GET_SCN_SCNLEN(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_scn.x_scnlen)
304 #ifndef GET_SCN_NRELOC
305 #define GET_SCN_NRELOC(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nreloc)
307 #ifndef GET_SCN_NLINNO
308 #define GET_SCN_NLINNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nlinno)
310 #ifndef PUT_SCN_SCNLEN
311 #define PUT_SCN_SCNLEN(abfd,in, ext) bfd_h_put_32(abfd, in, (bfd_byte *) ext->x_scn.x_scnlen)
313 #ifndef PUT_SCN_NRELOC
314 #define PUT_SCN_NRELOC(abfd,in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_scn.x_nreloc)
316 #ifndef PUT_SCN_NLINNO
317 #define PUT_SCN_NLINNO(abfd,in, ext) bfd_h_put_16(abfd,in, (bfd_byte *) ext->x_scn.x_nlinno)
319 #ifndef GET_LINENO_LNNO
320 #define GET_LINENO_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) (ext->l_lnno));
322 #ifndef PUT_LINENO_LNNO
323 #define PUT_LINENO_LNNO(abfd,val, ext) bfd_h_put_16(abfd,val, (bfd_byte *) (ext->l_lnno));
327 /* void warning(); */
330 * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the
331 * incoming SEC_* flags. The inverse of this function is styp_to_sec_flags().
332 * NOTE: If you add to/change this routine, you should mirror the changes
333 * in styp_to_sec_flags().
336 DEFUN(sec_to_styp_flags
, (sec_name
, sec_flags
),
337 CONST
char * sec_name AND
342 if (!strcmp(sec_name
, _TEXT
)) {
343 return((long)STYP_TEXT
);
344 } else if (!strcmp(sec_name
, _DATA
)) {
345 return((long)STYP_DATA
);
347 } else if (!strcmp(sec_name
, ".data2")) {
348 return((long)STYP_DATA
);
349 #endif /* TWO_DATA_SECS */
350 } else if (!strcmp(sec_name
, _BSS
)) {
351 return((long)STYP_BSS
);
353 } else if (!strcmp(sec_name
, _COMMENT
)) {
354 return((long)STYP_INFO
);
355 #endif /* _COMMENT */
357 } else if (!strcmp(sec_name
, _LIB
)) {
358 return((long)STYP_LIB
);
362 /* Try and figure out what it should be */
363 if (sec_flags
& SEC_CODE
) styp_flags
= STYP_TEXT
;
364 if (sec_flags
& SEC_DATA
) styp_flags
= STYP_DATA
;
365 else if (sec_flags
& SEC_READONLY
)
366 #ifdef STYP_LIT /* 29k readonly text/data section */
367 styp_flags
= STYP_LIT
;
369 styp_flags
= STYP_TEXT
;
370 #endif /* STYP_LIT */
371 else if (sec_flags
& SEC_LOAD
) styp_flags
= STYP_TEXT
;
373 if (styp_flags
== 0) styp_flags
= STYP_BSS
;
376 if (sec_flags
& SEC_NEVER_LOAD
)
377 styp_flags
|= STYP_NOLOAD
;
383 * Return a word with SEC_* flags set to represent the incoming
384 * STYP_* flags (from scnhdr.s_flags). The inverse of this
385 * function is sec_to_styp_flags().
386 * NOTE: If you add to/change this routine, you should mirror the changes
387 * in sec_to_styp_flags().
390 DEFUN(styp_to_sec_flags
, (styp_flags
),
393 flagword sec_flags
=0;
396 if (styp_flags
& STYP_NOLOAD
)
398 sec_flags
|= SEC_NEVER_LOAD
;
400 #endif /* STYP_NOLOAD */
402 /* For 386 COFF, at least, an unloadable text or data section is
403 actually a shared library section. */
404 if (styp_flags
& STYP_TEXT
)
406 if (sec_flags
& SEC_NEVER_LOAD
)
407 sec_flags
|= SEC_CODE
| SEC_SHARED_LIBRARY
;
409 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
411 else if (styp_flags
& STYP_DATA
)
413 if (sec_flags
& SEC_NEVER_LOAD
)
414 sec_flags
|= SEC_DATA
| SEC_SHARED_LIBRARY
;
416 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
418 else if (styp_flags
& STYP_BSS
)
420 sec_flags
|= SEC_ALLOC
;
422 else if (styp_flags
& STYP_INFO
)
424 sec_flags
|= SEC_NEVER_LOAD
;
428 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
431 #ifdef STYP_LIT /* A29k readonly text/data section type */
432 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
434 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
436 #endif /* STYP_LIT */
437 #ifdef STYP_OTHER_LOAD /* Other loaded sections */
438 if (styp_flags
& STYP_OTHER_LOAD
)
440 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
442 #endif /* STYP_SDATA */
447 #define get_index(symbol) ((int) (symbol)->udata)
448 #define set_index(symbol, idx) ((symbol)->udata =(PTR) (idx))
450 /* **********************************************************************
451 Here are all the routines for swapping the structures seen in the
452 outside world into the internal forms.
457 DEFUN(bfd_swap_reloc_in
,(abfd
, reloc_src
, reloc_dst
),
460 struct internal_reloc
*reloc_dst
)
462 reloc_dst
->r_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*)reloc_src
->r_vaddr
);
463 reloc_dst
->r_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) reloc_src
->r_symndx
);
466 reloc_dst
->r_type
= bfd_h_get_8(abfd
, reloc_src
->r_type
);
467 reloc_dst
->r_size
= bfd_h_get_8(abfd
, reloc_src
->r_size
);
469 reloc_dst
->r_type
= bfd_h_get_16(abfd
, (bfd_byte
*) reloc_src
->r_type
);
472 #ifdef SWAP_IN_RELOC_OFFSET
473 reloc_dst
->r_offset
= SWAP_IN_RELOC_OFFSET(abfd
,
474 (bfd_byte
*) reloc_src
->r_offset
);
480 DEFUN(coff_swap_reloc_out
,(abfd
, src
, dst
),
485 struct internal_reloc
*reloc_src
= (struct internal_reloc
*)src
;
486 struct external_reloc
*reloc_dst
= (struct external_reloc
*)dst
;
487 bfd_h_put_32(abfd
, reloc_src
->r_vaddr
, (bfd_byte
*) reloc_dst
->r_vaddr
);
488 bfd_h_put_32(abfd
, reloc_src
->r_symndx
, (bfd_byte
*) reloc_dst
->r_symndx
);
489 bfd_h_put_16(abfd
, reloc_src
->r_type
, (bfd_byte
*)
492 #ifdef SWAP_OUT_RELOC_OFFSET
493 SWAP_OUT_RELOC_OFFSET(abfd
,
495 (bfd_byte
*) reloc_dst
->r_offset
);
497 #ifdef SWAP_OUT_RELOC_EXTRA
498 SWAP_OUT_RELOC_EXTRA(abfd
,reloc_src
, reloc_dst
);
501 return sizeof(struct external_reloc
);
505 DEFUN(bfd_swap_filehdr_in
,(abfd
, filehdr_src
, filehdr_dst
),
507 FILHDR
*filehdr_src AND
508 struct internal_filehdr
*filehdr_dst
)
510 filehdr_dst
->f_magic
= bfd_h_get_16(abfd
, (bfd_byte
*) filehdr_src
->f_magic
);
511 filehdr_dst
->f_nscns
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_nscns
);
512 filehdr_dst
->f_timdat
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_timdat
);
513 filehdr_dst
->f_symptr
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_symptr
);
514 filehdr_dst
->f_nsyms
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_nsyms
);
515 filehdr_dst
->f_opthdr
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_opthdr
);
516 filehdr_dst
->f_flags
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_flags
);
520 DEFUN(coff_swap_filehdr_out
,(abfd
, in
, out
),
525 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*)in
;
526 FILHDR
*filehdr_out
= (FILHDR
*)out
;
527 bfd_h_put_16(abfd
, filehdr_in
->f_magic
, (bfd_byte
*) filehdr_out
->f_magic
);
528 bfd_h_put_16(abfd
, filehdr_in
->f_nscns
, (bfd_byte
*) filehdr_out
->f_nscns
);
529 bfd_h_put_32(abfd
, filehdr_in
->f_timdat
, (bfd_byte
*) filehdr_out
->f_timdat
);
530 bfd_h_put_32(abfd
, filehdr_in
->f_symptr
, (bfd_byte
*) filehdr_out
->f_symptr
);
531 bfd_h_put_32(abfd
, filehdr_in
->f_nsyms
, (bfd_byte
*) filehdr_out
->f_nsyms
);
532 bfd_h_put_16(abfd
, filehdr_in
->f_opthdr
, (bfd_byte
*) filehdr_out
->f_opthdr
);
533 bfd_h_put_16(abfd
, filehdr_in
->f_flags
, (bfd_byte
*) filehdr_out
->f_flags
);
534 return sizeof(FILHDR
);
538 #ifndef NO_COFF_SYMBOLS
541 DEFUN(coff_swap_sym_in
,(abfd
, ext1
, in1
),
546 SYMENT
*ext
= (SYMENT
*)ext1
;
547 struct internal_syment
*in
= (struct internal_syment
*)in1
;
549 if( ext
->e
.e_name
[0] == 0) {
550 in
->_n
._n_n
._n_zeroes
= 0;
551 in
->_n
._n_n
._n_offset
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e
.e
.e_offset
);
554 #if SYMNMLEN != E_SYMNMLEN
555 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
557 memcpy(in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
560 in
->n_value
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_value
);
561 in
->n_scnum
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_scnum
);
562 if (sizeof(ext
->e_type
) == 2){
563 in
->n_type
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_type
);
566 in
->n_type
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_type
);
568 in
->n_sclass
= bfd_h_get_8(abfd
, ext
->e_sclass
);
569 in
->n_numaux
= bfd_h_get_8(abfd
, ext
->e_numaux
);
573 DEFUN(coff_swap_sym_out
,(abfd
, inp
, extp
),
578 struct internal_syment
*in
= (struct internal_syment
*)inp
;
579 SYMENT
*ext
=(SYMENT
*)extp
;
580 if(in
->_n
._n_name
[0] == 0) {
581 bfd_h_put_32(abfd
, 0, (bfd_byte
*) ext
->e
.e
.e_zeroes
);
582 bfd_h_put_32(abfd
, in
->_n
._n_n
._n_offset
, (bfd_byte
*) ext
->e
.e
.e_offset
);
585 #if SYMNMLEN != E_SYMNMLEN
586 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
588 memcpy(ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
591 bfd_h_put_32(abfd
, in
->n_value
, (bfd_byte
*) ext
->e_value
);
592 bfd_h_put_16(abfd
, in
->n_scnum
, (bfd_byte
*) ext
->e_scnum
);
593 if (sizeof(ext
->e_type
) == 2)
595 bfd_h_put_16(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
599 bfd_h_put_32(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
601 bfd_h_put_8(abfd
, in
->n_sclass
, ext
->e_sclass
);
602 bfd_h_put_8(abfd
, in
->n_numaux
, ext
->e_numaux
);
603 return sizeof(SYMENT
);
607 DEFUN(coff_swap_aux_in
,(abfd
, ext1
, type
, class, in1
),
614 AUXENT
*ext
= (AUXENT
*)ext1
;
615 union internal_auxent
*in
= (union internal_auxent
*)in1
;
619 if (ext
->x_file
.x_fname
[0] == 0) {
620 in
->x_file
.x_n
.x_zeroes
= 0;
621 in
->x_file
.x_n
.x_offset
=
622 bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
624 #if FILNMLEN != E_FILNMLEN
625 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
627 memcpy (in
->x_file
.x_fname
, ext
->x_file
.x_fname
, FILNMLEN
);
632 /* RS/6000 "csect" auxents */
636 in
->x_csect
.x_scnlen
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_scnlen
);
637 in
->x_csect
.x_parmhash
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_parmhash
);
638 in
->x_csect
.x_snhash
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snhash
);
639 /* We don't have to hack bitfields in x_smtyp because it's defined by
640 shifts-and-ands, which are equivalent on all byte orders. */
641 in
->x_csect
.x_smtyp
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smtyp
);
642 in
->x_csect
.x_smclas
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smclas
);
643 in
->x_csect
.x_stab
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_stab
);
644 in
->x_csect
.x_snstab
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snstab
);
653 if (type
== T_NULL
) {
654 in
->x_scn
.x_scnlen
= GET_SCN_SCNLEN(abfd
, ext
);
655 in
->x_scn
.x_nreloc
= GET_SCN_NRELOC(abfd
, ext
);
656 in
->x_scn
.x_nlinno
= GET_SCN_NLINNO(abfd
, ext
);
660 in
->x_sym
.x_tagndx
.l
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
662 in
->x_sym
.x_tvndx
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
666 #if DIMNUM != E_DIMNUM
667 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
669 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]);
670 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]);
671 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]);
672 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]);
675 if (class == C_BLOCK
|| ISFCN(type
) || ISTAG(type
)) {
676 in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= GET_FCN_LNNOPTR(abfd
, ext
);
677 in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= GET_FCN_ENDNDX(abfd
, ext
);
681 in
->x_sym
.x_misc
.x_fsize
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
684 in
->x_sym
.x_misc
.x_lnsz
.x_lnno
= GET_LNSZ_LNNO(abfd
, ext
);
685 in
->x_sym
.x_misc
.x_lnsz
.x_size
= GET_LNSZ_SIZE(abfd
, ext
);
691 DEFUN(coff_swap_aux_out
,(abfd
, inp
, type
, class, extp
),
698 union internal_auxent
*in
= (union internal_auxent
*)inp
;
699 AUXENT
*ext
= (AUXENT
*)extp
;
701 memset((PTR
)ext
, 0, AUXESZ
);
704 if (in
->x_file
.x_fname
[0] == 0) {
705 PUTWORD(abfd
, 0, (bfd_byte
*) ext
->x_file
.x_n
.x_zeroes
);
707 in
->x_file
.x_n
.x_offset
,
708 (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
711 #if FILNMLEN != E_FILNMLEN
712 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
714 memcpy (ext
->x_file
.x_fname
, in
->x_file
.x_fname
, FILNMLEN
);
720 /* RS/6000 "csect" auxents */
723 PUTWORD (abfd
, in
->x_csect
.x_scnlen
, ext
->x_csect
.x_scnlen
);
724 PUTWORD (abfd
, in
->x_csect
.x_parmhash
, ext
->x_csect
.x_parmhash
);
725 PUTHALF (abfd
, in
->x_csect
.x_snhash
, ext
->x_csect
.x_snhash
);
726 /* We don't have to hack bitfields in x_smtyp because it's defined by
727 shifts-and-ands, which are equivalent on all byte orders. */
728 PUTBYTE (abfd
, in
->x_csect
.x_smtyp
, ext
->x_csect
.x_smtyp
);
729 PUTBYTE (abfd
, in
->x_csect
.x_smclas
, ext
->x_csect
.x_smclas
);
730 PUTWORD (abfd
, in
->x_csect
.x_stab
, ext
->x_csect
.x_stab
);
731 PUTHALF (abfd
, in
->x_csect
.x_snstab
, ext
->x_csect
.x_snstab
);
740 if (type
== T_NULL
) {
741 PUT_SCN_SCNLEN(abfd
, in
->x_scn
.x_scnlen
, ext
);
742 PUT_SCN_NRELOC(abfd
, in
->x_scn
.x_nreloc
, ext
);
743 PUT_SCN_NLINNO(abfd
, in
->x_scn
.x_nlinno
, ext
);
747 PUTWORD(abfd
, in
->x_sym
.x_tagndx
.l
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
749 bfd_h_put_16(abfd
, in
->x_sym
.x_tvndx
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
752 if (class == C_BLOCK
|| ISFCN(type
) || ISTAG(type
)) {
753 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
754 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
758 PUTWORD(abfd
, in
->x_sym
.x_misc
.x_fsize
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
762 #if DIMNUM != E_DIMNUM
763 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
765 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]);
766 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]);
767 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]);
768 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]);
771 PUT_LNSZ_LNNO(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
772 PUT_LNSZ_SIZE(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
775 return sizeof(AUXENT
);
778 #endif /* NO_COFF_SYMBOLS */
780 #ifndef NO_COFF_LINENOS
783 DEFUN(coff_swap_lineno_in
,(abfd
, ext1
, in1
),
788 LINENO
*ext
= (LINENO
*)ext1
;
789 struct internal_lineno
*in
= (struct internal_lineno
*)in1
;
791 in
->l_addr
.l_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->l_addr
.l_symndx
);
792 in
->l_lnno
= GET_LINENO_LNNO(abfd
, ext
);
796 DEFUN(coff_swap_lineno_out
,(abfd
, inp
, outp
),
801 struct internal_lineno
*in
= (struct internal_lineno
*)inp
;
802 struct external_lineno
*ext
= (struct external_lineno
*)outp
;
803 PUTWORD(abfd
, in
->l_addr
.l_symndx
, (bfd_byte
*)
804 ext
->l_addr
.l_symndx
);
806 PUT_LINENO_LNNO (abfd
, in
->l_lnno
, ext
);
807 return sizeof(struct external_lineno
);
810 #endif /* NO_COFF_LINENOS */
814 DEFUN(bfd_swap_aouthdr_in
,(abfd
, aouthdr_ext1
, aouthdr_int1
),
819 AOUTHDR
*aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
820 struct internal_aouthdr
*aouthdr_int
= (struct internal_aouthdr
*)aouthdr_int1
;
822 aouthdr_int
->magic
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->magic
);
823 aouthdr_int
->vstamp
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->vstamp
);
824 aouthdr_int
->tsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tsize
);
825 aouthdr_int
->dsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->dsize
);
826 aouthdr_int
->bsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->bsize
);
827 aouthdr_int
->entry
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->entry
);
828 aouthdr_int
->text_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->text_start
);
829 aouthdr_int
->data_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->data_start
);
831 aouthdr_int
->tagentries
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tagentries
);
835 aouthdr_int
->o_toc
= bfd_h_get_32(abfd
, aouthdr_ext
->o_toc
);
836 aouthdr_int
->o_snentry
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snentry
);
837 aouthdr_int
->o_sntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntext
);
838 aouthdr_int
->o_sndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sndata
);
839 aouthdr_int
->o_sntoc
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntoc
);
840 aouthdr_int
->o_snloader
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snloader
);
841 aouthdr_int
->o_snbss
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snbss
);
842 aouthdr_int
->o_algntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algntext
);
843 aouthdr_int
->o_algndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algndata
);
844 aouthdr_int
->o_modtype
= bfd_h_get_16(abfd
, aouthdr_ext
->o_modtype
);
845 aouthdr_int
->o_maxstack
= bfd_h_get_32(abfd
, aouthdr_ext
->o_maxstack
);
850 DEFUN(coff_swap_aouthdr_out
,(abfd
, in
, out
),
855 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*)in
;
856 AOUTHDR
*aouthdr_out
= (AOUTHDR
*)out
;
857 bfd_h_put_16(abfd
, aouthdr_in
->magic
, (bfd_byte
*) aouthdr_out
->magic
);
858 bfd_h_put_16(abfd
, aouthdr_in
->vstamp
, (bfd_byte
*) aouthdr_out
->vstamp
);
859 bfd_h_put_32(abfd
, aouthdr_in
->tsize
, (bfd_byte
*) aouthdr_out
->tsize
);
860 bfd_h_put_32(abfd
, aouthdr_in
->dsize
, (bfd_byte
*) aouthdr_out
->dsize
);
861 bfd_h_put_32(abfd
, aouthdr_in
->bsize
, (bfd_byte
*) aouthdr_out
->bsize
);
862 bfd_h_put_32(abfd
, aouthdr_in
->entry
, (bfd_byte
*) aouthdr_out
->entry
);
863 bfd_h_put_32(abfd
, aouthdr_in
->text_start
,
864 (bfd_byte
*) aouthdr_out
->text_start
);
865 bfd_h_put_32(abfd
, aouthdr_in
->data_start
, (bfd_byte
*) aouthdr_out
->data_start
);
867 bfd_h_put_32(abfd
, aouthdr_in
->tagentries
, (bfd_byte
*) aouthdr_out
->tagentries
);
869 return sizeof(AOUTHDR
);
873 DEFUN(coff_swap_scnhdr_in
,(abfd
, scnhdr_ext
, scnhdr_int
),
875 SCNHDR
*scnhdr_ext AND
876 struct internal_scnhdr
*scnhdr_int
)
878 memcpy(scnhdr_int
->s_name
, scnhdr_ext
->s_name
, sizeof(scnhdr_int
->s_name
));
879 scnhdr_int
->s_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
880 scnhdr_int
->s_paddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
881 scnhdr_int
->s_size
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_size
);
883 scnhdr_int
->s_scnptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
884 scnhdr_int
->s_relptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
885 scnhdr_int
->s_lnnoptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
886 scnhdr_int
->s_flags
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_flags
);
888 scnhdr_int
->s_nreloc
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
889 scnhdr_int
->s_nlnno
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
891 scnhdr_int
->s_nreloc
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
892 scnhdr_int
->s_nlnno
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
895 scnhdr_int
->s_align
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_align
);
900 DEFUN(coff_swap_scnhdr_out
,(abfd
, in
, out
),
905 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*)in
;
906 SCNHDR
*scnhdr_ext
= (SCNHDR
*)out
;
907 memcpy(scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof(scnhdr_int
->s_name
));
908 PUTWORD(abfd
, scnhdr_int
->s_vaddr
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
909 PUTWORD(abfd
, scnhdr_int
->s_paddr
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
910 PUTWORD(abfd
, scnhdr_int
->s_size
, (bfd_byte
*) scnhdr_ext
->s_size
);
911 PUTWORD(abfd
, scnhdr_int
->s_scnptr
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
912 PUTWORD(abfd
, scnhdr_int
->s_relptr
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
913 PUTWORD(abfd
, scnhdr_int
->s_lnnoptr
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
914 PUTWORD(abfd
, scnhdr_int
->s_flags
, (bfd_byte
*) scnhdr_ext
->s_flags
);
916 PUTWORD(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
917 PUTWORD(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
919 PUTHALF(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
920 PUTHALF(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
924 PUTWORD(abfd
, scnhdr_int
->s_align
, (bfd_byte
*) scnhdr_ext
->s_align
);
926 return sizeof(SCNHDR
);
931 initialize a section structure with information peculiar to this
932 particular implementation of coff
936 DEFUN(coff_new_section_hook
,(abfd
, section
),
940 section
->alignment_power
= abfd
->xvec
->align_power_min
;
941 /* Allocate aux records for section symbols, to store size and
944 @@ Shouldn't use constant multiplier here! */
945 coffsymbol (section
->symbol
)->native
=
946 (combined_entry_type
*) bfd_zalloc (abfd
,
947 sizeof (combined_entry_type
) * 10);
951 static asection bfd_debug_section
= { "*DEBUG*" };
953 /* Take a section header read from a coff file (in HOST byte order),
954 and make a BFD "section" out of it. */
956 DEFUN(make_a_section_from_file
,(abfd
, hdr
, target_index
),
958 struct internal_scnhdr
*hdr AND
959 unsigned int target_index
)
961 asection
*return_section
;
964 /* Assorted wastage to null-terminate the name, thanks AT&T! */
965 name
= bfd_alloc(abfd
, sizeof (hdr
->s_name
)+1);
967 bfd_error
= no_memory
;
970 strncpy(name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
971 name
[sizeof (hdr
->s_name
)] = 0;
973 return_section
= bfd_make_section(abfd
, name
);
975 /* On SCO a file created by the Microsoft assembler can have two
976 .data sections. We use .data2 for the second one. */
977 if (return_section
== NULL
&& strcmp(name
, _DATA
) == 0)
978 return_section
= bfd_make_section(abfd
, ".data2");
979 #endif /* TWO_DATA_SECS */
980 if (return_section
== NULL
)
983 /* s_paddr is presumed to be = to s_vaddr */
985 return_section
->vma
= hdr
->s_vaddr
;
986 return_section
->_raw_size
= hdr
->s_size
;
987 return_section
->filepos
= hdr
->s_scnptr
;
988 return_section
->rel_filepos
= hdr
->s_relptr
;
989 return_section
->reloc_count
= hdr
->s_nreloc
;
992 /* FIXME, use a temp var rather than alignment_power */
993 return_section
->alignment_power
= hdr
->s_align
;
996 for (i
= 0; i
< 32; i
++) {
997 if ((1 << i
) >= (int) (return_section
->alignment_power
)) {
998 return_section
->alignment_power
= i
;
1005 return_section
->line_filepos
= hdr
->s_lnnoptr
;
1007 return_section->linesize = hdr->s_nlnno * sizeof (struct lineno);
1010 return_section
->lineno_count
= hdr
->s_nlnno
;
1011 return_section
->userdata
= NULL
;
1012 return_section
->next
= (asection
*) NULL
;
1013 return_section
->flags
= styp_to_sec_flags(hdr
->s_flags
);
1015 return_section
->target_index
= target_index
;
1017 if (hdr
->s_nreloc
!= 0)
1018 return_section
->flags
|= SEC_RELOC
;
1019 /* FIXME: should this check 'hdr->s_size > 0' */
1020 if (hdr
->s_scnptr
!= 0)
1021 return_section
->flags
|= SEC_HAS_CONTENTS
;
1025 DEFUN(coff_mkobject
,(abfd
),
1028 abfd
->tdata
.coff_obj_data
= (struct coff_tdata
*)bfd_zalloc (abfd
,sizeof(coff_data_type
));
1029 if (abfd
->tdata
.coff_obj_data
== 0){
1030 bfd_error
= no_memory
;
1033 coff_data(abfd
)->relocbase
= 0;
1034 /* make_abs_section(abfd);*/
1040 DEFUN(coff_real_object_p
,(abfd
, nscns
, internal_f
, internal_a
),
1043 struct internal_filehdr
*internal_f AND
1044 struct internal_aouthdr
*internal_a
)
1046 coff_data_type
*coff
;
1047 enum bfd_architecture arch
;
1049 size_t readsize
; /* length of file_info */
1050 SCNHDR
*external_sections
;
1052 /* Build a play area */
1053 if (coff_mkobject(abfd
) != true)
1056 coff
= coff_data(abfd
);
1059 external_sections
= (SCNHDR
*)bfd_alloc(abfd
, readsize
= (nscns
* SCNHSZ
));
1061 if (bfd_read((PTR
)external_sections
, 1, readsize
, abfd
) != readsize
) {
1066 /* Now copy data as required; construct all asections etc */
1067 coff
->symbol_index_slew
= 0;
1069 coff
->raw_syment_count
= 0;
1070 coff
->raw_linenos
= 0;
1071 coff
->raw_syments
= 0;
1072 coff
->sym_filepos
=0;
1073 coff
->flags
= internal_f
->f_flags
;
1076 for (i
= 0; i
< nscns
; i
++) {
1077 struct internal_scnhdr tmp
;
1078 coff_swap_scnhdr_in(abfd
, external_sections
+ i
, &tmp
);
1079 make_a_section_from_file(abfd
,&tmp
, i
+1);
1083 /* make_abs_section(abfd);*/
1085 /* Determine the machine architecture and type. */
1087 switch (internal_f
->f_magic
) {
1090 arch
= bfd_arch_i386
;
1095 #ifdef A29K_MAGIC_BIG
1096 case A29K_MAGIC_BIG
:
1097 case A29K_MAGIC_LITTLE
:
1098 arch
= bfd_arch_a29k
;
1107 arch
= bfd_arch_mips
;
1115 arch
= bfd_arch_m68k
;
1123 arch
= bfd_arch_m88k
;
1129 arch
= bfd_arch_z8k
;
1130 switch (internal_f
->f_flags
& F_MACHMASK
)
1133 machine
= bfd_mach_z8001
;
1136 machine
= bfd_mach_z8002
;
1147 arch
= bfd_arch_i960
;
1148 switch (F_I960TYPE
& internal_f
->f_flags
)
1152 machine
= bfd_mach_i960_core
;
1155 machine
= bfd_mach_i960_kb_sb
;
1158 machine
= bfd_mach_i960_mc
;
1161 machine
= bfd_mach_i960_xa
;
1164 machine
= bfd_mach_i960_ca
;
1167 machine
= bfd_mach_i960_ka_sa
;
1178 arch
= bfd_arch_rs6000
;
1185 arch
= bfd_arch_we32k
;
1192 arch
= bfd_arch_h8300
;
1197 default: /* Unreadable input file type */
1198 arch
= bfd_arch_obscure
;
1202 bfd_default_set_arch_mach(abfd
, arch
, machine
);
1203 if (!(internal_f
->f_flags
& F_RELFLG
))
1204 abfd
->flags
|= HAS_RELOC
;
1205 if ((internal_f
->f_flags
& F_EXEC
))
1206 abfd
->flags
|= EXEC_P
;
1207 if (!(internal_f
->f_flags
& F_LNNO
))
1208 abfd
->flags
|= HAS_LINENO
;
1209 if (!(internal_f
->f_flags
& F_LSYMS
))
1210 abfd
->flags
|= HAS_LOCALS
;
1213 bfd_get_symcount(abfd
) = internal_f
->f_nsyms
;
1214 if (internal_f
->f_nsyms
)
1215 abfd
->flags
|= HAS_SYMS
;
1217 coff
->sym_filepos
= internal_f
->f_symptr
;
1219 /* These members communicate important constants about the symbol table
1220 to GDB's symbol-reading code. These `constants' unfortunately vary
1221 from coff implementation to implementation... */
1222 #ifndef NO_COFF_SYMBOLS
1223 coff
->local_n_btmask
= N_BTMASK
;
1224 coff
->local_n_btshft
= N_BTSHFT
;
1225 coff
->local_n_tmask
= N_TMASK
;
1226 coff
->local_n_tshift
= N_TSHIFT
;
1227 coff
->local_symesz
= SYMESZ
;
1228 coff
->local_auxesz
= AUXESZ
;
1229 coff
->local_linesz
= LINESZ
;
1232 coff
->symbols
= (coff_symbol_type
*) NULL
;
1233 bfd_get_start_address(abfd
) = internal_f
->f_opthdr
? internal_a
->entry
: 0;
1237 bfd_release(abfd
, coff
);
1238 return (bfd_target
*)NULL
;
1242 DEFUN(coff_object_p
,(abfd
),
1248 struct internal_filehdr internal_f
;
1249 struct internal_aouthdr internal_a
;
1251 bfd_error
= system_call_error
;
1253 /* figure out how much to read */
1254 if (bfd_read((PTR
) &filehdr
, 1, FILHSZ
, abfd
) != FILHSZ
)
1257 bfd_swap_filehdr_in(abfd
, &filehdr
, &internal_f
);
1259 if (BADMAG(internal_f
)) {
1260 bfd_error
= wrong_format
;
1263 nscns
=internal_f
.f_nscns
;
1265 if (internal_f
.f_opthdr
) {
1266 if (bfd_read((PTR
) &opthdr
, 1,AOUTSZ
, abfd
) != AOUTSZ
) {
1269 bfd_swap_aouthdr_in(abfd
, (char *)&opthdr
, (char *)&internal_a
);
1272 /* Seek past the opt hdr stuff */
1273 bfd_seek(abfd
, (file_ptr
) (internal_f
.f_opthdr
+ FILHSZ
), SEEK_SET
);
1275 /* if the optional header is NULL or not the correct size then
1276 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1277 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1278 optional header is of a different size.
1280 But the mips keeps extra stuff in it's opthdr, so dont check
1284 #if defined(M88) || defined(I960)
1285 if (internal_f
.f_opthdr
!= 0 && AOUTSZ
!= internal_f
.f_opthdr
)
1286 return (bfd_target
*)NULL
;
1289 return coff_real_object_p(abfd
, nscns
, &internal_f
, &internal_a
);
1294 #ifndef NO_COFF_LINENOS
1297 DEFUN(coff_count_linenumbers
,(abfd
),
1300 unsigned int limit
= bfd_get_symcount(abfd
);
1304 asection
*s
= abfd
->sections
->output_section
;
1306 BFD_ASSERT(s
->lineno_count
== 0);
1312 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++) {
1313 asymbol
*q_maybe
= *p
;
1314 if (q_maybe
->the_bfd
->xvec
->flavour
== bfd_target_coff_flavour
) {
1315 coff_symbol_type
*q
= coffsymbol(q_maybe
);
1318 This symbol has a linenumber, increment the owning
1319 section's linenumber count
1321 alent
*l
= q
->lineno
;
1322 q
->symbol
.section
->output_section
->lineno_count
++;
1324 while (l
->line_number
) {
1325 q
->symbol
.section
->output_section
->lineno_count
++;
1333 #endif /* NO_COFF_LINENOS */
1335 #ifndef NO_COFF_SYMBOLS
1338 Takes a bfd and a symbol, returns a pointer to the coff specific area
1339 of the symbol if there is one.
1341 static coff_symbol_type
*
1342 DEFUN(coff_symbol_from
,(ignore_abfd
, symbol
),
1343 bfd
*ignore_abfd AND
1346 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
1347 return (coff_symbol_type
*)NULL
;
1349 if (symbol
->the_bfd
->tdata
.coff_obj_data
== (coff_data_type
*)NULL
)
1350 return (coff_symbol_type
*)NULL
;
1352 return (coff_symbol_type
*) symbol
;
1358 DEFUN(fixup_symbol_value
,(coff_symbol_ptr
, syment
),
1359 coff_symbol_type
*coff_symbol_ptr AND
1360 struct internal_syment
*syment
)
1363 /* Normalize the symbol flags */
1364 if (coff_symbol_ptr
->symbol
.section
== &bfd_com_section
) {
1365 /* a common symbol is undefined with a value */
1366 syment
->n_scnum
= N_UNDEF
;
1367 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1369 else if (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) {
1370 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1372 else if (coff_symbol_ptr
->symbol
.section
== & bfd_und_section
) {
1373 syment
->n_scnum
= N_UNDEF
;
1374 syment
->n_value
= 0;
1377 if (coff_symbol_ptr
->symbol
.section
) {
1379 coff_symbol_ptr
->symbol
.section
->output_section
->target_index
;
1382 coff_symbol_ptr
->symbol
.value
+
1383 coff_symbol_ptr
->symbol
.section
->output_offset
+
1384 coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
1388 /* This can happen, but I don't know why yet (steve@cygnus.com) */
1389 syment
->n_scnum
= N_ABS
;
1390 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1395 /* run through all the symbols in the symbol table and work out what
1396 their indexes into the symbol table will be when output
1398 Coff requires that each C_FILE symbol points to the next one in the
1399 chain, and that the last one points to the first external symbol. We
1404 DEFUN(coff_renumber_symbols
,(bfd_ptr
),
1407 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1408 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1409 unsigned int native_index
= 0;
1410 struct internal_syment
*last_file
= (struct internal_syment
*)NULL
;
1411 unsigned int symbol_index
;
1413 /* COFF demands that undefined symbols come after all other symbols.
1414 Since we don't need to impose this extra knowledge on all our client
1415 programs, deal with that here. Sort the symbol table; just move the
1416 undefined symbols to the end, leaving the rest alone. */
1417 /* @@ Do we have some condition we could test for, so we don't always
1418 have to do this? I don't think relocatability is quite right, but
1419 I'm not certain. [raeburn:19920508.1711EST] */
1424 newsyms
= (asymbol
**) bfd_alloc_by_size_t (bfd_ptr
,
1426 * (symbol_count
+ 1));
1427 bfd_ptr
->outsymbols
= newsyms
;
1428 for (i
= 0; i
< symbol_count
; i
++)
1429 if (symbol_ptr_ptr
[i
]->section
!= &bfd_und_section
)
1430 *newsyms
++ = symbol_ptr_ptr
[i
];
1431 for (i
= 0; i
< symbol_count
; i
++)
1432 if (symbol_ptr_ptr
[i
]->section
== &bfd_und_section
)
1433 *newsyms
++ = symbol_ptr_ptr
[i
];
1434 *newsyms
= (asymbol
*) NULL
;
1435 symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1438 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1440 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1441 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1442 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1445 if (s
->u
.syment
.n_sclass
== C_FILE
)
1447 if (last_file
!= (struct internal_syment
*)NULL
) {
1448 last_file
->n_value
= native_index
;
1450 last_file
= &(s
->u
.syment
);
1454 /* Modify the symbol values according to their section and
1457 fixup_symbol_value(coff_symbol_ptr
, &(s
->u
.syment
));
1459 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++) {
1460 s
[i
].offset
= native_index
++;
1467 obj_conv_table_size (bfd_ptr
) = native_index
;
1472 Run thorough the symbol table again, and fix it so that all pointers to
1473 entries are changed to the entries' index in the output symbol table.
1477 DEFUN(coff_mangle_symbols
,(bfd_ptr
),
1480 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1481 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1482 unsigned int symbol_index
;
1484 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1486 coff_symbol_type
*coff_symbol_ptr
=
1487 coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1489 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1491 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1493 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++) {
1494 combined_entry_type
*a
= s
+ i
+ 1;
1496 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
1497 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
1501 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
1502 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
1512 static int string_size
;
1514 DEFUN(coff_fix_symbol_name
,(ignore_abfd
, symbol
, native
),
1515 bfd
*ignore_abfd AND
1517 combined_entry_type
*native
)
1519 unsigned int name_length
;
1520 union internal_auxent
*auxent
;
1521 char * name
= ( char *)(symbol
->name
);
1523 if (name
== (char *) NULL
) {
1524 /* coff symbols always have names, so we'll make one up */
1525 symbol
->name
= "strange";
1526 name
= (char *)symbol
->name
;
1528 name_length
= strlen(name
);
1530 if (native
->u
.syment
.n_sclass
== C_FILE
) {
1531 strncpy(native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
1532 auxent
= &(native
+1)->u
.auxent
;
1534 #ifdef COFF_LONG_FILENAMES
1535 if (name_length
<= FILNMLEN
) {
1536 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1539 auxent
->x_file
.x_n
.x_offset
= string_size
+ 4;
1540 auxent
->x_file
.x_n
.x_zeroes
= 0;
1541 string_size
+= name_length
+ 1;
1544 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1545 if (name_length
> FILNMLEN
) {
1546 name
[FILNMLEN
] = '\0';
1551 { /* NOT A C_FILE SYMBOL */
1552 if (name_length
<= SYMNMLEN
) {
1553 /* This name will fit into the symbol neatly */
1554 strncpy(native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
1557 native
->u
.syment
._n
._n_n
._n_offset
= string_size
+ 4;
1558 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1559 string_size
+= name_length
+ 1;
1567 DEFUN(coff_write_symbol
,(abfd
, symbol
, native
, written
),
1570 combined_entry_type
*native AND
1571 unsigned int written
)
1573 unsigned int numaux
= native
->u
.syment
.n_numaux
;
1574 int type
= native
->u
.syment
.n_type
;
1575 int class = native
->u
.syment
.n_sclass
;
1579 /* @@ bfd_debug_section isn't accessible outside this file, but we know
1580 that C_FILE symbols belong there. So move them. */
1581 if (native
->u
.syment
.n_sclass
== C_FILE
)
1582 symbol
->section
= &bfd_debug_section
;
1584 if (symbol
->section
== &bfd_abs_section
)
1586 native
->u
.syment
.n_scnum
= N_ABS
;
1588 else if (symbol
->section
== &bfd_debug_section
)
1590 native
->u
.syment
.n_scnum
= N_DEBUG
;
1592 else if (symbol
->section
== &bfd_und_section
)
1594 native
->u
.syment
.n_scnum
= N_UNDEF
;
1598 native
->u
.syment
.n_scnum
=
1599 symbol
->section
->output_section
->target_index
;
1603 coff_fix_symbol_name(abfd
, symbol
, native
);
1605 coff_swap_sym_out(abfd
, &native
->u
.syment
, &buf
);
1606 bfd_write((PTR
)& buf
, 1, SYMESZ
, abfd
);
1607 for (j
= 0; j
< native
->u
.syment
.n_numaux
; j
++)
1610 coff_swap_aux_out(abfd
,
1611 &( (native
+ j
+ 1)->u
.auxent
), type
, class, &buf1
);
1612 bfd_write((PTR
) (&buf1
), 1, AUXESZ
, abfd
);
1615 Reuse somewhere in the symbol to keep the index
1617 set_index(symbol
, written
);
1618 return written
+ 1 + numaux
;
1623 DEFUN(coff_write_alien_symbol
,(abfd
, symbol
, written
),
1626 unsigned int written
)
1629 This symbol has been created by the loader, or come from a non
1630 coff format. It has no native element to inherit, make our
1633 combined_entry_type
*native
;
1634 combined_entry_type dummy
;
1636 native
->u
.syment
.n_type
= T_NULL
;
1638 native
->u
.syment
.n_flags
= 0;
1640 if (symbol
->section
== &bfd_und_section
)
1642 native
->u
.syment
.n_scnum
= N_UNDEF
;
1643 native
->u
.syment
.n_value
= symbol
->value
;
1645 else if (symbol
->section
== &bfd_com_section
)
1647 native
->u
.syment
.n_scnum
= N_UNDEF
;
1648 native
->u
.syment
.n_value
= symbol
->value
;
1652 else if (symbol
->flags
& BSF_DEBUGGING
) {
1654 remove name so it doesn't take up any space
1659 native
->u
.syment
.n_scnum
= symbol
->section
->output_section
->target_index
;
1660 native
->u
.syment
.n_value
= symbol
->value
+
1661 symbol
->section
->output_section
->vma
+
1662 symbol
->section
->output_offset
;
1664 /* Copy the any flags from the the file hdr into the symbol */
1666 coff_symbol_type
*c
= coff_symbol_from(abfd
, symbol
);
1667 if (c
!= (coff_symbol_type
*)NULL
) {
1668 native
->u
.syment
.n_flags
= c
->symbol
.the_bfd
->flags
;
1675 native
->u
.syment
.pad1
[0] = 0;
1676 native
->u
.syment
.pad1
[0] = 0;
1679 native
->u
.syment
.n_type
= 0;
1680 if (symbol
->flags
& BSF_LOCAL
)
1681 native
->u
.syment
.n_sclass
= C_STAT
;
1683 native
->u
.syment
.n_sclass
= C_EXT
;
1684 native
->u
.syment
.n_numaux
= 0;
1686 return coff_write_symbol(abfd
, symbol
, native
, written
);
1690 DEFUN(coff_write_native_symbol
,(abfd
, symbol
, written
),
1692 coff_symbol_type
*symbol AND
1693 unsigned int written
)
1696 Does this symbol have an ascociated line number - if so then
1697 make it remember this symbol index. Also tag the auxent of
1698 this symbol to point to the right place in the lineno table
1700 combined_entry_type
*native
= symbol
->native
;
1702 alent
*lineno
= symbol
->lineno
;
1704 if (lineno
&& !symbol
->done_lineno
) {
1705 unsigned int count
= 0;
1706 lineno
[count
].u
.offset
= written
;
1707 if (native
->u
.syment
.n_numaux
) {
1708 union internal_auxent
*a
= &((native
+1)->u
.auxent
);
1710 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1711 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1714 And count and relocate all other linenumbers
1718 while (lineno
[count
].line_number
) {
1721 I've been told this, but still need proof:
1722 > The second bug is also in `bfd/coffcode.h'. This bug causes the linker to screw
1723 > up the pc-relocations for all the line numbers in COFF code. This bug isn't
1724 > only specific to A29K implementations, but affects all systems using COFF
1725 > format binaries. Note that in COFF object files, the line number core offsets
1726 > output by the assembler are relative to the start of each procedure, not
1727 > to the start of the .text section. This patch relocates the line numbers
1728 > relative to the `native->u.syment.n_value' instead of the section virtual
1729 > address. modular!olson@cs.arizona.edu (Jon Olson)
1731 lineno
[count
].u
.offset
+= native
->u
.syment
.n_value
;
1734 lineno
[count
].u
.offset
+=
1735 symbol
->symbol
.section
->output_section
->vma
+
1736 symbol
->symbol
.section
->output_offset
;
1740 symbol
->done_lineno
= true;
1742 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1745 return coff_write_symbol(abfd
, &( symbol
->symbol
), native
,written
);
1749 DEFUN(coff_write_symbols
,(abfd
),
1753 unsigned int limit
= bfd_get_symcount(abfd
);
1754 unsigned int written
= 0;
1761 /* Seek to the right place */
1762 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
1764 /* Output all the symbols we have */
1767 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1769 asymbol
*symbol
= *p
;
1770 coff_symbol_type
*c_symbol
= coff_symbol_from(abfd
, symbol
);
1772 if (c_symbol
== (coff_symbol_type
*) NULL
||
1773 c_symbol
->native
== (combined_entry_type
*)NULL
)
1775 written
= coff_write_alien_symbol(abfd
, symbol
, written
);
1779 written
= coff_write_native_symbol(abfd
, c_symbol
, written
);
1784 bfd_get_symcount(abfd
) = written
;
1786 /* Now write out strings */
1788 if (string_size
!= 0)
1790 unsigned int size
= string_size
+ 4;
1793 bfd_h_put_32(abfd
, size
, buffer
);
1794 bfd_write((PTR
) buffer
, 1, sizeof(buffer
), abfd
);
1795 for (p
= abfd
->outsymbols
, i
= 0;
1800 size_t name_length
= strlen(q
->name
);
1802 coff_symbol_type
* c_symbol
= coff_symbol_from(abfd
, q
);
1803 maxlen
= ((c_symbol
!= NULL
&& c_symbol
->native
!= NULL
) &&
1804 (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
)) ?
1805 FILNMLEN
: SYMNMLEN
;
1807 if (name_length
> maxlen
) {
1808 bfd_write((PTR
) (q
->name
), 1, name_length
+ 1, abfd
);
1813 /* We would normally not write anything here, but we'll write
1814 out 4 so that any stupid coff reader which tries to read
1815 the string table even when there isn't one won't croak.
1818 uint32e_type size
= 4;
1820 bfd_write((PTR
)&size
, 1, sizeof(size
), abfd
);
1829 To write relocations, all the back end does is step though the
1830 canonical relocation table, and create an
1831 @code{internal_reloc}. The symbol index to use is removed from
1832 the @code{offset} field in the symbol table supplied, the
1833 address comes directly from the sum of the section base
1834 address and the relocation offset and the type is dug directly
1835 from the howto field. Then the @code{internal_reloc} is
1836 swapped into the shape of an @code{external_reloc} and written
1842 DEFUN(coff_write_relocs
,(abfd
),
1846 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1848 struct external_reloc dst
;
1850 arelent
**p
= s
->orelocation
;
1851 bfd_seek(abfd
, s
->rel_filepos
, SEEK_SET
);
1852 for (i
= 0; i
< s
->reloc_count
; i
++) {
1853 struct internal_reloc n
;
1855 memset((PTR
)&n
, 0, sizeof(n
));
1857 n
.r_vaddr
= q
->address
+ s
->vma
;
1858 /* The 29k const/consth reloc pair is a real kludge - the consth
1859 part doesn't have a symbol - it has an offset. So rebuilt
1862 if (q
->howto
->type
== R_IHCONST
)
1863 n
.r_symndx
= q
->addend
;
1870 if (q
->sym_ptr_ptr
== bfd_abs_section
.symbol_ptr_ptr
)
1872 /* This is a relocation relative to the absolute symbol */
1877 n
.r_symndx
= get_index((*(q
->sym_ptr_ptr
)));
1878 /* Take notice if the symbol reloc points to a symbol we don't have
1879 in our symbol table. What should we do for this?? */
1880 if (n
.r_symndx
> obj_conv_table_size (abfd
))
1888 /* Work out reloc type from what is required */
1889 SELECT_RELOC(n
.r_type
, q
->howto
);
1891 n
.r_type
= q
->howto
->type
;
1893 coff_swap_reloc_out(abfd
, &n
, &dst
);
1894 bfd_write((PTR
) &dst
, 1, RELSZ
, abfd
);
1898 #endif /* NO_COFF_SYMBOLS */
1900 #ifndef NO_COFF_LINENOS
1903 DEFUN(coff_write_linenumbers
,(abfd
),
1907 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1908 if (s
->lineno_count
) {
1909 asymbol
**q
= abfd
->outsymbols
;
1910 bfd_seek(abfd
, s
->line_filepos
, SEEK_SET
);
1911 /* Find all the linenumbers in this section */
1914 alent
*l
= BFD_SEND(p
->the_bfd
, _get_lineno
, (p
->the_bfd
, p
));
1916 /* Found a linenumber entry, output */
1917 struct internal_lineno out
;
1919 memset( (PTR
)&out
, 0, sizeof(out
));
1921 out
.l_addr
.l_symndx
= l
->u
.offset
;
1922 coff_swap_lineno_out(abfd
, &out
, &buff
);
1923 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1925 while (l
->line_number
) {
1926 out
.l_lnno
= l
->line_number
;
1927 out
.l_addr
.l_symndx
= l
->u
.offset
;
1928 coff_swap_lineno_out(abfd
, &out
, &buff
);
1929 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1940 DEFUN(coff_get_lineno
,(ignore_abfd
, symbol
),
1941 bfd
*ignore_abfd AND
1944 return coffsymbol(symbol
)->lineno
;
1947 #endif /* NO_COFF_LINENOS */
1950 coff_make_empty_symbol(abfd
)
1953 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc(abfd
, sizeof(coff_symbol_type
));
1955 bfd_error
= no_memory
;
1958 new->symbol
.section
= 0;
1960 new->lineno
= (alent
*) NULL
;
1961 new->done_lineno
= false;
1962 new->symbol
.the_bfd
= abfd
;
1963 return &new->symbol
;
1966 #ifndef NO_COFF_SYMBOLS
1969 DEFUN (coff_make_debug_symbol
, (abfd
, ptr
, sz
),
1974 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc(abfd
, sizeof(coff_symbol_type
));
1976 bfd_error
= no_memory
;
1979 /* @@ This shouldn't be using a constant multiplier. */
1980 new->native
= (combined_entry_type
*) bfd_zalloc (abfd
, sizeof (combined_entry_type
) * 10);
1981 new->symbol
.section
= &bfd_debug_section
;
1982 new->lineno
= (alent
*) NULL
;
1983 new->done_lineno
= false;
1984 new->symbol
.the_bfd
= abfd
;
1985 return &new->symbol
;
1989 DEFUN(coff_print_symbol
,(ignore_abfd
, filep
, symbol
, how
),
1990 bfd
*ignore_abfd AND
1993 bfd_print_symbol_type how
)
1995 FILE *file
= (FILE *)filep
;
1997 case bfd_print_symbol_name
:
1998 fprintf(file
, "%s", symbol
->name
);
2000 case bfd_print_symbol_more
:
2001 fprintf(file
, "coff %lx %lx", (unsigned long) coffsymbol(symbol
)->native
,
2002 (unsigned long) coffsymbol(symbol
)->lineno
);
2004 case bfd_print_symbol_nm
:
2007 CONST
char *section_name
= symbol
->section
->name
;
2008 bfd_print_symbol_vandf((PTR
) file
, symbol
);
2011 fprintf(file
, " %-5s %s %s %s",
2013 coffsymbol(symbol
)->native
? "n" : "g",
2014 coffsymbol(symbol
)->lineno
? "l" : " ",
2020 case bfd_print_symbol_all
:
2021 /* Print out the symbols in a reasonable way */
2023 CONST
char *section_name
= symbol
->section
->name
;
2026 if (coffsymbol(symbol
)->native
)
2029 combined_entry_type
*combined
= coffsymbol(symbol
)->native
;
2030 combined_entry_type
*root
= obj_raw_syments(ignore_abfd
);
2032 fprintf(file
,"[%3d]",
2036 fprintf(file
, "(sc %2d)(fl%4x)(ty%3x)(sc%3d) nx(%d) %08x %s",
2037 combined
->u
.syment
.n_scnum
,
2038 combined
->u
.syment
.n_flags
,
2039 combined
->u
.syment
.n_type
,
2040 combined
->u
.syment
.n_sclass
,
2041 combined
->u
.syment
.n_numaux
,
2042 combined
->u
.syment
.n_value
,
2045 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
2048 switch (combined
->u
.syment
.n_sclass
) {
2050 fprintf(file
, "File ");
2053 fprintf(file
, "AUX lnno %x size %x tagndx %x",
2054 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
2055 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
2056 combined
[aux
+1].u
.auxent
.x_sym
.x_tagndx
.l
);
2064 struct lineno_cache_entry
*l
= coffsymbol(symbol
)->lineno
;
2067 printf("\n%s :", l
->u
.sym
->name
);
2069 while (l
->line_number
)
2071 printf("\n%4d : %x",
2085 bfd_print_symbol_vandf((PTR
) file
, symbol
);
2086 fprintf(file
, " %-5s %s %s %s",
2088 coffsymbol(symbol
)->native
? "n" : "g",
2089 coffsymbol(symbol
)->lineno
? "l" : " ",
2098 #endif /* NO_COFF_SYMBOLS */
2100 /* Set flags and magic number of a coff file from architecture and machine
2101 type. Result is true if we can represent the arch&type, false if not. */
2104 DEFUN(coff_set_flags
,(abfd
, magicp
, flagsp
),
2106 unsigned *magicp AND
2107 unsigned short *flagsp
)
2109 switch (bfd_get_arch(abfd
)) {
2113 switch (bfd_get_mach(abfd
))
2115 case bfd_mach_z8001
:
2118 case bfd_mach_z8002
:
2132 *magicp
= I960ROMAGIC
;
2134 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2135 I960RWMAGIC); FIXME???
2137 switch (bfd_get_mach(abfd
)) {
2138 case bfd_mach_i960_core
:
2141 case bfd_mach_i960_kb_sb
:
2144 case bfd_mach_i960_mc
:
2147 case bfd_mach_i960_xa
:
2150 case bfd_mach_i960_ca
:
2153 case bfd_mach_i960_ka_sa
:
2166 *magicp
= MIPS_MAGIC_2
;
2172 *magicp
= I386MAGIC
;
2178 *magicp
= MC68MAGIC
;
2185 *magicp
= MC88OMAGIC
;
2190 case bfd_arch_h8300
:
2191 *magicp
= H8300MAGIC
;
2195 #ifdef A29K_MAGIC_BIG
2197 if (abfd
->xvec
->byteorder_big_p
)
2198 *magicp
= A29K_MAGIC_BIG
;
2200 *magicp
= A29K_MAGIC_LITTLE
;
2206 case bfd_arch_we32k
:
2207 *magicp
= WE32KMAGIC
;
2213 case bfd_arch_rs6000
:
2214 *magicp
= U802TOCMAGIC
;
2219 default: /* Unknown architecture */
2220 /* return false; -- fall through to "return false" below, to avoid
2221 "statement never reached" errors on the one below. */
2230 DEFUN(coff_set_arch_mach
,(abfd
, arch
, machine
),
2232 enum bfd_architecture arch AND
2233 unsigned long machine
)
2236 unsigned short dummy2
;
2237 bfd_default_set_arch_mach(abfd
, arch
, machine
);
2239 if (arch
!= bfd_arch_unknown
&&
2240 coff_set_flags(abfd
, &dummy1
, &dummy2
) != true)
2241 return false; /* We can't represent this type */
2242 return true; /* We're easy ... */
2246 /* Calculate the file position for each section. */
2249 DEFUN(coff_compute_section_file_positions
,(abfd
),
2253 asection
*previous
= (asection
*)NULL
;
2254 file_ptr sofar
= FILHSZ
;
2256 if (bfd_get_start_address(abfd
))
2258 /* A start address may have been added to the original file. In this
2259 case it will need an optional header to record it. */
2260 abfd
->flags
|= EXEC_P
;
2263 if (abfd
->flags
& EXEC_P
)
2266 sofar
+= abfd
->section_count
* SCNHSZ
;
2267 for (current
= abfd
->sections
;
2268 current
!= (asection
*)NULL
;
2269 current
= current
->next
) {
2271 /* Only deal with sections which have contents */
2272 if (!(current
->flags
& SEC_HAS_CONTENTS
))
2275 /* Align the sections in the file to the same boundary on
2276 which they are aligned in virtual memory. I960 doesn't
2277 do this (FIXME) so we can stay in sync with Intel. 960
2278 doesn't yet page from files... */
2281 /* make sure this section is aligned on the right boundary - by
2282 padding the previous section up if necessary */
2285 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2286 if (previous
!= (asection
*)NULL
) {
2287 previous
->_raw_size
+= sofar
- old_sofar
;
2292 /* FIXME, in demand paged files, the low order bits of the file
2293 offset must match the low order bits of the virtual address.
2294 "Low order" is apparently implementation defined. Add code
2295 here to round sofar up to match the virtual address. */
2297 current
->filepos
= sofar
;
2299 sofar
+= current
->_raw_size
;
2301 /* make sure that this section is of the right size too */
2303 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2304 current
->_raw_size
+= sofar
- old_sofar
;
2309 obj_relocbase(abfd
) = sofar
;
2312 #ifndef NO_COFF_SYMBOLS
2314 coff_section_symbol (abfd
, name
)
2318 asection
*sec
= bfd_make_section_old_way (abfd
, name
);
2320 combined_entry_type
*csym
;
2323 if (coff_symbol_from (abfd
, sym
))
2324 csym
= coff_symbol_from (abfd
, sym
)->native
;
2327 /* Make sure back-end COFF stuff is there. */
2331 coff_symbol_type sym
;
2332 /* @@FIXME This shouldn't use a fixed size!! */
2333 combined_entry_type e
[10];
2336 f
= (struct foo
*) bfd_alloc_by_size_t (abfd
, sizeof (*f
));
2337 memset ((char *) f
, 0, sizeof (*f
));
2338 coff_symbol_from (abfd
, sym
)->native
= csym
= f
->e
;
2340 csym
[0].u
.syment
.n_sclass
= C_STAT
;
2341 csym
[0].u
.syment
.n_numaux
= 1;
2342 /* SF_SET_STATICS (sym); @@ ??? */
2345 csym
[1].u
.auxent
.x_scn
.x_scnlen
= sec
->_raw_size
;
2346 csym
[1].u
.auxent
.x_scn
.x_nreloc
= sec
->reloc_count
;
2347 csym
[1].u
.auxent
.x_scn
.x_nlinno
= sec
->lineno_count
;
2351 csym
[1].u
.auxent
.x_scn
.x_scnlen
= 0;
2352 csym
[1].u
.auxent
.x_scn
.x_nreloc
= 0;
2353 csym
[1].u
.auxent
.x_scn
.x_nlinno
= 0;
2358 /* If .file, .text, .data, .bss symbols are missing, add them. */
2359 /* @@ Should we only be adding missing symbols, or overriding the aux
2360 values for existing section symbols? */
2362 coff_add_missing_symbols (abfd
)
2365 unsigned int nsyms
= bfd_get_symcount (abfd
);
2366 asymbol
**sympp
= abfd
->outsymbols
;
2369 int need_text
= 1, need_data
= 1, need_bss
= 1, need_file
= 1;
2371 for (i
= 0; i
< nsyms
; i
++)
2373 coff_symbol_type
*csym
= coff_symbol_from (abfd
, sympp
[i
]);
2377 /* only do this if there is a coff representation of the input
2379 if (csym
->native
&& csym
->native
->u
.syment
.n_sclass
== C_FILE
)
2384 name
= csym
->symbol
.name
;
2387 if (!strcmp (name
, _TEXT
))
2389 else if (!strcmp (name
, _DATA
))
2391 else if (!strcmp (name
, _BSS
))
2395 /* Now i == bfd_get_symcount (abfd). */
2396 /* @@ For now, don't deal with .file symbol. */
2399 if (!need_text
&& !need_data
&& !need_bss
&& !need_file
)
2401 nsyms
+= need_text
+ need_data
+ need_bss
+ need_file
;
2402 sympp2
= (asymbol
**) bfd_alloc_by_size_t (abfd
, nsyms
* sizeof (asymbol
*));
2403 memcpy (sympp2
, sympp
, i
* sizeof (asymbol
*));
2406 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
2410 sympp2
[i
++] = coff_section_symbol (abfd
, _TEXT
);
2412 sympp2
[i
++] = coff_section_symbol (abfd
, _DATA
);
2414 sympp2
[i
++] = coff_section_symbol (abfd
, _BSS
);
2415 BFD_ASSERT (i
== nsyms
);
2416 bfd_set_symtab (abfd
, sympp2
, nsyms
);
2418 #endif /* NO_COFF_SYMBOLS */
2423 DEFUN(coff_write_object_contents
,(abfd
),
2429 boolean hasrelocs
= false;
2430 boolean haslinno
= false;
2431 file_ptr reloc_base
;
2432 file_ptr lineno_base
;
2436 unsigned long reloc_size
= 0;
2437 unsigned long lnno_size
= 0;
2438 asection
*text_sec
= NULL
;
2439 asection
*data_sec
= NULL
;
2440 asection
*bss_sec
= NULL
;
2442 struct internal_filehdr internal_f
;
2443 struct internal_aouthdr internal_a
;
2446 bfd_error
= system_call_error
;
2447 /* Number the output sections, starting from one on the first section
2448 with a name which doesn't start with a *.
2449 @@ The code doesn't make this check. Is it supposed to be done,
2452 for (current
= abfd
->sections
; current
!= (asection
*)NULL
;
2453 current
= current
->next
)
2455 current
->target_index
= count
;
2459 if(abfd
->output_has_begun
== false) {
2460 coff_compute_section_file_positions(abfd
);
2463 if (abfd
->sections
!= (asection
*)NULL
) {
2464 scn_base
= abfd
->sections
->filepos
;
2469 if (bfd_seek(abfd
, scn_base
, SEEK_SET
) != 0)
2471 reloc_base
= obj_relocbase(abfd
);
2473 /* Make a pass through the symbol table to count line number entries and
2474 put them into the correct asections */
2476 #ifndef NO_COFF_LINENOS
2477 coff_count_linenumbers(abfd
);
2479 data_base
= scn_base
;
2481 /* Work out the size of the reloc and linno areas */
2483 for (current
= abfd
->sections
; current
!= NULL
; current
=
2486 /* We give section headers to +ve indexes */
2487 if (current
->target_index
> 0)
2490 reloc_size
+= current
->reloc_count
* RELSZ
;
2491 #ifndef NO_COFF_LINENOS
2492 lnno_size
+= current
->lineno_count
* LINESZ
;
2494 data_base
+= SCNHSZ
;
2499 lineno_base
= reloc_base
+ reloc_size
;
2500 sym_base
= lineno_base
+ lnno_size
;
2502 /* Indicate in each section->line_filepos its actual file address */
2503 for (current
= abfd
->sections
; current
!= NULL
; current
=
2506 if (current
->target_index
> 0)
2509 if (current
->lineno_count
) {
2510 current
->line_filepos
= lineno_base
;
2511 current
->moving_line_filepos
= lineno_base
;
2512 #ifndef NO_COFF_LINENOS
2513 lineno_base
+= current
->lineno_count
* LINESZ
;
2517 current
->line_filepos
= 0;
2519 if (current
->reloc_count
) {
2520 current
->rel_filepos
= reloc_base
;
2521 reloc_base
+= current
->reloc_count
* RELSZ
;
2524 current
->rel_filepos
= 0;
2531 /* Write section headers to the file. */
2532 internal_f
.f_nscns
= 0;
2534 (file_ptr
) ((abfd
->flags
& EXEC_P
) ?
2535 (FILHSZ
+ AOUTSZ
) : FILHSZ
),
2540 unsigned int pad
= abfd
->flags
& D_PAGED
? data_base
: 0;
2542 unsigned int pad
= 0;
2544 for (current
= abfd
->sections
;
2546 current
= current
->next
) {
2547 struct internal_scnhdr section
;
2548 if (current
->target_index
> 0)
2550 internal_f
.f_nscns
++;
2551 strncpy(&(section
.s_name
[0]), current
->name
, 8);
2553 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
2554 Ian Taylor <ian@cygnus.com>. */
2555 if (strcmp (current
->name
, _LIB
) == 0)
2556 section
.s_vaddr
= 0;
2559 section
.s_vaddr
= current
->vma
+ pad
;
2560 section
.s_paddr
= current
->vma
+ pad
;
2561 section
.s_size
= current
->_raw_size
- pad
;
2563 If this section has no size or is unloadable then the scnptr
2566 if (current
->_raw_size
- pad
== 0 ||
2567 (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0) {
2568 section
.s_scnptr
= 0;
2571 section
.s_scnptr
= current
->filepos
;
2573 section
.s_relptr
= current
->rel_filepos
;
2574 section
.s_lnnoptr
= current
->line_filepos
;
2575 section
.s_nreloc
= current
->reloc_count
;
2576 section
.s_nlnno
= current
->lineno_count
;
2577 if (current
->reloc_count
!= 0)
2579 if (current
->lineno_count
!= 0)
2582 section
.s_flags
= sec_to_styp_flags(current
->name
,current
->flags
);
2584 if (!strcmp(current
->name
, _TEXT
)) {
2586 } else if (!strcmp(current
->name
, _DATA
)) {
2588 #ifdef TWO_DATA_SECS
2589 } else if (!strcmp(current
->name
, ".data2")) {
2591 #endif /* TWO_DATA_SECS */
2592 } else if (!strcmp(current
->name
, _BSS
)) {
2597 section
.s_align
= (current
->alignment_power
2598 ? 1 << current
->alignment_power
2605 coff_swap_scnhdr_out(abfd
, §ion
, &buff
);
2606 bfd_write((PTR
) (&buff
), 1, SCNHSZ
, abfd
);
2616 /* OK, now set up the filehdr... */
2618 /* Don't include the internal abs section in the section count */
2621 We will NOT put a fucking timestamp in the header here. Every time you
2622 put it back, I will come in and take it out again. I'm sorry. This
2623 field does not belong here. We fill it with a 0 so it compares the
2624 same but is not a reasonable time. -- gnu@cygnus.com
2626 internal_f
.f_timdat
= 0;
2628 if (bfd_get_symcount(abfd
) != 0)
2629 internal_f
.f_symptr
= sym_base
;
2631 internal_f
.f_symptr
= 0;
2633 internal_f
.f_flags
= 0;
2635 if (abfd
->flags
& EXEC_P
)
2636 internal_f
.f_opthdr
= AOUTSZ
;
2638 internal_f
.f_opthdr
= 0;
2641 internal_f
.f_flags
|= F_RELFLG
;
2643 internal_f
.f_flags
|= F_LNNO
;
2644 if (0 == bfd_get_symcount(abfd
))
2645 internal_f
.f_flags
|= F_LSYMS
;
2646 if (abfd
->flags
& EXEC_P
)
2647 internal_f
.f_flags
|= F_EXEC
;
2649 if (!abfd
->xvec
->byteorder_big_p
)
2650 internal_f
.f_flags
|= F_AR32WR
;
2652 internal_f
.f_flags
|= F_AR32W
;
2655 FIXME, should do something about the other byte orders and
2659 /* Set up architecture-dependent stuff */
2661 { unsigned int magic
= 0;
2662 unsigned short flags
= 0;
2663 coff_set_flags(abfd
, &magic
, &flags
);
2664 internal_f
.f_magic
= magic
;
2665 internal_f
.f_flags
|= flags
;
2666 /* ...and the "opt"hdr... */
2669 # ifdef ULTRA3 /* NYU's machine */
2670 /* FIXME: This is a bogus check. I really want to see if there
2671 * is a .shbss or a .shdata section, if so then set the magic
2672 * number to indicate a shared data executable.
2674 if (internal_f
.f_nscns
>= 7)
2675 internal_a
.magic
= SHMAGIC
; /* Shared magic */
2677 # endif /* ULTRA3 */
2678 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
2679 #define __A_MAGIC_SET__
2682 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
2683 #define __A_MAGIC_SET__
2686 #define __A_MAGIC_SET__
2687 internal_a
.magic
= PAGEMAGICBCS
;
2690 #if M68 || MIPS || WE32K
2691 #define __A_MAGIC_SET__
2692 /* Never was anything here for the 68k */
2693 #endif /* M68 || MIPS || WE32K */
2696 # define __A_MAGIC_SET__
2697 internal_a
.magic
= ZMAGIC
;
2701 #define __A_MAGIC_SET__
2702 internal_a
.magic
= (abfd
->flags
& D_PAGED
)? RS6K_AOUTHDR_ZMAGIC
:
2703 (abfd
->flags
& WP_TEXT
)? RS6K_AOUTHDR_NMAGIC
:
2704 RS6K_AOUTHDR_OMAGIC
;
2707 #ifndef __A_MAGIC_SET__
2708 # include "Your aouthdr magic number is not being set!"
2710 # undef __A_MAGIC_SET__
2713 /* Now should write relocs, strings, syms */
2714 obj_sym_filepos(abfd
) = sym_base
;
2716 #ifndef NO_COFF_SYMBOLS
2717 if (bfd_get_symcount(abfd
) != 0) {
2718 coff_add_missing_symbols (abfd
);
2719 coff_renumber_symbols(abfd
);
2720 coff_mangle_symbols(abfd
);
2721 coff_write_symbols(abfd
);
2722 coff_write_linenumbers(abfd
);
2723 coff_write_relocs(abfd
);
2725 #endif /* NO_COFF_SYMBOLS */
2727 internal_a
.tsize
= bfd_get_section_size_before_reloc(text_sec
);
2728 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
2731 internal_a
.dsize
= bfd_get_section_size_before_reloc(data_sec
);
2732 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
2735 internal_a
.bsize
= bfd_get_section_size_before_reloc(bss_sec
);
2738 internal_a
.entry
= bfd_get_start_address(abfd
);
2739 internal_f
.f_nsyms
= bfd_get_symcount(abfd
);
2741 /* now write them */
2742 if (bfd_seek(abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
2746 coff_swap_filehdr_out(abfd
, (PTR
)&internal_f
, (PTR
)&buff
);
2747 bfd_write((PTR
) &buff
, 1, FILHSZ
, abfd
);
2749 if (abfd
->flags
& EXEC_P
) {
2751 coff_swap_aouthdr_out(abfd
, (PTR
)&internal_a
, (PTR
)&buff
);
2752 bfd_write((PTR
) &buff
, 1, AOUTSZ
, abfd
);
2757 #ifndef NO_COFF_SYMBOLS
2760 this function transforms the offsets into the symbol table into
2761 pointers to syments.
2766 DEFUN(coff_pointerize_aux
,(ignore_abfd
, table_base
, type
, class, auxent
),
2767 bfd
*ignore_abfd AND
2768 combined_entry_type
*table_base AND
2771 combined_entry_type
*auxent
)
2773 /* Don't bother if this is a file or a section */
2774 if (class == C_STAT
&& type
== T_NULL
) return;
2775 if (class == C_FILE
) return;
2777 /* Otherwise patch up */
2778 if (ISFCN(type
) || ISTAG(class) || class == C_BLOCK
) {
2779 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
= table_base
+
2780 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2781 auxent
->fix_end
= 1;
2783 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
!= 0) {
2784 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
=
2785 table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
2786 auxent
->fix_tag
= 1;
2790 #endif /* NO_COFF_SYMBOLS */
2793 DEFUN(coff_set_section_contents
,(abfd
, section
, location
, offset
, count
),
2798 bfd_size_type count
)
2800 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
2801 coff_compute_section_file_positions(abfd
);
2804 /* If this is a .lib section, bump the vma address so that it
2805 winds up being the number of .lib sections output. This is
2806 right for SVR3.2. Shared libraries should probably get more
2807 generic support. Ian Taylor <ian@cygnus.com>. */
2808 if (strcmp (section
->name
, _LIB
) == 0)
2812 bfd_seek(abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
);
2815 return (bfd_write(location
, 1, count
, abfd
) == count
) ? true : false;
2821 coff_close_and_cleanup(abfd
)
2824 if (!bfd_read_p(abfd
))
2825 switch (abfd
->format
) {
2827 if (!_bfd_write_archive_contents(abfd
))
2831 if (!coff_write_object_contents(abfd
))
2835 bfd_error
= invalid_operation
;
2839 /* We depend on bfd_close to free all the memory on the obstack. */
2840 /* FIXME if bfd_release is not using obstacks! */
2846 buy_and_read(abfd
, where
, seek_direction
, size
)
2852 PTR area
= (PTR
) bfd_alloc(abfd
, size
);
2854 bfd_error
= no_memory
;
2857 bfd_seek(abfd
, where
, seek_direction
);
2858 if (bfd_read(area
, 1, size
, abfd
) != size
) {
2859 bfd_error
= system_call_error
;
2863 } /* buy_and_read() */
2866 #ifndef NO_COFF_SYMBOLS
2869 DEFUN(build_string_table
,(abfd
),
2872 char string_table_size_buffer
[4];
2873 unsigned int string_table_size
;
2876 /* At this point we should be "seek"'d to the end of the
2877 symbols === the symbol table size. */
2878 if (bfd_read((char *) string_table_size_buffer
,
2879 sizeof(string_table_size_buffer
),
2880 1, abfd
) != sizeof(string_table_size
)) {
2881 bfd_error
= system_call_error
;
2885 string_table_size
= bfd_h_get_32(abfd
, (bfd_byte
*) string_table_size_buffer
);
2887 if ((string_table
= (PTR
) bfd_alloc(abfd
, string_table_size
-= 4)) == NULL
) {
2888 bfd_error
= no_memory
;
2890 } /* on mallocation error */
2891 if (bfd_read(string_table
, string_table_size
, 1, abfd
) != string_table_size
) {
2892 bfd_error
= system_call_error
;
2895 return string_table
;
2898 /* Allocate space for the ".debug" section, and read it.
2899 We did not read the debug section until now, because
2900 we didn't want to go to the trouble until someone needed it. */
2903 DEFUN(build_debug_section
,(abfd
),
2906 char *debug_section
;
2909 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
2912 bfd_error
= no_debug_section
;
2916 debug_section
= (PTR
) bfd_alloc (abfd
,
2917 bfd_get_section_size_before_reloc (sect
));
2918 if (debug_section
== NULL
) {
2919 bfd_error
= no_memory
;
2923 /* Seek to the beginning of the `.debug' section and read it.
2924 Save the current position first; it is needed by our caller.
2925 Then read debug section and reset the file pointer. */
2927 position
= bfd_tell (abfd
);
2928 bfd_seek (abfd
, sect
->filepos
, SEEK_SET
);
2929 if (bfd_read (debug_section
,
2930 bfd_get_section_size_before_reloc (sect
), 1, abfd
)
2931 != bfd_get_section_size_before_reloc(sect
)) {
2932 bfd_error
= system_call_error
;
2935 bfd_seek (abfd
, position
, SEEK_SET
);
2936 return debug_section
;
2940 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
2941 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
2942 be \0-terminated. */
2944 DEFUN(copy_name
,(abfd
, name
, maxlen
),
2952 for (len
= 0; len
< maxlen
; ++len
) {
2953 if (name
[len
] == '\0') {
2958 if ((newname
= (PTR
) bfd_alloc(abfd
, len
+1)) == NULL
) {
2959 bfd_error
= no_memory
;
2962 strncpy(newname
, name
, len
);
2963 newname
[len
] = '\0';
2968 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
2969 knit the symbol names into a normalized form. By normalized here I
2970 mean that all symbols have an n_offset pointer that points to a null-
2971 terminated string. */
2973 #ifndef SYMNAME_IN_DEBUG
2974 #define SYMNAME_IN_DEBUG(x) 0
2977 static combined_entry_type
*
2978 DEFUN(get_normalized_symtab
,(abfd
),
2981 combined_entry_type
*internal
;
2982 combined_entry_type
*internal_ptr
;
2983 combined_entry_type
*symbol_ptr
;
2984 combined_entry_type
*internal_end
;
2988 char *string_table
= NULL
;
2989 char *debug_section
= NULL
;
2992 unsigned int raw_size
;
2993 if (obj_raw_syments(abfd
) != (combined_entry_type
*)NULL
) {
2994 return obj_raw_syments(abfd
);
2996 if ((size
= bfd_get_symcount(abfd
) * sizeof(combined_entry_type
)) == 0) {
2997 bfd_error
= no_symbols
;
3001 internal
= (combined_entry_type
*)bfd_alloc(abfd
, size
);
3002 internal_end
= internal
+ bfd_get_symcount(abfd
);
3004 raw_size
= bfd_get_symcount(abfd
) * SYMESZ
;
3005 raw
= (SYMENT
*)bfd_alloc(abfd
,raw_size
);
3007 if (bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
) == -1
3008 || bfd_read((PTR
)raw
, raw_size
, 1, abfd
) != raw_size
) {
3009 bfd_error
= system_call_error
;
3012 /* mark the end of the symbols */
3013 raw_end
= raw
+ bfd_get_symcount(abfd
);
3015 FIXME SOMEDAY. A string table size of zero is very weird, but
3016 probably possible. If one shows up, it will probably kill us.
3019 /* Swap all the raw entries */
3020 for (raw_src
= raw
, internal_ptr
= internal
;
3022 raw_src
++, internal_ptr
++) {
3025 coff_swap_sym_in(abfd
, (PTR
)raw_src
, (PTR
)&internal_ptr
->u
.syment
);
3026 internal_ptr
->fix_tag
= 0;
3027 internal_ptr
->fix_end
= 0;
3028 symbol_ptr
= internal_ptr
;
3031 i
< symbol_ptr
->u
.syment
.n_numaux
;
3037 internal_ptr
->fix_tag
= 0;
3038 internal_ptr
->fix_end
= 0;
3039 coff_swap_aux_in(abfd
, (char *)(raw_src
),
3040 symbol_ptr
->u
.syment
.n_type
,
3041 symbol_ptr
->u
.syment
.n_sclass
,
3042 &(internal_ptr
->u
.auxent
));
3043 /* Remember that bal entries arn't pointerized */
3044 if (i
!= 1 || symbol_ptr
->u
.syment
.n_sclass
!= C_LEAFPROC
)
3047 coff_pointerize_aux(abfd
,
3049 symbol_ptr
->u
.syment
.n_type
,
3050 symbol_ptr
->u
.syment
.n_sclass
,
3057 /* Free all the raw stuff */
3058 bfd_release(abfd
, raw
);
3060 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
3063 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
) {
3064 /* make a file symbol point to the name in the auxent, since
3065 the text ".file" is redundant */
3066 if ((internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_zeroes
== 0) {
3067 /* the filename is a long one, point into the string table */
3068 if (string_table
== NULL
) {
3069 string_table
= build_string_table(abfd
);
3072 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
3073 (int) (string_table
- 4 +
3074 (internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_offset
);
3077 /* ordinary short filename, put into memory anyway */
3078 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
3079 copy_name(abfd
, (internal_ptr
+1)->u
.auxent
.x_file
.x_fname
,
3084 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0) {
3085 /* This is a "short" name. Make it long. */
3086 unsigned long i
= 0;
3087 char *newstring
= NULL
;
3089 /* find the length of this string without walking into memory
3091 for (i
= 0; i
< 8; ++i
) {
3092 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0') {
3094 } /* if end of string */
3095 } /* possible lengths of this string. */
3097 if ((newstring
= (PTR
) bfd_alloc(abfd
, ++i
)) == NULL
) {
3098 bfd_error
= no_memory
;
3101 memset(newstring
, 0, i
);
3102 strncpy(newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
-1);
3103 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int) newstring
;
3104 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
3106 else if (!SYMNAME_IN_DEBUG(&internal_ptr
->u
.syment
)) {
3107 /* Long name already. Point symbol at the string in the table. */
3108 if (string_table
== NULL
) {
3109 string_table
= build_string_table(abfd
);
3111 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
3112 (string_table
- 4 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
3115 /* Long name in debug section. Very similar. */
3116 if (debug_section
== NULL
) {
3117 debug_section
= build_debug_section(abfd
);
3119 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
3120 (debug_section
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
3123 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
3126 obj_raw_syments(abfd
) = internal
;
3129 } /* get_normalized_symtab() */
3131 #endif /* NO_COFF_SYMBOLS */
3135 DEFUN(section_from_bfd_index
,(abfd
, index
),
3139 struct sec
*answer
= abfd
->sections
;
3143 return &bfd_abs_section
;
3145 if (index
== N_UNDEF
)
3147 return &bfd_und_section
;
3149 if(index
== N_DEBUG
)
3151 return &bfd_debug_section
;
3156 if (answer
->target_index
== index
)
3158 answer
= answer
->next
;
3161 return &bfd_und_section
; /* For gcc -W and lint. Never executed. */
3164 #ifndef NO_COFF_LINENOS
3170 Creating the linenumber table is done by reading in the entire
3171 coff linenumber table, and creating another table for internal use.
3173 A coff line number table is structured so that each function
3174 is marked as having a line number of 0. Each line within the
3175 function is an offset from the first line in the function. The
3176 base of the line number information for the table is stored in
3177 the symbol associated with the function.
3179 The information is copied from the external to the internal
3180 table, and each symbol which marks a function is marked by
3183 How does this work ?
3188 coff_slurp_line_table(abfd
, asect
)
3192 LINENO
*native_lineno
;
3193 alent
*lineno_cache
;
3195 BFD_ASSERT(asect
->lineno
== (alent
*) NULL
);
3197 native_lineno
= (LINENO
*) buy_and_read(abfd
,
3198 asect
->line_filepos
,
3201 asect
->lineno_count
));
3203 (alent
*) bfd_alloc(abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof(alent
)));
3204 if (lineno_cache
== NULL
) {
3205 bfd_error
= no_memory
;
3208 unsigned int counter
= 0;
3209 alent
*cache_ptr
= lineno_cache
;
3210 LINENO
*src
= native_lineno
;
3212 while (counter
< asect
->lineno_count
) {
3213 struct internal_lineno dst
;
3214 coff_swap_lineno_in(abfd
, src
, &dst
);
3215 cache_ptr
->line_number
= dst
.l_lnno
;
3217 if (cache_ptr
->line_number
== 0) {
3218 coff_symbol_type
*sym
=
3219 (coff_symbol_type
*) (dst
.l_addr
.l_symndx
3220 + obj_raw_syments(abfd
))->u
.syment
._n
._n_n
._n_zeroes
;
3221 cache_ptr
->u
.sym
= (asymbol
*) sym
;
3222 sym
->lineno
= cache_ptr
;
3225 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
3226 - bfd_section_vma(abfd
, asect
);
3227 } /* If no linenumber expect a symbol index */
3233 cache_ptr
->line_number
= 0;
3236 asect
->lineno
= lineno_cache
;
3237 /* FIXME, free native_lineno here, or use alloca or something. */
3239 } /* coff_slurp_line_table() */
3241 #endif /* NO_COFF_LINENOS */
3243 #ifndef NO_COFF_LINENOS
3246 DEFUN(coff_slurp_symbol_table
,(abfd
),
3249 combined_entry_type
*native_symbols
;
3250 coff_symbol_type
*cached_area
;
3251 unsigned int *table_ptr
;
3253 unsigned int number_of_symbols
= 0;
3254 if (obj_symbols(abfd
))
3256 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
3258 /* Read in the symbol table */
3259 if ((native_symbols
= get_normalized_symtab(abfd
)) == NULL
) {
3263 /* Allocate enough room for all the symbols in cached form */
3265 (coff_symbol_type
*)
3266 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(coff_symbol_type
)));
3268 if (cached_area
== NULL
) {
3269 bfd_error
= no_memory
;
3274 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(unsigned int)));
3276 if (table_ptr
== NULL
) {
3277 bfd_error
= no_memory
;
3282 coff_symbol_type
*dst
= cached_area
;
3283 unsigned int last_native_index
= bfd_get_symcount(abfd
);
3284 unsigned int this_index
= 0;
3285 while (this_index
< last_native_index
) {
3286 combined_entry_type
*src
= native_symbols
+ this_index
;
3287 table_ptr
[this_index
] = number_of_symbols
;
3288 dst
->symbol
.the_bfd
= abfd
;
3290 dst
->symbol
.name
= (char *)(src
->u
.syment
._n
._n_n
._n_offset
);
3292 We use the native name field to point to the cached field
3294 src
->u
.syment
._n
._n_n
._n_zeroes
= (int) dst
;
3295 dst
->symbol
.section
= section_from_bfd_index(abfd
,
3296 src
->u
.syment
.n_scnum
);
3297 dst
->symbol
.flags
= 0;
3298 dst
->done_lineno
= false;
3300 switch (src
->u
.syment
.n_sclass
) {
3304 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
3305 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
3306 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
3308 /* Fall through to next case */
3316 if ((src
->u
.syment
.n_scnum
) == 0) {
3317 if ((src
->u
.syment
.n_value
) == 0) {
3318 dst
->symbol
.section
= &bfd_und_section
;
3319 dst
->symbol
.value
= 0;
3322 dst
->symbol
.section
= &bfd_com_section
;
3323 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3328 Base the value as an index from the base of the
3332 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
3333 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
3335 if (ISFCN((src
->u
.syment
.n_type
))) {
3337 A function ext does not go at the end of a file
3339 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
3346 case C_STAT
: /* static */
3348 case C_LEAFSTAT
: /* static leaf procedure */
3350 case C_LABEL
: /* label */
3351 if (src
->u
.syment
.n_scnum
== -2)
3352 dst
->symbol
.flags
= BSF_DEBUGGING
;
3354 dst
->symbol
.flags
= BSF_LOCAL
;
3356 Base the value as an index from the base of the section, if
3359 if (dst
->symbol
.section
)
3360 dst
->symbol
.value
= (src
->u
.syment
.n_value
) -
3361 dst
->symbol
.section
->vma
;
3363 dst
->symbol
.value
= (src
->u
.syment
.n_value
) ;
3366 case C_MOS
: /* member of structure */
3367 case C_EOS
: /* end of structure */
3368 #ifdef NOTDEF /* C_AUTOARG has the same value */
3370 case C_GLBLREG
: /* A29k-specific storage class */
3373 case C_REGPARM
: /* register parameter */
3374 case C_REG
: /* register variable */
3376 case C_AUTOARG
: /* 960-specific storage class */
3378 case C_TPDEF
: /* type definition */
3380 case C_AUTO
: /* automatic variable */
3381 case C_FIELD
: /* bit field */
3382 case C_ENTAG
: /* enumeration tag */
3383 case C_MOE
: /* member of enumeration */
3384 case C_MOU
: /* member of union */
3385 case C_UNTAG
: /* union tag */
3386 dst
->symbol
.flags
= BSF_DEBUGGING
;
3387 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3390 case C_FILE
: /* file name */
3391 case C_STRTAG
: /* structure tag */
3393 case C_BINCL
: /* beginning of include file */
3394 case C_EINCL
: /* ending of include file */
3407 dst
->symbol
.flags
= BSF_DEBUGGING
;
3408 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3411 case C_BLOCK
: /* ".bb" or ".eb" */
3412 case C_FCN
: /* ".bf" or ".ef" */
3413 case C_EFCN
: /* physical end of function */
3414 dst
->symbol
.flags
= BSF_LOCAL
;
3416 Base the value as an index from the base of the section
3418 dst
->symbol
.value
= (src
->u
.syment
.n_value
) - dst
->symbol
.section
->vma
;
3422 case C_EXTDEF
: /* external definition */
3423 case C_ULABEL
: /* undefined label */
3424 case C_USTATIC
: /* undefined static */
3425 case C_LINE
: /* line # reformatted as symbol table entry */
3426 case C_ALIAS
: /* duplicate tag */
3427 case C_HIDDEN
: /* ext symbol in dmert public lib */
3430 fprintf(stderr
,"Unrecognized storage class %d\n",
3431 src
->u
.syment
.n_sclass
);
3433 dst
->symbol
.flags
= BSF_DEBUGGING
;
3434 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3438 /* BFD_ASSERT(dst->symbol.flags != 0);*/
3442 dst
->symbol
.udata
= 0;
3443 dst
->lineno
= (alent
*) NULL
;
3444 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
3446 number_of_symbols
++;
3447 } /* walk the native symtab */
3448 } /* bfdize the native symtab */
3450 obj_symbols(abfd
) = cached_area
;
3451 obj_raw_syments(abfd
) = native_symbols
;
3453 obj_conv_table_size (abfd
) = bfd_get_symcount (abfd
);
3454 bfd_get_symcount(abfd
) = number_of_symbols
;
3455 obj_convert(abfd
) = table_ptr
;
3456 /* Slurp the line tables for each section too */
3461 coff_slurp_line_table(abfd
, p
);
3466 } /* coff_slurp_symbol_table() */
3469 coff_get_symtab_upper_bound(abfd
)
3472 if (!coff_slurp_symbol_table(abfd
))
3475 return (bfd_get_symcount(abfd
) + 1) * (sizeof(coff_symbol_type
*));
3480 DEFUN(coff_get_symtab
, (abfd
, alocation
),
3482 asymbol
**alocation
)
3484 unsigned int counter
= 0;
3485 coff_symbol_type
*symbase
;
3486 coff_symbol_type
**location
= (coff_symbol_type
**) (alocation
);
3487 if (!coff_slurp_symbol_table(abfd
))
3490 symbase
= obj_symbols(abfd
);
3491 while (counter
< bfd_get_symcount(abfd
))
3493 /* This nasty code looks at the symbol to decide whether or
3494 not it is descibes a constructor/destructor entry point. It
3495 is structured this way to (hopefully) speed non matches */
3497 if (0 && symbase
->symbol
.name
[9] == '$')
3499 bfd_constructor_entry(abfd
,
3500 (asymbol
**)location
,
3501 symbase
->symbol
.name
[10] == 'I' ?
3505 *(location
++) = symbase
++;
3509 return bfd_get_symcount(abfd
);
3512 #endif /* NO_COFF_SYMBOLS */
3515 coff_get_reloc_upper_bound(abfd
, asect
)
3519 if (bfd_get_format(abfd
) != bfd_object
) {
3520 bfd_error
= invalid_operation
;
3523 return (asect
->reloc_count
+ 1) * sizeof(arelent
*);
3530 Coff relocations are easily transformed into the internal BFD form
3533 Reading a coff relocation table is done in the following stages:
3535 o The entire coff relocation table is read into memory.
3537 o Each relocation is processed in turn, first it is swapped from the
3538 external to the internal form.
3540 o The symbol referenced in the relocation's symbol index is
3541 turned intoa pointer into the canonical symbol table. Note
3542 that this table is the same as the one returned by a call to
3543 @code{bfd_canonicalize_symtab}. The back end will call the
3544 routine and save the result if a canonicalization hasn't been done.
3546 o The reloc index is turned into a pointer to a howto
3547 structure, in a back end specific way. For instance, the 386
3548 and 960 use the @code{r_type} to directly produce an index
3549 into a howto table vector; the 88k subtracts a number from the
3550 @code{r_type} field and creates an addend field.
3556 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
3557 if (ptr && ptr->the_bfd == abfd \
3558 && ((ptr->flags & BSF_OLD_COMMON)== 0)) \
3560 cache_ptr->addend = -(ptr->section->vma + ptr->value); \
3563 cache_ptr->addend = 0; \
3568 DEFUN(coff_slurp_reloc_table
,(abfd
, asect
, symbols
),
3573 RELOC
*native_relocs
;
3574 arelent
*reloc_cache
;
3579 if (asect
->relocation
)
3581 if (asect
->reloc_count
== 0)
3583 if (asect
->flags
& SEC_CONSTRUCTOR
)
3585 #ifndef NO_COFF_SYMBOLS
3586 if (!coff_slurp_symbol_table(abfd
))
3590 (RELOC
*) buy_and_read(abfd
,
3594 asect
->reloc_count
));
3595 reloc_cache
= (arelent
*)
3596 bfd_alloc(abfd
, (size_t) (asect
->reloc_count
* sizeof(arelent
)));
3598 if (reloc_cache
== NULL
) {
3599 bfd_error
= no_memory
;
3604 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
3606 #ifdef RELOC_PROCESSING
3607 struct internal_reloc dst
;
3608 struct external_reloc
*src
;
3610 cache_ptr
= reloc_cache
+ idx
;
3611 src
= native_relocs
+ idx
;
3612 bfd_swap_reloc_in(abfd
, src
, &dst
);
3614 RELOC_PROCESSING(cache_ptr
, &dst
, symbols
, abfd
, asect
);
3616 struct internal_reloc dst
;
3618 struct external_reloc
*src
;
3620 cache_ptr
= reloc_cache
+ idx
;
3621 src
= native_relocs
+ idx
;
3623 bfd_swap_reloc_in(abfd
, src
, &dst
);
3626 cache_ptr
->address
= dst
.r_vaddr
;
3628 if (dst
.r_symndx
!= -1)
3630 /* @@ Should never be greater than count of symbols! */
3631 if (dst
.r_symndx
>= obj_conv_table_size (abfd
))
3633 cache_ptr
->sym_ptr_ptr
= symbols
+ obj_convert(abfd
)[dst
.r_symndx
];
3634 ptr
= *(cache_ptr
->sym_ptr_ptr
);
3638 cache_ptr
->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
3643 The symbols definitions that we have read in have been
3644 relocated as if their sections started at 0. But the offsets
3645 refering to the symbols in the raw data have not been
3646 modified, so we have to have a negative addend to compensate.
3648 Note that symbols which used to be common must be left alone */
3650 /* Calculate any reloc addend by looking at the symbol */
3651 CALC_ADDEND(abfd
, ptr
, dst
, cache_ptr
);
3653 cache_ptr
->address
-= asect
->vma
;
3654 /* !! cache_ptr->section = (asection *) NULL;*/
3656 /* Fill in the cache_ptr->howto field from dst.r_type */
3657 RTYPE2HOWTO(cache_ptr
, &dst
);
3662 asect
->relocation
= reloc_cache
;
3667 /* This is stupid. This function should be a boolean predicate */
3669 DEFUN(coff_canonicalize_reloc
, (abfd
, section
, relptr
, symbols
),
3672 arelent
**relptr AND
3675 arelent
*tblptr
= section
->relocation
;
3676 unsigned int count
= 0;
3679 if (section
->flags
& SEC_CONSTRUCTOR
)
3681 /* this section has relocs made up by us, they are not in the
3682 file, so take them out of their chain and place them into
3683 the data area provided */
3684 arelent_chain
*chain
= section
->constructor_chain
;
3685 for (count
= 0; count
< section
->reloc_count
; count
++)
3687 *relptr
++ = &chain
->relent
;
3688 chain
= chain
->next
;
3694 coff_slurp_reloc_table(abfd
, section
, symbols
);
3697 tblptr
= section
->relocation
;
3701 for (; count
++ < section
->reloc_count
;)
3702 *relptr
++ = tblptr
++;
3707 return section
->reloc_count
;
3710 #ifndef NO_COFF_SYMBOLS
3713 provided a BFD, a section and an offset into the section, calculate and
3714 return the name of the source file and the line nearest to the wanted
3719 DEFUN(coff_find_nearest_line
,(abfd
,
3727 asection
*section AND
3728 asymbol
**ignore_symbols AND
3730 CONST
char **filename_ptr AND
3731 CONST
char **functionname_ptr AND
3732 unsigned int *line_ptr
)
3734 static bfd
*cache_abfd
;
3735 static asection
*cache_section
;
3736 static bfd_vma cache_offset
;
3737 static unsigned int cache_i
;
3738 static alent
*cache_l
;
3741 coff_data_type
*cof
= coff_data(abfd
);
3742 /* Run through the raw syments if available */
3743 combined_entry_type
*p
;
3745 unsigned int line_base
= 0;
3749 *functionname_ptr
= 0;
3752 /* Don't try and find line numbers in a non coff file */
3753 if (abfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
3759 p
= cof
->raw_syments
;
3761 for (i
= 0; i
< cof
->raw_syment_count
; i
++) {
3762 if (p
->u
.syment
.n_sclass
== C_FILE
) {
3763 /* File name has been moved into symbol */
3764 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
3767 p
+= 1 + p
->u
.syment
.n_numaux
;
3769 /* Now wander though the raw linenumbers of the section */
3771 If this is the same BFD as we were previously called with and this is
3772 the same section, and the offset we want is further down then we can
3773 prime the lookup loop
3775 if (abfd
== cache_abfd
&&
3776 section
== cache_section
&&
3777 offset
>= cache_offset
) {
3783 l
= section
->lineno
;
3786 for (; i
< section
->lineno_count
; i
++) {
3787 if (l
->line_number
== 0) {
3788 /* Get the symbol this line number points at */
3789 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
3790 *functionname_ptr
= coff
->symbol
.name
;
3792 combined_entry_type
*s
= coff
->native
;
3793 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
3795 S should now point to the .bf of the function
3797 if (s
->u
.syment
.n_numaux
) {
3799 The linenumber is stored in the auxent
3801 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
3802 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
3807 if (l
->u
.offset
> offset
)
3809 *line_ptr
= l
->line_number
+ line_base
+ 1;
3815 cache_section
= section
;
3816 cache_offset
= offset
;
3825 coff_sym_filepos(abfd
)
3828 return obj_sym_filepos(abfd
);
3832 #endif /* NO_COFF_SYMBOLS */
3836 DEFUN(coff_sizeof_headers
,(abfd
, reloc
),
3842 if (reloc
== false) {
3843 size
= FILHSZ
+ AOUTSZ
;
3849 size
+= abfd
->section_count
* SCNHSZ
;
3854 DEFUN(get_value
,(reloc
, seclet
),
3856 bfd_seclet_type
*seclet
)
3859 asymbol
*symbol
= *(reloc
->sym_ptr_ptr
);
3860 /* A symbol holds a pointer to a section, and an offset from the
3861 base of the section. To relocate, we find where the section will
3862 live in the output and add that in */
3864 if (symbol
->section
== &bfd_und_section
)
3866 /* Ouch, this is an undefined symbol.. */
3867 bfd_error_vector
.undefined_symbol(reloc
, seclet
);
3868 value
= symbol
->value
;
3872 value
= symbol
->value
+
3873 symbol
->section
->output_offset
+
3874 symbol
->section
->output_section
->vma
;
3878 /* Add the value contained in the relocation */
3879 value
+= (short)((reloc
->addend
) & 0xffff);
3885 DEFUN(perform_slip
,(s
, slip
, input_section
, value
),
3887 unsigned int slip AND
3888 asection
*input_section AND
3892 /* Find all symbols past this point, and make them know
3897 if (p
->section
== input_section
)
3899 /* This was pointing into this section, so mangle it */
3900 if (p
->value
> value
)
3910 DEFUN(movb1
,(input_section
, symbols
, r
, shrink
),
3911 asection
*input_section AND
3912 asymbol
**symbols AND
3914 unsigned int shrink
)
3916 bfd_vma value
= get_value(r
,0);
3918 if (value
>= 0xff00)
3921 /* Change the reloc type from 16bit, possible 8 to 8bit
3923 r
->howto
= r
->howto
+ 1;
3924 /* The place to relc moves back by one */
3927 /* This will be two bytes smaller in the long run */
3929 perform_slip(symbols
, 2, input_section
, r
->address
- shrink
+1);
3937 DEFUN(jmp1
,(input_section
, symbols
, r
, shrink
),
3938 asection
*input_section AND
3939 asymbol
**symbols AND
3941 unsigned int shrink
)
3945 bfd_vma value
= get_value(r
, 0);
3947 bfd_vma dot
= input_section
->output_section
->vma
+
3948 input_section
->output_offset
+ r
->address
;
3951 /* See if the address we're looking at within 127 bytes of where
3952 we are, if so then we can use a small branch rather than the
3953 jump we were going to */
3955 gap
= value
- (dot
- shrink
);
3958 if (-120 < (long)gap
&& (long)gap
< 120 )
3961 /* Change the reloc type from 16bit, possible 8 to 8bit
3963 r
->howto
= r
->howto
+ 1;
3964 /* The place to relc moves back by one */
3967 /* This will be two bytes smaller in the long run */
3969 perform_slip(symbols
, 2, input_section
, r
->address
-shrink
+1);
3977 DEFUN(bfd_coff_relax_section
,(abfd
, i
, symbols
),
3983 /* Get enough memory to hold the stuff */
3984 bfd
*input_bfd
= i
->owner
;
3985 asection
*input_section
= i
;
3987 boolean
new = false;
3989 bfd_size_type reloc_size
= bfd_get_reloc_upper_bound(input_bfd
,
3991 arelent
**reloc_vector
= (arelent
**)bfd_xmalloc(reloc_size
);
3993 /* Get the relocs and think about them */
3994 if (bfd_canonicalize_reloc(input_bfd
,
4000 for (parent
= reloc_vector
; *parent
; parent
++)
4002 arelent
*r
= *parent
;
4003 switch (r
->howto
->type
) {
4011 shrink
= movb1(input_section
, symbols
, r
, shrink
);
4016 shrink
= jmp1(input_section
, symbols
, r
, shrink
);
4024 input_section
->_cooked_size
-= shrink
;
4025 free((char *)reloc_vector
);
4030 DEFUN(bfd_coff_get_relocated_section_contents
,(in_abfd
, seclet
, data
),
4032 bfd_seclet_type
*seclet AND
4036 /* Get enough memory to hold the stuff */
4037 bfd
*input_bfd
= seclet
->u
.indirect
.section
->owner
;
4038 asection
*input_section
= seclet
->u
.indirect
.section
;
4039 bfd_size_type reloc_size
= bfd_get_reloc_upper_bound(input_bfd
,
4041 arelent
**reloc_vector
= (arelent
**)bfd_xmalloc(reloc_size
);
4043 /* read in the section */
4044 bfd_get_section_contents(input_bfd
,
4048 input_section
->_raw_size
);
4051 if (bfd_canonicalize_reloc(input_bfd
,
4054 seclet
->u
.indirect
.symbols
) )
4056 arelent
**parent
= reloc_vector
;
4061 unsigned int dst_address
= 0;
4062 unsigned int src_address
= 0;
4066 /* Find how long a run we can do */
4067 while (dst_address
< seclet
->size
)
4073 /* Note that the relaxing didn't tie up the addresses in the
4074 relocation, so we use the original address to work out the
4075 run of non-relocated data */
4076 run
= reloc
->address
- src_address
;
4082 run
= seclet
->size
- dst_address
;
4084 /* Copy the bytes */
4085 for (idx
= 0; idx
< run
; idx
++)
4087 data
[dst_address
++] = data
[src_address
++];
4090 /* Now do the relocation */
4094 switch (reloc
->howto
->type
)
4097 /* Speciial relaxed type */
4099 bfd_vma dot
= seclet
->offset
+ dst_address
+ seclet
->u
.indirect
.section
->output_section
->vma
;
4100 int gap
= get_value(reloc
,seclet
)-dot
-1;
4101 if ((gap
& ~0xff ) != 0 &&((gap
& 0xff00)!= 0xff00)) abort();
4103 bfd_put_8(in_abfd
,gap
, data
+dst_address
);
4105 switch (data
[dst_address
-1])
4110 bfd_put_8(in_abfd
, 0x55, data
+dst_address
-1);
4114 bfd_put_8(in_abfd
, 0x40, data
+dst_address
-1);
4133 /* Special relaxed type, there will be a gap between where we
4134 get stuff from and where we put stuff to now
4136 for a mov.b @aa:16 -> mov.b @aa:8
4137 opcode 0x6a 0x0y offset
4140 if (data
[dst_address
-1] != 0x6a)
4142 switch (data
[src_address
] & 0xf0)
4146 data
[dst_address
-1] = (data
[src_address
] & 0xf) | 0x20;
4150 data
[dst_address
-1] = (data
[src_address
] & 0xf) | 0x30;
4156 /* the offset must fit ! after all, what was all the relaxing
4159 bfd_put_8(in_abfd
, get_value(reloc
, seclet
), data
+ dst_address
);
4161 /* Note the magic - src goes up by two bytes, but dst by only
4170 bfd_vma dot
= seclet
->offset
+ dst_address
+ seclet
->u
.indirect
.section
->output_section
->vma
;
4171 int gap
= get_value(reloc
,seclet
)-dot
;
4172 if (gap
> 127 || gap
< -128)
4174 bfd_error_vector
.reloc_value_truncated(reloc
, seclet
);
4177 bfd_put_8(in_abfd
,gap
, data
+dst_address
);
4186 unsigned int gap
=get_value(reloc
,seclet
);
4187 if (gap
> 0xff && gap
< ~0xff)
4189 bfd_error_vector
.reloc_value_truncated(reloc
, seclet
);
4192 bfd_put_8(in_abfd
, gap
, data
+dst_address
);
4200 /* A relword which would have like to have been a pcrel */
4202 /* A relword which would like to have been modified but
4205 bfd_put_16(in_abfd
, get_value(reloc
,seclet
), data
+dst_address
);
4220 free((char *)reloc_vector
);
4226 #define coff_core_file_failing_command _bfd_dummy_core_file_failing_command
4227 #define coff_core_file_failing_signal _bfd_dummy_core_file_failing_signal
4228 #define coff_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
4229 #define coff_slurp_armap bfd_slurp_coff_armap
4230 #define coff_slurp_extended_name_table _bfd_slurp_extended_name_table
4231 #define coff_truncate_arname bfd_dont_truncate_arname
4232 #define coff_openr_next_archived_file bfd_generic_openr_next_archived_file
4233 #define coff_generic_stat_arch_elt bfd_generic_stat_arch_elt
4234 #define coff_get_section_contents bfd_generic_get_section_contents
4235 #define coff_close_and_cleanup bfd_generic_close_and_cleanup
4237 #define coff_bfd_debug_info_start bfd_void
4238 #define coff_bfd_debug_info_end bfd_void
4239 #define coff_bfd_debug_info_accumulate (PROTO(void,(*),(bfd*, struct sec *))) bfd_void
4240 #define coff_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
4241 #define coff_bfd_relax_section bfd_generic_relax_section