1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright (C) 1990-1991 Free Software Foundation, Inc.
3 Written by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
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
);
346 } else if (!strcmp(sec_name
, _BSS
)) {
347 return((long)STYP_BSS
);
349 } else if (!strcmp(sec_name
, _COMMENT
)) {
350 return((long)STYP_INFO
);
351 #endif /* _COMMENT */
354 /* Try and figure out what it should be */
355 if (sec_flags
& SEC_CODE
) styp_flags
= STYP_TEXT
;
356 if (sec_flags
& SEC_DATA
) styp_flags
= STYP_DATA
;
357 else if (sec_flags
& SEC_READONLY
)
358 #ifdef STYP_LIT /* 29k readonly text/data section */
359 styp_flags
= STYP_LIT
;
361 styp_flags
= STYP_TEXT
;
362 #endif /* STYP_LIT */
363 else if (sec_flags
& SEC_LOAD
) styp_flags
= STYP_TEXT
;
365 if (styp_flags
== 0) styp_flags
= STYP_BSS
;
370 * Return a word with SEC_* flags set to represent the incoming
371 * STYP_* flags (from scnhdr.s_flags). The inverse of this
372 * function is sec_to_styp_flags().
373 * NOTE: If you add to/change this routine, you should mirror the changes
374 * in sec_to_styp_flags().
377 DEFUN(styp_to_sec_flags
, (styp_flags
),
380 flagword sec_flags
=0;
382 if ((styp_flags
& STYP_TEXT
) || (styp_flags
& STYP_DATA
))
384 sec_flags
= SEC_LOAD
| SEC_ALLOC
;
386 else if (styp_flags
& STYP_BSS
)
388 sec_flags
= SEC_ALLOC
;
390 else if (styp_flags
& STYP_INFO
)
392 sec_flags
= SEC_NEVER_LOAD
;
396 sec_flags
= SEC_ALLOC
| SEC_LOAD
;
398 #ifdef STYP_LIT /* A29k readonly text/data section type */
399 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
401 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
403 #endif /* STYP_LIT */
404 #ifdef STYP_OTHER_LOAD /* Other loaded sections */
405 if (styp_flags
& STYP_OTHER_LOAD
)
407 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
409 #endif /* STYP_SDATA */
414 #define get_index(symbol) ((int) (symbol)->udata)
415 #define set_index(symbol, idx) ((symbol)->udata =(PTR) (idx))
417 /* **********************************************************************
418 Here are all the routines for swapping the structures seen in the
419 outside world into the internal forms.
424 DEFUN(bfd_swap_reloc_in
,(abfd
, reloc_src
, reloc_dst
),
427 struct internal_reloc
*reloc_dst
)
429 reloc_dst
->r_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*)reloc_src
->r_vaddr
);
430 reloc_dst
->r_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) reloc_src
->r_symndx
);
433 reloc_dst
->r_type
= bfd_h_get_8(abfd
, reloc_src
->r_type
);
434 reloc_dst
->r_size
= bfd_h_get_8(abfd
, reloc_src
->r_size
);
436 reloc_dst
->r_type
= bfd_h_get_16(abfd
, (bfd_byte
*) reloc_src
->r_type
);
439 #ifdef SWAP_IN_RELOC_OFFSET
440 reloc_dst
->r_offset
= SWAP_IN_RELOC_OFFSET(abfd
,
441 (bfd_byte
*) reloc_src
->r_offset
);
447 DEFUN(coff_swap_reloc_out
,(abfd
, src
, dst
),
452 struct internal_reloc
*reloc_src
= (struct internal_reloc
*)src
;
453 struct external_reloc
*reloc_dst
= (struct external_reloc
*)dst
;
454 bfd_h_put_32(abfd
, reloc_src
->r_vaddr
, (bfd_byte
*) reloc_dst
->r_vaddr
);
455 bfd_h_put_32(abfd
, reloc_src
->r_symndx
, (bfd_byte
*) reloc_dst
->r_symndx
);
456 bfd_h_put_16(abfd
, reloc_src
->r_type
, (bfd_byte
*)
459 #ifdef SWAP_OUT_RELOC_OFFSET
460 SWAP_OUT_RELOC_OFFSET(abfd
,
462 (bfd_byte
*) reloc_dst
->r_offset
);
464 #ifdef SWAP_OUT_RELOC_EXTRA
465 SWAP_OUT_RELOC_EXTRA(abfd
,reloc_src
, reloc_dst
);
468 return sizeof(struct external_reloc
);
472 DEFUN(bfd_swap_filehdr_in
,(abfd
, filehdr_src
, filehdr_dst
),
474 FILHDR
*filehdr_src AND
475 struct internal_filehdr
*filehdr_dst
)
477 filehdr_dst
->f_magic
= bfd_h_get_16(abfd
, (bfd_byte
*) filehdr_src
->f_magic
);
478 filehdr_dst
->f_nscns
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_nscns
);
479 filehdr_dst
->f_timdat
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_timdat
);
480 filehdr_dst
->f_symptr
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_symptr
);
481 filehdr_dst
->f_nsyms
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_nsyms
);
482 filehdr_dst
->f_opthdr
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_opthdr
);
483 filehdr_dst
->f_flags
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_flags
);
487 DEFUN(coff_swap_filehdr_out
,(abfd
, in
, out
),
492 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*)in
;
493 FILHDR
*filehdr_out
= (FILHDR
*)out
;
494 bfd_h_put_16(abfd
, filehdr_in
->f_magic
, (bfd_byte
*) filehdr_out
->f_magic
);
495 bfd_h_put_16(abfd
, filehdr_in
->f_nscns
, (bfd_byte
*) filehdr_out
->f_nscns
);
496 bfd_h_put_32(abfd
, filehdr_in
->f_timdat
, (bfd_byte
*) filehdr_out
->f_timdat
);
497 bfd_h_put_32(abfd
, filehdr_in
->f_symptr
, (bfd_byte
*) filehdr_out
->f_symptr
);
498 bfd_h_put_32(abfd
, filehdr_in
->f_nsyms
, (bfd_byte
*) filehdr_out
->f_nsyms
);
499 bfd_h_put_16(abfd
, filehdr_in
->f_opthdr
, (bfd_byte
*) filehdr_out
->f_opthdr
);
500 bfd_h_put_16(abfd
, filehdr_in
->f_flags
, (bfd_byte
*) filehdr_out
->f_flags
);
501 return sizeof(FILHDR
);
505 #ifndef NO_COFF_SYMBOLS
508 DEFUN(coff_swap_sym_in
,(abfd
, ext1
, in1
),
513 SYMENT
*ext
= (SYMENT
*)ext1
;
514 struct internal_syment
*in
= (struct internal_syment
*)in1
;
516 if( ext
->e
.e_name
[0] == 0) {
517 in
->_n
._n_n
._n_zeroes
= 0;
518 in
->_n
._n_n
._n_offset
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e
.e
.e_offset
);
521 #if SYMNMLEN != E_SYMNMLEN
522 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
524 memcpy(in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
527 in
->n_value
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_value
);
528 in
->n_scnum
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_scnum
);
529 if (sizeof(ext
->e_type
) == 2){
530 in
->n_type
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_type
);
533 in
->n_type
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_type
);
535 in
->n_sclass
= bfd_h_get_8(abfd
, ext
->e_sclass
);
536 in
->n_numaux
= bfd_h_get_8(abfd
, ext
->e_numaux
);
540 DEFUN(coff_swap_sym_out
,(abfd
, inp
, extp
),
545 struct internal_syment
*in
= (struct internal_syment
*)inp
;
546 SYMENT
*ext
=(SYMENT
*)extp
;
547 if(in
->_n
._n_name
[0] == 0) {
548 bfd_h_put_32(abfd
, 0, (bfd_byte
*) ext
->e
.e
.e_zeroes
);
549 bfd_h_put_32(abfd
, in
->_n
._n_n
._n_offset
, (bfd_byte
*) ext
->e
.e
.e_offset
);
552 #if SYMNMLEN != E_SYMNMLEN
553 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
555 memcpy(ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
558 bfd_h_put_32(abfd
, in
->n_value
, (bfd_byte
*) ext
->e_value
);
559 bfd_h_put_16(abfd
, in
->n_scnum
, (bfd_byte
*) ext
->e_scnum
);
560 if (sizeof(ext
->e_type
) == 2)
562 bfd_h_put_16(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
566 bfd_h_put_32(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
568 bfd_h_put_8(abfd
, in
->n_sclass
, ext
->e_sclass
);
569 bfd_h_put_8(abfd
, in
->n_numaux
, ext
->e_numaux
);
570 return sizeof(SYMENT
);
574 DEFUN(coff_swap_aux_in
,(abfd
, ext1
, type
, class, in1
),
581 AUXENT
*ext
= (AUXENT
*)ext1
;
582 union internal_auxent
*in
= (union internal_auxent
*)in1
;
586 if (ext
->x_file
.x_fname
[0] == 0) {
587 in
->x_file
.x_n
.x_zeroes
= 0;
588 in
->x_file
.x_n
.x_offset
=
589 bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
591 #if FILNMLEN != E_FILNMLEN
592 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
594 memcpy (in
->x_file
.x_fname
, ext
->x_file
.x_fname
, FILNMLEN
);
599 /* RS/6000 "csect" auxents */
603 in
->x_csect
.x_scnlen
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_scnlen
);
604 in
->x_csect
.x_parmhash
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_parmhash
);
605 in
->x_csect
.x_snhash
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snhash
);
606 /* We don't have to hack bitfields in x_smtyp because it's defined by
607 shifts-and-ands, which are equivalent on all byte orders. */
608 in
->x_csect
.x_smtyp
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smtyp
);
609 in
->x_csect
.x_smclas
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smclas
);
610 in
->x_csect
.x_stab
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_stab
);
611 in
->x_csect
.x_snstab
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snstab
);
620 if (type
== T_NULL
) {
621 in
->x_scn
.x_scnlen
= GET_SCN_SCNLEN(abfd
, ext
);
622 in
->x_scn
.x_nreloc
= GET_SCN_NRELOC(abfd
, ext
);
623 in
->x_scn
.x_nlinno
= GET_SCN_NLINNO(abfd
, ext
);
627 in
->x_sym
.x_tagndx
.l
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
629 in
->x_sym
.x_tvndx
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
632 if (ISARY(type
) || class == C_BLOCK
) {
633 #if DIMNUM != E_DIMNUM
634 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
636 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]);
637 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]);
638 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]);
639 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]);
642 in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= GET_FCN_LNNOPTR(abfd
, ext
);
643 in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= GET_FCN_ENDNDX(abfd
, ext
);
646 in
->x_sym
.x_misc
.x_fsize
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
649 in
->x_sym
.x_misc
.x_lnsz
.x_lnno
= GET_LNSZ_LNNO(abfd
, ext
);
650 in
->x_sym
.x_misc
.x_lnsz
.x_size
= GET_LNSZ_SIZE(abfd
, ext
);
656 DEFUN(coff_swap_aux_out
,(abfd
, inp
, type
, class, extp
),
663 union internal_auxent
*in
= (union internal_auxent
*)inp
;
664 AUXENT
*ext
= (AUXENT
*)extp
;
667 if (in
->x_file
.x_fname
[0] == 0) {
668 PUTWORD(abfd
, 0, (bfd_byte
*) ext
->x_file
.x_n
.x_zeroes
);
670 in
->x_file
.x_n
.x_offset
,
671 (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
674 #if FILNMLEN != E_FILNMLEN
675 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
677 memcpy (ext
->x_file
.x_fname
, in
->x_file
.x_fname
, FILNMLEN
);
683 /* RS/6000 "csect" auxents */
686 PUTWORD (abfd
, in
->x_csect
.x_scnlen
, ext
->x_csect
.x_scnlen
);
687 PUTWORD (abfd
, in
->x_csect
.x_parmhash
, ext
->x_csect
.x_parmhash
);
688 PUTHALF (abfd
, in
->x_csect
.x_snhash
, ext
->x_csect
.x_snhash
);
689 /* We don't have to hack bitfields in x_smtyp because it's defined by
690 shifts-and-ands, which are equivalent on all byte orders. */
691 PUTBYTE (abfd
, in
->x_csect
.x_smtyp
, ext
->x_csect
.x_smtyp
);
692 PUTBYTE (abfd
, in
->x_csect
.x_smclas
, ext
->x_csect
.x_smclas
);
693 PUTWORD (abfd
, in
->x_csect
.x_stab
, ext
->x_csect
.x_stab
);
694 PUTHALF (abfd
, in
->x_csect
.x_snstab
, ext
->x_csect
.x_snstab
);
703 if (type
== T_NULL
) {
704 PUT_SCN_SCNLEN(abfd
, in
->x_scn
.x_scnlen
, ext
);
705 PUT_SCN_NRELOC(abfd
, in
->x_scn
.x_nreloc
, ext
);
706 PUT_SCN_NLINNO(abfd
, in
->x_scn
.x_nlinno
, ext
);
710 PUTWORD(abfd
, in
->x_sym
.x_tagndx
.l
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
712 bfd_h_put_16(abfd
, in
->x_sym
.x_tvndx
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
716 PUTWORD(abfd
, in
->x_sym
.x_misc
.x_fsize
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
717 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
718 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
722 if (ISARY(type
) || class == C_BLOCK
) {
723 #if DIMNUM != E_DIMNUM
724 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
726 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]);
727 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]);
728 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]);
729 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]);
732 PUT_LNSZ_LNNO(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
733 PUT_LNSZ_SIZE(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
735 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
736 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
741 return sizeof(AUXENT
);
744 #endif /* NO_COFF_SYMBOLS */
746 #ifndef NO_COFF_LINENOS
749 DEFUN(coff_swap_lineno_in
,(abfd
, ext1
, in1
),
754 LINENO
*ext
= (LINENO
*)ext1
;
755 struct internal_lineno
*in
= (struct internal_lineno
*)in1
;
757 in
->l_addr
.l_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->l_addr
.l_symndx
);
758 in
->l_lnno
= GET_LINENO_LNNO(abfd
, ext
);
762 DEFUN(coff_swap_lineno_out
,(abfd
, inp
, outp
),
767 struct internal_lineno
*in
= (struct internal_lineno
*)inp
;
768 struct external_lineno
*ext
= (struct external_lineno
*)outp
;
769 PUTWORD(abfd
, in
->l_addr
.l_symndx
, (bfd_byte
*)
770 ext
->l_addr
.l_symndx
);
772 PUT_LINENO_LNNO (abfd
, in
->l_lnno
, ext
);
773 return sizeof(struct external_lineno
);
776 #endif /* NO_COFF_LINENOS */
780 DEFUN(bfd_swap_aouthdr_in
,(abfd
, aouthdr_ext1
, aouthdr_int1
),
785 AOUTHDR
*aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
786 struct internal_aouthdr
*aouthdr_int
= (struct internal_aouthdr
*)aouthdr_int1
;
788 aouthdr_int
->magic
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->magic
);
789 aouthdr_int
->vstamp
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->vstamp
);
790 aouthdr_int
->tsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tsize
);
791 aouthdr_int
->dsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->dsize
);
792 aouthdr_int
->bsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->bsize
);
793 aouthdr_int
->entry
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->entry
);
794 aouthdr_int
->text_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->text_start
);
795 aouthdr_int
->data_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->data_start
);
797 aouthdr_int
->tagentries
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tagentries
);
801 aouthdr_int
->o_toc
= bfd_h_get_32(abfd
, aouthdr_ext
->o_toc
);
802 aouthdr_int
->o_snentry
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snentry
);
803 aouthdr_int
->o_sntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntext
);
804 aouthdr_int
->o_sndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sndata
);
805 aouthdr_int
->o_sntoc
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntoc
);
806 aouthdr_int
->o_snloader
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snloader
);
807 aouthdr_int
->o_snbss
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snbss
);
808 aouthdr_int
->o_algntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algntext
);
809 aouthdr_int
->o_algndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algndata
);
810 aouthdr_int
->o_modtype
= bfd_h_get_16(abfd
, aouthdr_ext
->o_modtype
);
811 aouthdr_int
->o_maxstack
= bfd_h_get_32(abfd
, aouthdr_ext
->o_maxstack
);
816 DEFUN(coff_swap_aouthdr_out
,(abfd
, in
, out
),
821 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*)in
;
822 AOUTHDR
*aouthdr_out
= (AOUTHDR
*)out
;
823 bfd_h_put_16(abfd
, aouthdr_in
->magic
, (bfd_byte
*) aouthdr_out
->magic
);
824 bfd_h_put_16(abfd
, aouthdr_in
->vstamp
, (bfd_byte
*) aouthdr_out
->vstamp
);
825 bfd_h_put_32(abfd
, aouthdr_in
->tsize
, (bfd_byte
*) aouthdr_out
->tsize
);
826 bfd_h_put_32(abfd
, aouthdr_in
->dsize
, (bfd_byte
*) aouthdr_out
->dsize
);
827 bfd_h_put_32(abfd
, aouthdr_in
->bsize
, (bfd_byte
*) aouthdr_out
->bsize
);
828 bfd_h_put_32(abfd
, aouthdr_in
->entry
, (bfd_byte
*) aouthdr_out
->entry
);
829 bfd_h_put_32(abfd
, aouthdr_in
->text_start
,
830 (bfd_byte
*) aouthdr_out
->text_start
);
831 bfd_h_put_32(abfd
, aouthdr_in
->data_start
, (bfd_byte
*) aouthdr_out
->data_start
);
833 bfd_h_put_32(abfd
, aouthdr_in
->tagentries
, (bfd_byte
*) aouthdr_out
->tagentries
);
835 return sizeof(AOUTHDR
);
839 DEFUN(coff_swap_scnhdr_in
,(abfd
, scnhdr_ext
, scnhdr_int
),
841 SCNHDR
*scnhdr_ext AND
842 struct internal_scnhdr
*scnhdr_int
)
844 memcpy(scnhdr_int
->s_name
, scnhdr_ext
->s_name
, sizeof(scnhdr_int
->s_name
));
845 scnhdr_int
->s_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
846 scnhdr_int
->s_paddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
847 scnhdr_int
->s_size
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_size
);
849 scnhdr_int
->s_scnptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
850 scnhdr_int
->s_relptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
851 scnhdr_int
->s_lnnoptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
852 scnhdr_int
->s_flags
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_flags
);
854 scnhdr_int
->s_nreloc
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
855 scnhdr_int
->s_nlnno
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
857 scnhdr_int
->s_nreloc
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
858 scnhdr_int
->s_nlnno
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
861 scnhdr_int
->s_align
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_align
);
866 DEFUN(coff_swap_scnhdr_out
,(abfd
, in
, out
),
871 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*)in
;
872 SCNHDR
*scnhdr_ext
= (SCNHDR
*)out
;
873 memcpy(scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof(scnhdr_int
->s_name
));
874 PUTWORD(abfd
, scnhdr_int
->s_vaddr
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
875 PUTWORD(abfd
, scnhdr_int
->s_paddr
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
876 PUTWORD(abfd
, scnhdr_int
->s_size
, (bfd_byte
*) scnhdr_ext
->s_size
);
877 PUTWORD(abfd
, scnhdr_int
->s_scnptr
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
878 PUTWORD(abfd
, scnhdr_int
->s_relptr
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
879 PUTWORD(abfd
, scnhdr_int
->s_lnnoptr
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
880 PUTWORD(abfd
, scnhdr_int
->s_flags
, (bfd_byte
*) scnhdr_ext
->s_flags
);
882 PUTWORD(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
883 PUTWORD(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
885 PUTHALF(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
886 PUTHALF(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
890 PUTWORD(abfd
, scnhdr_int
->s_align
, (bfd_byte
*) scnhdr_ext
->s_align
);
892 return sizeof(SCNHDR
);
897 initialize a section structure with information peculiar to this
898 particular implementation of coff
902 DEFUN(coff_new_section_hook
,(abfd
, section
),
906 section
->alignment_power
= abfd
->xvec
->align_power_min
;
907 /* Allocate aux records for section symbols, to store size and
910 @@ Shouldn't use constant multiplier here! */
911 coffsymbol (section
->symbol
)->native
=
912 (combined_entry_type
*) bfd_zalloc (abfd
,
913 sizeof (combined_entry_type
) * 10);
917 static asection bfd_debug_section
= { "*DEBUG*" };
919 /* Take a section header read from a coff file (in HOST byte order),
920 and make a BFD "section" out of it. */
922 DEFUN(make_a_section_from_file
,(abfd
, hdr
, target_index
),
924 struct internal_scnhdr
*hdr AND
925 unsigned int target_index
)
927 asection
*return_section
;
930 /* Assorted wastage to null-terminate the name, thanks AT&T! */
931 name
= bfd_alloc(abfd
, sizeof (hdr
->s_name
)+1);
933 bfd_error
= no_memory
;
936 strncpy(name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
937 name
[sizeof (hdr
->s_name
)] = 0;
939 return_section
= bfd_make_section(abfd
, name
);
940 if (return_section
== NULL
)
943 /* s_paddr is presumed to be = to s_vaddr */
945 return_section
->vma
= hdr
->s_vaddr
;
946 return_section
->_raw_size
= hdr
->s_size
;
947 return_section
->filepos
= hdr
->s_scnptr
;
948 return_section
->rel_filepos
= hdr
->s_relptr
;
949 return_section
->reloc_count
= hdr
->s_nreloc
;
952 /* FIXME, use a temp var rather than alignment_power */
953 return_section
->alignment_power
= hdr
->s_align
;
956 for (i
= 0; i
< 32; i
++) {
957 if ((1 << i
) >= (int) (return_section
->alignment_power
)) {
958 return_section
->alignment_power
= i
;
965 return_section
->line_filepos
= hdr
->s_lnnoptr
;
967 return_section->linesize = hdr->s_nlnno * sizeof (struct lineno);
970 return_section
->lineno_count
= hdr
->s_nlnno
;
971 return_section
->userdata
= NULL
;
972 return_section
->next
= (asection
*) NULL
;
973 return_section
->flags
= styp_to_sec_flags(hdr
->s_flags
);
975 return_section
->target_index
= target_index
;
977 if (hdr
->s_nreloc
!= 0)
978 return_section
->flags
|= SEC_RELOC
;
979 /* FIXME: should this check 'hdr->s_size > 0' */
980 if (hdr
->s_scnptr
!= 0)
981 return_section
->flags
|= SEC_HAS_CONTENTS
;
985 DEFUN(coff_mkobject
,(abfd
),
988 abfd
->tdata
.coff_obj_data
= (struct coff_tdata
*)bfd_zalloc (abfd
,sizeof(coff_data_type
));
989 if (abfd
->tdata
.coff_obj_data
== 0){
990 bfd_error
= no_memory
;
993 coff_data(abfd
)->relocbase
= 0;
994 /* make_abs_section(abfd);*/
1000 DEFUN(coff_real_object_p
,(abfd
, nscns
, internal_f
, internal_a
),
1003 struct internal_filehdr
*internal_f AND
1004 struct internal_aouthdr
*internal_a
)
1006 coff_data_type
*coff
;
1007 enum bfd_architecture arch
;
1009 size_t readsize
; /* length of file_info */
1010 SCNHDR
*external_sections
;
1012 /* Build a play area */
1013 if (coff_mkobject(abfd
) != true)
1016 coff
= coff_data(abfd
);
1019 external_sections
= (SCNHDR
*)bfd_alloc(abfd
, readsize
= (nscns
* SCNHSZ
));
1021 if (bfd_read((PTR
)external_sections
, 1, readsize
, abfd
) != readsize
) {
1026 /* Now copy data as required; construct all asections etc */
1027 coff
->symbol_index_slew
= 0;
1029 coff
->raw_syment_count
= 0;
1030 coff
->raw_linenos
= 0;
1031 coff
->raw_syments
= 0;
1032 coff
->sym_filepos
=0;
1033 coff
->flags
= internal_f
->f_flags
;
1036 for (i
= 0; i
< nscns
; i
++) {
1037 struct internal_scnhdr tmp
;
1038 coff_swap_scnhdr_in(abfd
, external_sections
+ i
, &tmp
);
1039 make_a_section_from_file(abfd
,&tmp
, i
+1);
1043 /* make_abs_section(abfd);*/
1045 /* Determine the machine architecture and type. */
1047 switch (internal_f
->f_magic
) {
1050 arch
= bfd_arch_i386
;
1055 #ifdef A29K_MAGIC_BIG
1056 case A29K_MAGIC_BIG
:
1057 case A29K_MAGIC_LITTLE
:
1058 arch
= bfd_arch_a29k
;
1067 arch
= bfd_arch_mips
;
1075 arch
= bfd_arch_m68k
;
1083 arch
= bfd_arch_m88k
;
1089 arch
= bfd_arch_z8k
;
1090 switch (internal_f
->f_flags
& F_MACHMASK
)
1093 machine
= bfd_mach_z8001
;
1096 machine
= bfd_mach_z8002
;
1107 arch
= bfd_arch_i960
;
1108 switch (F_I960TYPE
& internal_f
->f_flags
)
1112 machine
= bfd_mach_i960_core
;
1115 machine
= bfd_mach_i960_kb_sb
;
1118 machine
= bfd_mach_i960_mc
;
1121 machine
= bfd_mach_i960_xa
;
1124 machine
= bfd_mach_i960_ca
;
1127 machine
= bfd_mach_i960_ka_sa
;
1138 arch
= bfd_arch_rs6000
;
1145 arch
= bfd_arch_we32k
;
1152 arch
= bfd_arch_h8300
;
1157 default: /* Unreadable input file type */
1158 arch
= bfd_arch_obscure
;
1162 bfd_default_set_arch_mach(abfd
, arch
, machine
);
1163 if (!(internal_f
->f_flags
& F_RELFLG
))
1164 abfd
->flags
|= HAS_RELOC
;
1165 if ((internal_f
->f_flags
& F_EXEC
))
1166 abfd
->flags
|= EXEC_P
;
1167 if (!(internal_f
->f_flags
& F_LNNO
))
1168 abfd
->flags
|= HAS_LINENO
;
1169 if (!(internal_f
->f_flags
& F_LSYMS
))
1170 abfd
->flags
|= HAS_LOCALS
;
1173 bfd_get_symcount(abfd
) = internal_f
->f_nsyms
;
1174 if (internal_f
->f_nsyms
)
1175 abfd
->flags
|= HAS_SYMS
;
1177 coff
->sym_filepos
= internal_f
->f_symptr
;
1179 /* These members communicate important constants about the symbol table
1180 to GDB's symbol-reading code. These `constants' unfortunately vary
1181 from coff implementation to implementation... */
1182 #ifndef NO_COFF_SYMBOLS
1183 coff
->local_n_btmask
= N_BTMASK
;
1184 coff
->local_n_btshft
= N_BTSHFT
;
1185 coff
->local_n_tmask
= N_TMASK
;
1186 coff
->local_n_tshift
= N_TSHIFT
;
1187 coff
->local_symesz
= SYMESZ
;
1188 coff
->local_auxesz
= AUXESZ
;
1189 coff
->local_linesz
= LINESZ
;
1192 coff
->symbols
= (coff_symbol_type
*) NULL
;
1193 bfd_get_start_address(abfd
) = internal_f
->f_opthdr
? internal_a
->entry
: 0;
1197 bfd_release(abfd
, coff
);
1198 return (bfd_target
*)NULL
;
1202 DEFUN(coff_object_p
,(abfd
),
1208 struct internal_filehdr internal_f
;
1209 struct internal_aouthdr internal_a
;
1211 bfd_error
= system_call_error
;
1213 /* figure out how much to read */
1214 if (bfd_read((PTR
) &filehdr
, 1, FILHSZ
, abfd
) != FILHSZ
)
1217 bfd_swap_filehdr_in(abfd
, &filehdr
, &internal_f
);
1219 if (BADMAG(internal_f
)) {
1220 bfd_error
= wrong_format
;
1223 nscns
=internal_f
.f_nscns
;
1225 if (internal_f
.f_opthdr
) {
1226 if (bfd_read((PTR
) &opthdr
, 1,AOUTSZ
, abfd
) != AOUTSZ
) {
1229 bfd_swap_aouthdr_in(abfd
, (char *)&opthdr
, (char *)&internal_a
);
1232 /* Seek past the opt hdr stuff */
1233 bfd_seek(abfd
, internal_f
.f_opthdr
+ FILHSZ
, SEEK_SET
);
1235 /* if the optional header is NULL or not the correct size then
1236 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1237 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1238 optional header is of a different size.
1240 But the mips keeps extra stuff in it's opthdr, so dont check
1244 #if defined(M88) || defined(I960)
1245 if (internal_f
.f_opthdr
!= 0 && AOUTSZ
!= internal_f
.f_opthdr
)
1246 return (bfd_target
*)NULL
;
1249 return coff_real_object_p(abfd
, nscns
, &internal_f
, &internal_a
);
1254 #ifndef NO_COFF_LINENOS
1257 DEFUN(coff_count_linenumbers
,(abfd
),
1260 unsigned int limit
= bfd_get_symcount(abfd
);
1264 asection
*s
= abfd
->sections
->output_section
;
1266 BFD_ASSERT(s
->lineno_count
== 0);
1272 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++) {
1273 asymbol
*q_maybe
= *p
;
1274 if (q_maybe
->the_bfd
->xvec
->flavour
== bfd_target_coff_flavour
) {
1275 coff_symbol_type
*q
= coffsymbol(q_maybe
);
1278 This symbol has a linenumber, increment the owning
1279 section's linenumber count
1281 alent
*l
= q
->lineno
;
1282 q
->symbol
.section
->output_section
->lineno_count
++;
1284 while (l
->line_number
) {
1285 q
->symbol
.section
->output_section
->lineno_count
++;
1293 #endif /* NO_COFF_LINENOS */
1295 #ifndef NO_COFF_SYMBOLS
1298 Takes a bfd and a symbol, returns a pointer to the coff specific area
1299 of the symbol if there is one.
1301 static coff_symbol_type
*
1302 DEFUN(coff_symbol_from
,(ignore_abfd
, symbol
),
1303 bfd
*ignore_abfd AND
1306 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
1307 return (coff_symbol_type
*)NULL
;
1309 if (symbol
->the_bfd
->tdata
.coff_obj_data
== (coff_data_type
*)NULL
)
1310 return (coff_symbol_type
*)NULL
;
1312 return (coff_symbol_type
*) symbol
;
1318 DEFUN(fixup_symbol_value
,(coff_symbol_ptr
, syment
),
1319 coff_symbol_type
*coff_symbol_ptr AND
1320 struct internal_syment
*syment
)
1323 /* Normalize the symbol flags */
1324 if (coff_symbol_ptr
->symbol
.section
== &bfd_com_section
) {
1325 /* a common symbol is undefined with a value */
1326 syment
->n_scnum
= N_UNDEF
;
1327 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1329 else if (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) {
1330 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1332 else if (coff_symbol_ptr
->symbol
.section
== & bfd_und_section
) {
1333 syment
->n_scnum
= N_UNDEF
;
1334 syment
->n_value
= 0;
1337 if (coff_symbol_ptr
->symbol
.section
) {
1339 coff_symbol_ptr
->symbol
.section
->output_section
->target_index
;
1342 coff_symbol_ptr
->symbol
.value
+
1343 coff_symbol_ptr
->symbol
.section
->output_offset
+
1344 coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
1348 /* This can happen, but I don't know why yet (steve@cygnus.com) */
1349 syment
->n_scnum
= N_ABS
;
1350 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1355 /* run through all the symbols in the symbol table and work out what
1356 their indexes into the symbol table will be when output
1358 Coff requires that each C_FILE symbol points to the next one in the
1359 chain, and that the last one points to the first external symbol. We
1364 DEFUN(coff_renumber_symbols
,(bfd_ptr
),
1367 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1368 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1369 unsigned int native_index
= 0;
1370 struct internal_syment
*last_file
= (struct internal_syment
*)NULL
;
1371 unsigned int symbol_index
;
1373 /* COFF demands that undefined symbols come after all other symbols.
1374 Since we don't need to impose this extra knowledge on all our client
1375 programs, deal with that here. Sort the symbol table; just move the
1376 undefined symbols to the end, leaving the rest alone. */
1377 /* @@ Do we have some condition we could test for, so we don't always
1378 have to do this? I don't think relocatability is quite right, but
1379 I'm not certain. [raeburn:19920508.1711EST] */
1384 newsyms
= (asymbol
**) bfd_alloc_by_size_t (bfd_ptr
,
1386 * (symbol_count
+ 1));
1387 bfd_ptr
->outsymbols
= newsyms
;
1388 for (i
= 0; i
< symbol_count
; i
++)
1389 if (symbol_ptr_ptr
[i
]->section
!= &bfd_und_section
)
1390 *newsyms
++ = symbol_ptr_ptr
[i
];
1391 for (i
= 0; i
< symbol_count
; i
++)
1392 if (symbol_ptr_ptr
[i
]->section
== &bfd_und_section
)
1393 *newsyms
++ = symbol_ptr_ptr
[i
];
1394 *newsyms
= (asymbol
*) NULL
;
1395 symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1398 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1400 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1401 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1402 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1405 if (s
->u
.syment
.n_sclass
== C_FILE
)
1407 if (last_file
!= (struct internal_syment
*)NULL
) {
1408 last_file
->n_value
= native_index
;
1410 last_file
= &(s
->u
.syment
);
1414 /* Modify the symbol values according to their section and
1417 fixup_symbol_value(coff_symbol_ptr
, &(s
->u
.syment
));
1419 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++) {
1420 s
[i
].offset
= native_index
++;
1427 obj_conv_table_size (bfd_ptr
) = native_index
;
1432 Run thorough the symbol table again, and fix it so that all pointers to
1433 entries are changed to the entries' index in the output symbol table.
1437 DEFUN(coff_mangle_symbols
,(bfd_ptr
),
1440 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1441 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1442 unsigned int symbol_index
;
1444 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1446 coff_symbol_type
*coff_symbol_ptr
=
1447 coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1449 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1451 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1453 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++) {
1454 combined_entry_type
*a
= s
+ i
+ 1;
1456 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
1457 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
1461 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
1462 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
1472 static int string_size
;
1474 DEFUN(coff_fix_symbol_name
,(ignore_abfd
, symbol
, native
),
1475 bfd
*ignore_abfd AND
1477 combined_entry_type
*native
)
1479 unsigned int name_length
;
1480 union internal_auxent
*auxent
;
1481 char * name
= ( char *)(symbol
->name
);
1483 if (name
== (char *) NULL
) {
1484 /* coff symbols always have names, so we'll make one up */
1485 symbol
->name
= "strange";
1486 name
= (char *)symbol
->name
;
1488 name_length
= strlen(name
);
1490 if (native
->u
.syment
.n_sclass
== C_FILE
) {
1491 strncpy(native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
1492 auxent
= &(native
+1)->u
.auxent
;
1494 #ifdef COFF_LONG_FILENAMES
1495 if (name_length
<= FILNMLEN
) {
1496 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1499 auxent
->x_file
.x_n
.x_offset
= string_size
+ 4;
1500 auxent
->x_file
.x_n
.x_zeroes
= 0;
1501 string_size
+= name_length
+ 1;
1504 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1505 if (name_length
> FILNMLEN
) {
1506 name
[FILNMLEN
] = '\0';
1511 { /* NOT A C_FILE SYMBOL */
1512 if (name_length
<= SYMNMLEN
) {
1513 /* This name will fit into the symbol neatly */
1514 strncpy(native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
1517 native
->u
.syment
._n
._n_n
._n_offset
= string_size
+ 4;
1518 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1519 string_size
+= name_length
+ 1;
1527 DEFUN(coff_write_symbol
,(abfd
, symbol
, native
, written
),
1530 combined_entry_type
*native AND
1531 unsigned int written
)
1533 unsigned int numaux
= native
->u
.syment
.n_numaux
;
1534 int type
= native
->u
.syment
.n_type
;
1535 int class = native
->u
.syment
.n_sclass
;
1539 /* @@ bfd_debug_section isn't accessible outside this file, but we know
1540 that C_FILE symbols belong there. So move them. */
1541 if (native
->u
.syment
.n_sclass
== C_FILE
)
1542 symbol
->section
= &bfd_debug_section
;
1544 if (symbol
->section
== &bfd_abs_section
)
1546 native
->u
.syment
.n_scnum
= N_ABS
;
1548 else if (symbol
->section
== &bfd_debug_section
)
1550 native
->u
.syment
.n_scnum
= N_DEBUG
;
1552 else if (symbol
->section
== &bfd_und_section
)
1554 native
->u
.syment
.n_scnum
= N_UNDEF
;
1558 native
->u
.syment
.n_scnum
=
1559 symbol
->section
->output_section
->target_index
;
1563 coff_fix_symbol_name(abfd
, symbol
, native
);
1565 coff_swap_sym_out(abfd
, &native
->u
.syment
, &buf
);
1566 bfd_write((PTR
)& buf
, 1, SYMESZ
, abfd
);
1567 for (j
= 0; j
< native
->u
.syment
.n_numaux
; j
++)
1570 memset((PTR
)&buf
, 0, AUXESZ
);
1571 coff_swap_aux_out(abfd
,
1572 &( (native
+ j
+ 1)->u
.auxent
), type
, class, &buf1
);
1573 bfd_write((PTR
) (&buf1
), 1, AUXESZ
, abfd
);
1576 Reuse somewhere in the symbol to keep the index
1578 set_index(symbol
, written
);
1579 return written
+ 1 + numaux
;
1584 DEFUN(coff_write_alien_symbol
,(abfd
, symbol
, written
),
1587 unsigned int written
)
1590 This symbol has been created by the loader, or come from a non
1591 coff format. It has no native element to inherit, make our
1594 combined_entry_type
*native
;
1595 combined_entry_type dummy
;
1597 native
->u
.syment
.n_type
= T_NULL
;
1599 native
->u
.syment
.n_flags
= 0;
1601 if (symbol
->section
== &bfd_und_section
)
1603 native
->u
.syment
.n_scnum
= N_UNDEF
;
1604 native
->u
.syment
.n_value
= symbol
->value
;
1606 else if (symbol
->section
== &bfd_com_section
)
1608 native
->u
.syment
.n_scnum
= N_UNDEF
;
1609 native
->u
.syment
.n_value
= symbol
->value
;
1613 else if (symbol
->flags
& BSF_DEBUGGING
) {
1615 remove name so it doesn't take up any space
1620 native
->u
.syment
.n_scnum
= symbol
->section
->output_section
->target_index
;
1621 native
->u
.syment
.n_value
= symbol
->value
+
1622 symbol
->section
->output_section
->vma
+
1623 symbol
->section
->output_offset
;
1625 /* Copy the any flags from the the file hdr into the symbol */
1627 coff_symbol_type
*c
= coff_symbol_from(abfd
, symbol
);
1628 if (c
!= (coff_symbol_type
*)NULL
) {
1629 native
->u
.syment
.n_flags
= c
->symbol
.the_bfd
->flags
;
1636 native
->u
.syment
.pad1
[0] = 0;
1637 native
->u
.syment
.pad1
[0] = 0;
1640 native
->u
.syment
.n_type
= 0;
1641 if (symbol
->flags
& BSF_LOCAL
)
1642 native
->u
.syment
.n_sclass
= C_STAT
;
1644 native
->u
.syment
.n_sclass
= C_EXT
;
1645 native
->u
.syment
.n_numaux
= 0;
1647 return coff_write_symbol(abfd
, symbol
, native
, written
);
1651 DEFUN(coff_write_native_symbol
,(abfd
, symbol
, written
),
1653 coff_symbol_type
*symbol AND
1654 unsigned int written
)
1657 Does this symbol have an ascociated line number - if so then
1658 make it remember this symbol index. Also tag the auxent of
1659 this symbol to point to the right place in the lineno table
1661 combined_entry_type
*native
= symbol
->native
;
1663 alent
*lineno
= symbol
->lineno
;
1665 if (lineno
&& !symbol
->done_lineno
) {
1666 unsigned int count
= 0;
1667 lineno
[count
].u
.offset
= written
;
1668 if (native
->u
.syment
.n_numaux
) {
1669 union internal_auxent
*a
= &((native
+1)->u
.auxent
);
1671 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1672 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1675 And count and relocate all other linenumbers
1679 while (lineno
[count
].line_number
) {
1682 I've been told this, but still need proof:
1683 > The second bug is also in `bfd/coffcode.h'. This bug causes the linker to screw
1684 > up the pc-relocations for all the line numbers in COFF code. This bug isn't
1685 > only specific to A29K implementations, but affects all systems using COFF
1686 > format binaries. Note that in COFF object files, the line number core offsets
1687 > output by the assembler are relative to the start of each procedure, not
1688 > to the start of the .text section. This patch relocates the line numbers
1689 > relative to the `native->u.syment.n_value' instead of the section virtual
1690 > address. modular!olson@cs.arizona.edu (Jon Olson)
1692 lineno
[count
].u
.offset
+= native
->u
.syment
.n_value
;
1695 lineno
[count
].u
.offset
+=
1696 symbol
->symbol
.section
->output_section
->vma
+
1697 symbol
->symbol
.section
->output_offset
;
1701 symbol
->done_lineno
= true;
1703 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1706 return coff_write_symbol(abfd
, &( symbol
->symbol
), native
,written
);
1710 DEFUN(coff_write_symbols
,(abfd
),
1714 unsigned int limit
= bfd_get_symcount(abfd
);
1715 unsigned int written
= 0;
1722 /* Seek to the right place */
1723 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
1725 /* Output all the symbols we have */
1728 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1730 asymbol
*symbol
= *p
;
1731 coff_symbol_type
*c_symbol
= coff_symbol_from(abfd
, symbol
);
1733 if (c_symbol
== (coff_symbol_type
*) NULL
||
1734 c_symbol
->native
== (combined_entry_type
*)NULL
)
1736 written
= coff_write_alien_symbol(abfd
, symbol
, written
);
1740 written
= coff_write_native_symbol(abfd
, c_symbol
, written
);
1745 bfd_get_symcount(abfd
) = written
;
1747 /* Now write out strings */
1749 if (string_size
!= 0)
1751 unsigned int size
= string_size
+ 4;
1754 bfd_h_put_32(abfd
, size
, buffer
);
1755 bfd_write((PTR
) buffer
, 1, sizeof(buffer
), abfd
);
1756 for (p
= abfd
->outsymbols
, i
= 0;
1761 size_t name_length
= strlen(q
->name
);
1763 coff_symbol_type
* c_symbol
= coff_symbol_from(abfd
, q
);
1764 maxlen
= ((c_symbol
!= NULL
&& c_symbol
->native
!= NULL
) &&
1765 (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
)) ?
1766 FILNMLEN
: SYMNMLEN
;
1768 if (name_length
> maxlen
) {
1769 bfd_write((PTR
) (q
->name
), 1, name_length
+ 1, abfd
);
1774 /* We would normally not write anything here, but we'll write
1775 out 4 so that any stupid coff reader which tries to read
1776 the string table even when there isn't one won't croak.
1779 uint32e_type size
= 4;
1781 bfd_write((PTR
)&size
, 1, sizeof(size
), abfd
);
1790 To write relocations, all the back end does is step though the
1791 canonical relocation table, and create an
1792 @code{internal_reloc}. The symbol index to use is removed from
1793 the @code{offset} field in the symbol table supplied, the
1794 address comes directly from the sum of the section base
1795 address and the relocation offset and the type is dug directly
1796 from the howto field. Then the @code{internal_reloc} is
1797 swapped into the shape of an @code{external_reloc} and written
1803 DEFUN(coff_write_relocs
,(abfd
),
1807 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1809 struct external_reloc dst
;
1811 arelent
**p
= s
->orelocation
;
1812 bfd_seek(abfd
, s
->rel_filepos
, SEEK_SET
);
1813 for (i
= 0; i
< s
->reloc_count
; i
++) {
1814 struct internal_reloc n
;
1816 memset((PTR
)&n
, 0, sizeof(n
));
1819 #ifndef SWAP_OUT_RELOC_OFFSET
1820 /* @@FIXME COFF relocs don't support addends. Code should probably be
1821 in the target-independent code, using a target flag to decide whether
1822 to fold the addend into the section contents. */
1826 if (q
->howto
->type
!= R_IHCONST
)
1831 n
.r_vaddr
= q
->address
+ s
->vma
;
1832 /* The 29k const/consth reloc pair is a real kludge - the consth
1833 part doesn't have a symbol - it has an offset. So rebuilt
1836 if (q
->howto
->type
== R_IHCONST
)
1837 n
.r_symndx
= q
->addend
;
1841 if (q
->sym_ptr_ptr
) {
1842 n
.r_symndx
= get_index((*(q
->sym_ptr_ptr
)));
1843 /* Take notice if the symbol reloc points to a symbol we don't have
1844 in our symbol table. What should we do for this?? */
1845 if (n
.r_symndx
> obj_conv_table_size (abfd
))
1849 /* Work out reloc type from what is required */
1850 SELECT_RELOC(n
.r_type
, q
->howto
);
1852 n
.r_type
= q
->howto
->type
;
1854 coff_swap_reloc_out(abfd
, &n
, &dst
);
1855 bfd_write((PTR
) &dst
, 1, RELSZ
, abfd
);
1859 #endif /* NO_COFF_SYMBOLS */
1861 #ifndef NO_COFF_LINENOS
1864 DEFUN(coff_write_linenumbers
,(abfd
),
1868 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1869 if (s
->lineno_count
) {
1870 asymbol
**q
= abfd
->outsymbols
;
1871 bfd_seek(abfd
, s
->line_filepos
, SEEK_SET
);
1872 /* Find all the linenumbers in this section */
1875 alent
*l
= BFD_SEND(p
->the_bfd
, _get_lineno
, (p
->the_bfd
, p
));
1877 /* Found a linenumber entry, output */
1878 struct internal_lineno out
;
1880 memset( (PTR
)&out
, 0, sizeof(out
));
1882 out
.l_addr
.l_symndx
= l
->u
.offset
;
1883 coff_swap_lineno_out(abfd
, &out
, &buff
);
1884 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1886 while (l
->line_number
) {
1887 out
.l_lnno
= l
->line_number
;
1888 out
.l_addr
.l_symndx
= l
->u
.offset
;
1889 coff_swap_lineno_out(abfd
, &out
, &buff
);
1890 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1901 DEFUN(coff_get_lineno
,(ignore_abfd
, symbol
),
1902 bfd
*ignore_abfd AND
1905 return coffsymbol(symbol
)->lineno
;
1908 #endif /* NO_COFF_LINENOS */
1911 coff_make_empty_symbol(abfd
)
1914 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc(abfd
, sizeof(coff_symbol_type
));
1916 bfd_error
= no_memory
;
1919 new->symbol
.section
= 0;
1921 new->lineno
= (alent
*) NULL
;
1922 new->done_lineno
= false;
1923 new->symbol
.the_bfd
= abfd
;
1924 return &new->symbol
;
1927 #ifndef NO_COFF_SYMBOLS
1930 DEFUN (coff_make_debug_symbol
, (abfd
, ptr
, sz
),
1935 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc(abfd
, sizeof(coff_symbol_type
));
1937 bfd_error
= no_memory
;
1940 /* @@ This shouldn't be using a constant multiplier. */
1941 new->native
= (combined_entry_type
*) bfd_zalloc (abfd
, sizeof (combined_entry_type
) * 10);
1942 new->symbol
.section
= &bfd_debug_section
;
1943 new->lineno
= (alent
*) NULL
;
1944 new->done_lineno
= false;
1945 new->symbol
.the_bfd
= abfd
;
1946 return &new->symbol
;
1950 DEFUN(coff_print_symbol
,(ignore_abfd
, filep
, symbol
, how
),
1951 bfd
*ignore_abfd AND
1954 bfd_print_symbol_type how
)
1956 FILE *file
= (FILE *)filep
;
1958 case bfd_print_symbol_name
:
1959 fprintf(file
, "%s", symbol
->name
);
1961 case bfd_print_symbol_more
:
1962 fprintf(file
, "coff %lx %lx", (unsigned long) coffsymbol(symbol
)->native
,
1963 (unsigned long) coffsymbol(symbol
)->lineno
);
1965 case bfd_print_symbol_nm
:
1968 CONST
char *section_name
= symbol
->section
->name
;
1969 bfd_print_symbol_vandf((PTR
) file
, symbol
);
1972 fprintf(file
, " %-5s %s %s %s",
1974 coffsymbol(symbol
)->native
? "n" : "g",
1975 coffsymbol(symbol
)->lineno
? "l" : " ",
1981 case bfd_print_symbol_all
:
1982 /* Print out the symbols in a reasonable way */
1984 CONST
char *section_name
= symbol
->section
->name
;
1987 if (coffsymbol(symbol
)->native
)
1990 combined_entry_type
*combined
= coffsymbol(symbol
)->native
;
1991 combined_entry_type
*root
= obj_raw_syments(ignore_abfd
);
1993 fprintf(file
,"[%3d]",
1997 fprintf(file
, "(sc %2d)(fl%4x)(ty%3x)(sc%3d) nx(%d) %08x %s",
1998 combined
->u
.syment
.n_scnum
,
1999 combined
->u
.syment
.n_flags
,
2000 combined
->u
.syment
.n_type
,
2001 combined
->u
.syment
.n_sclass
,
2002 combined
->u
.syment
.n_numaux
,
2003 combined
->u
.syment
.n_value
,
2006 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
2009 switch (combined
->u
.syment
.n_sclass
) {
2011 fprintf(file
, "File ");
2014 fprintf(file
, "AUX lnno %x size %x tagndx %x",
2015 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
2016 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
2017 combined
[aux
+1].u
.auxent
.x_sym
.x_tagndx
.l
);
2025 struct lineno_cache_entry
*l
= coffsymbol(symbol
)->lineno
;
2028 printf("\n%s :", l
->u
.sym
->name
);
2030 while (l
->line_number
)
2032 printf("\n%4d : %x",
2046 bfd_print_symbol_vandf((PTR
) file
, symbol
);
2047 fprintf(file
, " %-5s %s %s %s",
2049 coffsymbol(symbol
)->native
? "n" : "g",
2050 coffsymbol(symbol
)->lineno
? "l" : " ",
2059 #endif /* NO_COFF_SYMBOLS */
2061 /* Set flags and magic number of a coff file from architecture and machine
2062 type. Result is true if we can represent the arch&type, false if not. */
2065 DEFUN(coff_set_flags
,(abfd
, magicp
, flagsp
),
2067 unsigned *magicp AND
2068 unsigned short *flagsp
)
2070 switch (bfd_get_arch(abfd
)) {
2074 switch (bfd_get_mach(abfd
))
2076 case bfd_mach_z8001
:
2079 case bfd_mach_z8002
:
2093 *magicp
= I960ROMAGIC
;
2095 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2096 I960RWMAGIC); FIXME???
2098 switch (bfd_get_mach(abfd
)) {
2099 case bfd_mach_i960_core
:
2102 case bfd_mach_i960_kb_sb
:
2105 case bfd_mach_i960_mc
:
2108 case bfd_mach_i960_xa
:
2111 case bfd_mach_i960_ca
:
2114 case bfd_mach_i960_ka_sa
:
2127 *magicp
= MIPS_MAGIC_2
;
2133 *magicp
= I386MAGIC
;
2139 *magicp
= MC68MAGIC
;
2146 *magicp
= MC88OMAGIC
;
2151 case bfd_arch_h8300
:
2152 *magicp
= H8300MAGIC
;
2156 #ifdef A29K_MAGIC_BIG
2158 if (abfd
->xvec
->byteorder_big_p
)
2159 *magicp
= A29K_MAGIC_BIG
;
2161 *magicp
= A29K_MAGIC_LITTLE
;
2167 case bfd_arch_we32k
:
2168 *magicp
= WE32KMAGIC
;
2174 case bfd_arch_rs6000
:
2175 *magicp
= U802TOCMAGIC
;
2180 default: /* Unknown architecture */
2181 /* return false; -- fall through to "return false" below, to avoid
2182 "statement never reached" errors on the one below. */
2191 DEFUN(coff_set_arch_mach
,(abfd
, arch
, machine
),
2193 enum bfd_architecture arch AND
2194 unsigned long machine
)
2197 unsigned short dummy2
;
2198 bfd_default_set_arch_mach(abfd
, arch
, machine
);
2200 if (arch
!= bfd_arch_unknown
&&
2201 coff_set_flags(abfd
, &dummy1
, &dummy2
) != true)
2202 return false; /* We can't represent this type */
2203 return true; /* We're easy ... */
2207 /* Calculate the file position for each section. */
2210 DEFUN(coff_compute_section_file_positions
,(abfd
),
2214 asection
*previous
= (asection
*)NULL
;
2215 file_ptr sofar
= FILHSZ
;
2217 if (bfd_get_start_address(abfd
))
2219 /* A start address may have been added to the original file. In this
2220 case it will need an optional header to record it. */
2221 abfd
->flags
|= EXEC_P
;
2224 if (abfd
->flags
& EXEC_P
)
2227 sofar
+= abfd
->section_count
* SCNHSZ
;
2228 for (current
= abfd
->sections
;
2229 current
!= (asection
*)NULL
;
2230 current
= current
->next
) {
2232 /* Only deal with sections which have contents */
2233 if (!(current
->flags
& SEC_HAS_CONTENTS
))
2236 /* Align the sections in the file to the same boundary on
2237 which they are aligned in virtual memory. I960 doesn't
2238 do this (FIXME) so we can stay in sync with Intel. 960
2239 doesn't yet page from files... */
2242 /* make sure this section is aligned on the right boundary - by
2243 padding the previous section up if necessary */
2246 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2247 if (previous
!= (asection
*)NULL
) {
2248 previous
->_raw_size
+= sofar
- old_sofar
;
2253 /* FIXME, in demand paged files, the low order bits of the file
2254 offset must match the low order bits of the virtual address.
2255 "Low order" is apparently implementation defined. Add code
2256 here to round sofar up to match the virtual address. */
2258 current
->filepos
= sofar
;
2260 sofar
+= current
->_raw_size
;
2262 /* make sure that this section is of the right size too */
2264 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2265 current
->_raw_size
+= sofar
- old_sofar
;
2270 obj_relocbase(abfd
) = sofar
;
2273 #ifndef NO_COFF_SYMBOLS
2275 coff_section_symbol (abfd
, name
)
2279 asection
*sec
= bfd_get_section_by_name (abfd
, name
);
2281 combined_entry_type
*csym
;
2285 /* create empty symbol */
2289 if (coff_symbol_from (abfd
, sym
))
2290 csym
= coff_symbol_from (abfd
, sym
)->native
;
2293 /* Make sure back-end COFF stuff is there. */
2297 coff_symbol_type sym
;
2298 /* @@FIXME This shouldn't use a fixed size!! */
2299 combined_entry_type e
[10];
2302 f
= (struct foo
*) bfd_alloc_by_size_t (abfd
, sizeof (*f
));
2303 memset ((char *) f
, 0, sizeof (*f
));
2304 coff_symbol_from (abfd
, sym
)->native
= csym
= f
->e
;
2306 csym
[0].u
.syment
.n_sclass
= C_STAT
;
2307 csym
[0].u
.syment
.n_numaux
= 1;
2308 /* SF_SET_STATICS (sym); @@ ??? */
2311 csym
[1].u
.auxent
.x_scn
.x_scnlen
= sec
->_raw_size
;
2312 csym
[1].u
.auxent
.x_scn
.x_nreloc
= sec
->reloc_count
;
2313 csym
[1].u
.auxent
.x_scn
.x_nlinno
= sec
->lineno_count
;
2317 csym
[1].u
.auxent
.x_scn
.x_scnlen
= 0;
2318 csym
[1].u
.auxent
.x_scn
.x_nreloc
= 0;
2319 csym
[1].u
.auxent
.x_scn
.x_nlinno
= 0;
2324 /* If .file, .text, .data, .bss symbols are missing, add them. */
2325 /* @@ Should we only be adding missing symbols, or overriding the aux
2326 values for existing section symbols? */
2328 coff_add_missing_symbols (abfd
)
2331 unsigned int nsyms
= bfd_get_symcount (abfd
);
2332 asymbol
**sympp
= abfd
->outsymbols
;
2335 int need_text
= 1, need_data
= 1, need_bss
= 1, need_file
= 1;
2336 coff_data_type
*cdata
= coff_data (abfd
);
2338 for (i
= 0; i
< nsyms
; i
++)
2340 coff_symbol_type
*csym
= coff_symbol_from (abfd
, sympp
[i
]);
2344 /* only do this if there is a coff representation of the input
2346 if (csym
->native
&& csym
->native
->u
.syment
.n_sclass
== C_FILE
)
2351 name
= csym
->symbol
.name
;
2354 if (!strcmp (name
, _TEXT
))
2356 else if (!strcmp (name
, _DATA
))
2358 else if (!strcmp (name
, _BSS
))
2362 /* Now i == bfd_get_symcount (abfd). */
2363 /* @@ For now, don't deal with .file symbol. */
2366 if (!need_text
&& !need_data
&& !need_bss
&& !need_file
)
2368 nsyms
+= need_text
+ need_data
+ need_bss
+ need_file
;
2369 sympp2
= (asymbol
**) bfd_alloc_by_size_t (abfd
, nsyms
* sizeof (asymbol
*));
2370 memcpy (sympp2
, sympp
, i
* sizeof (asymbol
*));
2373 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
2377 sympp2
[i
++] = coff_section_symbol (abfd
, _TEXT
);
2379 sympp2
[i
++] = coff_section_symbol (abfd
, _DATA
);
2381 sympp2
[i
++] = coff_section_symbol (abfd
, _BSS
);
2382 BFD_ASSERT (i
== nsyms
);
2383 bfd_set_symtab (abfd
, sympp2
, nsyms
);
2385 #endif /* NO_COFF_SYMBOLS */
2390 DEFUN(coff_write_object_contents
,(abfd
),
2396 boolean hasrelocs
= false;
2397 boolean haslinno
= false;
2398 file_ptr reloc_base
;
2399 file_ptr lineno_base
;
2403 unsigned long reloc_size
= 0;
2404 unsigned long lnno_size
= 0;
2405 asection
*text_sec
= NULL
;
2406 asection
*data_sec
= NULL
;
2407 asection
*bss_sec
= NULL
;
2409 struct internal_filehdr internal_f
;
2410 struct internal_aouthdr internal_a
;
2413 bfd_error
= system_call_error
;
2414 /* Number the output sections, starting from one on the first section
2415 with a name which doesn't start with a *.
2416 @@ The code doesn't make this check. Is it supposed to be done,
2419 for (current
= abfd
->sections
; current
!= (asection
*)NULL
;
2420 current
= current
->next
)
2422 current
->target_index
= count
;
2430 if(abfd
->output_has_begun
== false) {
2431 coff_compute_section_file_positions(abfd
);
2434 if (abfd
->sections
!= (asection
*)NULL
) {
2435 scn_base
= abfd
->sections
->filepos
;
2440 if (bfd_seek(abfd
, scn_base
, SEEK_SET
) != 0)
2442 reloc_base
= obj_relocbase(abfd
);
2444 /* Make a pass through the symbol table to count line number entries and
2445 put them into the correct asections */
2447 #ifndef NO_COFF_LINENOS
2448 coff_count_linenumbers(abfd
);
2450 data_base
= scn_base
;
2452 /* Work out the size of the reloc and linno areas */
2454 for (current
= abfd
->sections
; current
!= NULL
; current
=
2457 /* We give section headers to +ve indexes */
2458 if (current
->target_index
> 0)
2461 reloc_size
+= current
->reloc_count
* RELSZ
;
2462 #ifndef NO_COFF_LINENOS
2463 lnno_size
+= current
->lineno_count
* LINESZ
;
2465 data_base
+= SCNHSZ
;
2470 lineno_base
= reloc_base
+ reloc_size
;
2471 sym_base
= lineno_base
+ lnno_size
;
2473 /* Indicate in each section->line_filepos its actual file address */
2474 for (current
= abfd
->sections
; current
!= NULL
; current
=
2477 if (current
->target_index
> 0)
2480 if (current
->lineno_count
) {
2481 current
->line_filepos
= lineno_base
;
2482 current
->moving_line_filepos
= lineno_base
;
2483 #ifndef NO_COFF_LINENOS
2484 lineno_base
+= current
->lineno_count
* LINESZ
;
2488 current
->line_filepos
= 0;
2490 if (current
->reloc_count
) {
2491 current
->rel_filepos
= reloc_base
;
2492 reloc_base
+= current
->reloc_count
* RELSZ
;
2495 current
->rel_filepos
= 0;
2502 /* Write section headers to the file. */
2503 internal_f
.f_nscns
= 0;
2505 (file_ptr
) ((abfd
->flags
& EXEC_P
) ?
2506 (FILHSZ
+ AOUTSZ
) : FILHSZ
),
2511 unsigned int pad
= abfd
->flags
& D_PAGED
? data_base
: 0;
2513 unsigned int pad
= 0;
2515 for (current
= abfd
->sections
;
2517 current
= current
->next
) {
2518 struct internal_scnhdr section
;
2519 if (current
->target_index
> 0)
2521 internal_f
.f_nscns
++;
2522 strncpy(&(section
.s_name
[0]), current
->name
, 8);
2523 section
.s_vaddr
= current
->vma
+ pad
;
2524 section
.s_paddr
= current
->vma
+ pad
;
2525 section
.s_size
= current
->_raw_size
- pad
;
2527 If this section has no size or is unloadable then the scnptr
2530 if (current
->_raw_size
- pad
== 0 ||
2531 (current
->flags
& SEC_LOAD
) == 0) {
2532 section
.s_scnptr
= 0;
2535 section
.s_scnptr
= current
->filepos
;
2537 section
.s_relptr
= current
->rel_filepos
;
2538 section
.s_lnnoptr
= current
->line_filepos
;
2539 section
.s_nreloc
= current
->reloc_count
;
2540 section
.s_nlnno
= current
->lineno_count
;
2541 if (current
->reloc_count
!= 0)
2543 if (current
->lineno_count
!= 0)
2546 section
.s_flags
= sec_to_styp_flags(current
->name
,current
->flags
);
2548 if (!strcmp(current
->name
, _TEXT
)) {
2550 } else if (!strcmp(current
->name
, _DATA
)) {
2552 } else if (!strcmp(current
->name
, _BSS
)) {
2557 section
.s_align
= (current
->alignment_power
2558 ? 1 << current
->alignment_power
2565 coff_swap_scnhdr_out(abfd
, §ion
, &buff
);
2566 bfd_write((PTR
) (&buff
), 1, SCNHSZ
, abfd
);
2576 /* OK, now set up the filehdr... */
2578 /* Don't include the internal abs section in the section count */
2581 We will NOT put a fucking timestamp in the header here. Every time you
2582 put it back, I will come in and take it out again. I'm sorry. This
2583 field does not belong here. We fill it with a 0 so it compares the
2584 same but is not a reasonable time. -- gnu@cygnus.com
2587 Well, I like it, and now we have *customers* who have requested it,
2588 so I'm conditionally compiling it in.
2592 #ifndef NOCOFF_TIMESTAMP
2593 internal_f
.f_timdat
= time(0);
2595 internal_f
.f_timdat
= 0;
2598 if (bfd_get_symcount(abfd
) != 0)
2599 internal_f
.f_symptr
= sym_base
;
2601 internal_f
.f_symptr
= 0;
2603 internal_f
.f_flags
= 0;
2605 if (abfd
->flags
& EXEC_P
)
2606 internal_f
.f_opthdr
= AOUTSZ
;
2608 internal_f
.f_opthdr
= 0;
2611 internal_f
.f_flags
|= F_RELFLG
;
2613 internal_f
.f_flags
|= F_LNNO
;
2614 if (0 == bfd_get_symcount(abfd
))
2615 internal_f
.f_flags
|= F_LSYMS
;
2616 if (abfd
->flags
& EXEC_P
)
2617 internal_f
.f_flags
|= F_EXEC
;
2619 if (!abfd
->xvec
->byteorder_big_p
)
2620 internal_f
.f_flags
|= F_AR32WR
;
2622 internal_f
.f_flags
|= F_AR32W
;
2625 FIXME, should do something about the other byte orders and
2629 /* Set up architecture-dependent stuff */
2631 { unsigned int magic
= 0;
2632 unsigned short flags
= 0;
2633 coff_set_flags(abfd
, &magic
, &flags
);
2634 internal_f
.f_magic
= magic
;
2635 internal_f
.f_flags
|= flags
;
2636 /* ...and the "opt"hdr... */
2639 # ifdef ULTRA3 /* NYU's machine */
2640 /* FIXME: This is a bogus check. I really want to see if there
2641 * is a .shbss or a .shdata section, if so then set the magic
2642 * number to indicate a shared data executable.
2644 if (internal_f
.f_nscns
>= 7)
2645 internal_a
.magic
= SHMAGIC
; /* Shared magic */
2647 # endif /* ULTRA3 */
2648 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
2649 #define __A_MAGIC_SET__
2652 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
2653 #define __A_MAGIC_SET__
2656 #define __A_MAGIC_SET__
2657 internal_a
.magic
= PAGEMAGICBCS
;
2660 #if M68 || MIPS || WE32K
2661 #define __A_MAGIC_SET__
2662 /* Never was anything here for the 68k */
2663 #endif /* M68 || MIPS || WE32K */
2666 # define __A_MAGIC_SET__
2667 internal_a
.magic
= ZMAGIC
;
2671 #define __A_MAGIC_SET__
2672 internal_a
.magic
= (abfd
->flags
& D_PAGED
)? RS6K_AOUTHDR_ZMAGIC
:
2673 (abfd
->flags
& WP_TEXT
)? RS6K_AOUTHDR_NMAGIC
:
2674 RS6K_AOUTHDR_OMAGIC
;
2677 #ifndef __A_MAGIC_SET__
2678 # include "Your aouthdr magic number is not being set!"
2680 # undef __A_MAGIC_SET__
2683 /* Now should write relocs, strings, syms */
2684 obj_sym_filepos(abfd
) = sym_base
;
2686 #ifndef NO_COFF_SYMBOLS
2687 if (bfd_get_symcount(abfd
) != 0) {
2688 coff_add_missing_symbols (abfd
);
2689 coff_renumber_symbols(abfd
);
2690 coff_mangle_symbols(abfd
);
2691 coff_write_symbols(abfd
);
2692 coff_write_linenumbers(abfd
);
2693 coff_write_relocs(abfd
);
2695 #endif /* NO_COFF_SYMBOLS */
2697 internal_a
.tsize
= bfd_get_section_size_before_reloc(text_sec
);
2698 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
2701 internal_a
.dsize
= bfd_get_section_size_before_reloc(data_sec
);
2702 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
2705 internal_a
.bsize
= bfd_get_section_size_before_reloc(bss_sec
);
2708 internal_a
.entry
= bfd_get_start_address(abfd
);
2709 internal_f
.f_nsyms
= bfd_get_symcount(abfd
);
2711 /* now write them */
2712 if (bfd_seek(abfd
, 0L, SEEK_SET
) != 0)
2716 coff_swap_filehdr_out(abfd
, (PTR
)&internal_f
, (PTR
)&buff
);
2717 bfd_write((PTR
) &buff
, 1, FILHSZ
, abfd
);
2719 if (abfd
->flags
& EXEC_P
) {
2721 coff_swap_aouthdr_out(abfd
, (PTR
)&internal_a
, (PTR
)&buff
);
2722 bfd_write((PTR
) &buff
, 1, AOUTSZ
, abfd
);
2727 #ifndef NO_COFF_SYMBOLS
2730 this function transforms the offsets into the symbol table into
2731 pointers to syments.
2736 DEFUN(coff_pointerize_aux
,(ignore_abfd
, table_base
, type
, class, auxent
),
2737 bfd
*ignore_abfd AND
2738 combined_entry_type
*table_base AND
2741 combined_entry_type
*auxent
)
2743 /* Don't bother if this is a file or a section */
2744 if (class == C_STAT
&& type
== T_NULL
) return;
2745 if (class == C_FILE
) return;
2747 /* Otherwise patch up */
2748 if (ISFCN(type
) || ISTAG(class) || class == C_BLOCK
) {
2749 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
= table_base
+
2750 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2751 auxent
->fix_end
= 1;
2753 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
!= 0) {
2754 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
=
2755 table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
2756 auxent
->fix_tag
= 1;
2760 #endif /* NO_COFF_SYMBOLS */
2763 DEFUN(coff_set_section_contents
,(abfd
, section
, location
, offset
, count
),
2768 bfd_size_type count
)
2770 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
2771 coff_compute_section_file_positions(abfd
);
2773 bfd_seek(abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
);
2776 return (bfd_write(location
, 1, count
, abfd
) == count
) ? true : false;
2782 coff_close_and_cleanup(abfd
)
2785 if (!bfd_read_p(abfd
))
2786 switch (abfd
->format
) {
2788 if (!_bfd_write_archive_contents(abfd
))
2792 if (!coff_write_object_contents(abfd
))
2796 bfd_error
= invalid_operation
;
2800 /* We depend on bfd_close to free all the memory on the obstack. */
2801 /* FIXME if bfd_release is not using obstacks! */
2807 buy_and_read(abfd
, where
, seek_direction
, size
)
2813 PTR area
= (PTR
) bfd_alloc(abfd
, size
);
2815 bfd_error
= no_memory
;
2818 bfd_seek(abfd
, where
, seek_direction
);
2819 if (bfd_read(area
, 1, size
, abfd
) != size
) {
2820 bfd_error
= system_call_error
;
2824 } /* buy_and_read() */
2827 #ifndef NO_COFF_SYMBOLS
2830 DEFUN(build_string_table
,(abfd
),
2833 char string_table_size_buffer
[4];
2834 unsigned int string_table_size
;
2837 /* At this point we should be "seek"'d to the end of the
2838 symbols === the symbol table size. */
2839 if (bfd_read((char *) string_table_size_buffer
,
2840 sizeof(string_table_size_buffer
),
2841 1, abfd
) != sizeof(string_table_size
)) {
2842 bfd_error
= system_call_error
;
2846 string_table_size
= bfd_h_get_32(abfd
, (bfd_byte
*) string_table_size_buffer
);
2848 if ((string_table
= (PTR
) bfd_alloc(abfd
, string_table_size
-= 4)) == NULL
) {
2849 bfd_error
= no_memory
;
2851 } /* on mallocation error */
2852 if (bfd_read(string_table
, string_table_size
, 1, abfd
) != string_table_size
) {
2853 bfd_error
= system_call_error
;
2856 return string_table
;
2859 /* Allocate space for the ".debug" section, and read it.
2860 We did not read the debug section until now, because
2861 we didn't want to go to the trouble until someone needed it. */
2864 DEFUN(build_debug_section
,(abfd
),
2867 char *debug_section
;
2870 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
2873 bfd_error
= no_debug_section
;
2877 debug_section
= (PTR
) bfd_alloc (abfd
,
2878 bfd_get_section_size_before_reloc (sect
));
2879 if (debug_section
== NULL
) {
2880 bfd_error
= no_memory
;
2884 /* Seek to the beginning of the `.debug' section and read it.
2885 Save the current position first; it is needed by our caller.
2886 Then read debug section and reset the file pointer. */
2888 position
= bfd_tell (abfd
);
2889 bfd_seek (abfd
, sect
->filepos
, SEEK_SET
);
2890 if (bfd_read (debug_section
,
2891 bfd_get_section_size_before_reloc (sect
), 1, abfd
)
2892 != bfd_get_section_size_before_reloc(sect
)) {
2893 bfd_error
= system_call_error
;
2896 bfd_seek (abfd
, position
, SEEK_SET
);
2897 return debug_section
;
2901 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
2902 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
2903 be \0-terminated. */
2905 DEFUN(copy_name
,(abfd
, name
, maxlen
),
2913 for (len
= 0; len
< maxlen
; ++len
) {
2914 if (name
[len
] == '\0') {
2919 if ((newname
= (PTR
) bfd_alloc(abfd
, len
+1)) == NULL
) {
2920 bfd_error
= no_memory
;
2923 strncpy(newname
, name
, len
);
2924 newname
[len
] = '\0';
2929 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
2930 knit the symbol names into a normalized form. By normalized here I
2931 mean that all symbols have an n_offset pointer that points to a null-
2932 terminated string. */
2934 #ifndef SYMNAME_IN_DEBUG
2935 #define SYMNAME_IN_DEBUG(x) 0
2938 static combined_entry_type
*
2939 DEFUN(get_normalized_symtab
,(abfd
),
2942 combined_entry_type
*internal
;
2943 combined_entry_type
*internal_ptr
;
2944 combined_entry_type
*symbol_ptr
;
2945 combined_entry_type
*internal_end
;
2949 char *string_table
= NULL
;
2950 char *debug_section
= NULL
;
2953 unsigned int raw_size
;
2954 if (obj_raw_syments(abfd
) != (combined_entry_type
*)NULL
) {
2955 return obj_raw_syments(abfd
);
2957 if ((size
= bfd_get_symcount(abfd
) * sizeof(combined_entry_type
)) == 0) {
2958 bfd_error
= no_symbols
;
2962 internal
= (combined_entry_type
*)bfd_alloc(abfd
, size
);
2963 internal_end
= internal
+ bfd_get_symcount(abfd
);
2965 raw_size
= bfd_get_symcount(abfd
) * SYMESZ
;
2966 raw
= (SYMENT
*)bfd_alloc(abfd
,raw_size
);
2968 if (bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
) == -1
2969 || bfd_read((PTR
)raw
, raw_size
, 1, abfd
) != raw_size
) {
2970 bfd_error
= system_call_error
;
2973 /* mark the end of the symbols */
2974 raw_end
= raw
+ bfd_get_symcount(abfd
);
2976 FIXME SOMEDAY. A string table size of zero is very weird, but
2977 probably possible. If one shows up, it will probably kill us.
2980 /* Swap all the raw entries */
2981 for (raw_src
= raw
, internal_ptr
= internal
;
2983 raw_src
++, internal_ptr
++) {
2986 coff_swap_sym_in(abfd
, (PTR
)raw_src
, (PTR
)&internal_ptr
->u
.syment
);
2987 internal_ptr
->fix_tag
= 0;
2988 internal_ptr
->fix_end
= 0;
2989 symbol_ptr
= internal_ptr
;
2992 i
< symbol_ptr
->u
.syment
.n_numaux
;
2998 internal_ptr
->fix_tag
= 0;
2999 internal_ptr
->fix_end
= 0;
3000 coff_swap_aux_in(abfd
, (char *)(raw_src
),
3001 symbol_ptr
->u
.syment
.n_type
,
3002 symbol_ptr
->u
.syment
.n_sclass
,
3003 &(internal_ptr
->u
.auxent
));
3004 /* Remember that bal entries arn't pointerized */
3005 if (i
!= 1 || symbol_ptr
->u
.syment
.n_sclass
!= C_LEAFPROC
)
3008 coff_pointerize_aux(abfd
,
3010 symbol_ptr
->u
.syment
.n_type
,
3011 symbol_ptr
->u
.syment
.n_sclass
,
3018 /* Free all the raw stuff */
3019 bfd_release(abfd
, raw
);
3021 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
3024 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
) {
3025 /* make a file symbol point to the name in the auxent, since
3026 the text ".file" is redundant */
3027 if ((internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_zeroes
== 0) {
3028 /* the filename is a long one, point into the string table */
3029 if (string_table
== NULL
) {
3030 string_table
= build_string_table(abfd
);
3033 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
3034 (int) (string_table
- 4 +
3035 (internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_offset
);
3038 /* ordinary short filename, put into memory anyway */
3039 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
3040 copy_name(abfd
, (internal_ptr
+1)->u
.auxent
.x_file
.x_fname
,
3045 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0) {
3046 /* This is a "short" name. Make it long. */
3047 unsigned long i
= 0;
3048 char *newstring
= NULL
;
3050 /* find the length of this string without walking into memory
3052 for (i
= 0; i
< 8; ++i
) {
3053 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0') {
3055 } /* if end of string */
3056 } /* possible lengths of this string. */
3058 if ((newstring
= (PTR
) bfd_alloc(abfd
, ++i
)) == NULL
) {
3059 bfd_error
= no_memory
;
3062 memset(newstring
, 0, i
);
3063 strncpy(newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
-1);
3064 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int) newstring
;
3065 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
3067 else if (!SYMNAME_IN_DEBUG(&internal_ptr
->u
.syment
)) {
3068 /* Long name already. Point symbol at the string in the table. */
3069 if (string_table
== NULL
) {
3070 string_table
= build_string_table(abfd
);
3072 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
3073 (string_table
- 4 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
3076 /* Long name in debug section. Very similar. */
3077 if (debug_section
== NULL
) {
3078 debug_section
= build_debug_section(abfd
);
3080 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
3081 (debug_section
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
3084 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
3087 obj_raw_syments(abfd
) = internal
;
3090 } /* get_normalized_symtab() */
3092 #endif /* NO_COFF_SYMBOLS */
3096 DEFUN(section_from_bfd_index
,(abfd
, index
),
3100 struct sec
*answer
= abfd
->sections
;
3104 return &bfd_abs_section
;
3106 if (index
== N_UNDEF
)
3108 return &bfd_und_section
;
3110 if(index
== N_DEBUG
)
3112 return &bfd_debug_section
;
3117 if (answer
->target_index
== index
)
3119 answer
= answer
->next
;
3122 return &bfd_und_section
; /* For gcc -W and lint. Never executed. */
3125 #ifndef NO_COFF_LINENOS
3131 Creating the linenumber table is done by reading in the entire
3132 coff linenumber table, and creating another table for internal use.
3134 A coff line number table is structured so that each function
3135 is marked as having a line number of 0. Each line within the
3136 function is an offset from the first line in the function. The
3137 base of the line number information for the table is stored in
3138 the symbol associated with the function.
3140 The information is copied from the external to the internal
3141 table, and each symbol which marks a function is marked by
3144 How does this work ?
3149 coff_slurp_line_table(abfd
, asect
)
3153 LINENO
*native_lineno
;
3154 alent
*lineno_cache
;
3156 BFD_ASSERT(asect
->lineno
== (alent
*) NULL
);
3158 native_lineno
= (LINENO
*) buy_and_read(abfd
,
3159 asect
->line_filepos
,
3162 asect
->lineno_count
));
3164 (alent
*) bfd_alloc(abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof(alent
)));
3165 if (lineno_cache
== NULL
) {
3166 bfd_error
= no_memory
;
3169 unsigned int counter
= 0;
3170 alent
*cache_ptr
= lineno_cache
;
3171 LINENO
*src
= native_lineno
;
3173 while (counter
< asect
->lineno_count
) {
3174 struct internal_lineno dst
;
3175 coff_swap_lineno_in(abfd
, src
, &dst
);
3176 cache_ptr
->line_number
= dst
.l_lnno
;
3178 if (cache_ptr
->line_number
== 0) {
3179 coff_symbol_type
*sym
=
3180 (coff_symbol_type
*) (dst
.l_addr
.l_symndx
3181 + obj_raw_syments(abfd
))->u
.syment
._n
._n_n
._n_zeroes
;
3182 cache_ptr
->u
.sym
= (asymbol
*) sym
;
3183 sym
->lineno
= cache_ptr
;
3186 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
3187 - bfd_section_vma(abfd
, asect
);
3188 } /* If no linenumber expect a symbol index */
3194 cache_ptr
->line_number
= 0;
3197 asect
->lineno
= lineno_cache
;
3198 /* FIXME, free native_lineno here, or use alloca or something. */
3200 } /* coff_slurp_line_table() */
3202 #endif /* NO_COFF_LINENOS */
3204 #ifndef NO_COFF_LINENOS
3207 DEFUN(coff_slurp_symbol_table
,(abfd
),
3210 combined_entry_type
*native_symbols
;
3211 coff_symbol_type
*cached_area
;
3212 unsigned int *table_ptr
;
3214 unsigned int number_of_symbols
= 0;
3215 if (obj_symbols(abfd
))
3217 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
3219 /* Read in the symbol table */
3220 if ((native_symbols
= get_normalized_symtab(abfd
)) == NULL
) {
3224 /* Allocate enough room for all the symbols in cached form */
3226 (coff_symbol_type
*)
3227 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(coff_symbol_type
)));
3229 if (cached_area
== NULL
) {
3230 bfd_error
= no_memory
;
3235 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(unsigned int)));
3237 if (table_ptr
== NULL
) {
3238 bfd_error
= no_memory
;
3243 coff_symbol_type
*dst
= cached_area
;
3244 unsigned int last_native_index
= bfd_get_symcount(abfd
);
3245 unsigned int this_index
= 0;
3246 while (this_index
< last_native_index
) {
3247 combined_entry_type
*src
= native_symbols
+ this_index
;
3248 table_ptr
[this_index
] = number_of_symbols
;
3249 dst
->symbol
.the_bfd
= abfd
;
3251 dst
->symbol
.name
= (char *)(src
->u
.syment
._n
._n_n
._n_offset
);
3253 We use the native name field to point to the cached field
3255 src
->u
.syment
._n
._n_n
._n_zeroes
= (int) dst
;
3256 dst
->symbol
.section
= section_from_bfd_index(abfd
,
3257 src
->u
.syment
.n_scnum
);
3258 dst
->symbol
.flags
= 0;
3259 dst
->done_lineno
= false;
3261 switch (src
->u
.syment
.n_sclass
) {
3265 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
3266 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
3267 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
3269 /* Fall through to next case */
3277 if ((src
->u
.syment
.n_scnum
) == 0) {
3278 if ((src
->u
.syment
.n_value
) == 0) {
3279 dst
->symbol
.section
= &bfd_und_section
;
3280 dst
->symbol
.value
= 0;
3283 dst
->symbol
.section
= &bfd_com_section
;
3284 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3289 Base the value as an index from the base of the
3293 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
3294 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
3296 if (ISFCN((src
->u
.syment
.n_type
))) {
3298 A function ext does not go at the end of a file
3300 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
3307 case C_STAT
: /* static */
3309 case C_LEAFSTAT
: /* static leaf procedure */
3311 case C_LABEL
: /* label */
3312 if (src
->u
.syment
.n_scnum
== -2)
3313 dst
->symbol
.flags
= BSF_DEBUGGING
;
3315 dst
->symbol
.flags
= BSF_LOCAL
;
3317 Base the value as an index from the base of the section, if
3320 if (dst
->symbol
.section
)
3321 dst
->symbol
.value
= (src
->u
.syment
.n_value
) -
3322 dst
->symbol
.section
->vma
;
3324 dst
->symbol
.value
= (src
->u
.syment
.n_value
) ;
3327 case C_MOS
: /* member of structure */
3328 case C_EOS
: /* end of structure */
3329 #ifdef NOTDEF /* C_AUTOARG has the same value */
3331 case C_GLBLREG
: /* A29k-specific storage class */
3334 case C_REGPARM
: /* register parameter */
3335 case C_REG
: /* register variable */
3337 case C_AUTOARG
: /* 960-specific storage class */
3339 case C_TPDEF
: /* type definition */
3341 case C_AUTO
: /* automatic variable */
3342 case C_FIELD
: /* bit field */
3343 case C_ENTAG
: /* enumeration tag */
3344 case C_MOE
: /* member of enumeration */
3345 case C_MOU
: /* member of union */
3346 case C_UNTAG
: /* union tag */
3347 dst
->symbol
.flags
= BSF_DEBUGGING
;
3348 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3351 case C_FILE
: /* file name */
3352 case C_STRTAG
: /* structure tag */
3354 case C_BINCL
: /* beginning of include file */
3355 case C_EINCL
: /* ending of include file */
3368 dst
->symbol
.flags
= BSF_DEBUGGING
;
3369 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3372 case C_BLOCK
: /* ".bb" or ".eb" */
3373 case C_FCN
: /* ".bf" or ".ef" */
3374 case C_EFCN
: /* physical end of function */
3375 dst
->symbol
.flags
= BSF_LOCAL
;
3377 Base the value as an index from the base of the section
3379 dst
->symbol
.value
= (src
->u
.syment
.n_value
) - dst
->symbol
.section
->vma
;
3383 case C_EXTDEF
: /* external definition */
3384 case C_ULABEL
: /* undefined label */
3385 case C_USTATIC
: /* undefined static */
3386 case C_LINE
: /* line # reformatted as symbol table entry */
3387 case C_ALIAS
: /* duplicate tag */
3388 case C_HIDDEN
: /* ext symbol in dmert public lib */
3391 fprintf(stderr
,"Unrecognized storage class %d\n",
3392 src
->u
.syment
.n_sclass
);
3394 dst
->symbol
.flags
= BSF_DEBUGGING
;
3395 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3399 /* BFD_ASSERT(dst->symbol.flags != 0);*/
3403 dst
->symbol
.udata
= 0;
3404 dst
->lineno
= (alent
*) NULL
;
3405 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
3407 number_of_symbols
++;
3408 } /* walk the native symtab */
3409 } /* bfdize the native symtab */
3411 obj_symbols(abfd
) = cached_area
;
3412 obj_raw_syments(abfd
) = native_symbols
;
3414 obj_conv_table_size (abfd
) = bfd_get_symcount (abfd
);
3415 bfd_get_symcount(abfd
) = number_of_symbols
;
3416 obj_convert(abfd
) = table_ptr
;
3417 /* Slurp the line tables for each section too */
3422 coff_slurp_line_table(abfd
, p
);
3427 } /* coff_slurp_symbol_table() */
3430 coff_get_symtab_upper_bound(abfd
)
3433 if (!coff_slurp_symbol_table(abfd
))
3436 return (bfd_get_symcount(abfd
) + 1) * (sizeof(coff_symbol_type
*));
3441 DEFUN(coff_get_symtab
, (abfd
, alocation
),
3443 asymbol
**alocation
)
3445 unsigned int counter
= 0;
3446 coff_symbol_type
*symbase
;
3447 coff_symbol_type
**location
= (coff_symbol_type
**) (alocation
);
3448 if (!coff_slurp_symbol_table(abfd
))
3451 symbase
= obj_symbols(abfd
);
3452 while (counter
< bfd_get_symcount(abfd
))
3454 /* This nasty code looks at the symbol to decide whether or
3455 not it is descibes a constructor/destructor entry point. It
3456 is structured this way to (hopefully) speed non matches */
3458 if (0 && symbase
->symbol
.name
[9] == '$')
3460 bfd_constructor_entry(abfd
,
3461 (asymbol
**)location
,
3462 symbase
->symbol
.name
[10] == 'I' ?
3466 *(location
++) = symbase
++;
3470 return bfd_get_symcount(abfd
);
3473 #endif /* NO_COFF_SYMBOLS */
3476 coff_get_reloc_upper_bound(abfd
, asect
)
3480 if (bfd_get_format(abfd
) != bfd_object
) {
3481 bfd_error
= invalid_operation
;
3484 return (asect
->reloc_count
+ 1) * sizeof(arelent
*);
3491 Coff relocations are easily transformed into the internal BFD form
3494 Reading a coff relocation table is done in the following stages:
3496 o The entire coff relocation table is read into memory.
3498 o Each relocation is processed in turn, first it is swapped from the
3499 external to the internal form.
3501 o The symbol referenced in the relocation's symbol index is
3502 turned intoa pointer into the canonical symbol table. Note
3503 that this table is the same as the one returned by a call to
3504 @code{bfd_canonicalize_symtab}. The back end will call the
3505 routine and save the result if a canonicalization hasn't been done.
3507 o The reloc index is turned into a pointer to a howto
3508 structure, in a back end specific way. For instance, the 386
3509 and 960 use the @code{r_type} to directly produce an index
3510 into a howto table vector; the 88k subtracts a number from the
3511 @code{r_type} field and creates an addend field.
3517 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
3518 if (ptr && ptr->the_bfd == abfd \
3519 && ((ptr->flags & BSF_OLD_COMMON)== 0)) \
3521 cache_ptr->addend = -(ptr->section->vma + ptr->value); \
3524 cache_ptr->addend = 0; \
3529 DEFUN(coff_slurp_reloc_table
,(abfd
, asect
, symbols
),
3534 RELOC
*native_relocs
;
3535 arelent
*reloc_cache
;
3540 if (asect
->relocation
)
3542 if (asect
->reloc_count
== 0)
3544 if (asect
->flags
& SEC_CONSTRUCTOR
)
3546 #ifndef NO_COFF_SYMBOLS
3547 if (!coff_slurp_symbol_table(abfd
))
3551 (RELOC
*) buy_and_read(abfd
,
3555 asect
->reloc_count
));
3556 reloc_cache
= (arelent
*)
3557 bfd_alloc(abfd
, (size_t) (asect
->reloc_count
* sizeof(arelent
)));
3559 if (reloc_cache
== NULL
) {
3560 bfd_error
= no_memory
;
3565 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
3567 #ifdef RELOC_PROCESSING
3568 struct internal_reloc dst
;
3569 struct external_reloc
*src
;
3571 cache_ptr
= reloc_cache
+ idx
;
3572 src
= native_relocs
+ idx
;
3573 bfd_swap_reloc_in(abfd
, src
, &dst
);
3575 RELOC_PROCESSING(cache_ptr
, &dst
, symbols
, abfd
, asect
);
3577 struct internal_reloc dst
;
3579 struct external_reloc
*src
;
3581 cache_ptr
= reloc_cache
+ idx
;
3582 src
= native_relocs
+ idx
;
3584 bfd_swap_reloc_in(abfd
, src
, &dst
);
3587 cache_ptr
->address
= dst
.r_vaddr
;
3589 if (dst
.r_symndx
!= -1)
3591 /* @@ Should never be greater than count of symbols! */
3592 if (dst
.r_symndx
>= obj_conv_table_size (abfd
))
3594 cache_ptr
->sym_ptr_ptr
= symbols
+ obj_convert(abfd
)[dst
.r_symndx
];
3595 ptr
= *(cache_ptr
->sym_ptr_ptr
);
3599 cache_ptr
->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
3604 The symbols definitions that we have read in have been
3605 relocated as if their sections started at 0. But the offsets
3606 refering to the symbols in the raw data have not been
3607 modified, so we have to have a negative addend to compensate.
3609 Note that symbols which used to be common must be left alone */
3611 /* Calculate any reloc addend by looking at the symbol */
3612 CALC_ADDEND(abfd
, ptr
, dst
, cache_ptr
);
3614 cache_ptr
->address
-= asect
->vma
;
3615 /* !! cache_ptr->section = (asection *) NULL;*/
3617 /* Fill in the cache_ptr->howto field from dst.r_type */
3618 RTYPE2HOWTO(cache_ptr
, &dst
);
3623 asect
->relocation
= reloc_cache
;
3628 /* This is stupid. This function should be a boolean predicate */
3630 DEFUN(coff_canonicalize_reloc
, (abfd
, section
, relptr
, symbols
),
3633 arelent
**relptr AND
3636 arelent
*tblptr
= section
->relocation
;
3637 unsigned int count
= 0;
3640 if (section
->flags
& SEC_CONSTRUCTOR
)
3642 /* this section has relocs made up by us, they are not in the
3643 file, so take them out of their chain and place them into
3644 the data area provided */
3645 arelent_chain
*chain
= section
->constructor_chain
;
3646 for (count
= 0; count
< section
->reloc_count
; count
++)
3648 *relptr
++ = &chain
->relent
;
3649 chain
= chain
->next
;
3655 coff_slurp_reloc_table(abfd
, section
, symbols
);
3658 tblptr
= section
->relocation
;
3662 for (; count
++ < section
->reloc_count
;)
3663 *relptr
++ = tblptr
++;
3668 return section
->reloc_count
;
3671 #ifndef NO_COFF_SYMBOLS
3674 provided a BFD, a section and an offset into the section, calculate and
3675 return the name of the source file and the line nearest to the wanted
3680 DEFUN(coff_find_nearest_line
,(abfd
,
3688 asection
*section AND
3689 asymbol
**ignore_symbols AND
3691 CONST
char **filename_ptr AND
3692 CONST
char **functionname_ptr AND
3693 unsigned int *line_ptr
)
3695 static bfd
*cache_abfd
;
3696 static asection
*cache_section
;
3697 static bfd_vma cache_offset
;
3698 static unsigned int cache_i
;
3699 static alent
*cache_l
;
3702 coff_data_type
*cof
= coff_data(abfd
);
3703 /* Run through the raw syments if available */
3704 combined_entry_type
*p
;
3706 unsigned int line_base
= 0;
3710 *functionname_ptr
= 0;
3713 /* Don't try and find line numbers in a non coff file */
3714 if (abfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
3720 p
= cof
->raw_syments
;
3722 for (i
= 0; i
< cof
->raw_syment_count
; i
++) {
3723 if (p
->u
.syment
.n_sclass
== C_FILE
) {
3724 /* File name has been moved into symbol */
3725 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
3728 p
+= 1 + p
->u
.syment
.n_numaux
;
3730 /* Now wander though the raw linenumbers of the section */
3732 If this is the same BFD as we were previously called with and this is
3733 the same section, and the offset we want is further down then we can
3734 prime the lookup loop
3736 if (abfd
== cache_abfd
&&
3737 section
== cache_section
&&
3738 offset
>= cache_offset
) {
3744 l
= section
->lineno
;
3747 for (; i
< section
->lineno_count
; i
++) {
3748 if (l
->line_number
== 0) {
3749 /* Get the symbol this line number points at */
3750 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
3751 *functionname_ptr
= coff
->symbol
.name
;
3753 combined_entry_type
*s
= coff
->native
;
3754 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
3756 S should now point to the .bf of the function
3758 if (s
->u
.syment
.n_numaux
) {
3760 The linenumber is stored in the auxent
3762 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
3763 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
3768 if (l
->u
.offset
> offset
)
3770 *line_ptr
= l
->line_number
+ line_base
+ 1;
3776 cache_section
= section
;
3777 cache_offset
= offset
;
3786 coff_sym_filepos(abfd
)
3789 return obj_sym_filepos(abfd
);
3793 #endif /* NO_COFF_SYMBOLS */
3797 DEFUN(coff_sizeof_headers
,(abfd
, reloc
),
3803 if (reloc
== false) {
3804 size
= FILHSZ
+ AOUTSZ
;
3810 size
+= abfd
->section_count
* SCNHSZ
;
3815 DEFUN(get_value
,(reloc
, seclet
),
3817 bfd_seclet_type
*seclet
)
3820 asymbol
*symbol
= *(reloc
->sym_ptr_ptr
);
3821 /* A symbol holds a pointer to a section, and an offset from the
3822 base of the section. To relocate, we find where the section will
3823 live in the output and add that in */
3825 if (symbol
->section
== &bfd_und_section
)
3827 /* Ouch, this is an undefined symbol.. */
3828 bfd_error_vector
.undefined_symbol(reloc
, seclet
);
3829 value
= symbol
->value
;
3833 value
= symbol
->value
+
3834 symbol
->section
->output_offset
+
3835 symbol
->section
->output_section
->vma
;
3839 /* Add the value contained in the relocation */
3840 value
+= (short)((reloc
->addend
) & 0xffff);
3846 DEFUN(perform_slip
,(s
, slip
, input_section
, value
),
3848 unsigned int slip AND
3849 asection
*input_section AND
3853 /* Find all symbols past this point, and make them know
3858 if (p
->section
== input_section
)
3860 /* This was pointing into this section, so mangle it */
3861 if (p
->value
> value
)
3871 DEFUN(movb1
,(input_section
, symbols
, r
, shrink
),
3872 asection
*input_section AND
3873 asymbol
**symbols AND
3875 unsigned int shrink
)
3877 bfd_vma value
= get_value(r
,0);
3879 if (value
>= 0xff00)
3882 /* Change the reloc type from 16bit, possible 8 to 8bit
3884 r
->howto
= r
->howto
+ 1;
3885 /* The place to relc moves back by one */
3888 /* This will be two bytes smaller in the long run */
3890 perform_slip(symbols
, 2, input_section
, r
->address
- shrink
+1);
3898 DEFUN(jmp1
,(input_section
, symbols
, r
, shrink
),
3899 asection
*input_section AND
3900 asymbol
**symbols AND
3902 unsigned int shrink
)
3906 bfd_vma value
= get_value(r
, 0);
3908 bfd_vma dot
= input_section
->output_section
->vma
+
3909 input_section
->output_offset
+ r
->address
;
3912 /* See if the address we're looking at within 127 bytes of where
3913 we are, if so then we can use a small branch rather than the
3914 jump we were going to */
3916 gap
= value
- (dot
- shrink
);
3919 if (-120 < (long)gap
&& (long)gap
< 120 )
3922 /* Change the reloc type from 16bit, possible 8 to 8bit
3924 r
->howto
= r
->howto
+ 1;
3925 /* The place to relc moves back by one */
3928 /* This will be two bytes smaller in the long run */
3930 perform_slip(symbols
, 2, input_section
, r
->address
-shrink
+1);
3938 DEFUN(bfd_coff_relax_section
,(abfd
, i
, symbols
),
3944 /* Get enough memory to hold the stuff */
3945 bfd
*input_bfd
= i
->owner
;
3946 asection
*input_section
= i
;
3948 boolean
new = false;
3950 bfd_size_type reloc_size
= bfd_get_reloc_upper_bound(input_bfd
,
3952 arelent
**reloc_vector
= (arelent
**)bfd_xmalloc(reloc_size
);
3954 /* Get the relocs and think about them */
3955 if (bfd_canonicalize_reloc(input_bfd
,
3961 for (parent
= reloc_vector
; *parent
; parent
++)
3963 arelent
*r
= *parent
;
3964 switch (r
->howto
->type
) {
3972 shrink
= movb1(input_section
, symbols
, r
, shrink
);
3977 shrink
= jmp1(input_section
, symbols
, r
, shrink
);
3985 input_section
->_cooked_size
-= shrink
;
3986 free((char *)reloc_vector
);
3991 DEFUN(bfd_coff_get_relocated_section_contents
,(in_abfd
, seclet
, data
),
3993 bfd_seclet_type
*seclet AND
3997 /* Get enough memory to hold the stuff */
3998 bfd
*input_bfd
= seclet
->u
.indirect
.section
->owner
;
3999 asection
*input_section
= seclet
->u
.indirect
.section
;
4000 bfd_size_type reloc_size
= bfd_get_reloc_upper_bound(input_bfd
,
4002 arelent
**reloc_vector
= (arelent
**)bfd_xmalloc(reloc_size
);
4004 /* read in the section */
4005 bfd_get_section_contents(input_bfd
,
4009 input_section
->_raw_size
);
4012 if (bfd_canonicalize_reloc(input_bfd
,
4015 seclet
->u
.indirect
.symbols
) )
4017 arelent
**parent
= reloc_vector
;
4022 unsigned int dst_address
= 0;
4023 unsigned int src_address
= 0;
4027 /* Find how long a run we can do */
4028 while (dst_address
< seclet
->size
)
4034 /* Note that the relaxing didn't tie up the addresses in the
4035 relocation, so we use the original address to work out the
4036 run of non-relocated data */
4037 run
= reloc
->address
- src_address
;
4043 run
= seclet
->size
- dst_address
;
4045 /* Copy the bytes */
4046 for (idx
= 0; idx
< run
; idx
++)
4048 data
[dst_address
++] = data
[src_address
++];
4051 /* Now do the relocation */
4055 switch (reloc
->howto
->type
)
4058 /* Speciial relaxed type */
4060 bfd_vma dot
= seclet
->offset
+ dst_address
+ seclet
->u
.indirect
.section
->output_section
->vma
;
4061 int gap
= get_value(reloc
,seclet
)-dot
-1;
4062 if ((gap
& ~0xff ) != 0 &&((gap
& 0xff00)!= 0xff00)) abort();
4064 bfd_put_8(in_abfd
,gap
, data
+dst_address
);
4066 switch (data
[dst_address
-1])
4071 bfd_put_8(in_abfd
, 0x55, data
+dst_address
-1);
4075 bfd_put_8(in_abfd
, 0x40, data
+dst_address
-1);
4094 /* Special relaxed type, there will be a gap between where we
4095 get stuff from and where we put stuff to now
4097 for a mov.b @aa:16 -> mov.b @aa:8
4098 opcode 0x6a 0x0y offset
4101 if (data
[dst_address
-1] != 0x6a)
4103 switch (data
[src_address
] & 0xf0)
4107 data
[dst_address
-1] = (data
[src_address
] & 0xf) | 0x20;
4111 data
[dst_address
-1] = (data
[src_address
] & 0xf) | 0x30;
4117 /* the offset must fit ! after all, what was all the relaxing
4120 bfd_put_8(in_abfd
, get_value(reloc
, seclet
), data
+ dst_address
);
4122 /* Note the magic - src goes up by two bytes, but dst by only
4131 bfd_vma dot
= seclet
->offset
+ dst_address
+ seclet
->u
.indirect
.section
->output_section
->vma
;
4132 int gap
= get_value(reloc
,seclet
)-dot
;
4133 if (gap
> 127 || gap
< -128)
4135 bfd_error_vector
.reloc_value_truncated(reloc
, seclet
);
4138 bfd_put_8(in_abfd
,gap
, data
+dst_address
);
4147 unsigned int gap
=get_value(reloc
,seclet
);
4148 if (gap
> 0xff && gap
< ~0xff)
4150 bfd_error_vector
.reloc_value_truncated(reloc
, seclet
);
4153 bfd_put_8(in_abfd
, gap
, data
+dst_address
);
4161 /* A relword which would have like to have been a pcrel */
4163 /* A relword which would like to have been modified but
4166 bfd_put_16(in_abfd
, get_value(reloc
,seclet
), data
+dst_address
);
4181 free((char *)reloc_vector
);
4187 #define coff_core_file_failing_command _bfd_dummy_core_file_failing_command
4188 #define coff_core_file_failing_signal _bfd_dummy_core_file_failing_signal
4189 #define coff_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
4190 #define coff_slurp_armap bfd_slurp_coff_armap
4191 #define coff_slurp_extended_name_table _bfd_slurp_extended_name_table
4192 #define coff_truncate_arname bfd_dont_truncate_arname
4193 #define coff_openr_next_archived_file bfd_generic_openr_next_archived_file
4194 #define coff_generic_stat_arch_elt bfd_generic_stat_arch_elt
4195 #define coff_get_section_contents bfd_generic_get_section_contents
4196 #define coff_close_and_cleanup bfd_generic_close_and_cleanup
4198 #define coff_bfd_debug_info_start bfd_void
4199 #define coff_bfd_debug_info_end bfd_void
4200 #define coff_bfd_debug_info_accumulate (PROTO(void,(*),(bfd*, struct sec *))) bfd_void
4201 #define coff_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
4202 #define coff_bfd_relax_section bfd_generic_relax_section