1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
3 Written by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
22 Most of this hacked by Steve Chamberlain,
30 BFD supports a number of different flavours of coff format.
31 The major difference between formats are the sizes and
32 alignments of fields in structures on disk, and the occasional
35 Coff in all its varieties is implimented with a few common
36 files and a number of implementation specific files. For
37 example, The 88k bcs coff format is implemented in the file
38 @code{coff-m88k.c}. This file @code{#include}s
39 @code{coff-m88k.h} which defines the external structure of the
40 coff format for the 88k, and @code{internalcoff.h} which
41 defines the internal structure. @code{coff-m88k.c} also
42 defines pthe relocations used by the 88k format
43 @xref{Relocations}. Then the major portion of coff code is
44 included (@code{coffcode.h}) which defines the methods used to
45 act upon the types defined in @code{coff-m88k.h} and
46 @code{internalcoff.h}.
49 The Intel i960 processor version of coff is implemented in
50 @code{coff-i960.c}. This file has the same structure as
51 @code{coff-m88k.c}, except that it includes @code{coff-i960.h}
52 rather than @code{coff-m88k.h}.
55 Porting To A New Version of Coff
57 The recommended method is to select from the existing
58 implimentations the version of coff which is most like the one
59 you want to use, for our purposes, we'll say that i386 coff is
60 the one you select, and that your coff flavour is called foo.
61 Copy the @code{i386coff.c} to @code{foocoff.c}, copy
62 @code{../include/i386coff.h} to @code{../include/foocoff.h}
63 and add the lines to @code{targets.c} and @code{Makefile.in}
64 so that your new back end is used. Alter the shapes of the
65 structures in @code{../include/foocoff.h} so that they match
66 what you need. You will probably also have to add
67 @code{#ifdef}s to the code in @code{internalcoff.h} and
68 @code{coffcode.h} if your version of coff is too wild.
70 You can verify that your new BFD backend works quite simply by
71 building @code{objdump} from the @code{binutils} directory,
72 and making sure that its version of what's going on at your
73 host systems idea (assuming it has the pretty standard coff
74 dump utility (usually called @code{att-dump} or just
75 @code{dump})) are the same. Then clean up your code, and send
76 what you've done to Cygnus. Then your stuff will be in the
77 next release, and you won't have to keep integrating it.
80 How The Coff Backend Works
85 Each flavour of coff supported in BFD has its own header file
86 descibing the external layout of the structures. There is also
87 an internal description of the coff layout (in
88 @code{internalcoff.h}) file (@code{}). A major function of the
89 coff backend is swapping the bytes and twiddling the bits to
90 translate the external form of the structures into the normal
91 internal form. This is all performed in the
92 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
93 elements are different sizes between different versions of
94 coff, it is the duty of the coff version specific include file
95 to override the definitions of various packing routines in
96 @code{coffcode.h}. Eg the size of line number entry in coff is
97 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
98 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
99 correct one. No doubt, some day someone will find a version of
100 coff which has a varying field size not catered for at the
101 moment. To port BFD, that person will have to add more @code{#defines}.
102 Three of the bit twiddling routines are exported to
103 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
104 and @code{coff_swap_linno_in}. @code{GDB} reads the symbol
105 table on its own, but uses BFD to fix things up. More of the
106 bit twiddlers are exported for @code{gas};
107 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
108 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
109 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
110 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
111 of all the symbol table and reloc drudgery itself, thereby
112 saving the internal BFD overhead, but uses BFD to swap things
113 on the way out, making cross ports much safer. This also
114 allows BFD (and thus the linker) to use the same header files
115 as @code{gas}, which makes one avenue to disaster disappear.
120 The simple canonical form for symbols used by BFD is not rich
121 enough to keep all the information available in a coff symbol
122 table. The back end gets around this by keeping the original
123 symbol table around, "behind the scenes".
125 When a symbol table is requested (through a call to
126 @code{bfd_canonicalize_symtab}, a request gets through to
127 @code{get_normalized_symtab}. This reads the symbol table from
128 the coff file and swaps all the structures inside into the
129 internal form. It also fixes up all the pointers in the table
130 (represented in the file by offsets from the first symbol in
131 the table) into physical pointers to elements in the new
132 internal table. This involves some work since the meanings of
133 fields changes depending upon context; a field that is a
134 pointer to another structure in the symbol table at one moment
135 may be the size in bytes of a structure in the next. Another
136 pass is made over the table. All symbols which mark file names
137 (<<C_FILE>> symbols) are modified so that the internal
138 string points to the value in the auxent (the real filename)
139 rather than the normal text associated with the symbol
142 At this time the symbol names are moved around. Coff stores
143 all symbols less than nine characters long physically
144 within the symbol table, longer strings are kept at the end of
145 the file in the string table. This pass moves all strings
146 into memory, and replaces them with pointers to the strings.
149 The symbol table is massaged once again, this time to create
150 the canonical table used by the BFD application. Each symbol
151 is inspected in turn, and a decision made (using the
152 @code{sclass} field) about the various flags to set in the
153 @code{asymbol} @xref{Symbols}. The generated canonical table
154 shares strings with the hidden internal symbol table.
156 Any linenumbers are read from the coff file too, and attached
157 to the symbols which own the functions the linenumbers belong to.
162 Writing a symbol to a coff file which didn't come from a coff
163 file will lose any debugging information. The @code{asymbol}
164 structure remembers the BFD from which was born, and on output
165 the back end makes sure that the same destination target as
166 source target is present.
168 When the symbols have come from a coff file then all the
169 debugging information is preserved.
171 Symbol tables are provided for writing to the back end in a
172 vector of pointers to pointers. This allows applications like
173 the linker to accumulate and output large symbol tables
174 without having to do too much byte copying.
176 This function runs through the provided symbol table and
177 patches each symbol marked as a file place holder
178 (@code{C_FILE}) to point to the next file place holder in the
179 list. It also marks each @code{offset} field in the list with
180 the offset from the first symbol of the current symbol.
182 Another function of this procedure is to turn the canonical
183 value form of BFD into the form used by coff. Internally, BFD
184 expects symbol values to be offsets from a section base; so a
185 symbol physically at 0x120, but in a section starting at
186 0x100, would have the value 0x20. Coff expects symbols to
187 contain their final value, so symbols have their values
188 changed at this point to reflect their sum with their owning
189 section. Note that this transformation uses the
190 <<output_section>> field of the @code{asymbol}'s
191 @code{asection} @xref{Sections}.
193 o coff_mangle_symbols
195 This routine runs though the provided symbol table and uses
196 the offsets generated by the previous pass and the pointers
197 generated when the symbol table was read in to create the
198 structured hierachy required by coff. It changes each pointer
199 to a symbol to an index into the symbol table of the symbol
204 This routine runs through the symbol table and patches up the
205 symbols from their internal form into the coff way, calls the
206 bit twiddlers and writes out the tabel to the file.
215 The hidden information for an asymbol is described in a
216 coff_ptr_struct, which is typedefed to a combined_entry_type
220 .typedef struct coff_ptr_struct
223 . {* Remembers the offset from the first symbol in the file for
224 . this symbol. Generated by coff_renumber_symbols. *}
225 .unsigned int offset;
227 . {* Should the tag field of this symbol be renumbered.
228 . Created by coff_pointerize_aux. *}
231 . {* Should the endidx field of this symbol be renumbered.
232 . Created by coff_pointerize_aux. *}
235 . {* The container for the symbol structure as read and translated
239 . union internal_auxent auxent;
240 . struct internal_syment syment;
242 .} combined_entry_type;
245 .{* Each canonical asymbol really looks like this: *}
247 .typedef struct coff_symbol_struct
249 . {* The actual symbol which the rest of BFD works with *}
252 . {* A pointer to the hidden information for this symbol *}
253 .combined_entry_type *native;
255 . {* A pointer to the linenumber information for this symbol *}
256 .struct lineno_cache_entry *lineno;
258 . {* Have the line numbers been relocated yet ? *}
259 .boolean done_lineno;
266 extern bfd_error_vector_type bfd_error_vector
;
271 #define PUTWORD bfd_h_put_32
272 #define PUTHALF bfd_h_put_16
273 #define PUTBYTE bfd_h_put_8
275 #ifndef GET_FCN_LNNOPTR
276 #define GET_FCN_LNNOPTR(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
279 #ifndef GET_FCN_ENDNDX
280 #define GET_FCN_ENDNDX(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
283 #ifndef PUT_FCN_LNNOPTR
284 #define PUT_FCN_LNNOPTR(abfd, in, ext) PUTWORD(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
286 #ifndef PUT_FCN_ENDNDX
287 #define PUT_FCN_ENDNDX(abfd, in, ext) PUTWORD(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
289 #ifndef GET_LNSZ_LNNO
290 #define GET_LNSZ_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_lnno)
292 #ifndef GET_LNSZ_SIZE
293 #define GET_LNSZ_SIZE(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_size)
295 #ifndef PUT_LNSZ_LNNO
296 #define PUT_LNSZ_LNNO(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_sym.x_misc.x_lnsz.x_lnno)
298 #ifndef PUT_LNSZ_SIZE
299 #define PUT_LNSZ_SIZE(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte*) ext->x_sym.x_misc.x_lnsz.x_size)
301 #ifndef GET_SCN_SCNLEN
302 #define GET_SCN_SCNLEN(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_scn.x_scnlen)
304 #ifndef GET_SCN_NRELOC
305 #define GET_SCN_NRELOC(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nreloc)
307 #ifndef GET_SCN_NLINNO
308 #define GET_SCN_NLINNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nlinno)
310 #ifndef PUT_SCN_SCNLEN
311 #define PUT_SCN_SCNLEN(abfd,in, ext) bfd_h_put_32(abfd, in, (bfd_byte *) ext->x_scn.x_scnlen)
313 #ifndef PUT_SCN_NRELOC
314 #define PUT_SCN_NRELOC(abfd,in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_scn.x_nreloc)
316 #ifndef PUT_SCN_NLINNO
317 #define PUT_SCN_NLINNO(abfd,in, ext) bfd_h_put_16(abfd,in, (bfd_byte *) ext->x_scn.x_nlinno)
319 #ifndef GET_LINENO_LNNO
320 #define GET_LINENO_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) (ext->l_lnno));
322 #ifndef PUT_LINENO_LNNO
323 #define PUT_LINENO_LNNO(abfd,val, ext) bfd_h_put_16(abfd,val, (bfd_byte *) (ext->l_lnno));
327 /* void warning(); */
330 * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the
331 * incoming SEC_* flags. The inverse of this function is styp_to_sec_flags().
332 * NOTE: If you add to/change this routine, you should mirror the changes
333 * in styp_to_sec_flags().
336 DEFUN(sec_to_styp_flags
, (sec_name
, sec_flags
),
337 CONST
char * sec_name AND
342 if (!strcmp(sec_name
, _TEXT
)) {
343 return((long)STYP_TEXT
);
344 } else if (!strcmp(sec_name
, _DATA
)) {
345 return((long)STYP_DATA
);
347 } else if (!strcmp(sec_name
, ".data2")) {
348 return((long)STYP_DATA
);
349 #endif /* TWO_DATA_SECS */
350 } else if (!strcmp(sec_name
, _BSS
)) {
351 return((long)STYP_BSS
);
353 } else if (!strcmp(sec_name
, _COMMENT
)) {
354 return((long)STYP_INFO
);
355 #endif /* _COMMENT */
357 } else if (!strcmp(sec_name
, _LIB
)) {
358 return((long)STYP_LIB
);
362 /* Try and figure out what it should be */
363 if (sec_flags
& SEC_CODE
) styp_flags
= STYP_TEXT
;
364 if (sec_flags
& SEC_DATA
) styp_flags
= STYP_DATA
;
365 else if (sec_flags
& SEC_READONLY
)
366 #ifdef STYP_LIT /* 29k readonly text/data section */
367 styp_flags
= STYP_LIT
;
369 styp_flags
= STYP_TEXT
;
370 #endif /* STYP_LIT */
371 else if (sec_flags
& SEC_LOAD
) styp_flags
= STYP_TEXT
;
373 if (styp_flags
== 0) styp_flags
= STYP_BSS
;
376 if (sec_flags
& SEC_NEVER_LOAD
)
377 styp_flags
|= STYP_NOLOAD
;
383 * Return a word with SEC_* flags set to represent the incoming
384 * STYP_* flags (from scnhdr.s_flags). The inverse of this
385 * function is sec_to_styp_flags().
386 * NOTE: If you add to/change this routine, you should mirror the changes
387 * in sec_to_styp_flags().
390 DEFUN(styp_to_sec_flags
, (styp_flags
),
393 flagword sec_flags
=0;
396 if (styp_flags
& STYP_NOLOAD
)
398 sec_flags
|= SEC_NEVER_LOAD
;
400 #endif /* STYP_NOLOAD */
402 if ((styp_flags
& STYP_TEXT
) || (styp_flags
& STYP_DATA
))
404 sec_flags
|= SEC_LOAD
| SEC_ALLOC
;
406 else if (styp_flags
& STYP_BSS
)
408 sec_flags
|= SEC_ALLOC
;
410 else if (styp_flags
& STYP_INFO
)
412 sec_flags
|= SEC_NEVER_LOAD
;
416 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
419 #ifdef STYP_LIT /* A29k readonly text/data section type */
420 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
422 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
424 #endif /* STYP_LIT */
425 #ifdef STYP_OTHER_LOAD /* Other loaded sections */
426 if (styp_flags
& STYP_OTHER_LOAD
)
428 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
430 #endif /* STYP_SDATA */
435 #define get_index(symbol) ((int) (symbol)->udata)
436 #define set_index(symbol, idx) ((symbol)->udata =(PTR) (idx))
438 /* **********************************************************************
439 Here are all the routines for swapping the structures seen in the
440 outside world into the internal forms.
445 DEFUN(bfd_swap_reloc_in
,(abfd
, reloc_src
, reloc_dst
),
448 struct internal_reloc
*reloc_dst
)
450 reloc_dst
->r_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*)reloc_src
->r_vaddr
);
451 reloc_dst
->r_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) reloc_src
->r_symndx
);
454 reloc_dst
->r_type
= bfd_h_get_8(abfd
, reloc_src
->r_type
);
455 reloc_dst
->r_size
= bfd_h_get_8(abfd
, reloc_src
->r_size
);
457 reloc_dst
->r_type
= bfd_h_get_16(abfd
, (bfd_byte
*) reloc_src
->r_type
);
460 #ifdef SWAP_IN_RELOC_OFFSET
461 reloc_dst
->r_offset
= SWAP_IN_RELOC_OFFSET(abfd
,
462 (bfd_byte
*) reloc_src
->r_offset
);
468 DEFUN(coff_swap_reloc_out
,(abfd
, src
, dst
),
473 struct internal_reloc
*reloc_src
= (struct internal_reloc
*)src
;
474 struct external_reloc
*reloc_dst
= (struct external_reloc
*)dst
;
475 bfd_h_put_32(abfd
, reloc_src
->r_vaddr
, (bfd_byte
*) reloc_dst
->r_vaddr
);
476 bfd_h_put_32(abfd
, reloc_src
->r_symndx
, (bfd_byte
*) reloc_dst
->r_symndx
);
477 bfd_h_put_16(abfd
, reloc_src
->r_type
, (bfd_byte
*)
480 #ifdef SWAP_OUT_RELOC_OFFSET
481 SWAP_OUT_RELOC_OFFSET(abfd
,
483 (bfd_byte
*) reloc_dst
->r_offset
);
485 #ifdef SWAP_OUT_RELOC_EXTRA
486 SWAP_OUT_RELOC_EXTRA(abfd
,reloc_src
, reloc_dst
);
489 return sizeof(struct external_reloc
);
493 DEFUN(bfd_swap_filehdr_in
,(abfd
, filehdr_src
, filehdr_dst
),
495 FILHDR
*filehdr_src AND
496 struct internal_filehdr
*filehdr_dst
)
498 filehdr_dst
->f_magic
= bfd_h_get_16(abfd
, (bfd_byte
*) filehdr_src
->f_magic
);
499 filehdr_dst
->f_nscns
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_nscns
);
500 filehdr_dst
->f_timdat
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_timdat
);
501 filehdr_dst
->f_symptr
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_symptr
);
502 filehdr_dst
->f_nsyms
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_nsyms
);
503 filehdr_dst
->f_opthdr
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_opthdr
);
504 filehdr_dst
->f_flags
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_flags
);
508 DEFUN(coff_swap_filehdr_out
,(abfd
, in
, out
),
513 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*)in
;
514 FILHDR
*filehdr_out
= (FILHDR
*)out
;
515 bfd_h_put_16(abfd
, filehdr_in
->f_magic
, (bfd_byte
*) filehdr_out
->f_magic
);
516 bfd_h_put_16(abfd
, filehdr_in
->f_nscns
, (bfd_byte
*) filehdr_out
->f_nscns
);
517 bfd_h_put_32(abfd
, filehdr_in
->f_timdat
, (bfd_byte
*) filehdr_out
->f_timdat
);
518 bfd_h_put_32(abfd
, filehdr_in
->f_symptr
, (bfd_byte
*) filehdr_out
->f_symptr
);
519 bfd_h_put_32(abfd
, filehdr_in
->f_nsyms
, (bfd_byte
*) filehdr_out
->f_nsyms
);
520 bfd_h_put_16(abfd
, filehdr_in
->f_opthdr
, (bfd_byte
*) filehdr_out
->f_opthdr
);
521 bfd_h_put_16(abfd
, filehdr_in
->f_flags
, (bfd_byte
*) filehdr_out
->f_flags
);
522 return sizeof(FILHDR
);
526 #ifndef NO_COFF_SYMBOLS
529 DEFUN(coff_swap_sym_in
,(abfd
, ext1
, in1
),
534 SYMENT
*ext
= (SYMENT
*)ext1
;
535 struct internal_syment
*in
= (struct internal_syment
*)in1
;
537 if( ext
->e
.e_name
[0] == 0) {
538 in
->_n
._n_n
._n_zeroes
= 0;
539 in
->_n
._n_n
._n_offset
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e
.e
.e_offset
);
542 #if SYMNMLEN != E_SYMNMLEN
543 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
545 memcpy(in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
548 in
->n_value
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_value
);
549 in
->n_scnum
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_scnum
);
550 if (sizeof(ext
->e_type
) == 2){
551 in
->n_type
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_type
);
554 in
->n_type
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_type
);
556 in
->n_sclass
= bfd_h_get_8(abfd
, ext
->e_sclass
);
557 in
->n_numaux
= bfd_h_get_8(abfd
, ext
->e_numaux
);
561 DEFUN(coff_swap_sym_out
,(abfd
, inp
, extp
),
566 struct internal_syment
*in
= (struct internal_syment
*)inp
;
567 SYMENT
*ext
=(SYMENT
*)extp
;
568 if(in
->_n
._n_name
[0] == 0) {
569 bfd_h_put_32(abfd
, 0, (bfd_byte
*) ext
->e
.e
.e_zeroes
);
570 bfd_h_put_32(abfd
, in
->_n
._n_n
._n_offset
, (bfd_byte
*) ext
->e
.e
.e_offset
);
573 #if SYMNMLEN != E_SYMNMLEN
574 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
576 memcpy(ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
579 bfd_h_put_32(abfd
, in
->n_value
, (bfd_byte
*) ext
->e_value
);
580 bfd_h_put_16(abfd
, in
->n_scnum
, (bfd_byte
*) ext
->e_scnum
);
581 if (sizeof(ext
->e_type
) == 2)
583 bfd_h_put_16(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
587 bfd_h_put_32(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
589 bfd_h_put_8(abfd
, in
->n_sclass
, ext
->e_sclass
);
590 bfd_h_put_8(abfd
, in
->n_numaux
, ext
->e_numaux
);
591 return sizeof(SYMENT
);
595 DEFUN(coff_swap_aux_in
,(abfd
, ext1
, type
, class, in1
),
602 AUXENT
*ext
= (AUXENT
*)ext1
;
603 union internal_auxent
*in
= (union internal_auxent
*)in1
;
607 if (ext
->x_file
.x_fname
[0] == 0) {
608 in
->x_file
.x_n
.x_zeroes
= 0;
609 in
->x_file
.x_n
.x_offset
=
610 bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
612 #if FILNMLEN != E_FILNMLEN
613 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
615 memcpy (in
->x_file
.x_fname
, ext
->x_file
.x_fname
, FILNMLEN
);
620 /* RS/6000 "csect" auxents */
624 in
->x_csect
.x_scnlen
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_scnlen
);
625 in
->x_csect
.x_parmhash
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_parmhash
);
626 in
->x_csect
.x_snhash
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snhash
);
627 /* We don't have to hack bitfields in x_smtyp because it's defined by
628 shifts-and-ands, which are equivalent on all byte orders. */
629 in
->x_csect
.x_smtyp
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smtyp
);
630 in
->x_csect
.x_smclas
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smclas
);
631 in
->x_csect
.x_stab
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_stab
);
632 in
->x_csect
.x_snstab
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snstab
);
641 if (type
== T_NULL
) {
642 in
->x_scn
.x_scnlen
= GET_SCN_SCNLEN(abfd
, ext
);
643 in
->x_scn
.x_nreloc
= GET_SCN_NRELOC(abfd
, ext
);
644 in
->x_scn
.x_nlinno
= GET_SCN_NLINNO(abfd
, ext
);
648 in
->x_sym
.x_tagndx
.l
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
650 in
->x_sym
.x_tvndx
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
653 if (ISARY(type
) || class == C_BLOCK
) {
654 #if DIMNUM != E_DIMNUM
655 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
657 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]);
658 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]);
659 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]);
660 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]);
663 in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= GET_FCN_LNNOPTR(abfd
, ext
);
664 in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= GET_FCN_ENDNDX(abfd
, ext
);
667 in
->x_sym
.x_misc
.x_fsize
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
670 in
->x_sym
.x_misc
.x_lnsz
.x_lnno
= GET_LNSZ_LNNO(abfd
, ext
);
671 in
->x_sym
.x_misc
.x_lnsz
.x_size
= GET_LNSZ_SIZE(abfd
, ext
);
677 DEFUN(coff_swap_aux_out
,(abfd
, inp
, type
, class, extp
),
684 union internal_auxent
*in
= (union internal_auxent
*)inp
;
685 AUXENT
*ext
= (AUXENT
*)extp
;
688 if (in
->x_file
.x_fname
[0] == 0) {
689 PUTWORD(abfd
, 0, (bfd_byte
*) ext
->x_file
.x_n
.x_zeroes
);
691 in
->x_file
.x_n
.x_offset
,
692 (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
695 #if FILNMLEN != E_FILNMLEN
696 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
698 memcpy (ext
->x_file
.x_fname
, in
->x_file
.x_fname
, FILNMLEN
);
704 /* RS/6000 "csect" auxents */
707 PUTWORD (abfd
, in
->x_csect
.x_scnlen
, ext
->x_csect
.x_scnlen
);
708 PUTWORD (abfd
, in
->x_csect
.x_parmhash
, ext
->x_csect
.x_parmhash
);
709 PUTHALF (abfd
, in
->x_csect
.x_snhash
, ext
->x_csect
.x_snhash
);
710 /* We don't have to hack bitfields in x_smtyp because it's defined by
711 shifts-and-ands, which are equivalent on all byte orders. */
712 PUTBYTE (abfd
, in
->x_csect
.x_smtyp
, ext
->x_csect
.x_smtyp
);
713 PUTBYTE (abfd
, in
->x_csect
.x_smclas
, ext
->x_csect
.x_smclas
);
714 PUTWORD (abfd
, in
->x_csect
.x_stab
, ext
->x_csect
.x_stab
);
715 PUTHALF (abfd
, in
->x_csect
.x_snstab
, ext
->x_csect
.x_snstab
);
724 if (type
== T_NULL
) {
725 PUT_SCN_SCNLEN(abfd
, in
->x_scn
.x_scnlen
, ext
);
726 PUT_SCN_NRELOC(abfd
, in
->x_scn
.x_nreloc
, ext
);
727 PUT_SCN_NLINNO(abfd
, in
->x_scn
.x_nlinno
, ext
);
731 PUTWORD(abfd
, in
->x_sym
.x_tagndx
.l
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
733 bfd_h_put_16(abfd
, in
->x_sym
.x_tvndx
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
737 PUTWORD(abfd
, in
->x_sym
.x_misc
.x_fsize
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
738 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
739 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
743 if (ISARY(type
) || class == C_BLOCK
) {
744 #if DIMNUM != E_DIMNUM
745 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
747 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]);
748 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]);
749 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]);
750 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]);
753 PUT_LNSZ_LNNO(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
754 PUT_LNSZ_SIZE(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
756 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
757 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
762 return sizeof(AUXENT
);
765 #endif /* NO_COFF_SYMBOLS */
767 #ifndef NO_COFF_LINENOS
770 DEFUN(coff_swap_lineno_in
,(abfd
, ext1
, in1
),
775 LINENO
*ext
= (LINENO
*)ext1
;
776 struct internal_lineno
*in
= (struct internal_lineno
*)in1
;
778 in
->l_addr
.l_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->l_addr
.l_symndx
);
779 in
->l_lnno
= GET_LINENO_LNNO(abfd
, ext
);
783 DEFUN(coff_swap_lineno_out
,(abfd
, inp
, outp
),
788 struct internal_lineno
*in
= (struct internal_lineno
*)inp
;
789 struct external_lineno
*ext
= (struct external_lineno
*)outp
;
790 PUTWORD(abfd
, in
->l_addr
.l_symndx
, (bfd_byte
*)
791 ext
->l_addr
.l_symndx
);
793 PUT_LINENO_LNNO (abfd
, in
->l_lnno
, ext
);
794 return sizeof(struct external_lineno
);
797 #endif /* NO_COFF_LINENOS */
801 DEFUN(bfd_swap_aouthdr_in
,(abfd
, aouthdr_ext1
, aouthdr_int1
),
806 AOUTHDR
*aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
807 struct internal_aouthdr
*aouthdr_int
= (struct internal_aouthdr
*)aouthdr_int1
;
809 aouthdr_int
->magic
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->magic
);
810 aouthdr_int
->vstamp
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->vstamp
);
811 aouthdr_int
->tsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tsize
);
812 aouthdr_int
->dsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->dsize
);
813 aouthdr_int
->bsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->bsize
);
814 aouthdr_int
->entry
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->entry
);
815 aouthdr_int
->text_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->text_start
);
816 aouthdr_int
->data_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->data_start
);
818 aouthdr_int
->tagentries
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tagentries
);
822 aouthdr_int
->o_toc
= bfd_h_get_32(abfd
, aouthdr_ext
->o_toc
);
823 aouthdr_int
->o_snentry
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snentry
);
824 aouthdr_int
->o_sntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntext
);
825 aouthdr_int
->o_sndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sndata
);
826 aouthdr_int
->o_sntoc
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntoc
);
827 aouthdr_int
->o_snloader
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snloader
);
828 aouthdr_int
->o_snbss
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snbss
);
829 aouthdr_int
->o_algntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algntext
);
830 aouthdr_int
->o_algndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algndata
);
831 aouthdr_int
->o_modtype
= bfd_h_get_16(abfd
, aouthdr_ext
->o_modtype
);
832 aouthdr_int
->o_maxstack
= bfd_h_get_32(abfd
, aouthdr_ext
->o_maxstack
);
837 DEFUN(coff_swap_aouthdr_out
,(abfd
, in
, out
),
842 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*)in
;
843 AOUTHDR
*aouthdr_out
= (AOUTHDR
*)out
;
844 bfd_h_put_16(abfd
, aouthdr_in
->magic
, (bfd_byte
*) aouthdr_out
->magic
);
845 bfd_h_put_16(abfd
, aouthdr_in
->vstamp
, (bfd_byte
*) aouthdr_out
->vstamp
);
846 bfd_h_put_32(abfd
, aouthdr_in
->tsize
, (bfd_byte
*) aouthdr_out
->tsize
);
847 bfd_h_put_32(abfd
, aouthdr_in
->dsize
, (bfd_byte
*) aouthdr_out
->dsize
);
848 bfd_h_put_32(abfd
, aouthdr_in
->bsize
, (bfd_byte
*) aouthdr_out
->bsize
);
849 bfd_h_put_32(abfd
, aouthdr_in
->entry
, (bfd_byte
*) aouthdr_out
->entry
);
850 bfd_h_put_32(abfd
, aouthdr_in
->text_start
,
851 (bfd_byte
*) aouthdr_out
->text_start
);
852 bfd_h_put_32(abfd
, aouthdr_in
->data_start
, (bfd_byte
*) aouthdr_out
->data_start
);
854 bfd_h_put_32(abfd
, aouthdr_in
->tagentries
, (bfd_byte
*) aouthdr_out
->tagentries
);
856 return sizeof(AOUTHDR
);
860 DEFUN(coff_swap_scnhdr_in
,(abfd
, scnhdr_ext
, scnhdr_int
),
862 SCNHDR
*scnhdr_ext AND
863 struct internal_scnhdr
*scnhdr_int
)
865 memcpy(scnhdr_int
->s_name
, scnhdr_ext
->s_name
, sizeof(scnhdr_int
->s_name
));
866 scnhdr_int
->s_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
867 scnhdr_int
->s_paddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
868 scnhdr_int
->s_size
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_size
);
870 scnhdr_int
->s_scnptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
871 scnhdr_int
->s_relptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
872 scnhdr_int
->s_lnnoptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
873 scnhdr_int
->s_flags
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_flags
);
875 scnhdr_int
->s_nreloc
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
876 scnhdr_int
->s_nlnno
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
878 scnhdr_int
->s_nreloc
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
879 scnhdr_int
->s_nlnno
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
882 scnhdr_int
->s_align
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_align
);
887 DEFUN(coff_swap_scnhdr_out
,(abfd
, in
, out
),
892 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*)in
;
893 SCNHDR
*scnhdr_ext
= (SCNHDR
*)out
;
894 memcpy(scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof(scnhdr_int
->s_name
));
895 PUTWORD(abfd
, scnhdr_int
->s_vaddr
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
896 PUTWORD(abfd
, scnhdr_int
->s_paddr
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
897 PUTWORD(abfd
, scnhdr_int
->s_size
, (bfd_byte
*) scnhdr_ext
->s_size
);
898 PUTWORD(abfd
, scnhdr_int
->s_scnptr
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
899 PUTWORD(abfd
, scnhdr_int
->s_relptr
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
900 PUTWORD(abfd
, scnhdr_int
->s_lnnoptr
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
901 PUTWORD(abfd
, scnhdr_int
->s_flags
, (bfd_byte
*) scnhdr_ext
->s_flags
);
903 PUTWORD(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
904 PUTWORD(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
906 PUTHALF(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
907 PUTHALF(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
911 PUTWORD(abfd
, scnhdr_int
->s_align
, (bfd_byte
*) scnhdr_ext
->s_align
);
913 return sizeof(SCNHDR
);
918 initialize a section structure with information peculiar to this
919 particular implementation of coff
923 DEFUN(coff_new_section_hook
,(abfd
, section
),
927 section
->alignment_power
= abfd
->xvec
->align_power_min
;
928 /* Allocate aux records for section symbols, to store size and
931 @@ Shouldn't use constant multiplier here! */
932 coffsymbol (section
->symbol
)->native
=
933 (combined_entry_type
*) bfd_zalloc (abfd
,
934 sizeof (combined_entry_type
) * 10);
938 static asection bfd_debug_section
= { "*DEBUG*" };
940 /* Take a section header read from a coff file (in HOST byte order),
941 and make a BFD "section" out of it. */
943 DEFUN(make_a_section_from_file
,(abfd
, hdr
, target_index
),
945 struct internal_scnhdr
*hdr AND
946 unsigned int target_index
)
948 asection
*return_section
;
951 /* Assorted wastage to null-terminate the name, thanks AT&T! */
952 name
= bfd_alloc(abfd
, sizeof (hdr
->s_name
)+1);
954 bfd_error
= no_memory
;
957 strncpy(name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
958 name
[sizeof (hdr
->s_name
)] = 0;
960 return_section
= bfd_make_section(abfd
, name
);
962 /* On SCO a file created by the Microsoft assembler can have two
963 .data sections. We use .data2 for the second one. */
964 if (return_section
== NULL
&& strcmp(name
, _DATA
) == 0)
965 return_section
= bfd_make_section(abfd
, ".data2");
966 #endif /* TWO_DATA_SECS */
967 if (return_section
== NULL
)
970 /* s_paddr is presumed to be = to s_vaddr */
972 return_section
->vma
= hdr
->s_vaddr
;
973 return_section
->_raw_size
= hdr
->s_size
;
974 return_section
->filepos
= hdr
->s_scnptr
;
975 return_section
->rel_filepos
= hdr
->s_relptr
;
976 return_section
->reloc_count
= hdr
->s_nreloc
;
979 /* FIXME, use a temp var rather than alignment_power */
980 return_section
->alignment_power
= hdr
->s_align
;
983 for (i
= 0; i
< 32; i
++) {
984 if ((1 << i
) >= (int) (return_section
->alignment_power
)) {
985 return_section
->alignment_power
= i
;
992 return_section
->line_filepos
= hdr
->s_lnnoptr
;
994 return_section->linesize = hdr->s_nlnno * sizeof (struct lineno);
997 return_section
->lineno_count
= hdr
->s_nlnno
;
998 return_section
->userdata
= NULL
;
999 return_section
->next
= (asection
*) NULL
;
1000 return_section
->flags
= styp_to_sec_flags(hdr
->s_flags
);
1002 return_section
->target_index
= target_index
;
1004 if (hdr
->s_nreloc
!= 0)
1005 return_section
->flags
|= SEC_RELOC
;
1006 /* FIXME: should this check 'hdr->s_size > 0' */
1007 if (hdr
->s_scnptr
!= 0)
1008 return_section
->flags
|= SEC_HAS_CONTENTS
;
1012 DEFUN(coff_mkobject
,(abfd
),
1015 abfd
->tdata
.coff_obj_data
= (struct coff_tdata
*)bfd_zalloc (abfd
,sizeof(coff_data_type
));
1016 if (abfd
->tdata
.coff_obj_data
== 0){
1017 bfd_error
= no_memory
;
1020 coff_data(abfd
)->relocbase
= 0;
1021 /* make_abs_section(abfd);*/
1027 DEFUN(coff_real_object_p
,(abfd
, nscns
, internal_f
, internal_a
),
1030 struct internal_filehdr
*internal_f AND
1031 struct internal_aouthdr
*internal_a
)
1033 coff_data_type
*coff
;
1034 enum bfd_architecture arch
;
1036 size_t readsize
; /* length of file_info */
1037 SCNHDR
*external_sections
;
1039 /* Build a play area */
1040 if (coff_mkobject(abfd
) != true)
1043 coff
= coff_data(abfd
);
1046 external_sections
= (SCNHDR
*)bfd_alloc(abfd
, readsize
= (nscns
* SCNHSZ
));
1048 if (bfd_read((PTR
)external_sections
, 1, readsize
, abfd
) != readsize
) {
1053 /* Now copy data as required; construct all asections etc */
1054 coff
->symbol_index_slew
= 0;
1056 coff
->raw_syment_count
= 0;
1057 coff
->raw_linenos
= 0;
1058 coff
->raw_syments
= 0;
1059 coff
->sym_filepos
=0;
1060 coff
->flags
= internal_f
->f_flags
;
1063 for (i
= 0; i
< nscns
; i
++) {
1064 struct internal_scnhdr tmp
;
1065 coff_swap_scnhdr_in(abfd
, external_sections
+ i
, &tmp
);
1066 make_a_section_from_file(abfd
,&tmp
, i
+1);
1070 /* make_abs_section(abfd);*/
1072 /* Determine the machine architecture and type. */
1074 switch (internal_f
->f_magic
) {
1077 arch
= bfd_arch_i386
;
1082 #ifdef A29K_MAGIC_BIG
1083 case A29K_MAGIC_BIG
:
1084 case A29K_MAGIC_LITTLE
:
1085 arch
= bfd_arch_a29k
;
1094 arch
= bfd_arch_mips
;
1102 arch
= bfd_arch_m68k
;
1110 arch
= bfd_arch_m88k
;
1116 arch
= bfd_arch_z8k
;
1117 switch (internal_f
->f_flags
& F_MACHMASK
)
1120 machine
= bfd_mach_z8001
;
1123 machine
= bfd_mach_z8002
;
1134 arch
= bfd_arch_i960
;
1135 switch (F_I960TYPE
& internal_f
->f_flags
)
1139 machine
= bfd_mach_i960_core
;
1142 machine
= bfd_mach_i960_kb_sb
;
1145 machine
= bfd_mach_i960_mc
;
1148 machine
= bfd_mach_i960_xa
;
1151 machine
= bfd_mach_i960_ca
;
1154 machine
= bfd_mach_i960_ka_sa
;
1165 arch
= bfd_arch_rs6000
;
1172 arch
= bfd_arch_we32k
;
1179 arch
= bfd_arch_h8300
;
1184 default: /* Unreadable input file type */
1185 arch
= bfd_arch_obscure
;
1189 bfd_default_set_arch_mach(abfd
, arch
, machine
);
1190 if (!(internal_f
->f_flags
& F_RELFLG
))
1191 abfd
->flags
|= HAS_RELOC
;
1192 if ((internal_f
->f_flags
& F_EXEC
))
1193 abfd
->flags
|= EXEC_P
;
1194 if (!(internal_f
->f_flags
& F_LNNO
))
1195 abfd
->flags
|= HAS_LINENO
;
1196 if (!(internal_f
->f_flags
& F_LSYMS
))
1197 abfd
->flags
|= HAS_LOCALS
;
1200 bfd_get_symcount(abfd
) = internal_f
->f_nsyms
;
1201 if (internal_f
->f_nsyms
)
1202 abfd
->flags
|= HAS_SYMS
;
1204 coff
->sym_filepos
= internal_f
->f_symptr
;
1206 /* These members communicate important constants about the symbol table
1207 to GDB's symbol-reading code. These `constants' unfortunately vary
1208 from coff implementation to implementation... */
1209 #ifndef NO_COFF_SYMBOLS
1210 coff
->local_n_btmask
= N_BTMASK
;
1211 coff
->local_n_btshft
= N_BTSHFT
;
1212 coff
->local_n_tmask
= N_TMASK
;
1213 coff
->local_n_tshift
= N_TSHIFT
;
1214 coff
->local_symesz
= SYMESZ
;
1215 coff
->local_auxesz
= AUXESZ
;
1216 coff
->local_linesz
= LINESZ
;
1219 coff
->symbols
= (coff_symbol_type
*) NULL
;
1220 bfd_get_start_address(abfd
) = internal_f
->f_opthdr
? internal_a
->entry
: 0;
1224 bfd_release(abfd
, coff
);
1225 return (bfd_target
*)NULL
;
1229 DEFUN(coff_object_p
,(abfd
),
1235 struct internal_filehdr internal_f
;
1236 struct internal_aouthdr internal_a
;
1238 bfd_error
= system_call_error
;
1240 /* figure out how much to read */
1241 if (bfd_read((PTR
) &filehdr
, 1, FILHSZ
, abfd
) != FILHSZ
)
1244 bfd_swap_filehdr_in(abfd
, &filehdr
, &internal_f
);
1246 if (BADMAG(internal_f
)) {
1247 bfd_error
= wrong_format
;
1250 nscns
=internal_f
.f_nscns
;
1252 if (internal_f
.f_opthdr
) {
1253 if (bfd_read((PTR
) &opthdr
, 1,AOUTSZ
, abfd
) != AOUTSZ
) {
1256 bfd_swap_aouthdr_in(abfd
, (char *)&opthdr
, (char *)&internal_a
);
1259 /* Seek past the opt hdr stuff */
1260 bfd_seek(abfd
, (file_ptr
) (internal_f
.f_opthdr
+ FILHSZ
), SEEK_SET
);
1262 /* if the optional header is NULL or not the correct size then
1263 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1264 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1265 optional header is of a different size.
1267 But the mips keeps extra stuff in it's opthdr, so dont check
1271 #if defined(M88) || defined(I960)
1272 if (internal_f
.f_opthdr
!= 0 && AOUTSZ
!= internal_f
.f_opthdr
)
1273 return (bfd_target
*)NULL
;
1276 return coff_real_object_p(abfd
, nscns
, &internal_f
, &internal_a
);
1281 #ifndef NO_COFF_LINENOS
1284 DEFUN(coff_count_linenumbers
,(abfd
),
1287 unsigned int limit
= bfd_get_symcount(abfd
);
1291 asection
*s
= abfd
->sections
->output_section
;
1293 BFD_ASSERT(s
->lineno_count
== 0);
1299 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++) {
1300 asymbol
*q_maybe
= *p
;
1301 if (q_maybe
->the_bfd
->xvec
->flavour
== bfd_target_coff_flavour
) {
1302 coff_symbol_type
*q
= coffsymbol(q_maybe
);
1305 This symbol has a linenumber, increment the owning
1306 section's linenumber count
1308 alent
*l
= q
->lineno
;
1309 q
->symbol
.section
->output_section
->lineno_count
++;
1311 while (l
->line_number
) {
1312 q
->symbol
.section
->output_section
->lineno_count
++;
1320 #endif /* NO_COFF_LINENOS */
1322 #ifndef NO_COFF_SYMBOLS
1325 Takes a bfd and a symbol, returns a pointer to the coff specific area
1326 of the symbol if there is one.
1328 static coff_symbol_type
*
1329 DEFUN(coff_symbol_from
,(ignore_abfd
, symbol
),
1330 bfd
*ignore_abfd AND
1333 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
1334 return (coff_symbol_type
*)NULL
;
1336 if (symbol
->the_bfd
->tdata
.coff_obj_data
== (coff_data_type
*)NULL
)
1337 return (coff_symbol_type
*)NULL
;
1339 return (coff_symbol_type
*) symbol
;
1345 DEFUN(fixup_symbol_value
,(coff_symbol_ptr
, syment
),
1346 coff_symbol_type
*coff_symbol_ptr AND
1347 struct internal_syment
*syment
)
1350 /* Normalize the symbol flags */
1351 if (coff_symbol_ptr
->symbol
.section
== &bfd_com_section
) {
1352 /* a common symbol is undefined with a value */
1353 syment
->n_scnum
= N_UNDEF
;
1354 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1356 else if (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) {
1357 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1359 else if (coff_symbol_ptr
->symbol
.section
== & bfd_und_section
) {
1360 syment
->n_scnum
= N_UNDEF
;
1361 syment
->n_value
= 0;
1364 if (coff_symbol_ptr
->symbol
.section
) {
1366 coff_symbol_ptr
->symbol
.section
->output_section
->target_index
;
1369 coff_symbol_ptr
->symbol
.value
+
1370 coff_symbol_ptr
->symbol
.section
->output_offset
+
1371 coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
1375 /* This can happen, but I don't know why yet (steve@cygnus.com) */
1376 syment
->n_scnum
= N_ABS
;
1377 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1382 /* run through all the symbols in the symbol table and work out what
1383 their indexes into the symbol table will be when output
1385 Coff requires that each C_FILE symbol points to the next one in the
1386 chain, and that the last one points to the first external symbol. We
1391 DEFUN(coff_renumber_symbols
,(bfd_ptr
),
1394 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1395 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1396 unsigned int native_index
= 0;
1397 struct internal_syment
*last_file
= (struct internal_syment
*)NULL
;
1398 unsigned int symbol_index
;
1400 /* COFF demands that undefined symbols come after all other symbols.
1401 Since we don't need to impose this extra knowledge on all our client
1402 programs, deal with that here. Sort the symbol table; just move the
1403 undefined symbols to the end, leaving the rest alone. */
1404 /* @@ Do we have some condition we could test for, so we don't always
1405 have to do this? I don't think relocatability is quite right, but
1406 I'm not certain. [raeburn:19920508.1711EST] */
1411 newsyms
= (asymbol
**) bfd_alloc_by_size_t (bfd_ptr
,
1413 * (symbol_count
+ 1));
1414 bfd_ptr
->outsymbols
= newsyms
;
1415 for (i
= 0; i
< symbol_count
; i
++)
1416 if (symbol_ptr_ptr
[i
]->section
!= &bfd_und_section
)
1417 *newsyms
++ = symbol_ptr_ptr
[i
];
1418 for (i
= 0; i
< symbol_count
; i
++)
1419 if (symbol_ptr_ptr
[i
]->section
== &bfd_und_section
)
1420 *newsyms
++ = symbol_ptr_ptr
[i
];
1421 *newsyms
= (asymbol
*) NULL
;
1422 symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1425 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1427 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1428 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1429 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1432 if (s
->u
.syment
.n_sclass
== C_FILE
)
1434 if (last_file
!= (struct internal_syment
*)NULL
) {
1435 last_file
->n_value
= native_index
;
1437 last_file
= &(s
->u
.syment
);
1441 /* Modify the symbol values according to their section and
1444 fixup_symbol_value(coff_symbol_ptr
, &(s
->u
.syment
));
1446 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++) {
1447 s
[i
].offset
= native_index
++;
1454 obj_conv_table_size (bfd_ptr
) = native_index
;
1459 Run thorough the symbol table again, and fix it so that all pointers to
1460 entries are changed to the entries' index in the output symbol table.
1464 DEFUN(coff_mangle_symbols
,(bfd_ptr
),
1467 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1468 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1469 unsigned int symbol_index
;
1471 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1473 coff_symbol_type
*coff_symbol_ptr
=
1474 coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1476 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1478 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1480 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++) {
1481 combined_entry_type
*a
= s
+ i
+ 1;
1483 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
1484 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
1488 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
1489 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
1499 static int string_size
;
1501 DEFUN(coff_fix_symbol_name
,(ignore_abfd
, symbol
, native
),
1502 bfd
*ignore_abfd AND
1504 combined_entry_type
*native
)
1506 unsigned int name_length
;
1507 union internal_auxent
*auxent
;
1508 char * name
= ( char *)(symbol
->name
);
1510 if (name
== (char *) NULL
) {
1511 /* coff symbols always have names, so we'll make one up */
1512 symbol
->name
= "strange";
1513 name
= (char *)symbol
->name
;
1515 name_length
= strlen(name
);
1517 if (native
->u
.syment
.n_sclass
== C_FILE
) {
1518 strncpy(native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
1519 auxent
= &(native
+1)->u
.auxent
;
1521 #ifdef COFF_LONG_FILENAMES
1522 if (name_length
<= FILNMLEN
) {
1523 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1526 auxent
->x_file
.x_n
.x_offset
= string_size
+ 4;
1527 auxent
->x_file
.x_n
.x_zeroes
= 0;
1528 string_size
+= name_length
+ 1;
1531 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1532 if (name_length
> FILNMLEN
) {
1533 name
[FILNMLEN
] = '\0';
1538 { /* NOT A C_FILE SYMBOL */
1539 if (name_length
<= SYMNMLEN
) {
1540 /* This name will fit into the symbol neatly */
1541 strncpy(native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
1544 native
->u
.syment
._n
._n_n
._n_offset
= string_size
+ 4;
1545 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1546 string_size
+= name_length
+ 1;
1554 DEFUN(coff_write_symbol
,(abfd
, symbol
, native
, written
),
1557 combined_entry_type
*native AND
1558 unsigned int written
)
1560 unsigned int numaux
= native
->u
.syment
.n_numaux
;
1561 int type
= native
->u
.syment
.n_type
;
1562 int class = native
->u
.syment
.n_sclass
;
1566 /* @@ bfd_debug_section isn't accessible outside this file, but we know
1567 that C_FILE symbols belong there. So move them. */
1568 if (native
->u
.syment
.n_sclass
== C_FILE
)
1569 symbol
->section
= &bfd_debug_section
;
1571 if (symbol
->section
== &bfd_abs_section
)
1573 native
->u
.syment
.n_scnum
= N_ABS
;
1575 else if (symbol
->section
== &bfd_debug_section
)
1577 native
->u
.syment
.n_scnum
= N_DEBUG
;
1579 else if (symbol
->section
== &bfd_und_section
)
1581 native
->u
.syment
.n_scnum
= N_UNDEF
;
1585 native
->u
.syment
.n_scnum
=
1586 symbol
->section
->output_section
->target_index
;
1590 coff_fix_symbol_name(abfd
, symbol
, native
);
1592 coff_swap_sym_out(abfd
, &native
->u
.syment
, &buf
);
1593 bfd_write((PTR
)& buf
, 1, SYMESZ
, abfd
);
1594 for (j
= 0; j
< native
->u
.syment
.n_numaux
; j
++)
1597 memset((PTR
)&buf
, 0, AUXESZ
);
1598 coff_swap_aux_out(abfd
,
1599 &( (native
+ j
+ 1)->u
.auxent
), type
, class, &buf1
);
1600 bfd_write((PTR
) (&buf1
), 1, AUXESZ
, abfd
);
1603 Reuse somewhere in the symbol to keep the index
1605 set_index(symbol
, written
);
1606 return written
+ 1 + numaux
;
1611 DEFUN(coff_write_alien_symbol
,(abfd
, symbol
, written
),
1614 unsigned int written
)
1617 This symbol has been created by the loader, or come from a non
1618 coff format. It has no native element to inherit, make our
1621 combined_entry_type
*native
;
1622 combined_entry_type dummy
;
1624 native
->u
.syment
.n_type
= T_NULL
;
1626 native
->u
.syment
.n_flags
= 0;
1628 if (symbol
->section
== &bfd_und_section
)
1630 native
->u
.syment
.n_scnum
= N_UNDEF
;
1631 native
->u
.syment
.n_value
= symbol
->value
;
1633 else if (symbol
->section
== &bfd_com_section
)
1635 native
->u
.syment
.n_scnum
= N_UNDEF
;
1636 native
->u
.syment
.n_value
= symbol
->value
;
1640 else if (symbol
->flags
& BSF_DEBUGGING
) {
1642 remove name so it doesn't take up any space
1647 native
->u
.syment
.n_scnum
= symbol
->section
->output_section
->target_index
;
1648 native
->u
.syment
.n_value
= symbol
->value
+
1649 symbol
->section
->output_section
->vma
+
1650 symbol
->section
->output_offset
;
1652 /* Copy the any flags from the the file hdr into the symbol */
1654 coff_symbol_type
*c
= coff_symbol_from(abfd
, symbol
);
1655 if (c
!= (coff_symbol_type
*)NULL
) {
1656 native
->u
.syment
.n_flags
= c
->symbol
.the_bfd
->flags
;
1663 native
->u
.syment
.pad1
[0] = 0;
1664 native
->u
.syment
.pad1
[0] = 0;
1667 native
->u
.syment
.n_type
= 0;
1668 if (symbol
->flags
& BSF_LOCAL
)
1669 native
->u
.syment
.n_sclass
= C_STAT
;
1671 native
->u
.syment
.n_sclass
= C_EXT
;
1672 native
->u
.syment
.n_numaux
= 0;
1674 return coff_write_symbol(abfd
, symbol
, native
, written
);
1678 DEFUN(coff_write_native_symbol
,(abfd
, symbol
, written
),
1680 coff_symbol_type
*symbol AND
1681 unsigned int written
)
1684 Does this symbol have an ascociated line number - if so then
1685 make it remember this symbol index. Also tag the auxent of
1686 this symbol to point to the right place in the lineno table
1688 combined_entry_type
*native
= symbol
->native
;
1690 alent
*lineno
= symbol
->lineno
;
1692 if (lineno
&& !symbol
->done_lineno
) {
1693 unsigned int count
= 0;
1694 lineno
[count
].u
.offset
= written
;
1695 if (native
->u
.syment
.n_numaux
) {
1696 union internal_auxent
*a
= &((native
+1)->u
.auxent
);
1698 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1699 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1702 And count and relocate all other linenumbers
1706 while (lineno
[count
].line_number
) {
1709 I've been told this, but still need proof:
1710 > The second bug is also in `bfd/coffcode.h'. This bug causes the linker to screw
1711 > up the pc-relocations for all the line numbers in COFF code. This bug isn't
1712 > only specific to A29K implementations, but affects all systems using COFF
1713 > format binaries. Note that in COFF object files, the line number core offsets
1714 > output by the assembler are relative to the start of each procedure, not
1715 > to the start of the .text section. This patch relocates the line numbers
1716 > relative to the `native->u.syment.n_value' instead of the section virtual
1717 > address. modular!olson@cs.arizona.edu (Jon Olson)
1719 lineno
[count
].u
.offset
+= native
->u
.syment
.n_value
;
1722 lineno
[count
].u
.offset
+=
1723 symbol
->symbol
.section
->output_section
->vma
+
1724 symbol
->symbol
.section
->output_offset
;
1728 symbol
->done_lineno
= true;
1730 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1733 return coff_write_symbol(abfd
, &( symbol
->symbol
), native
,written
);
1737 DEFUN(coff_write_symbols
,(abfd
),
1741 unsigned int limit
= bfd_get_symcount(abfd
);
1742 unsigned int written
= 0;
1749 /* Seek to the right place */
1750 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
1752 /* Output all the symbols we have */
1755 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1757 asymbol
*symbol
= *p
;
1758 coff_symbol_type
*c_symbol
= coff_symbol_from(abfd
, symbol
);
1760 if (c_symbol
== (coff_symbol_type
*) NULL
||
1761 c_symbol
->native
== (combined_entry_type
*)NULL
)
1763 written
= coff_write_alien_symbol(abfd
, symbol
, written
);
1767 written
= coff_write_native_symbol(abfd
, c_symbol
, written
);
1772 bfd_get_symcount(abfd
) = written
;
1774 /* Now write out strings */
1776 if (string_size
!= 0)
1778 unsigned int size
= string_size
+ 4;
1781 bfd_h_put_32(abfd
, size
, buffer
);
1782 bfd_write((PTR
) buffer
, 1, sizeof(buffer
), abfd
);
1783 for (p
= abfd
->outsymbols
, i
= 0;
1788 size_t name_length
= strlen(q
->name
);
1790 coff_symbol_type
* c_symbol
= coff_symbol_from(abfd
, q
);
1791 maxlen
= ((c_symbol
!= NULL
&& c_symbol
->native
!= NULL
) &&
1792 (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
)) ?
1793 FILNMLEN
: SYMNMLEN
;
1795 if (name_length
> maxlen
) {
1796 bfd_write((PTR
) (q
->name
), 1, name_length
+ 1, abfd
);
1801 /* We would normally not write anything here, but we'll write
1802 out 4 so that any stupid coff reader which tries to read
1803 the string table even when there isn't one won't croak.
1806 uint32e_type size
= 4;
1808 bfd_write((PTR
)&size
, 1, sizeof(size
), abfd
);
1817 To write relocations, all the back end does is step though the
1818 canonical relocation table, and create an
1819 @code{internal_reloc}. The symbol index to use is removed from
1820 the @code{offset} field in the symbol table supplied, the
1821 address comes directly from the sum of the section base
1822 address and the relocation offset and the type is dug directly
1823 from the howto field. Then the @code{internal_reloc} is
1824 swapped into the shape of an @code{external_reloc} and written
1830 DEFUN(coff_write_relocs
,(abfd
),
1834 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1836 struct external_reloc dst
;
1838 arelent
**p
= s
->orelocation
;
1839 bfd_seek(abfd
, s
->rel_filepos
, SEEK_SET
);
1840 for (i
= 0; i
< s
->reloc_count
; i
++) {
1841 struct internal_reloc n
;
1843 memset((PTR
)&n
, 0, sizeof(n
));
1845 n
.r_vaddr
= q
->address
+ s
->vma
;
1846 /* The 29k const/consth reloc pair is a real kludge - the consth
1847 part doesn't have a symbol - it has an offset. So rebuilt
1850 if (q
->howto
->type
== R_IHCONST
)
1851 n
.r_symndx
= q
->addend
;
1858 if (q
->sym_ptr_ptr
== bfd_abs_section
.symbol_ptr_ptr
)
1860 /* This is a relocation relative to the absolute symbol */
1865 n
.r_symndx
= get_index((*(q
->sym_ptr_ptr
)));
1866 /* Take notice if the symbol reloc points to a symbol we don't have
1867 in our symbol table. What should we do for this?? */
1868 if (n
.r_symndx
> obj_conv_table_size (abfd
))
1876 /* Work out reloc type from what is required */
1877 SELECT_RELOC(n
.r_type
, q
->howto
);
1879 n
.r_type
= q
->howto
->type
;
1881 coff_swap_reloc_out(abfd
, &n
, &dst
);
1882 bfd_write((PTR
) &dst
, 1, RELSZ
, abfd
);
1886 #endif /* NO_COFF_SYMBOLS */
1888 #ifndef NO_COFF_LINENOS
1891 DEFUN(coff_write_linenumbers
,(abfd
),
1895 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1896 if (s
->lineno_count
) {
1897 asymbol
**q
= abfd
->outsymbols
;
1898 bfd_seek(abfd
, s
->line_filepos
, SEEK_SET
);
1899 /* Find all the linenumbers in this section */
1902 alent
*l
= BFD_SEND(p
->the_bfd
, _get_lineno
, (p
->the_bfd
, p
));
1904 /* Found a linenumber entry, output */
1905 struct internal_lineno out
;
1907 memset( (PTR
)&out
, 0, sizeof(out
));
1909 out
.l_addr
.l_symndx
= l
->u
.offset
;
1910 coff_swap_lineno_out(abfd
, &out
, &buff
);
1911 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1913 while (l
->line_number
) {
1914 out
.l_lnno
= l
->line_number
;
1915 out
.l_addr
.l_symndx
= l
->u
.offset
;
1916 coff_swap_lineno_out(abfd
, &out
, &buff
);
1917 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1928 DEFUN(coff_get_lineno
,(ignore_abfd
, symbol
),
1929 bfd
*ignore_abfd AND
1932 return coffsymbol(symbol
)->lineno
;
1935 #endif /* NO_COFF_LINENOS */
1938 coff_make_empty_symbol(abfd
)
1941 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc(abfd
, sizeof(coff_symbol_type
));
1943 bfd_error
= no_memory
;
1946 new->symbol
.section
= 0;
1948 new->lineno
= (alent
*) NULL
;
1949 new->done_lineno
= false;
1950 new->symbol
.the_bfd
= abfd
;
1951 return &new->symbol
;
1954 #ifndef NO_COFF_SYMBOLS
1957 DEFUN (coff_make_debug_symbol
, (abfd
, ptr
, sz
),
1962 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc(abfd
, sizeof(coff_symbol_type
));
1964 bfd_error
= no_memory
;
1967 /* @@ This shouldn't be using a constant multiplier. */
1968 new->native
= (combined_entry_type
*) bfd_zalloc (abfd
, sizeof (combined_entry_type
) * 10);
1969 new->symbol
.section
= &bfd_debug_section
;
1970 new->lineno
= (alent
*) NULL
;
1971 new->done_lineno
= false;
1972 new->symbol
.the_bfd
= abfd
;
1973 return &new->symbol
;
1977 DEFUN(coff_print_symbol
,(ignore_abfd
, filep
, symbol
, how
),
1978 bfd
*ignore_abfd AND
1981 bfd_print_symbol_type how
)
1983 FILE *file
= (FILE *)filep
;
1985 case bfd_print_symbol_name
:
1986 fprintf(file
, "%s", symbol
->name
);
1988 case bfd_print_symbol_more
:
1989 fprintf(file
, "coff %lx %lx", (unsigned long) coffsymbol(symbol
)->native
,
1990 (unsigned long) coffsymbol(symbol
)->lineno
);
1992 case bfd_print_symbol_nm
:
1995 CONST
char *section_name
= symbol
->section
->name
;
1996 bfd_print_symbol_vandf((PTR
) file
, symbol
);
1999 fprintf(file
, " %-5s %s %s %s",
2001 coffsymbol(symbol
)->native
? "n" : "g",
2002 coffsymbol(symbol
)->lineno
? "l" : " ",
2008 case bfd_print_symbol_all
:
2009 /* Print out the symbols in a reasonable way */
2011 CONST
char *section_name
= symbol
->section
->name
;
2014 if (coffsymbol(symbol
)->native
)
2017 combined_entry_type
*combined
= coffsymbol(symbol
)->native
;
2018 combined_entry_type
*root
= obj_raw_syments(ignore_abfd
);
2020 fprintf(file
,"[%3d]",
2024 fprintf(file
, "(sc %2d)(fl%4x)(ty%3x)(sc%3d) nx(%d) %08x %s",
2025 combined
->u
.syment
.n_scnum
,
2026 combined
->u
.syment
.n_flags
,
2027 combined
->u
.syment
.n_type
,
2028 combined
->u
.syment
.n_sclass
,
2029 combined
->u
.syment
.n_numaux
,
2030 combined
->u
.syment
.n_value
,
2033 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
2036 switch (combined
->u
.syment
.n_sclass
) {
2038 fprintf(file
, "File ");
2041 fprintf(file
, "AUX lnno %x size %x tagndx %x",
2042 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
2043 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
2044 combined
[aux
+1].u
.auxent
.x_sym
.x_tagndx
.l
);
2052 struct lineno_cache_entry
*l
= coffsymbol(symbol
)->lineno
;
2055 printf("\n%s :", l
->u
.sym
->name
);
2057 while (l
->line_number
)
2059 printf("\n%4d : %x",
2073 bfd_print_symbol_vandf((PTR
) file
, symbol
);
2074 fprintf(file
, " %-5s %s %s %s",
2076 coffsymbol(symbol
)->native
? "n" : "g",
2077 coffsymbol(symbol
)->lineno
? "l" : " ",
2086 #endif /* NO_COFF_SYMBOLS */
2088 /* Set flags and magic number of a coff file from architecture and machine
2089 type. Result is true if we can represent the arch&type, false if not. */
2092 DEFUN(coff_set_flags
,(abfd
, magicp
, flagsp
),
2094 unsigned *magicp AND
2095 unsigned short *flagsp
)
2097 switch (bfd_get_arch(abfd
)) {
2101 switch (bfd_get_mach(abfd
))
2103 case bfd_mach_z8001
:
2106 case bfd_mach_z8002
:
2120 *magicp
= I960ROMAGIC
;
2122 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2123 I960RWMAGIC); FIXME???
2125 switch (bfd_get_mach(abfd
)) {
2126 case bfd_mach_i960_core
:
2129 case bfd_mach_i960_kb_sb
:
2132 case bfd_mach_i960_mc
:
2135 case bfd_mach_i960_xa
:
2138 case bfd_mach_i960_ca
:
2141 case bfd_mach_i960_ka_sa
:
2154 *magicp
= MIPS_MAGIC_2
;
2160 *magicp
= I386MAGIC
;
2166 *magicp
= MC68MAGIC
;
2173 *magicp
= MC88OMAGIC
;
2178 case bfd_arch_h8300
:
2179 *magicp
= H8300MAGIC
;
2183 #ifdef A29K_MAGIC_BIG
2185 if (abfd
->xvec
->byteorder_big_p
)
2186 *magicp
= A29K_MAGIC_BIG
;
2188 *magicp
= A29K_MAGIC_LITTLE
;
2194 case bfd_arch_we32k
:
2195 *magicp
= WE32KMAGIC
;
2201 case bfd_arch_rs6000
:
2202 *magicp
= U802TOCMAGIC
;
2207 default: /* Unknown architecture */
2208 /* return false; -- fall through to "return false" below, to avoid
2209 "statement never reached" errors on the one below. */
2218 DEFUN(coff_set_arch_mach
,(abfd
, arch
, machine
),
2220 enum bfd_architecture arch AND
2221 unsigned long machine
)
2224 unsigned short dummy2
;
2225 bfd_default_set_arch_mach(abfd
, arch
, machine
);
2227 if (arch
!= bfd_arch_unknown
&&
2228 coff_set_flags(abfd
, &dummy1
, &dummy2
) != true)
2229 return false; /* We can't represent this type */
2230 return true; /* We're easy ... */
2234 /* Calculate the file position for each section. */
2237 DEFUN(coff_compute_section_file_positions
,(abfd
),
2241 asection
*previous
= (asection
*)NULL
;
2242 file_ptr sofar
= FILHSZ
;
2244 if (bfd_get_start_address(abfd
))
2246 /* A start address may have been added to the original file. In this
2247 case it will need an optional header to record it. */
2248 abfd
->flags
|= EXEC_P
;
2251 if (abfd
->flags
& EXEC_P
)
2254 sofar
+= abfd
->section_count
* SCNHSZ
;
2255 for (current
= abfd
->sections
;
2256 current
!= (asection
*)NULL
;
2257 current
= current
->next
) {
2259 /* Only deal with sections which have contents */
2260 if (!(current
->flags
& SEC_HAS_CONTENTS
))
2263 /* Align the sections in the file to the same boundary on
2264 which they are aligned in virtual memory. I960 doesn't
2265 do this (FIXME) so we can stay in sync with Intel. 960
2266 doesn't yet page from files... */
2269 /* make sure this section is aligned on the right boundary - by
2270 padding the previous section up if necessary */
2273 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2274 if (previous
!= (asection
*)NULL
) {
2275 previous
->_raw_size
+= sofar
- old_sofar
;
2280 /* FIXME, in demand paged files, the low order bits of the file
2281 offset must match the low order bits of the virtual address.
2282 "Low order" is apparently implementation defined. Add code
2283 here to round sofar up to match the virtual address. */
2285 current
->filepos
= sofar
;
2287 sofar
+= current
->_raw_size
;
2289 /* make sure that this section is of the right size too */
2291 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2292 current
->_raw_size
+= sofar
- old_sofar
;
2297 obj_relocbase(abfd
) = sofar
;
2300 #ifndef NO_COFF_SYMBOLS
2302 coff_section_symbol (abfd
, name
)
2306 asection
*sec
= bfd_make_section_old_way (abfd
, name
);
2308 combined_entry_type
*csym
;
2311 if (coff_symbol_from (abfd
, sym
))
2312 csym
= coff_symbol_from (abfd
, sym
)->native
;
2315 /* Make sure back-end COFF stuff is there. */
2319 coff_symbol_type sym
;
2320 /* @@FIXME This shouldn't use a fixed size!! */
2321 combined_entry_type e
[10];
2324 f
= (struct foo
*) bfd_alloc_by_size_t (abfd
, sizeof (*f
));
2325 memset ((char *) f
, 0, sizeof (*f
));
2326 coff_symbol_from (abfd
, sym
)->native
= csym
= f
->e
;
2328 csym
[0].u
.syment
.n_sclass
= C_STAT
;
2329 csym
[0].u
.syment
.n_numaux
= 1;
2330 /* SF_SET_STATICS (sym); @@ ??? */
2333 csym
[1].u
.auxent
.x_scn
.x_scnlen
= sec
->_raw_size
;
2334 csym
[1].u
.auxent
.x_scn
.x_nreloc
= sec
->reloc_count
;
2335 csym
[1].u
.auxent
.x_scn
.x_nlinno
= sec
->lineno_count
;
2339 csym
[1].u
.auxent
.x_scn
.x_scnlen
= 0;
2340 csym
[1].u
.auxent
.x_scn
.x_nreloc
= 0;
2341 csym
[1].u
.auxent
.x_scn
.x_nlinno
= 0;
2346 /* If .file, .text, .data, .bss symbols are missing, add them. */
2347 /* @@ Should we only be adding missing symbols, or overriding the aux
2348 values for existing section symbols? */
2350 coff_add_missing_symbols (abfd
)
2353 unsigned int nsyms
= bfd_get_symcount (abfd
);
2354 asymbol
**sympp
= abfd
->outsymbols
;
2357 int need_text
= 1, need_data
= 1, need_bss
= 1, need_file
= 1;
2359 for (i
= 0; i
< nsyms
; i
++)
2361 coff_symbol_type
*csym
= coff_symbol_from (abfd
, sympp
[i
]);
2365 /* only do this if there is a coff representation of the input
2367 if (csym
->native
&& csym
->native
->u
.syment
.n_sclass
== C_FILE
)
2372 name
= csym
->symbol
.name
;
2375 if (!strcmp (name
, _TEXT
))
2377 else if (!strcmp (name
, _DATA
))
2379 else if (!strcmp (name
, _BSS
))
2383 /* Now i == bfd_get_symcount (abfd). */
2384 /* @@ For now, don't deal with .file symbol. */
2387 if (!need_text
&& !need_data
&& !need_bss
&& !need_file
)
2389 nsyms
+= need_text
+ need_data
+ need_bss
+ need_file
;
2390 sympp2
= (asymbol
**) bfd_alloc_by_size_t (abfd
, nsyms
* sizeof (asymbol
*));
2391 memcpy (sympp2
, sympp
, i
* sizeof (asymbol
*));
2394 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
2398 sympp2
[i
++] = coff_section_symbol (abfd
, _TEXT
);
2400 sympp2
[i
++] = coff_section_symbol (abfd
, _DATA
);
2402 sympp2
[i
++] = coff_section_symbol (abfd
, _BSS
);
2403 BFD_ASSERT (i
== nsyms
);
2404 bfd_set_symtab (abfd
, sympp2
, nsyms
);
2406 #endif /* NO_COFF_SYMBOLS */
2411 DEFUN(coff_write_object_contents
,(abfd
),
2417 boolean hasrelocs
= false;
2418 boolean haslinno
= false;
2419 file_ptr reloc_base
;
2420 file_ptr lineno_base
;
2424 unsigned long reloc_size
= 0;
2425 unsigned long lnno_size
= 0;
2426 asection
*text_sec
= NULL
;
2427 asection
*data_sec
= NULL
;
2428 asection
*bss_sec
= NULL
;
2430 struct internal_filehdr internal_f
;
2431 struct internal_aouthdr internal_a
;
2434 bfd_error
= system_call_error
;
2435 /* Number the output sections, starting from one on the first section
2436 with a name which doesn't start with a *.
2437 @@ The code doesn't make this check. Is it supposed to be done,
2440 for (current
= abfd
->sections
; current
!= (asection
*)NULL
;
2441 current
= current
->next
)
2443 current
->target_index
= count
;
2447 if(abfd
->output_has_begun
== false) {
2448 coff_compute_section_file_positions(abfd
);
2451 if (abfd
->sections
!= (asection
*)NULL
) {
2452 scn_base
= abfd
->sections
->filepos
;
2457 if (bfd_seek(abfd
, scn_base
, SEEK_SET
) != 0)
2459 reloc_base
= obj_relocbase(abfd
);
2461 /* Make a pass through the symbol table to count line number entries and
2462 put them into the correct asections */
2464 #ifndef NO_COFF_LINENOS
2465 coff_count_linenumbers(abfd
);
2467 data_base
= scn_base
;
2469 /* Work out the size of the reloc and linno areas */
2471 for (current
= abfd
->sections
; current
!= NULL
; current
=
2474 /* We give section headers to +ve indexes */
2475 if (current
->target_index
> 0)
2478 reloc_size
+= current
->reloc_count
* RELSZ
;
2479 #ifndef NO_COFF_LINENOS
2480 lnno_size
+= current
->lineno_count
* LINESZ
;
2482 data_base
+= SCNHSZ
;
2487 lineno_base
= reloc_base
+ reloc_size
;
2488 sym_base
= lineno_base
+ lnno_size
;
2490 /* Indicate in each section->line_filepos its actual file address */
2491 for (current
= abfd
->sections
; current
!= NULL
; current
=
2494 if (current
->target_index
> 0)
2497 if (current
->lineno_count
) {
2498 current
->line_filepos
= lineno_base
;
2499 current
->moving_line_filepos
= lineno_base
;
2500 #ifndef NO_COFF_LINENOS
2501 lineno_base
+= current
->lineno_count
* LINESZ
;
2505 current
->line_filepos
= 0;
2507 if (current
->reloc_count
) {
2508 current
->rel_filepos
= reloc_base
;
2509 reloc_base
+= current
->reloc_count
* RELSZ
;
2512 current
->rel_filepos
= 0;
2519 /* Write section headers to the file. */
2520 internal_f
.f_nscns
= 0;
2522 (file_ptr
) ((abfd
->flags
& EXEC_P
) ?
2523 (FILHSZ
+ AOUTSZ
) : FILHSZ
),
2528 unsigned int pad
= abfd
->flags
& D_PAGED
? data_base
: 0;
2530 unsigned int pad
= 0;
2532 for (current
= abfd
->sections
;
2534 current
= current
->next
) {
2535 struct internal_scnhdr section
;
2536 if (current
->target_index
> 0)
2538 internal_f
.f_nscns
++;
2539 strncpy(&(section
.s_name
[0]), current
->name
, 8);
2541 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
2542 Ian Taylor <ian@cygnus.com>. */
2543 if (strcmp (current
->name
, _LIB
) == 0)
2544 section
.s_vaddr
= 0;
2547 section
.s_vaddr
= current
->vma
+ pad
;
2548 section
.s_paddr
= current
->vma
+ pad
;
2549 section
.s_size
= current
->_raw_size
- pad
;
2551 If this section has no size or is unloadable then the scnptr
2554 if (current
->_raw_size
- pad
== 0 ||
2555 (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0) {
2556 section
.s_scnptr
= 0;
2559 section
.s_scnptr
= current
->filepos
;
2561 section
.s_relptr
= current
->rel_filepos
;
2562 section
.s_lnnoptr
= current
->line_filepos
;
2563 section
.s_nreloc
= current
->reloc_count
;
2564 section
.s_nlnno
= current
->lineno_count
;
2565 if (current
->reloc_count
!= 0)
2567 if (current
->lineno_count
!= 0)
2570 section
.s_flags
= sec_to_styp_flags(current
->name
,current
->flags
);
2572 if (!strcmp(current
->name
, _TEXT
)) {
2574 } else if (!strcmp(current
->name
, _DATA
)) {
2576 #ifdef TWO_DATA_SECS
2577 } else if (!strcmp(current
->name
, ".data2")) {
2579 #endif /* TWO_DATA_SECS */
2580 } else if (!strcmp(current
->name
, _BSS
)) {
2585 section
.s_align
= (current
->alignment_power
2586 ? 1 << current
->alignment_power
2593 coff_swap_scnhdr_out(abfd
, §ion
, &buff
);
2594 bfd_write((PTR
) (&buff
), 1, SCNHSZ
, abfd
);
2604 /* OK, now set up the filehdr... */
2606 /* Don't include the internal abs section in the section count */
2609 We will NOT put a fucking timestamp in the header here. Every time you
2610 put it back, I will come in and take it out again. I'm sorry. This
2611 field does not belong here. We fill it with a 0 so it compares the
2612 same but is not a reasonable time. -- gnu@cygnus.com
2615 Well, I like it, and now we have *customers* who have requested it,
2616 so I'm conditionally compiling it in.
2620 #ifndef NOCOFF_TIMESTAMP
2621 internal_f
.f_timdat
= time(0);
2623 internal_f
.f_timdat
= 0;
2626 if (bfd_get_symcount(abfd
) != 0)
2627 internal_f
.f_symptr
= sym_base
;
2629 internal_f
.f_symptr
= 0;
2631 internal_f
.f_flags
= 0;
2633 if (abfd
->flags
& EXEC_P
)
2634 internal_f
.f_opthdr
= AOUTSZ
;
2636 internal_f
.f_opthdr
= 0;
2639 internal_f
.f_flags
|= F_RELFLG
;
2641 internal_f
.f_flags
|= F_LNNO
;
2642 if (0 == bfd_get_symcount(abfd
))
2643 internal_f
.f_flags
|= F_LSYMS
;
2644 if (abfd
->flags
& EXEC_P
)
2645 internal_f
.f_flags
|= F_EXEC
;
2647 if (!abfd
->xvec
->byteorder_big_p
)
2648 internal_f
.f_flags
|= F_AR32WR
;
2650 internal_f
.f_flags
|= F_AR32W
;
2653 FIXME, should do something about the other byte orders and
2657 /* Set up architecture-dependent stuff */
2659 { unsigned int magic
= 0;
2660 unsigned short flags
= 0;
2661 coff_set_flags(abfd
, &magic
, &flags
);
2662 internal_f
.f_magic
= magic
;
2663 internal_f
.f_flags
|= flags
;
2664 /* ...and the "opt"hdr... */
2667 # ifdef ULTRA3 /* NYU's machine */
2668 /* FIXME: This is a bogus check. I really want to see if there
2669 * is a .shbss or a .shdata section, if so then set the magic
2670 * number to indicate a shared data executable.
2672 if (internal_f
.f_nscns
>= 7)
2673 internal_a
.magic
= SHMAGIC
; /* Shared magic */
2675 # endif /* ULTRA3 */
2676 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
2677 #define __A_MAGIC_SET__
2680 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
2681 #define __A_MAGIC_SET__
2684 #define __A_MAGIC_SET__
2685 internal_a
.magic
= PAGEMAGICBCS
;
2688 #if M68 || MIPS || WE32K
2689 #define __A_MAGIC_SET__
2690 /* Never was anything here for the 68k */
2691 #endif /* M68 || MIPS || WE32K */
2694 # define __A_MAGIC_SET__
2695 internal_a
.magic
= ZMAGIC
;
2699 #define __A_MAGIC_SET__
2700 internal_a
.magic
= (abfd
->flags
& D_PAGED
)? RS6K_AOUTHDR_ZMAGIC
:
2701 (abfd
->flags
& WP_TEXT
)? RS6K_AOUTHDR_NMAGIC
:
2702 RS6K_AOUTHDR_OMAGIC
;
2705 #ifndef __A_MAGIC_SET__
2706 # include "Your aouthdr magic number is not being set!"
2708 # undef __A_MAGIC_SET__
2711 /* Now should write relocs, strings, syms */
2712 obj_sym_filepos(abfd
) = sym_base
;
2714 #ifndef NO_COFF_SYMBOLS
2715 if (bfd_get_symcount(abfd
) != 0) {
2716 coff_add_missing_symbols (abfd
);
2717 coff_renumber_symbols(abfd
);
2718 coff_mangle_symbols(abfd
);
2719 coff_write_symbols(abfd
);
2720 coff_write_linenumbers(abfd
);
2721 coff_write_relocs(abfd
);
2723 #endif /* NO_COFF_SYMBOLS */
2725 internal_a
.tsize
= bfd_get_section_size_before_reloc(text_sec
);
2726 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
2729 internal_a
.dsize
= bfd_get_section_size_before_reloc(data_sec
);
2730 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
2733 internal_a
.bsize
= bfd_get_section_size_before_reloc(bss_sec
);
2736 internal_a
.entry
= bfd_get_start_address(abfd
);
2737 internal_f
.f_nsyms
= bfd_get_symcount(abfd
);
2739 /* now write them */
2740 if (bfd_seek(abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
2744 coff_swap_filehdr_out(abfd
, (PTR
)&internal_f
, (PTR
)&buff
);
2745 bfd_write((PTR
) &buff
, 1, FILHSZ
, abfd
);
2747 if (abfd
->flags
& EXEC_P
) {
2749 coff_swap_aouthdr_out(abfd
, (PTR
)&internal_a
, (PTR
)&buff
);
2750 bfd_write((PTR
) &buff
, 1, AOUTSZ
, abfd
);
2755 #ifndef NO_COFF_SYMBOLS
2758 this function transforms the offsets into the symbol table into
2759 pointers to syments.
2764 DEFUN(coff_pointerize_aux
,(ignore_abfd
, table_base
, type
, class, auxent
),
2765 bfd
*ignore_abfd AND
2766 combined_entry_type
*table_base AND
2769 combined_entry_type
*auxent
)
2771 /* Don't bother if this is a file or a section */
2772 if (class == C_STAT
&& type
== T_NULL
) return;
2773 if (class == C_FILE
) return;
2775 /* Otherwise patch up */
2776 if (ISFCN(type
) || ISTAG(class) || class == C_BLOCK
) {
2777 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
= table_base
+
2778 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2779 auxent
->fix_end
= 1;
2781 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
!= 0) {
2782 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
=
2783 table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
2784 auxent
->fix_tag
= 1;
2788 #endif /* NO_COFF_SYMBOLS */
2791 DEFUN(coff_set_section_contents
,(abfd
, section
, location
, offset
, count
),
2796 bfd_size_type count
)
2798 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
2799 coff_compute_section_file_positions(abfd
);
2802 /* If this is a .lib section, bump the vma address so that it
2803 winds up being the number of .lib sections output. This is
2804 right for SVR3.2. Shared libraries should probably get more
2805 generic support. Ian Taylor <ian@cygnus.com>. */
2806 if (strcmp (section
->name
, _LIB
) == 0)
2810 bfd_seek(abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
);
2813 return (bfd_write(location
, 1, count
, abfd
) == count
) ? true : false;
2819 coff_close_and_cleanup(abfd
)
2822 if (!bfd_read_p(abfd
))
2823 switch (abfd
->format
) {
2825 if (!_bfd_write_archive_contents(abfd
))
2829 if (!coff_write_object_contents(abfd
))
2833 bfd_error
= invalid_operation
;
2837 /* We depend on bfd_close to free all the memory on the obstack. */
2838 /* FIXME if bfd_release is not using obstacks! */
2844 buy_and_read(abfd
, where
, seek_direction
, size
)
2850 PTR area
= (PTR
) bfd_alloc(abfd
, size
);
2852 bfd_error
= no_memory
;
2855 bfd_seek(abfd
, where
, seek_direction
);
2856 if (bfd_read(area
, 1, size
, abfd
) != size
) {
2857 bfd_error
= system_call_error
;
2861 } /* buy_and_read() */
2864 #ifndef NO_COFF_SYMBOLS
2867 DEFUN(build_string_table
,(abfd
),
2870 char string_table_size_buffer
[4];
2871 unsigned int string_table_size
;
2874 /* At this point we should be "seek"'d to the end of the
2875 symbols === the symbol table size. */
2876 if (bfd_read((char *) string_table_size_buffer
,
2877 sizeof(string_table_size_buffer
),
2878 1, abfd
) != sizeof(string_table_size
)) {
2879 bfd_error
= system_call_error
;
2883 string_table_size
= bfd_h_get_32(abfd
, (bfd_byte
*) string_table_size_buffer
);
2885 if ((string_table
= (PTR
) bfd_alloc(abfd
, string_table_size
-= 4)) == NULL
) {
2886 bfd_error
= no_memory
;
2888 } /* on mallocation error */
2889 if (bfd_read(string_table
, string_table_size
, 1, abfd
) != string_table_size
) {
2890 bfd_error
= system_call_error
;
2893 return string_table
;
2896 /* Allocate space for the ".debug" section, and read it.
2897 We did not read the debug section until now, because
2898 we didn't want to go to the trouble until someone needed it. */
2901 DEFUN(build_debug_section
,(abfd
),
2904 char *debug_section
;
2907 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
2910 bfd_error
= no_debug_section
;
2914 debug_section
= (PTR
) bfd_alloc (abfd
,
2915 bfd_get_section_size_before_reloc (sect
));
2916 if (debug_section
== NULL
) {
2917 bfd_error
= no_memory
;
2921 /* Seek to the beginning of the `.debug' section and read it.
2922 Save the current position first; it is needed by our caller.
2923 Then read debug section and reset the file pointer. */
2925 position
= bfd_tell (abfd
);
2926 bfd_seek (abfd
, sect
->filepos
, SEEK_SET
);
2927 if (bfd_read (debug_section
,
2928 bfd_get_section_size_before_reloc (sect
), 1, abfd
)
2929 != bfd_get_section_size_before_reloc(sect
)) {
2930 bfd_error
= system_call_error
;
2933 bfd_seek (abfd
, position
, SEEK_SET
);
2934 return debug_section
;
2938 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
2939 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
2940 be \0-terminated. */
2942 DEFUN(copy_name
,(abfd
, name
, maxlen
),
2950 for (len
= 0; len
< maxlen
; ++len
) {
2951 if (name
[len
] == '\0') {
2956 if ((newname
= (PTR
) bfd_alloc(abfd
, len
+1)) == NULL
) {
2957 bfd_error
= no_memory
;
2960 strncpy(newname
, name
, len
);
2961 newname
[len
] = '\0';
2966 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
2967 knit the symbol names into a normalized form. By normalized here I
2968 mean that all symbols have an n_offset pointer that points to a null-
2969 terminated string. */
2971 #ifndef SYMNAME_IN_DEBUG
2972 #define SYMNAME_IN_DEBUG(x) 0
2975 static combined_entry_type
*
2976 DEFUN(get_normalized_symtab
,(abfd
),
2979 combined_entry_type
*internal
;
2980 combined_entry_type
*internal_ptr
;
2981 combined_entry_type
*symbol_ptr
;
2982 combined_entry_type
*internal_end
;
2986 char *string_table
= NULL
;
2987 char *debug_section
= NULL
;
2990 unsigned int raw_size
;
2991 if (obj_raw_syments(abfd
) != (combined_entry_type
*)NULL
) {
2992 return obj_raw_syments(abfd
);
2994 if ((size
= bfd_get_symcount(abfd
) * sizeof(combined_entry_type
)) == 0) {
2995 bfd_error
= no_symbols
;
2999 internal
= (combined_entry_type
*)bfd_alloc(abfd
, size
);
3000 internal_end
= internal
+ bfd_get_symcount(abfd
);
3002 raw_size
= bfd_get_symcount(abfd
) * SYMESZ
;
3003 raw
= (SYMENT
*)bfd_alloc(abfd
,raw_size
);
3005 if (bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
) == -1
3006 || bfd_read((PTR
)raw
, raw_size
, 1, abfd
) != raw_size
) {
3007 bfd_error
= system_call_error
;
3010 /* mark the end of the symbols */
3011 raw_end
= raw
+ bfd_get_symcount(abfd
);
3013 FIXME SOMEDAY. A string table size of zero is very weird, but
3014 probably possible. If one shows up, it will probably kill us.
3017 /* Swap all the raw entries */
3018 for (raw_src
= raw
, internal_ptr
= internal
;
3020 raw_src
++, internal_ptr
++) {
3023 coff_swap_sym_in(abfd
, (PTR
)raw_src
, (PTR
)&internal_ptr
->u
.syment
);
3024 internal_ptr
->fix_tag
= 0;
3025 internal_ptr
->fix_end
= 0;
3026 symbol_ptr
= internal_ptr
;
3029 i
< symbol_ptr
->u
.syment
.n_numaux
;
3035 internal_ptr
->fix_tag
= 0;
3036 internal_ptr
->fix_end
= 0;
3037 coff_swap_aux_in(abfd
, (char *)(raw_src
),
3038 symbol_ptr
->u
.syment
.n_type
,
3039 symbol_ptr
->u
.syment
.n_sclass
,
3040 &(internal_ptr
->u
.auxent
));
3041 /* Remember that bal entries arn't pointerized */
3042 if (i
!= 1 || symbol_ptr
->u
.syment
.n_sclass
!= C_LEAFPROC
)
3045 coff_pointerize_aux(abfd
,
3047 symbol_ptr
->u
.syment
.n_type
,
3048 symbol_ptr
->u
.syment
.n_sclass
,
3055 /* Free all the raw stuff */
3056 bfd_release(abfd
, raw
);
3058 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
3061 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
) {
3062 /* make a file symbol point to the name in the auxent, since
3063 the text ".file" is redundant */
3064 if ((internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_zeroes
== 0) {
3065 /* the filename is a long one, point into the string table */
3066 if (string_table
== NULL
) {
3067 string_table
= build_string_table(abfd
);
3070 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
3071 (int) (string_table
- 4 +
3072 (internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_offset
);
3075 /* ordinary short filename, put into memory anyway */
3076 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
3077 copy_name(abfd
, (internal_ptr
+1)->u
.auxent
.x_file
.x_fname
,
3082 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0) {
3083 /* This is a "short" name. Make it long. */
3084 unsigned long i
= 0;
3085 char *newstring
= NULL
;
3087 /* find the length of this string without walking into memory
3089 for (i
= 0; i
< 8; ++i
) {
3090 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0') {
3092 } /* if end of string */
3093 } /* possible lengths of this string. */
3095 if ((newstring
= (PTR
) bfd_alloc(abfd
, ++i
)) == NULL
) {
3096 bfd_error
= no_memory
;
3099 memset(newstring
, 0, i
);
3100 strncpy(newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
-1);
3101 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int) newstring
;
3102 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
3104 else if (!SYMNAME_IN_DEBUG(&internal_ptr
->u
.syment
)) {
3105 /* Long name already. Point symbol at the string in the table. */
3106 if (string_table
== NULL
) {
3107 string_table
= build_string_table(abfd
);
3109 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
3110 (string_table
- 4 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
3113 /* Long name in debug section. Very similar. */
3114 if (debug_section
== NULL
) {
3115 debug_section
= build_debug_section(abfd
);
3117 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
3118 (debug_section
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
3121 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
3124 obj_raw_syments(abfd
) = internal
;
3127 } /* get_normalized_symtab() */
3129 #endif /* NO_COFF_SYMBOLS */
3133 DEFUN(section_from_bfd_index
,(abfd
, index
),
3137 struct sec
*answer
= abfd
->sections
;
3141 return &bfd_abs_section
;
3143 if (index
== N_UNDEF
)
3145 return &bfd_und_section
;
3147 if(index
== N_DEBUG
)
3149 return &bfd_debug_section
;
3154 if (answer
->target_index
== index
)
3156 answer
= answer
->next
;
3159 return &bfd_und_section
; /* For gcc -W and lint. Never executed. */
3162 #ifndef NO_COFF_LINENOS
3168 Creating the linenumber table is done by reading in the entire
3169 coff linenumber table, and creating another table for internal use.
3171 A coff line number table is structured so that each function
3172 is marked as having a line number of 0. Each line within the
3173 function is an offset from the first line in the function. The
3174 base of the line number information for the table is stored in
3175 the symbol associated with the function.
3177 The information is copied from the external to the internal
3178 table, and each symbol which marks a function is marked by
3181 How does this work ?
3186 coff_slurp_line_table(abfd
, asect
)
3190 LINENO
*native_lineno
;
3191 alent
*lineno_cache
;
3193 BFD_ASSERT(asect
->lineno
== (alent
*) NULL
);
3195 native_lineno
= (LINENO
*) buy_and_read(abfd
,
3196 asect
->line_filepos
,
3199 asect
->lineno_count
));
3201 (alent
*) bfd_alloc(abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof(alent
)));
3202 if (lineno_cache
== NULL
) {
3203 bfd_error
= no_memory
;
3206 unsigned int counter
= 0;
3207 alent
*cache_ptr
= lineno_cache
;
3208 LINENO
*src
= native_lineno
;
3210 while (counter
< asect
->lineno_count
) {
3211 struct internal_lineno dst
;
3212 coff_swap_lineno_in(abfd
, src
, &dst
);
3213 cache_ptr
->line_number
= dst
.l_lnno
;
3215 if (cache_ptr
->line_number
== 0) {
3216 coff_symbol_type
*sym
=
3217 (coff_symbol_type
*) (dst
.l_addr
.l_symndx
3218 + obj_raw_syments(abfd
))->u
.syment
._n
._n_n
._n_zeroes
;
3219 cache_ptr
->u
.sym
= (asymbol
*) sym
;
3220 sym
->lineno
= cache_ptr
;
3223 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
3224 - bfd_section_vma(abfd
, asect
);
3225 } /* If no linenumber expect a symbol index */
3231 cache_ptr
->line_number
= 0;
3234 asect
->lineno
= lineno_cache
;
3235 /* FIXME, free native_lineno here, or use alloca or something. */
3237 } /* coff_slurp_line_table() */
3239 #endif /* NO_COFF_LINENOS */
3241 #ifndef NO_COFF_LINENOS
3244 DEFUN(coff_slurp_symbol_table
,(abfd
),
3247 combined_entry_type
*native_symbols
;
3248 coff_symbol_type
*cached_area
;
3249 unsigned int *table_ptr
;
3251 unsigned int number_of_symbols
= 0;
3252 if (obj_symbols(abfd
))
3254 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
3256 /* Read in the symbol table */
3257 if ((native_symbols
= get_normalized_symtab(abfd
)) == NULL
) {
3261 /* Allocate enough room for all the symbols in cached form */
3263 (coff_symbol_type
*)
3264 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(coff_symbol_type
)));
3266 if (cached_area
== NULL
) {
3267 bfd_error
= no_memory
;
3272 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(unsigned int)));
3274 if (table_ptr
== NULL
) {
3275 bfd_error
= no_memory
;
3280 coff_symbol_type
*dst
= cached_area
;
3281 unsigned int last_native_index
= bfd_get_symcount(abfd
);
3282 unsigned int this_index
= 0;
3283 while (this_index
< last_native_index
) {
3284 combined_entry_type
*src
= native_symbols
+ this_index
;
3285 table_ptr
[this_index
] = number_of_symbols
;
3286 dst
->symbol
.the_bfd
= abfd
;
3288 dst
->symbol
.name
= (char *)(src
->u
.syment
._n
._n_n
._n_offset
);
3290 We use the native name field to point to the cached field
3292 src
->u
.syment
._n
._n_n
._n_zeroes
= (int) dst
;
3293 dst
->symbol
.section
= section_from_bfd_index(abfd
,
3294 src
->u
.syment
.n_scnum
);
3295 dst
->symbol
.flags
= 0;
3296 dst
->done_lineno
= false;
3298 switch (src
->u
.syment
.n_sclass
) {
3302 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
3303 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
3304 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
3306 /* Fall through to next case */
3314 if ((src
->u
.syment
.n_scnum
) == 0) {
3315 if ((src
->u
.syment
.n_value
) == 0) {
3316 dst
->symbol
.section
= &bfd_und_section
;
3317 dst
->symbol
.value
= 0;
3320 dst
->symbol
.section
= &bfd_com_section
;
3321 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3326 Base the value as an index from the base of the
3330 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
3331 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
3333 if (ISFCN((src
->u
.syment
.n_type
))) {
3335 A function ext does not go at the end of a file
3337 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
3344 case C_STAT
: /* static */
3346 case C_LEAFSTAT
: /* static leaf procedure */
3348 case C_LABEL
: /* label */
3349 if (src
->u
.syment
.n_scnum
== -2)
3350 dst
->symbol
.flags
= BSF_DEBUGGING
;
3352 dst
->symbol
.flags
= BSF_LOCAL
;
3354 Base the value as an index from the base of the section, if
3357 if (dst
->symbol
.section
)
3358 dst
->symbol
.value
= (src
->u
.syment
.n_value
) -
3359 dst
->symbol
.section
->vma
;
3361 dst
->symbol
.value
= (src
->u
.syment
.n_value
) ;
3364 case C_MOS
: /* member of structure */
3365 case C_EOS
: /* end of structure */
3366 #ifdef NOTDEF /* C_AUTOARG has the same value */
3368 case C_GLBLREG
: /* A29k-specific storage class */
3371 case C_REGPARM
: /* register parameter */
3372 case C_REG
: /* register variable */
3374 case C_AUTOARG
: /* 960-specific storage class */
3376 case C_TPDEF
: /* type definition */
3378 case C_AUTO
: /* automatic variable */
3379 case C_FIELD
: /* bit field */
3380 case C_ENTAG
: /* enumeration tag */
3381 case C_MOE
: /* member of enumeration */
3382 case C_MOU
: /* member of union */
3383 case C_UNTAG
: /* union tag */
3384 dst
->symbol
.flags
= BSF_DEBUGGING
;
3385 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3388 case C_FILE
: /* file name */
3389 case C_STRTAG
: /* structure tag */
3391 case C_BINCL
: /* beginning of include file */
3392 case C_EINCL
: /* ending of include file */
3405 dst
->symbol
.flags
= BSF_DEBUGGING
;
3406 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3409 case C_BLOCK
: /* ".bb" or ".eb" */
3410 case C_FCN
: /* ".bf" or ".ef" */
3411 case C_EFCN
: /* physical end of function */
3412 dst
->symbol
.flags
= BSF_LOCAL
;
3414 Base the value as an index from the base of the section
3416 dst
->symbol
.value
= (src
->u
.syment
.n_value
) - dst
->symbol
.section
->vma
;
3420 case C_EXTDEF
: /* external definition */
3421 case C_ULABEL
: /* undefined label */
3422 case C_USTATIC
: /* undefined static */
3423 case C_LINE
: /* line # reformatted as symbol table entry */
3424 case C_ALIAS
: /* duplicate tag */
3425 case C_HIDDEN
: /* ext symbol in dmert public lib */
3428 fprintf(stderr
,"Unrecognized storage class %d\n",
3429 src
->u
.syment
.n_sclass
);
3431 dst
->symbol
.flags
= BSF_DEBUGGING
;
3432 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3436 /* BFD_ASSERT(dst->symbol.flags != 0);*/
3440 dst
->symbol
.udata
= 0;
3441 dst
->lineno
= (alent
*) NULL
;
3442 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
3444 number_of_symbols
++;
3445 } /* walk the native symtab */
3446 } /* bfdize the native symtab */
3448 obj_symbols(abfd
) = cached_area
;
3449 obj_raw_syments(abfd
) = native_symbols
;
3451 obj_conv_table_size (abfd
) = bfd_get_symcount (abfd
);
3452 bfd_get_symcount(abfd
) = number_of_symbols
;
3453 obj_convert(abfd
) = table_ptr
;
3454 /* Slurp the line tables for each section too */
3459 coff_slurp_line_table(abfd
, p
);
3464 } /* coff_slurp_symbol_table() */
3467 coff_get_symtab_upper_bound(abfd
)
3470 if (!coff_slurp_symbol_table(abfd
))
3473 return (bfd_get_symcount(abfd
) + 1) * (sizeof(coff_symbol_type
*));
3478 DEFUN(coff_get_symtab
, (abfd
, alocation
),
3480 asymbol
**alocation
)
3482 unsigned int counter
= 0;
3483 coff_symbol_type
*symbase
;
3484 coff_symbol_type
**location
= (coff_symbol_type
**) (alocation
);
3485 if (!coff_slurp_symbol_table(abfd
))
3488 symbase
= obj_symbols(abfd
);
3489 while (counter
< bfd_get_symcount(abfd
))
3491 /* This nasty code looks at the symbol to decide whether or
3492 not it is descibes a constructor/destructor entry point. It
3493 is structured this way to (hopefully) speed non matches */
3495 if (0 && symbase
->symbol
.name
[9] == '$')
3497 bfd_constructor_entry(abfd
,
3498 (asymbol
**)location
,
3499 symbase
->symbol
.name
[10] == 'I' ?
3503 *(location
++) = symbase
++;
3507 return bfd_get_symcount(abfd
);
3510 #endif /* NO_COFF_SYMBOLS */
3513 coff_get_reloc_upper_bound(abfd
, asect
)
3517 if (bfd_get_format(abfd
) != bfd_object
) {
3518 bfd_error
= invalid_operation
;
3521 return (asect
->reloc_count
+ 1) * sizeof(arelent
*);
3528 Coff relocations are easily transformed into the internal BFD form
3531 Reading a coff relocation table is done in the following stages:
3533 o The entire coff relocation table is read into memory.
3535 o Each relocation is processed in turn, first it is swapped from the
3536 external to the internal form.
3538 o The symbol referenced in the relocation's symbol index is
3539 turned intoa pointer into the canonical symbol table. Note
3540 that this table is the same as the one returned by a call to
3541 @code{bfd_canonicalize_symtab}. The back end will call the
3542 routine and save the result if a canonicalization hasn't been done.
3544 o The reloc index is turned into a pointer to a howto
3545 structure, in a back end specific way. For instance, the 386
3546 and 960 use the @code{r_type} to directly produce an index
3547 into a howto table vector; the 88k subtracts a number from the
3548 @code{r_type} field and creates an addend field.
3554 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
3555 if (ptr && ptr->the_bfd == abfd \
3556 && ((ptr->flags & BSF_OLD_COMMON)== 0)) \
3558 cache_ptr->addend = -(ptr->section->vma + ptr->value); \
3561 cache_ptr->addend = 0; \
3566 DEFUN(coff_slurp_reloc_table
,(abfd
, asect
, symbols
),
3571 RELOC
*native_relocs
;
3572 arelent
*reloc_cache
;
3577 if (asect
->relocation
)
3579 if (asect
->reloc_count
== 0)
3581 if (asect
->flags
& SEC_CONSTRUCTOR
)
3583 #ifndef NO_COFF_SYMBOLS
3584 if (!coff_slurp_symbol_table(abfd
))
3588 (RELOC
*) buy_and_read(abfd
,
3592 asect
->reloc_count
));
3593 reloc_cache
= (arelent
*)
3594 bfd_alloc(abfd
, (size_t) (asect
->reloc_count
* sizeof(arelent
)));
3596 if (reloc_cache
== NULL
) {
3597 bfd_error
= no_memory
;
3602 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
3604 #ifdef RELOC_PROCESSING
3605 struct internal_reloc dst
;
3606 struct external_reloc
*src
;
3608 cache_ptr
= reloc_cache
+ idx
;
3609 src
= native_relocs
+ idx
;
3610 bfd_swap_reloc_in(abfd
, src
, &dst
);
3612 RELOC_PROCESSING(cache_ptr
, &dst
, symbols
, abfd
, asect
);
3614 struct internal_reloc dst
;
3616 struct external_reloc
*src
;
3618 cache_ptr
= reloc_cache
+ idx
;
3619 src
= native_relocs
+ idx
;
3621 bfd_swap_reloc_in(abfd
, src
, &dst
);
3624 cache_ptr
->address
= dst
.r_vaddr
;
3626 if (dst
.r_symndx
!= -1)
3628 /* @@ Should never be greater than count of symbols! */
3629 if (dst
.r_symndx
>= obj_conv_table_size (abfd
))
3631 cache_ptr
->sym_ptr_ptr
= symbols
+ obj_convert(abfd
)[dst
.r_symndx
];
3632 ptr
= *(cache_ptr
->sym_ptr_ptr
);
3636 cache_ptr
->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
3641 The symbols definitions that we have read in have been
3642 relocated as if their sections started at 0. But the offsets
3643 refering to the symbols in the raw data have not been
3644 modified, so we have to have a negative addend to compensate.
3646 Note that symbols which used to be common must be left alone */
3648 /* Calculate any reloc addend by looking at the symbol */
3649 CALC_ADDEND(abfd
, ptr
, dst
, cache_ptr
);
3651 cache_ptr
->address
-= asect
->vma
;
3652 /* !! cache_ptr->section = (asection *) NULL;*/
3654 /* Fill in the cache_ptr->howto field from dst.r_type */
3655 RTYPE2HOWTO(cache_ptr
, &dst
);
3660 asect
->relocation
= reloc_cache
;
3665 /* This is stupid. This function should be a boolean predicate */
3667 DEFUN(coff_canonicalize_reloc
, (abfd
, section
, relptr
, symbols
),
3670 arelent
**relptr AND
3673 arelent
*tblptr
= section
->relocation
;
3674 unsigned int count
= 0;
3677 if (section
->flags
& SEC_CONSTRUCTOR
)
3679 /* this section has relocs made up by us, they are not in the
3680 file, so take them out of their chain and place them into
3681 the data area provided */
3682 arelent_chain
*chain
= section
->constructor_chain
;
3683 for (count
= 0; count
< section
->reloc_count
; count
++)
3685 *relptr
++ = &chain
->relent
;
3686 chain
= chain
->next
;
3692 coff_slurp_reloc_table(abfd
, section
, symbols
);
3695 tblptr
= section
->relocation
;
3699 for (; count
++ < section
->reloc_count
;)
3700 *relptr
++ = tblptr
++;
3705 return section
->reloc_count
;
3708 #ifndef NO_COFF_SYMBOLS
3711 provided a BFD, a section and an offset into the section, calculate and
3712 return the name of the source file and the line nearest to the wanted
3717 DEFUN(coff_find_nearest_line
,(abfd
,
3725 asection
*section AND
3726 asymbol
**ignore_symbols AND
3728 CONST
char **filename_ptr AND
3729 CONST
char **functionname_ptr AND
3730 unsigned int *line_ptr
)
3732 static bfd
*cache_abfd
;
3733 static asection
*cache_section
;
3734 static bfd_vma cache_offset
;
3735 static unsigned int cache_i
;
3736 static alent
*cache_l
;
3739 coff_data_type
*cof
= coff_data(abfd
);
3740 /* Run through the raw syments if available */
3741 combined_entry_type
*p
;
3743 unsigned int line_base
= 0;
3747 *functionname_ptr
= 0;
3750 /* Don't try and find line numbers in a non coff file */
3751 if (abfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
3757 p
= cof
->raw_syments
;
3759 for (i
= 0; i
< cof
->raw_syment_count
; i
++) {
3760 if (p
->u
.syment
.n_sclass
== C_FILE
) {
3761 /* File name has been moved into symbol */
3762 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
3765 p
+= 1 + p
->u
.syment
.n_numaux
;
3767 /* Now wander though the raw linenumbers of the section */
3769 If this is the same BFD as we were previously called with and this is
3770 the same section, and the offset we want is further down then we can
3771 prime the lookup loop
3773 if (abfd
== cache_abfd
&&
3774 section
== cache_section
&&
3775 offset
>= cache_offset
) {
3781 l
= section
->lineno
;
3784 for (; i
< section
->lineno_count
; i
++) {
3785 if (l
->line_number
== 0) {
3786 /* Get the symbol this line number points at */
3787 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
3788 *functionname_ptr
= coff
->symbol
.name
;
3790 combined_entry_type
*s
= coff
->native
;
3791 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
3793 S should now point to the .bf of the function
3795 if (s
->u
.syment
.n_numaux
) {
3797 The linenumber is stored in the auxent
3799 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
3800 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
3805 if (l
->u
.offset
> offset
)
3807 *line_ptr
= l
->line_number
+ line_base
+ 1;
3813 cache_section
= section
;
3814 cache_offset
= offset
;
3823 coff_sym_filepos(abfd
)
3826 return obj_sym_filepos(abfd
);
3830 #endif /* NO_COFF_SYMBOLS */
3834 DEFUN(coff_sizeof_headers
,(abfd
, reloc
),
3840 if (reloc
== false) {
3841 size
= FILHSZ
+ AOUTSZ
;
3847 size
+= abfd
->section_count
* SCNHSZ
;
3852 DEFUN(get_value
,(reloc
, seclet
),
3854 bfd_seclet_type
*seclet
)
3857 asymbol
*symbol
= *(reloc
->sym_ptr_ptr
);
3858 /* A symbol holds a pointer to a section, and an offset from the
3859 base of the section. To relocate, we find where the section will
3860 live in the output and add that in */
3862 if (symbol
->section
== &bfd_und_section
)
3864 /* Ouch, this is an undefined symbol.. */
3865 bfd_error_vector
.undefined_symbol(reloc
, seclet
);
3866 value
= symbol
->value
;
3870 value
= symbol
->value
+
3871 symbol
->section
->output_offset
+
3872 symbol
->section
->output_section
->vma
;
3876 /* Add the value contained in the relocation */
3877 value
+= (short)((reloc
->addend
) & 0xffff);
3883 DEFUN(perform_slip
,(s
, slip
, input_section
, value
),
3885 unsigned int slip AND
3886 asection
*input_section AND
3890 /* Find all symbols past this point, and make them know
3895 if (p
->section
== input_section
)
3897 /* This was pointing into this section, so mangle it */
3898 if (p
->value
> value
)
3908 DEFUN(movb1
,(input_section
, symbols
, r
, shrink
),
3909 asection
*input_section AND
3910 asymbol
**symbols AND
3912 unsigned int shrink
)
3914 bfd_vma value
= get_value(r
,0);
3916 if (value
>= 0xff00)
3919 /* Change the reloc type from 16bit, possible 8 to 8bit
3921 r
->howto
= r
->howto
+ 1;
3922 /* The place to relc moves back by one */
3925 /* This will be two bytes smaller in the long run */
3927 perform_slip(symbols
, 2, input_section
, r
->address
- shrink
+1);
3935 DEFUN(jmp1
,(input_section
, symbols
, r
, shrink
),
3936 asection
*input_section AND
3937 asymbol
**symbols AND
3939 unsigned int shrink
)
3943 bfd_vma value
= get_value(r
, 0);
3945 bfd_vma dot
= input_section
->output_section
->vma
+
3946 input_section
->output_offset
+ r
->address
;
3949 /* See if the address we're looking at within 127 bytes of where
3950 we are, if so then we can use a small branch rather than the
3951 jump we were going to */
3953 gap
= value
- (dot
- shrink
);
3956 if (-120 < (long)gap
&& (long)gap
< 120 )
3959 /* Change the reloc type from 16bit, possible 8 to 8bit
3961 r
->howto
= r
->howto
+ 1;
3962 /* The place to relc moves back by one */
3965 /* This will be two bytes smaller in the long run */
3967 perform_slip(symbols
, 2, input_section
, r
->address
-shrink
+1);
3975 DEFUN(bfd_coff_relax_section
,(abfd
, i
, symbols
),
3981 /* Get enough memory to hold the stuff */
3982 bfd
*input_bfd
= i
->owner
;
3983 asection
*input_section
= i
;
3985 boolean
new = false;
3987 bfd_size_type reloc_size
= bfd_get_reloc_upper_bound(input_bfd
,
3989 arelent
**reloc_vector
= (arelent
**)bfd_xmalloc(reloc_size
);
3991 /* Get the relocs and think about them */
3992 if (bfd_canonicalize_reloc(input_bfd
,
3998 for (parent
= reloc_vector
; *parent
; parent
++)
4000 arelent
*r
= *parent
;
4001 switch (r
->howto
->type
) {
4009 shrink
= movb1(input_section
, symbols
, r
, shrink
);
4014 shrink
= jmp1(input_section
, symbols
, r
, shrink
);
4022 input_section
->_cooked_size
-= shrink
;
4023 free((char *)reloc_vector
);
4028 DEFUN(bfd_coff_get_relocated_section_contents
,(in_abfd
, seclet
, data
),
4030 bfd_seclet_type
*seclet AND
4034 /* Get enough memory to hold the stuff */
4035 bfd
*input_bfd
= seclet
->u
.indirect
.section
->owner
;
4036 asection
*input_section
= seclet
->u
.indirect
.section
;
4037 bfd_size_type reloc_size
= bfd_get_reloc_upper_bound(input_bfd
,
4039 arelent
**reloc_vector
= (arelent
**)bfd_xmalloc(reloc_size
);
4041 /* read in the section */
4042 bfd_get_section_contents(input_bfd
,
4046 input_section
->_raw_size
);
4049 if (bfd_canonicalize_reloc(input_bfd
,
4052 seclet
->u
.indirect
.symbols
) )
4054 arelent
**parent
= reloc_vector
;
4059 unsigned int dst_address
= 0;
4060 unsigned int src_address
= 0;
4064 /* Find how long a run we can do */
4065 while (dst_address
< seclet
->size
)
4071 /* Note that the relaxing didn't tie up the addresses in the
4072 relocation, so we use the original address to work out the
4073 run of non-relocated data */
4074 run
= reloc
->address
- src_address
;
4080 run
= seclet
->size
- dst_address
;
4082 /* Copy the bytes */
4083 for (idx
= 0; idx
< run
; idx
++)
4085 data
[dst_address
++] = data
[src_address
++];
4088 /* Now do the relocation */
4092 switch (reloc
->howto
->type
)
4095 /* Speciial relaxed type */
4097 bfd_vma dot
= seclet
->offset
+ dst_address
+ seclet
->u
.indirect
.section
->output_section
->vma
;
4098 int gap
= get_value(reloc
,seclet
)-dot
-1;
4099 if ((gap
& ~0xff ) != 0 &&((gap
& 0xff00)!= 0xff00)) abort();
4101 bfd_put_8(in_abfd
,gap
, data
+dst_address
);
4103 switch (data
[dst_address
-1])
4108 bfd_put_8(in_abfd
, 0x55, data
+dst_address
-1);
4112 bfd_put_8(in_abfd
, 0x40, data
+dst_address
-1);
4131 /* Special relaxed type, there will be a gap between where we
4132 get stuff from and where we put stuff to now
4134 for a mov.b @aa:16 -> mov.b @aa:8
4135 opcode 0x6a 0x0y offset
4138 if (data
[dst_address
-1] != 0x6a)
4140 switch (data
[src_address
] & 0xf0)
4144 data
[dst_address
-1] = (data
[src_address
] & 0xf) | 0x20;
4148 data
[dst_address
-1] = (data
[src_address
] & 0xf) | 0x30;
4154 /* the offset must fit ! after all, what was all the relaxing
4157 bfd_put_8(in_abfd
, get_value(reloc
, seclet
), data
+ dst_address
);
4159 /* Note the magic - src goes up by two bytes, but dst by only
4168 bfd_vma dot
= seclet
->offset
+ dst_address
+ seclet
->u
.indirect
.section
->output_section
->vma
;
4169 int gap
= get_value(reloc
,seclet
)-dot
;
4170 if (gap
> 127 || gap
< -128)
4172 bfd_error_vector
.reloc_value_truncated(reloc
, seclet
);
4175 bfd_put_8(in_abfd
,gap
, data
+dst_address
);
4184 unsigned int gap
=get_value(reloc
,seclet
);
4185 if (gap
> 0xff && gap
< ~0xff)
4187 bfd_error_vector
.reloc_value_truncated(reloc
, seclet
);
4190 bfd_put_8(in_abfd
, gap
, data
+dst_address
);
4198 /* A relword which would have like to have been a pcrel */
4200 /* A relword which would like to have been modified but
4203 bfd_put_16(in_abfd
, get_value(reloc
,seclet
), data
+dst_address
);
4218 free((char *)reloc_vector
);
4224 #define coff_core_file_failing_command _bfd_dummy_core_file_failing_command
4225 #define coff_core_file_failing_signal _bfd_dummy_core_file_failing_signal
4226 #define coff_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
4227 #define coff_slurp_armap bfd_slurp_coff_armap
4228 #define coff_slurp_extended_name_table _bfd_slurp_extended_name_table
4229 #define coff_truncate_arname bfd_dont_truncate_arname
4230 #define coff_openr_next_archived_file bfd_generic_openr_next_archived_file
4231 #define coff_generic_stat_arch_elt bfd_generic_stat_arch_elt
4232 #define coff_get_section_contents bfd_generic_get_section_contents
4233 #define coff_close_and_cleanup bfd_generic_close_and_cleanup
4235 #define coff_bfd_debug_info_start bfd_void
4236 #define coff_bfd_debug_info_end bfd_void
4237 #define coff_bfd_debug_info_accumulate (PROTO(void,(*),(bfd*, struct sec *))) bfd_void
4238 #define coff_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
4239 #define coff_bfd_relax_section bfd_generic_relax_section