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
;
687 memset((PTR
)ext
, 0, AUXESZ
);
690 if (in
->x_file
.x_fname
[0] == 0) {
691 PUTWORD(abfd
, 0, (bfd_byte
*) ext
->x_file
.x_n
.x_zeroes
);
693 in
->x_file
.x_n
.x_offset
,
694 (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
697 #if FILNMLEN != E_FILNMLEN
698 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
700 memcpy (ext
->x_file
.x_fname
, in
->x_file
.x_fname
, FILNMLEN
);
706 /* RS/6000 "csect" auxents */
709 PUTWORD (abfd
, in
->x_csect
.x_scnlen
, ext
->x_csect
.x_scnlen
);
710 PUTWORD (abfd
, in
->x_csect
.x_parmhash
, ext
->x_csect
.x_parmhash
);
711 PUTHALF (abfd
, in
->x_csect
.x_snhash
, ext
->x_csect
.x_snhash
);
712 /* We don't have to hack bitfields in x_smtyp because it's defined by
713 shifts-and-ands, which are equivalent on all byte orders. */
714 PUTBYTE (abfd
, in
->x_csect
.x_smtyp
, ext
->x_csect
.x_smtyp
);
715 PUTBYTE (abfd
, in
->x_csect
.x_smclas
, ext
->x_csect
.x_smclas
);
716 PUTWORD (abfd
, in
->x_csect
.x_stab
, ext
->x_csect
.x_stab
);
717 PUTHALF (abfd
, in
->x_csect
.x_snstab
, ext
->x_csect
.x_snstab
);
726 if (type
== T_NULL
) {
727 PUT_SCN_SCNLEN(abfd
, in
->x_scn
.x_scnlen
, ext
);
728 PUT_SCN_NRELOC(abfd
, in
->x_scn
.x_nreloc
, ext
);
729 PUT_SCN_NLINNO(abfd
, in
->x_scn
.x_nlinno
, ext
);
733 PUTWORD(abfd
, in
->x_sym
.x_tagndx
.l
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
735 bfd_h_put_16(abfd
, in
->x_sym
.x_tvndx
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
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
);
742 PUTWORD(abfd
, in
->x_sym
.x_misc
.x_fsize
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
745 if (ISARY(type
) || class == C_BLOCK
) {
746 #if DIMNUM != E_DIMNUM
747 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
749 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]);
750 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]);
751 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]);
752 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]);
755 PUT_LNSZ_LNNO(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
756 PUT_LNSZ_SIZE(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
759 return sizeof(AUXENT
);
762 #endif /* NO_COFF_SYMBOLS */
764 #ifndef NO_COFF_LINENOS
767 DEFUN(coff_swap_lineno_in
,(abfd
, ext1
, in1
),
772 LINENO
*ext
= (LINENO
*)ext1
;
773 struct internal_lineno
*in
= (struct internal_lineno
*)in1
;
775 in
->l_addr
.l_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->l_addr
.l_symndx
);
776 in
->l_lnno
= GET_LINENO_LNNO(abfd
, ext
);
780 DEFUN(coff_swap_lineno_out
,(abfd
, inp
, outp
),
785 struct internal_lineno
*in
= (struct internal_lineno
*)inp
;
786 struct external_lineno
*ext
= (struct external_lineno
*)outp
;
787 PUTWORD(abfd
, in
->l_addr
.l_symndx
, (bfd_byte
*)
788 ext
->l_addr
.l_symndx
);
790 PUT_LINENO_LNNO (abfd
, in
->l_lnno
, ext
);
791 return sizeof(struct external_lineno
);
794 #endif /* NO_COFF_LINENOS */
798 DEFUN(bfd_swap_aouthdr_in
,(abfd
, aouthdr_ext1
, aouthdr_int1
),
803 AOUTHDR
*aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
804 struct internal_aouthdr
*aouthdr_int
= (struct internal_aouthdr
*)aouthdr_int1
;
806 aouthdr_int
->magic
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->magic
);
807 aouthdr_int
->vstamp
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->vstamp
);
808 aouthdr_int
->tsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tsize
);
809 aouthdr_int
->dsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->dsize
);
810 aouthdr_int
->bsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->bsize
);
811 aouthdr_int
->entry
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->entry
);
812 aouthdr_int
->text_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->text_start
);
813 aouthdr_int
->data_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->data_start
);
815 aouthdr_int
->tagentries
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tagentries
);
819 aouthdr_int
->o_toc
= bfd_h_get_32(abfd
, aouthdr_ext
->o_toc
);
820 aouthdr_int
->o_snentry
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snentry
);
821 aouthdr_int
->o_sntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntext
);
822 aouthdr_int
->o_sndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sndata
);
823 aouthdr_int
->o_sntoc
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntoc
);
824 aouthdr_int
->o_snloader
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snloader
);
825 aouthdr_int
->o_snbss
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snbss
);
826 aouthdr_int
->o_algntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algntext
);
827 aouthdr_int
->o_algndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algndata
);
828 aouthdr_int
->o_modtype
= bfd_h_get_16(abfd
, aouthdr_ext
->o_modtype
);
829 aouthdr_int
->o_maxstack
= bfd_h_get_32(abfd
, aouthdr_ext
->o_maxstack
);
834 DEFUN(coff_swap_aouthdr_out
,(abfd
, in
, out
),
839 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*)in
;
840 AOUTHDR
*aouthdr_out
= (AOUTHDR
*)out
;
841 bfd_h_put_16(abfd
, aouthdr_in
->magic
, (bfd_byte
*) aouthdr_out
->magic
);
842 bfd_h_put_16(abfd
, aouthdr_in
->vstamp
, (bfd_byte
*) aouthdr_out
->vstamp
);
843 bfd_h_put_32(abfd
, aouthdr_in
->tsize
, (bfd_byte
*) aouthdr_out
->tsize
);
844 bfd_h_put_32(abfd
, aouthdr_in
->dsize
, (bfd_byte
*) aouthdr_out
->dsize
);
845 bfd_h_put_32(abfd
, aouthdr_in
->bsize
, (bfd_byte
*) aouthdr_out
->bsize
);
846 bfd_h_put_32(abfd
, aouthdr_in
->entry
, (bfd_byte
*) aouthdr_out
->entry
);
847 bfd_h_put_32(abfd
, aouthdr_in
->text_start
,
848 (bfd_byte
*) aouthdr_out
->text_start
);
849 bfd_h_put_32(abfd
, aouthdr_in
->data_start
, (bfd_byte
*) aouthdr_out
->data_start
);
851 bfd_h_put_32(abfd
, aouthdr_in
->tagentries
, (bfd_byte
*) aouthdr_out
->tagentries
);
853 return sizeof(AOUTHDR
);
857 DEFUN(coff_swap_scnhdr_in
,(abfd
, scnhdr_ext
, scnhdr_int
),
859 SCNHDR
*scnhdr_ext AND
860 struct internal_scnhdr
*scnhdr_int
)
862 memcpy(scnhdr_int
->s_name
, scnhdr_ext
->s_name
, sizeof(scnhdr_int
->s_name
));
863 scnhdr_int
->s_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
864 scnhdr_int
->s_paddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
865 scnhdr_int
->s_size
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_size
);
867 scnhdr_int
->s_scnptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
868 scnhdr_int
->s_relptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
869 scnhdr_int
->s_lnnoptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
870 scnhdr_int
->s_flags
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_flags
);
872 scnhdr_int
->s_nreloc
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
873 scnhdr_int
->s_nlnno
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
875 scnhdr_int
->s_nreloc
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
876 scnhdr_int
->s_nlnno
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
879 scnhdr_int
->s_align
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_align
);
884 DEFUN(coff_swap_scnhdr_out
,(abfd
, in
, out
),
889 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*)in
;
890 SCNHDR
*scnhdr_ext
= (SCNHDR
*)out
;
891 memcpy(scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof(scnhdr_int
->s_name
));
892 PUTWORD(abfd
, scnhdr_int
->s_vaddr
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
893 PUTWORD(abfd
, scnhdr_int
->s_paddr
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
894 PUTWORD(abfd
, scnhdr_int
->s_size
, (bfd_byte
*) scnhdr_ext
->s_size
);
895 PUTWORD(abfd
, scnhdr_int
->s_scnptr
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
896 PUTWORD(abfd
, scnhdr_int
->s_relptr
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
897 PUTWORD(abfd
, scnhdr_int
->s_lnnoptr
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
898 PUTWORD(abfd
, scnhdr_int
->s_flags
, (bfd_byte
*) scnhdr_ext
->s_flags
);
900 PUTWORD(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
901 PUTWORD(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
903 PUTHALF(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
904 PUTHALF(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
908 PUTWORD(abfd
, scnhdr_int
->s_align
, (bfd_byte
*) scnhdr_ext
->s_align
);
910 return sizeof(SCNHDR
);
915 initialize a section structure with information peculiar to this
916 particular implementation of coff
920 DEFUN(coff_new_section_hook
,(abfd
, section
),
924 section
->alignment_power
= abfd
->xvec
->align_power_min
;
925 /* Allocate aux records for section symbols, to store size and
928 @@ Shouldn't use constant multiplier here! */
929 coffsymbol (section
->symbol
)->native
=
930 (combined_entry_type
*) bfd_zalloc (abfd
,
931 sizeof (combined_entry_type
) * 10);
935 static asection bfd_debug_section
= { "*DEBUG*" };
937 /* Take a section header read from a coff file (in HOST byte order),
938 and make a BFD "section" out of it. */
940 DEFUN(make_a_section_from_file
,(abfd
, hdr
, target_index
),
942 struct internal_scnhdr
*hdr AND
943 unsigned int target_index
)
945 asection
*return_section
;
948 /* Assorted wastage to null-terminate the name, thanks AT&T! */
949 name
= bfd_alloc(abfd
, sizeof (hdr
->s_name
)+1);
951 bfd_error
= no_memory
;
954 strncpy(name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
955 name
[sizeof (hdr
->s_name
)] = 0;
957 return_section
= bfd_make_section(abfd
, name
);
959 /* On SCO a file created by the Microsoft assembler can have two
960 .data sections. We use .data2 for the second one. */
961 if (return_section
== NULL
&& strcmp(name
, _DATA
) == 0)
962 return_section
= bfd_make_section(abfd
, ".data2");
963 #endif /* TWO_DATA_SECS */
964 if (return_section
== NULL
)
967 /* s_paddr is presumed to be = to s_vaddr */
969 return_section
->vma
= hdr
->s_vaddr
;
970 return_section
->_raw_size
= hdr
->s_size
;
971 return_section
->filepos
= hdr
->s_scnptr
;
972 return_section
->rel_filepos
= hdr
->s_relptr
;
973 return_section
->reloc_count
= hdr
->s_nreloc
;
976 /* FIXME, use a temp var rather than alignment_power */
977 return_section
->alignment_power
= hdr
->s_align
;
980 for (i
= 0; i
< 32; i
++) {
981 if ((1 << i
) >= (int) (return_section
->alignment_power
)) {
982 return_section
->alignment_power
= i
;
989 return_section
->line_filepos
= hdr
->s_lnnoptr
;
991 return_section->linesize = hdr->s_nlnno * sizeof (struct lineno);
994 return_section
->lineno_count
= hdr
->s_nlnno
;
995 return_section
->userdata
= NULL
;
996 return_section
->next
= (asection
*) NULL
;
997 return_section
->flags
= styp_to_sec_flags(hdr
->s_flags
);
999 return_section
->target_index
= target_index
;
1001 if (hdr
->s_nreloc
!= 0)
1002 return_section
->flags
|= SEC_RELOC
;
1003 /* FIXME: should this check 'hdr->s_size > 0' */
1004 if (hdr
->s_scnptr
!= 0)
1005 return_section
->flags
|= SEC_HAS_CONTENTS
;
1009 DEFUN(coff_mkobject
,(abfd
),
1012 abfd
->tdata
.coff_obj_data
= (struct coff_tdata
*)bfd_zalloc (abfd
,sizeof(coff_data_type
));
1013 if (abfd
->tdata
.coff_obj_data
== 0){
1014 bfd_error
= no_memory
;
1017 coff_data(abfd
)->relocbase
= 0;
1018 /* make_abs_section(abfd);*/
1024 DEFUN(coff_real_object_p
,(abfd
, nscns
, internal_f
, internal_a
),
1027 struct internal_filehdr
*internal_f AND
1028 struct internal_aouthdr
*internal_a
)
1030 coff_data_type
*coff
;
1031 enum bfd_architecture arch
;
1033 size_t readsize
; /* length of file_info */
1034 SCNHDR
*external_sections
;
1036 /* Build a play area */
1037 if (coff_mkobject(abfd
) != true)
1040 coff
= coff_data(abfd
);
1043 external_sections
= (SCNHDR
*)bfd_alloc(abfd
, readsize
= (nscns
* SCNHSZ
));
1045 if (bfd_read((PTR
)external_sections
, 1, readsize
, abfd
) != readsize
) {
1050 /* Now copy data as required; construct all asections etc */
1051 coff
->symbol_index_slew
= 0;
1053 coff
->raw_syment_count
= 0;
1054 coff
->raw_linenos
= 0;
1055 coff
->raw_syments
= 0;
1056 coff
->sym_filepos
=0;
1057 coff
->flags
= internal_f
->f_flags
;
1060 for (i
= 0; i
< nscns
; i
++) {
1061 struct internal_scnhdr tmp
;
1062 coff_swap_scnhdr_in(abfd
, external_sections
+ i
, &tmp
);
1063 make_a_section_from_file(abfd
,&tmp
, i
+1);
1067 /* make_abs_section(abfd);*/
1069 /* Determine the machine architecture and type. */
1071 switch (internal_f
->f_magic
) {
1074 arch
= bfd_arch_i386
;
1079 #ifdef A29K_MAGIC_BIG
1080 case A29K_MAGIC_BIG
:
1081 case A29K_MAGIC_LITTLE
:
1082 arch
= bfd_arch_a29k
;
1091 arch
= bfd_arch_mips
;
1099 arch
= bfd_arch_m68k
;
1107 arch
= bfd_arch_m88k
;
1113 arch
= bfd_arch_z8k
;
1114 switch (internal_f
->f_flags
& F_MACHMASK
)
1117 machine
= bfd_mach_z8001
;
1120 machine
= bfd_mach_z8002
;
1131 arch
= bfd_arch_i960
;
1132 switch (F_I960TYPE
& internal_f
->f_flags
)
1136 machine
= bfd_mach_i960_core
;
1139 machine
= bfd_mach_i960_kb_sb
;
1142 machine
= bfd_mach_i960_mc
;
1145 machine
= bfd_mach_i960_xa
;
1148 machine
= bfd_mach_i960_ca
;
1151 machine
= bfd_mach_i960_ka_sa
;
1162 arch
= bfd_arch_rs6000
;
1169 arch
= bfd_arch_we32k
;
1176 arch
= bfd_arch_h8300
;
1181 default: /* Unreadable input file type */
1182 arch
= bfd_arch_obscure
;
1186 bfd_default_set_arch_mach(abfd
, arch
, machine
);
1187 if (!(internal_f
->f_flags
& F_RELFLG
))
1188 abfd
->flags
|= HAS_RELOC
;
1189 if ((internal_f
->f_flags
& F_EXEC
))
1190 abfd
->flags
|= EXEC_P
;
1191 if (!(internal_f
->f_flags
& F_LNNO
))
1192 abfd
->flags
|= HAS_LINENO
;
1193 if (!(internal_f
->f_flags
& F_LSYMS
))
1194 abfd
->flags
|= HAS_LOCALS
;
1197 bfd_get_symcount(abfd
) = internal_f
->f_nsyms
;
1198 if (internal_f
->f_nsyms
)
1199 abfd
->flags
|= HAS_SYMS
;
1201 coff
->sym_filepos
= internal_f
->f_symptr
;
1203 /* These members communicate important constants about the symbol table
1204 to GDB's symbol-reading code. These `constants' unfortunately vary
1205 from coff implementation to implementation... */
1206 #ifndef NO_COFF_SYMBOLS
1207 coff
->local_n_btmask
= N_BTMASK
;
1208 coff
->local_n_btshft
= N_BTSHFT
;
1209 coff
->local_n_tmask
= N_TMASK
;
1210 coff
->local_n_tshift
= N_TSHIFT
;
1211 coff
->local_symesz
= SYMESZ
;
1212 coff
->local_auxesz
= AUXESZ
;
1213 coff
->local_linesz
= LINESZ
;
1216 coff
->symbols
= (coff_symbol_type
*) NULL
;
1217 bfd_get_start_address(abfd
) = internal_f
->f_opthdr
? internal_a
->entry
: 0;
1221 bfd_release(abfd
, coff
);
1222 return (bfd_target
*)NULL
;
1226 DEFUN(coff_object_p
,(abfd
),
1232 struct internal_filehdr internal_f
;
1233 struct internal_aouthdr internal_a
;
1235 bfd_error
= system_call_error
;
1237 /* figure out how much to read */
1238 if (bfd_read((PTR
) &filehdr
, 1, FILHSZ
, abfd
) != FILHSZ
)
1241 bfd_swap_filehdr_in(abfd
, &filehdr
, &internal_f
);
1243 if (BADMAG(internal_f
)) {
1244 bfd_error
= wrong_format
;
1247 nscns
=internal_f
.f_nscns
;
1249 if (internal_f
.f_opthdr
) {
1250 if (bfd_read((PTR
) &opthdr
, 1,AOUTSZ
, abfd
) != AOUTSZ
) {
1253 bfd_swap_aouthdr_in(abfd
, (char *)&opthdr
, (char *)&internal_a
);
1256 /* Seek past the opt hdr stuff */
1257 bfd_seek(abfd
, (file_ptr
) (internal_f
.f_opthdr
+ FILHSZ
), SEEK_SET
);
1259 /* if the optional header is NULL or not the correct size then
1260 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1261 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1262 optional header is of a different size.
1264 But the mips keeps extra stuff in it's opthdr, so dont check
1268 #if defined(M88) || defined(I960)
1269 if (internal_f
.f_opthdr
!= 0 && AOUTSZ
!= internal_f
.f_opthdr
)
1270 return (bfd_target
*)NULL
;
1273 return coff_real_object_p(abfd
, nscns
, &internal_f
, &internal_a
);
1278 #ifndef NO_COFF_LINENOS
1281 DEFUN(coff_count_linenumbers
,(abfd
),
1284 unsigned int limit
= bfd_get_symcount(abfd
);
1288 asection
*s
= abfd
->sections
->output_section
;
1290 BFD_ASSERT(s
->lineno_count
== 0);
1296 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++) {
1297 asymbol
*q_maybe
= *p
;
1298 if (q_maybe
->the_bfd
->xvec
->flavour
== bfd_target_coff_flavour
) {
1299 coff_symbol_type
*q
= coffsymbol(q_maybe
);
1302 This symbol has a linenumber, increment the owning
1303 section's linenumber count
1305 alent
*l
= q
->lineno
;
1306 q
->symbol
.section
->output_section
->lineno_count
++;
1308 while (l
->line_number
) {
1309 q
->symbol
.section
->output_section
->lineno_count
++;
1317 #endif /* NO_COFF_LINENOS */
1319 #ifndef NO_COFF_SYMBOLS
1322 Takes a bfd and a symbol, returns a pointer to the coff specific area
1323 of the symbol if there is one.
1325 static coff_symbol_type
*
1326 DEFUN(coff_symbol_from
,(ignore_abfd
, symbol
),
1327 bfd
*ignore_abfd AND
1330 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
1331 return (coff_symbol_type
*)NULL
;
1333 if (symbol
->the_bfd
->tdata
.coff_obj_data
== (coff_data_type
*)NULL
)
1334 return (coff_symbol_type
*)NULL
;
1336 return (coff_symbol_type
*) symbol
;
1342 DEFUN(fixup_symbol_value
,(coff_symbol_ptr
, syment
),
1343 coff_symbol_type
*coff_symbol_ptr AND
1344 struct internal_syment
*syment
)
1347 /* Normalize the symbol flags */
1348 if (coff_symbol_ptr
->symbol
.section
== &bfd_com_section
) {
1349 /* a common symbol is undefined with a value */
1350 syment
->n_scnum
= N_UNDEF
;
1351 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1353 else if (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) {
1354 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1356 else if (coff_symbol_ptr
->symbol
.section
== & bfd_und_section
) {
1357 syment
->n_scnum
= N_UNDEF
;
1358 syment
->n_value
= 0;
1361 if (coff_symbol_ptr
->symbol
.section
) {
1363 coff_symbol_ptr
->symbol
.section
->output_section
->target_index
;
1366 coff_symbol_ptr
->symbol
.value
+
1367 coff_symbol_ptr
->symbol
.section
->output_offset
+
1368 coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
1372 /* This can happen, but I don't know why yet (steve@cygnus.com) */
1373 syment
->n_scnum
= N_ABS
;
1374 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1379 /* run through all the symbols in the symbol table and work out what
1380 their indexes into the symbol table will be when output
1382 Coff requires that each C_FILE symbol points to the next one in the
1383 chain, and that the last one points to the first external symbol. We
1388 DEFUN(coff_renumber_symbols
,(bfd_ptr
),
1391 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1392 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1393 unsigned int native_index
= 0;
1394 struct internal_syment
*last_file
= (struct internal_syment
*)NULL
;
1395 unsigned int symbol_index
;
1397 /* COFF demands that undefined symbols come after all other symbols.
1398 Since we don't need to impose this extra knowledge on all our client
1399 programs, deal with that here. Sort the symbol table; just move the
1400 undefined symbols to the end, leaving the rest alone. */
1401 /* @@ Do we have some condition we could test for, so we don't always
1402 have to do this? I don't think relocatability is quite right, but
1403 I'm not certain. [raeburn:19920508.1711EST] */
1408 newsyms
= (asymbol
**) bfd_alloc_by_size_t (bfd_ptr
,
1410 * (symbol_count
+ 1));
1411 bfd_ptr
->outsymbols
= newsyms
;
1412 for (i
= 0; i
< symbol_count
; i
++)
1413 if (symbol_ptr_ptr
[i
]->section
!= &bfd_und_section
)
1414 *newsyms
++ = symbol_ptr_ptr
[i
];
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 *newsyms
= (asymbol
*) NULL
;
1419 symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1422 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1424 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1425 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1426 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1429 if (s
->u
.syment
.n_sclass
== C_FILE
)
1431 if (last_file
!= (struct internal_syment
*)NULL
) {
1432 last_file
->n_value
= native_index
;
1434 last_file
= &(s
->u
.syment
);
1438 /* Modify the symbol values according to their section and
1441 fixup_symbol_value(coff_symbol_ptr
, &(s
->u
.syment
));
1443 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++) {
1444 s
[i
].offset
= native_index
++;
1451 obj_conv_table_size (bfd_ptr
) = native_index
;
1456 Run thorough the symbol table again, and fix it so that all pointers to
1457 entries are changed to the entries' index in the output symbol table.
1461 DEFUN(coff_mangle_symbols
,(bfd_ptr
),
1464 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1465 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1466 unsigned int symbol_index
;
1468 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1470 coff_symbol_type
*coff_symbol_ptr
=
1471 coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1473 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1475 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1477 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++) {
1478 combined_entry_type
*a
= s
+ i
+ 1;
1480 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
1481 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
1485 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
1486 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
1496 static int string_size
;
1498 DEFUN(coff_fix_symbol_name
,(ignore_abfd
, symbol
, native
),
1499 bfd
*ignore_abfd AND
1501 combined_entry_type
*native
)
1503 unsigned int name_length
;
1504 union internal_auxent
*auxent
;
1505 char * name
= ( char *)(symbol
->name
);
1507 if (name
== (char *) NULL
) {
1508 /* coff symbols always have names, so we'll make one up */
1509 symbol
->name
= "strange";
1510 name
= (char *)symbol
->name
;
1512 name_length
= strlen(name
);
1514 if (native
->u
.syment
.n_sclass
== C_FILE
) {
1515 strncpy(native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
1516 auxent
= &(native
+1)->u
.auxent
;
1518 #ifdef COFF_LONG_FILENAMES
1519 if (name_length
<= FILNMLEN
) {
1520 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1523 auxent
->x_file
.x_n
.x_offset
= string_size
+ 4;
1524 auxent
->x_file
.x_n
.x_zeroes
= 0;
1525 string_size
+= name_length
+ 1;
1528 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1529 if (name_length
> FILNMLEN
) {
1530 name
[FILNMLEN
] = '\0';
1535 { /* NOT A C_FILE SYMBOL */
1536 if (name_length
<= SYMNMLEN
) {
1537 /* This name will fit into the symbol neatly */
1538 strncpy(native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
1541 native
->u
.syment
._n
._n_n
._n_offset
= string_size
+ 4;
1542 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1543 string_size
+= name_length
+ 1;
1551 DEFUN(coff_write_symbol
,(abfd
, symbol
, native
, written
),
1554 combined_entry_type
*native AND
1555 unsigned int written
)
1557 unsigned int numaux
= native
->u
.syment
.n_numaux
;
1558 int type
= native
->u
.syment
.n_type
;
1559 int class = native
->u
.syment
.n_sclass
;
1563 /* @@ bfd_debug_section isn't accessible outside this file, but we know
1564 that C_FILE symbols belong there. So move them. */
1565 if (native
->u
.syment
.n_sclass
== C_FILE
)
1566 symbol
->section
= &bfd_debug_section
;
1568 if (symbol
->section
== &bfd_abs_section
)
1570 native
->u
.syment
.n_scnum
= N_ABS
;
1572 else if (symbol
->section
== &bfd_debug_section
)
1574 native
->u
.syment
.n_scnum
= N_DEBUG
;
1576 else if (symbol
->section
== &bfd_und_section
)
1578 native
->u
.syment
.n_scnum
= N_UNDEF
;
1582 native
->u
.syment
.n_scnum
=
1583 symbol
->section
->output_section
->target_index
;
1587 coff_fix_symbol_name(abfd
, symbol
, native
);
1589 coff_swap_sym_out(abfd
, &native
->u
.syment
, &buf
);
1590 bfd_write((PTR
)& buf
, 1, SYMESZ
, abfd
);
1591 for (j
= 0; j
< native
->u
.syment
.n_numaux
; j
++)
1594 coff_swap_aux_out(abfd
,
1595 &( (native
+ j
+ 1)->u
.auxent
), type
, class, &buf1
);
1596 bfd_write((PTR
) (&buf1
), 1, AUXESZ
, abfd
);
1599 Reuse somewhere in the symbol to keep the index
1601 set_index(symbol
, written
);
1602 return written
+ 1 + numaux
;
1607 DEFUN(coff_write_alien_symbol
,(abfd
, symbol
, written
),
1610 unsigned int written
)
1613 This symbol has been created by the loader, or come from a non
1614 coff format. It has no native element to inherit, make our
1617 combined_entry_type
*native
;
1618 combined_entry_type dummy
;
1620 native
->u
.syment
.n_type
= T_NULL
;
1622 native
->u
.syment
.n_flags
= 0;
1624 if (symbol
->section
== &bfd_und_section
)
1626 native
->u
.syment
.n_scnum
= N_UNDEF
;
1627 native
->u
.syment
.n_value
= symbol
->value
;
1629 else if (symbol
->section
== &bfd_com_section
)
1631 native
->u
.syment
.n_scnum
= N_UNDEF
;
1632 native
->u
.syment
.n_value
= symbol
->value
;
1636 else if (symbol
->flags
& BSF_DEBUGGING
) {
1638 remove name so it doesn't take up any space
1643 native
->u
.syment
.n_scnum
= symbol
->section
->output_section
->target_index
;
1644 native
->u
.syment
.n_value
= symbol
->value
+
1645 symbol
->section
->output_section
->vma
+
1646 symbol
->section
->output_offset
;
1648 /* Copy the any flags from the the file hdr into the symbol */
1650 coff_symbol_type
*c
= coff_symbol_from(abfd
, symbol
);
1651 if (c
!= (coff_symbol_type
*)NULL
) {
1652 native
->u
.syment
.n_flags
= c
->symbol
.the_bfd
->flags
;
1659 native
->u
.syment
.pad1
[0] = 0;
1660 native
->u
.syment
.pad1
[0] = 0;
1663 native
->u
.syment
.n_type
= 0;
1664 if (symbol
->flags
& BSF_LOCAL
)
1665 native
->u
.syment
.n_sclass
= C_STAT
;
1667 native
->u
.syment
.n_sclass
= C_EXT
;
1668 native
->u
.syment
.n_numaux
= 0;
1670 return coff_write_symbol(abfd
, symbol
, native
, written
);
1674 DEFUN(coff_write_native_symbol
,(abfd
, symbol
, written
),
1676 coff_symbol_type
*symbol AND
1677 unsigned int written
)
1680 Does this symbol have an ascociated line number - if so then
1681 make it remember this symbol index. Also tag the auxent of
1682 this symbol to point to the right place in the lineno table
1684 combined_entry_type
*native
= symbol
->native
;
1686 alent
*lineno
= symbol
->lineno
;
1688 if (lineno
&& !symbol
->done_lineno
) {
1689 unsigned int count
= 0;
1690 lineno
[count
].u
.offset
= written
;
1691 if (native
->u
.syment
.n_numaux
) {
1692 union internal_auxent
*a
= &((native
+1)->u
.auxent
);
1694 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1695 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1698 And count and relocate all other linenumbers
1702 while (lineno
[count
].line_number
) {
1705 I've been told this, but still need proof:
1706 > The second bug is also in `bfd/coffcode.h'. This bug causes the linker to screw
1707 > up the pc-relocations for all the line numbers in COFF code. This bug isn't
1708 > only specific to A29K implementations, but affects all systems using COFF
1709 > format binaries. Note that in COFF object files, the line number core offsets
1710 > output by the assembler are relative to the start of each procedure, not
1711 > to the start of the .text section. This patch relocates the line numbers
1712 > relative to the `native->u.syment.n_value' instead of the section virtual
1713 > address. modular!olson@cs.arizona.edu (Jon Olson)
1715 lineno
[count
].u
.offset
+= native
->u
.syment
.n_value
;
1718 lineno
[count
].u
.offset
+=
1719 symbol
->symbol
.section
->output_section
->vma
+
1720 symbol
->symbol
.section
->output_offset
;
1724 symbol
->done_lineno
= true;
1726 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1729 return coff_write_symbol(abfd
, &( symbol
->symbol
), native
,written
);
1733 DEFUN(coff_write_symbols
,(abfd
),
1737 unsigned int limit
= bfd_get_symcount(abfd
);
1738 unsigned int written
= 0;
1745 /* Seek to the right place */
1746 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
1748 /* Output all the symbols we have */
1751 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1753 asymbol
*symbol
= *p
;
1754 coff_symbol_type
*c_symbol
= coff_symbol_from(abfd
, symbol
);
1756 if (c_symbol
== (coff_symbol_type
*) NULL
||
1757 c_symbol
->native
== (combined_entry_type
*)NULL
)
1759 written
= coff_write_alien_symbol(abfd
, symbol
, written
);
1763 written
= coff_write_native_symbol(abfd
, c_symbol
, written
);
1768 bfd_get_symcount(abfd
) = written
;
1770 /* Now write out strings */
1772 if (string_size
!= 0)
1774 unsigned int size
= string_size
+ 4;
1777 bfd_h_put_32(abfd
, size
, buffer
);
1778 bfd_write((PTR
) buffer
, 1, sizeof(buffer
), abfd
);
1779 for (p
= abfd
->outsymbols
, i
= 0;
1784 size_t name_length
= strlen(q
->name
);
1786 coff_symbol_type
* c_symbol
= coff_symbol_from(abfd
, q
);
1787 maxlen
= ((c_symbol
!= NULL
&& c_symbol
->native
!= NULL
) &&
1788 (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
)) ?
1789 FILNMLEN
: SYMNMLEN
;
1791 if (name_length
> maxlen
) {
1792 bfd_write((PTR
) (q
->name
), 1, name_length
+ 1, abfd
);
1797 /* We would normally not write anything here, but we'll write
1798 out 4 so that any stupid coff reader which tries to read
1799 the string table even when there isn't one won't croak.
1802 uint32e_type size
= 4;
1804 bfd_write((PTR
)&size
, 1, sizeof(size
), abfd
);
1813 To write relocations, all the back end does is step though the
1814 canonical relocation table, and create an
1815 @code{internal_reloc}. The symbol index to use is removed from
1816 the @code{offset} field in the symbol table supplied, the
1817 address comes directly from the sum of the section base
1818 address and the relocation offset and the type is dug directly
1819 from the howto field. Then the @code{internal_reloc} is
1820 swapped into the shape of an @code{external_reloc} and written
1826 DEFUN(coff_write_relocs
,(abfd
),
1830 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1832 struct external_reloc dst
;
1834 arelent
**p
= s
->orelocation
;
1835 bfd_seek(abfd
, s
->rel_filepos
, SEEK_SET
);
1836 for (i
= 0; i
< s
->reloc_count
; i
++) {
1837 struct internal_reloc n
;
1839 memset((PTR
)&n
, 0, sizeof(n
));
1841 n
.r_vaddr
= q
->address
+ s
->vma
;
1842 /* The 29k const/consth reloc pair is a real kludge - the consth
1843 part doesn't have a symbol - it has an offset. So rebuilt
1846 if (q
->howto
->type
== R_IHCONST
)
1847 n
.r_symndx
= q
->addend
;
1854 if (q
->sym_ptr_ptr
== bfd_abs_section
.symbol_ptr_ptr
)
1856 /* This is a relocation relative to the absolute symbol */
1861 n
.r_symndx
= get_index((*(q
->sym_ptr_ptr
)));
1862 /* Take notice if the symbol reloc points to a symbol we don't have
1863 in our symbol table. What should we do for this?? */
1864 if (n
.r_symndx
> obj_conv_table_size (abfd
))
1872 /* Work out reloc type from what is required */
1873 SELECT_RELOC(n
.r_type
, q
->howto
);
1875 n
.r_type
= q
->howto
->type
;
1877 coff_swap_reloc_out(abfd
, &n
, &dst
);
1878 bfd_write((PTR
) &dst
, 1, RELSZ
, abfd
);
1882 #endif /* NO_COFF_SYMBOLS */
1884 #ifndef NO_COFF_LINENOS
1887 DEFUN(coff_write_linenumbers
,(abfd
),
1891 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1892 if (s
->lineno_count
) {
1893 asymbol
**q
= abfd
->outsymbols
;
1894 bfd_seek(abfd
, s
->line_filepos
, SEEK_SET
);
1895 /* Find all the linenumbers in this section */
1898 alent
*l
= BFD_SEND(p
->the_bfd
, _get_lineno
, (p
->the_bfd
, p
));
1900 /* Found a linenumber entry, output */
1901 struct internal_lineno out
;
1903 memset( (PTR
)&out
, 0, sizeof(out
));
1905 out
.l_addr
.l_symndx
= l
->u
.offset
;
1906 coff_swap_lineno_out(abfd
, &out
, &buff
);
1907 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1909 while (l
->line_number
) {
1910 out
.l_lnno
= l
->line_number
;
1911 out
.l_addr
.l_symndx
= l
->u
.offset
;
1912 coff_swap_lineno_out(abfd
, &out
, &buff
);
1913 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1924 DEFUN(coff_get_lineno
,(ignore_abfd
, symbol
),
1925 bfd
*ignore_abfd AND
1928 return coffsymbol(symbol
)->lineno
;
1931 #endif /* NO_COFF_LINENOS */
1934 coff_make_empty_symbol(abfd
)
1937 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc(abfd
, sizeof(coff_symbol_type
));
1939 bfd_error
= no_memory
;
1942 new->symbol
.section
= 0;
1944 new->lineno
= (alent
*) NULL
;
1945 new->done_lineno
= false;
1946 new->symbol
.the_bfd
= abfd
;
1947 return &new->symbol
;
1950 #ifndef NO_COFF_SYMBOLS
1953 DEFUN (coff_make_debug_symbol
, (abfd
, ptr
, sz
),
1958 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc(abfd
, sizeof(coff_symbol_type
));
1960 bfd_error
= no_memory
;
1963 /* @@ This shouldn't be using a constant multiplier. */
1964 new->native
= (combined_entry_type
*) bfd_zalloc (abfd
, sizeof (combined_entry_type
) * 10);
1965 new->symbol
.section
= &bfd_debug_section
;
1966 new->lineno
= (alent
*) NULL
;
1967 new->done_lineno
= false;
1968 new->symbol
.the_bfd
= abfd
;
1969 return &new->symbol
;
1973 DEFUN(coff_print_symbol
,(ignore_abfd
, filep
, symbol
, how
),
1974 bfd
*ignore_abfd AND
1977 bfd_print_symbol_type how
)
1979 FILE *file
= (FILE *)filep
;
1981 case bfd_print_symbol_name
:
1982 fprintf(file
, "%s", symbol
->name
);
1984 case bfd_print_symbol_more
:
1985 fprintf(file
, "coff %lx %lx", (unsigned long) coffsymbol(symbol
)->native
,
1986 (unsigned long) coffsymbol(symbol
)->lineno
);
1988 case bfd_print_symbol_nm
:
1991 CONST
char *section_name
= symbol
->section
->name
;
1992 bfd_print_symbol_vandf((PTR
) file
, symbol
);
1995 fprintf(file
, " %-5s %s %s %s",
1997 coffsymbol(symbol
)->native
? "n" : "g",
1998 coffsymbol(symbol
)->lineno
? "l" : " ",
2004 case bfd_print_symbol_all
:
2005 /* Print out the symbols in a reasonable way */
2007 CONST
char *section_name
= symbol
->section
->name
;
2010 if (coffsymbol(symbol
)->native
)
2013 combined_entry_type
*combined
= coffsymbol(symbol
)->native
;
2014 combined_entry_type
*root
= obj_raw_syments(ignore_abfd
);
2016 fprintf(file
,"[%3d]",
2020 fprintf(file
, "(sc %2d)(fl%4x)(ty%3x)(sc%3d) nx(%d) %08x %s",
2021 combined
->u
.syment
.n_scnum
,
2022 combined
->u
.syment
.n_flags
,
2023 combined
->u
.syment
.n_type
,
2024 combined
->u
.syment
.n_sclass
,
2025 combined
->u
.syment
.n_numaux
,
2026 combined
->u
.syment
.n_value
,
2029 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
2032 switch (combined
->u
.syment
.n_sclass
) {
2034 fprintf(file
, "File ");
2037 fprintf(file
, "AUX lnno %x size %x tagndx %x",
2038 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
2039 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
2040 combined
[aux
+1].u
.auxent
.x_sym
.x_tagndx
.l
);
2048 struct lineno_cache_entry
*l
= coffsymbol(symbol
)->lineno
;
2051 printf("\n%s :", l
->u
.sym
->name
);
2053 while (l
->line_number
)
2055 printf("\n%4d : %x",
2069 bfd_print_symbol_vandf((PTR
) file
, symbol
);
2070 fprintf(file
, " %-5s %s %s %s",
2072 coffsymbol(symbol
)->native
? "n" : "g",
2073 coffsymbol(symbol
)->lineno
? "l" : " ",
2082 #endif /* NO_COFF_SYMBOLS */
2084 /* Set flags and magic number of a coff file from architecture and machine
2085 type. Result is true if we can represent the arch&type, false if not. */
2088 DEFUN(coff_set_flags
,(abfd
, magicp
, flagsp
),
2090 unsigned *magicp AND
2091 unsigned short *flagsp
)
2093 switch (bfd_get_arch(abfd
)) {
2097 switch (bfd_get_mach(abfd
))
2099 case bfd_mach_z8001
:
2102 case bfd_mach_z8002
:
2116 *magicp
= I960ROMAGIC
;
2118 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2119 I960RWMAGIC); FIXME???
2121 switch (bfd_get_mach(abfd
)) {
2122 case bfd_mach_i960_core
:
2125 case bfd_mach_i960_kb_sb
:
2128 case bfd_mach_i960_mc
:
2131 case bfd_mach_i960_xa
:
2134 case bfd_mach_i960_ca
:
2137 case bfd_mach_i960_ka_sa
:
2150 *magicp
= MIPS_MAGIC_2
;
2156 *magicp
= I386MAGIC
;
2162 *magicp
= MC68MAGIC
;
2169 *magicp
= MC88OMAGIC
;
2174 case bfd_arch_h8300
:
2175 *magicp
= H8300MAGIC
;
2179 #ifdef A29K_MAGIC_BIG
2181 if (abfd
->xvec
->byteorder_big_p
)
2182 *magicp
= A29K_MAGIC_BIG
;
2184 *magicp
= A29K_MAGIC_LITTLE
;
2190 case bfd_arch_we32k
:
2191 *magicp
= WE32KMAGIC
;
2197 case bfd_arch_rs6000
:
2198 *magicp
= U802TOCMAGIC
;
2203 default: /* Unknown architecture */
2204 /* return false; -- fall through to "return false" below, to avoid
2205 "statement never reached" errors on the one below. */
2214 DEFUN(coff_set_arch_mach
,(abfd
, arch
, machine
),
2216 enum bfd_architecture arch AND
2217 unsigned long machine
)
2220 unsigned short dummy2
;
2221 bfd_default_set_arch_mach(abfd
, arch
, machine
);
2223 if (arch
!= bfd_arch_unknown
&&
2224 coff_set_flags(abfd
, &dummy1
, &dummy2
) != true)
2225 return false; /* We can't represent this type */
2226 return true; /* We're easy ... */
2230 /* Calculate the file position for each section. */
2233 DEFUN(coff_compute_section_file_positions
,(abfd
),
2237 asection
*previous
= (asection
*)NULL
;
2238 file_ptr sofar
= FILHSZ
;
2240 if (bfd_get_start_address(abfd
))
2242 /* A start address may have been added to the original file. In this
2243 case it will need an optional header to record it. */
2244 abfd
->flags
|= EXEC_P
;
2247 if (abfd
->flags
& EXEC_P
)
2250 sofar
+= abfd
->section_count
* SCNHSZ
;
2251 for (current
= abfd
->sections
;
2252 current
!= (asection
*)NULL
;
2253 current
= current
->next
) {
2255 /* Only deal with sections which have contents */
2256 if (!(current
->flags
& SEC_HAS_CONTENTS
))
2259 /* Align the sections in the file to the same boundary on
2260 which they are aligned in virtual memory. I960 doesn't
2261 do this (FIXME) so we can stay in sync with Intel. 960
2262 doesn't yet page from files... */
2265 /* make sure this section is aligned on the right boundary - by
2266 padding the previous section up if necessary */
2269 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2270 if (previous
!= (asection
*)NULL
) {
2271 previous
->_raw_size
+= sofar
- old_sofar
;
2276 /* FIXME, in demand paged files, the low order bits of the file
2277 offset must match the low order bits of the virtual address.
2278 "Low order" is apparently implementation defined. Add code
2279 here to round sofar up to match the virtual address. */
2281 current
->filepos
= sofar
;
2283 sofar
+= current
->_raw_size
;
2285 /* make sure that this section is of the right size too */
2287 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2288 current
->_raw_size
+= sofar
- old_sofar
;
2293 obj_relocbase(abfd
) = sofar
;
2296 #ifndef NO_COFF_SYMBOLS
2298 coff_section_symbol (abfd
, name
)
2302 asection
*sec
= bfd_make_section_old_way (abfd
, name
);
2304 combined_entry_type
*csym
;
2307 if (coff_symbol_from (abfd
, sym
))
2308 csym
= coff_symbol_from (abfd
, sym
)->native
;
2311 /* Make sure back-end COFF stuff is there. */
2315 coff_symbol_type sym
;
2316 /* @@FIXME This shouldn't use a fixed size!! */
2317 combined_entry_type e
[10];
2320 f
= (struct foo
*) bfd_alloc_by_size_t (abfd
, sizeof (*f
));
2321 memset ((char *) f
, 0, sizeof (*f
));
2322 coff_symbol_from (abfd
, sym
)->native
= csym
= f
->e
;
2324 csym
[0].u
.syment
.n_sclass
= C_STAT
;
2325 csym
[0].u
.syment
.n_numaux
= 1;
2326 /* SF_SET_STATICS (sym); @@ ??? */
2329 csym
[1].u
.auxent
.x_scn
.x_scnlen
= sec
->_raw_size
;
2330 csym
[1].u
.auxent
.x_scn
.x_nreloc
= sec
->reloc_count
;
2331 csym
[1].u
.auxent
.x_scn
.x_nlinno
= sec
->lineno_count
;
2335 csym
[1].u
.auxent
.x_scn
.x_scnlen
= 0;
2336 csym
[1].u
.auxent
.x_scn
.x_nreloc
= 0;
2337 csym
[1].u
.auxent
.x_scn
.x_nlinno
= 0;
2342 /* If .file, .text, .data, .bss symbols are missing, add them. */
2343 /* @@ Should we only be adding missing symbols, or overriding the aux
2344 values for existing section symbols? */
2346 coff_add_missing_symbols (abfd
)
2349 unsigned int nsyms
= bfd_get_symcount (abfd
);
2350 asymbol
**sympp
= abfd
->outsymbols
;
2353 int need_text
= 1, need_data
= 1, need_bss
= 1, need_file
= 1;
2355 for (i
= 0; i
< nsyms
; i
++)
2357 coff_symbol_type
*csym
= coff_symbol_from (abfd
, sympp
[i
]);
2361 /* only do this if there is a coff representation of the input
2363 if (csym
->native
&& csym
->native
->u
.syment
.n_sclass
== C_FILE
)
2368 name
= csym
->symbol
.name
;
2371 if (!strcmp (name
, _TEXT
))
2373 else if (!strcmp (name
, _DATA
))
2375 else if (!strcmp (name
, _BSS
))
2379 /* Now i == bfd_get_symcount (abfd). */
2380 /* @@ For now, don't deal with .file symbol. */
2383 if (!need_text
&& !need_data
&& !need_bss
&& !need_file
)
2385 nsyms
+= need_text
+ need_data
+ need_bss
+ need_file
;
2386 sympp2
= (asymbol
**) bfd_alloc_by_size_t (abfd
, nsyms
* sizeof (asymbol
*));
2387 memcpy (sympp2
, sympp
, i
* sizeof (asymbol
*));
2390 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
2394 sympp2
[i
++] = coff_section_symbol (abfd
, _TEXT
);
2396 sympp2
[i
++] = coff_section_symbol (abfd
, _DATA
);
2398 sympp2
[i
++] = coff_section_symbol (abfd
, _BSS
);
2399 BFD_ASSERT (i
== nsyms
);
2400 bfd_set_symtab (abfd
, sympp2
, nsyms
);
2402 #endif /* NO_COFF_SYMBOLS */
2407 DEFUN(coff_write_object_contents
,(abfd
),
2413 boolean hasrelocs
= false;
2414 boolean haslinno
= false;
2415 file_ptr reloc_base
;
2416 file_ptr lineno_base
;
2420 unsigned long reloc_size
= 0;
2421 unsigned long lnno_size
= 0;
2422 asection
*text_sec
= NULL
;
2423 asection
*data_sec
= NULL
;
2424 asection
*bss_sec
= NULL
;
2426 struct internal_filehdr internal_f
;
2427 struct internal_aouthdr internal_a
;
2430 bfd_error
= system_call_error
;
2431 /* Number the output sections, starting from one on the first section
2432 with a name which doesn't start with a *.
2433 @@ The code doesn't make this check. Is it supposed to be done,
2436 for (current
= abfd
->sections
; current
!= (asection
*)NULL
;
2437 current
= current
->next
)
2439 current
->target_index
= count
;
2443 if(abfd
->output_has_begun
== false) {
2444 coff_compute_section_file_positions(abfd
);
2447 if (abfd
->sections
!= (asection
*)NULL
) {
2448 scn_base
= abfd
->sections
->filepos
;
2453 if (bfd_seek(abfd
, scn_base
, SEEK_SET
) != 0)
2455 reloc_base
= obj_relocbase(abfd
);
2457 /* Make a pass through the symbol table to count line number entries and
2458 put them into the correct asections */
2460 #ifndef NO_COFF_LINENOS
2461 coff_count_linenumbers(abfd
);
2463 data_base
= scn_base
;
2465 /* Work out the size of the reloc and linno areas */
2467 for (current
= abfd
->sections
; current
!= NULL
; current
=
2470 /* We give section headers to +ve indexes */
2471 if (current
->target_index
> 0)
2474 reloc_size
+= current
->reloc_count
* RELSZ
;
2475 #ifndef NO_COFF_LINENOS
2476 lnno_size
+= current
->lineno_count
* LINESZ
;
2478 data_base
+= SCNHSZ
;
2483 lineno_base
= reloc_base
+ reloc_size
;
2484 sym_base
= lineno_base
+ lnno_size
;
2486 /* Indicate in each section->line_filepos its actual file address */
2487 for (current
= abfd
->sections
; current
!= NULL
; current
=
2490 if (current
->target_index
> 0)
2493 if (current
->lineno_count
) {
2494 current
->line_filepos
= lineno_base
;
2495 current
->moving_line_filepos
= lineno_base
;
2496 #ifndef NO_COFF_LINENOS
2497 lineno_base
+= current
->lineno_count
* LINESZ
;
2501 current
->line_filepos
= 0;
2503 if (current
->reloc_count
) {
2504 current
->rel_filepos
= reloc_base
;
2505 reloc_base
+= current
->reloc_count
* RELSZ
;
2508 current
->rel_filepos
= 0;
2515 /* Write section headers to the file. */
2516 internal_f
.f_nscns
= 0;
2518 (file_ptr
) ((abfd
->flags
& EXEC_P
) ?
2519 (FILHSZ
+ AOUTSZ
) : FILHSZ
),
2524 unsigned int pad
= abfd
->flags
& D_PAGED
? data_base
: 0;
2526 unsigned int pad
= 0;
2528 for (current
= abfd
->sections
;
2530 current
= current
->next
) {
2531 struct internal_scnhdr section
;
2532 if (current
->target_index
> 0)
2534 internal_f
.f_nscns
++;
2535 strncpy(&(section
.s_name
[0]), current
->name
, 8);
2537 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
2538 Ian Taylor <ian@cygnus.com>. */
2539 if (strcmp (current
->name
, _LIB
) == 0)
2540 section
.s_vaddr
= 0;
2543 section
.s_vaddr
= current
->vma
+ pad
;
2544 section
.s_paddr
= current
->vma
+ pad
;
2545 section
.s_size
= current
->_raw_size
- pad
;
2547 If this section has no size or is unloadable then the scnptr
2550 if (current
->_raw_size
- pad
== 0 ||
2551 (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0) {
2552 section
.s_scnptr
= 0;
2555 section
.s_scnptr
= current
->filepos
;
2557 section
.s_relptr
= current
->rel_filepos
;
2558 section
.s_lnnoptr
= current
->line_filepos
;
2559 section
.s_nreloc
= current
->reloc_count
;
2560 section
.s_nlnno
= current
->lineno_count
;
2561 if (current
->reloc_count
!= 0)
2563 if (current
->lineno_count
!= 0)
2566 section
.s_flags
= sec_to_styp_flags(current
->name
,current
->flags
);
2568 if (!strcmp(current
->name
, _TEXT
)) {
2570 } else if (!strcmp(current
->name
, _DATA
)) {
2572 #ifdef TWO_DATA_SECS
2573 } else if (!strcmp(current
->name
, ".data2")) {
2575 #endif /* TWO_DATA_SECS */
2576 } else if (!strcmp(current
->name
, _BSS
)) {
2581 section
.s_align
= (current
->alignment_power
2582 ? 1 << current
->alignment_power
2589 coff_swap_scnhdr_out(abfd
, §ion
, &buff
);
2590 bfd_write((PTR
) (&buff
), 1, SCNHSZ
, abfd
);
2600 /* OK, now set up the filehdr... */
2602 /* Don't include the internal abs section in the section count */
2605 We will NOT put a fucking timestamp in the header here. Every time you
2606 put it back, I will come in and take it out again. I'm sorry. This
2607 field does not belong here. We fill it with a 0 so it compares the
2608 same but is not a reasonable time. -- gnu@cygnus.com
2611 Well, I like it, and now we have *customers* who have requested it,
2612 so I'm conditionally compiling it in.
2616 #ifndef NOCOFF_TIMESTAMP
2617 internal_f
.f_timdat
= time(0);
2619 internal_f
.f_timdat
= 0;
2622 if (bfd_get_symcount(abfd
) != 0)
2623 internal_f
.f_symptr
= sym_base
;
2625 internal_f
.f_symptr
= 0;
2627 internal_f
.f_flags
= 0;
2629 if (abfd
->flags
& EXEC_P
)
2630 internal_f
.f_opthdr
= AOUTSZ
;
2632 internal_f
.f_opthdr
= 0;
2635 internal_f
.f_flags
|= F_RELFLG
;
2637 internal_f
.f_flags
|= F_LNNO
;
2638 if (0 == bfd_get_symcount(abfd
))
2639 internal_f
.f_flags
|= F_LSYMS
;
2640 if (abfd
->flags
& EXEC_P
)
2641 internal_f
.f_flags
|= F_EXEC
;
2643 if (!abfd
->xvec
->byteorder_big_p
)
2644 internal_f
.f_flags
|= F_AR32WR
;
2646 internal_f
.f_flags
|= F_AR32W
;
2649 FIXME, should do something about the other byte orders and
2653 /* Set up architecture-dependent stuff */
2655 { unsigned int magic
= 0;
2656 unsigned short flags
= 0;
2657 coff_set_flags(abfd
, &magic
, &flags
);
2658 internal_f
.f_magic
= magic
;
2659 internal_f
.f_flags
|= flags
;
2660 /* ...and the "opt"hdr... */
2663 # ifdef ULTRA3 /* NYU's machine */
2664 /* FIXME: This is a bogus check. I really want to see if there
2665 * is a .shbss or a .shdata section, if so then set the magic
2666 * number to indicate a shared data executable.
2668 if (internal_f
.f_nscns
>= 7)
2669 internal_a
.magic
= SHMAGIC
; /* Shared magic */
2671 # endif /* ULTRA3 */
2672 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
2673 #define __A_MAGIC_SET__
2676 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
2677 #define __A_MAGIC_SET__
2680 #define __A_MAGIC_SET__
2681 internal_a
.magic
= PAGEMAGICBCS
;
2684 #if M68 || MIPS || WE32K
2685 #define __A_MAGIC_SET__
2686 /* Never was anything here for the 68k */
2687 #endif /* M68 || MIPS || WE32K */
2690 # define __A_MAGIC_SET__
2691 internal_a
.magic
= ZMAGIC
;
2695 #define __A_MAGIC_SET__
2696 internal_a
.magic
= (abfd
->flags
& D_PAGED
)? RS6K_AOUTHDR_ZMAGIC
:
2697 (abfd
->flags
& WP_TEXT
)? RS6K_AOUTHDR_NMAGIC
:
2698 RS6K_AOUTHDR_OMAGIC
;
2701 #ifndef __A_MAGIC_SET__
2702 # include "Your aouthdr magic number is not being set!"
2704 # undef __A_MAGIC_SET__
2707 /* Now should write relocs, strings, syms */
2708 obj_sym_filepos(abfd
) = sym_base
;
2710 #ifndef NO_COFF_SYMBOLS
2711 if (bfd_get_symcount(abfd
) != 0) {
2712 coff_add_missing_symbols (abfd
);
2713 coff_renumber_symbols(abfd
);
2714 coff_mangle_symbols(abfd
);
2715 coff_write_symbols(abfd
);
2716 coff_write_linenumbers(abfd
);
2717 coff_write_relocs(abfd
);
2719 #endif /* NO_COFF_SYMBOLS */
2721 internal_a
.tsize
= bfd_get_section_size_before_reloc(text_sec
);
2722 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
2725 internal_a
.dsize
= bfd_get_section_size_before_reloc(data_sec
);
2726 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
2729 internal_a
.bsize
= bfd_get_section_size_before_reloc(bss_sec
);
2732 internal_a
.entry
= bfd_get_start_address(abfd
);
2733 internal_f
.f_nsyms
= bfd_get_symcount(abfd
);
2735 /* now write them */
2736 if (bfd_seek(abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
2740 coff_swap_filehdr_out(abfd
, (PTR
)&internal_f
, (PTR
)&buff
);
2741 bfd_write((PTR
) &buff
, 1, FILHSZ
, abfd
);
2743 if (abfd
->flags
& EXEC_P
) {
2745 coff_swap_aouthdr_out(abfd
, (PTR
)&internal_a
, (PTR
)&buff
);
2746 bfd_write((PTR
) &buff
, 1, AOUTSZ
, abfd
);
2751 #ifndef NO_COFF_SYMBOLS
2754 this function transforms the offsets into the symbol table into
2755 pointers to syments.
2760 DEFUN(coff_pointerize_aux
,(ignore_abfd
, table_base
, type
, class, auxent
),
2761 bfd
*ignore_abfd AND
2762 combined_entry_type
*table_base AND
2765 combined_entry_type
*auxent
)
2767 /* Don't bother if this is a file or a section */
2768 if (class == C_STAT
&& type
== T_NULL
) return;
2769 if (class == C_FILE
) return;
2771 /* Otherwise patch up */
2772 if (ISFCN(type
) || ISTAG(class) || class == C_BLOCK
) {
2773 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
= table_base
+
2774 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2775 auxent
->fix_end
= 1;
2777 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
!= 0) {
2778 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
=
2779 table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
2780 auxent
->fix_tag
= 1;
2784 #endif /* NO_COFF_SYMBOLS */
2787 DEFUN(coff_set_section_contents
,(abfd
, section
, location
, offset
, count
),
2792 bfd_size_type count
)
2794 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
2795 coff_compute_section_file_positions(abfd
);
2798 /* If this is a .lib section, bump the vma address so that it
2799 winds up being the number of .lib sections output. This is
2800 right for SVR3.2. Shared libraries should probably get more
2801 generic support. Ian Taylor <ian@cygnus.com>. */
2802 if (strcmp (section
->name
, _LIB
) == 0)
2806 bfd_seek(abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
);
2809 return (bfd_write(location
, 1, count
, abfd
) == count
) ? true : false;
2815 coff_close_and_cleanup(abfd
)
2818 if (!bfd_read_p(abfd
))
2819 switch (abfd
->format
) {
2821 if (!_bfd_write_archive_contents(abfd
))
2825 if (!coff_write_object_contents(abfd
))
2829 bfd_error
= invalid_operation
;
2833 /* We depend on bfd_close to free all the memory on the obstack. */
2834 /* FIXME if bfd_release is not using obstacks! */
2840 buy_and_read(abfd
, where
, seek_direction
, size
)
2846 PTR area
= (PTR
) bfd_alloc(abfd
, size
);
2848 bfd_error
= no_memory
;
2851 bfd_seek(abfd
, where
, seek_direction
);
2852 if (bfd_read(area
, 1, size
, abfd
) != size
) {
2853 bfd_error
= system_call_error
;
2857 } /* buy_and_read() */
2860 #ifndef NO_COFF_SYMBOLS
2863 DEFUN(build_string_table
,(abfd
),
2866 char string_table_size_buffer
[4];
2867 unsigned int string_table_size
;
2870 /* At this point we should be "seek"'d to the end of the
2871 symbols === the symbol table size. */
2872 if (bfd_read((char *) string_table_size_buffer
,
2873 sizeof(string_table_size_buffer
),
2874 1, abfd
) != sizeof(string_table_size
)) {
2875 bfd_error
= system_call_error
;
2879 string_table_size
= bfd_h_get_32(abfd
, (bfd_byte
*) string_table_size_buffer
);
2881 if ((string_table
= (PTR
) bfd_alloc(abfd
, string_table_size
-= 4)) == NULL
) {
2882 bfd_error
= no_memory
;
2884 } /* on mallocation error */
2885 if (bfd_read(string_table
, string_table_size
, 1, abfd
) != string_table_size
) {
2886 bfd_error
= system_call_error
;
2889 return string_table
;
2892 /* Allocate space for the ".debug" section, and read it.
2893 We did not read the debug section until now, because
2894 we didn't want to go to the trouble until someone needed it. */
2897 DEFUN(build_debug_section
,(abfd
),
2900 char *debug_section
;
2903 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
2906 bfd_error
= no_debug_section
;
2910 debug_section
= (PTR
) bfd_alloc (abfd
,
2911 bfd_get_section_size_before_reloc (sect
));
2912 if (debug_section
== NULL
) {
2913 bfd_error
= no_memory
;
2917 /* Seek to the beginning of the `.debug' section and read it.
2918 Save the current position first; it is needed by our caller.
2919 Then read debug section and reset the file pointer. */
2921 position
= bfd_tell (abfd
);
2922 bfd_seek (abfd
, sect
->filepos
, SEEK_SET
);
2923 if (bfd_read (debug_section
,
2924 bfd_get_section_size_before_reloc (sect
), 1, abfd
)
2925 != bfd_get_section_size_before_reloc(sect
)) {
2926 bfd_error
= system_call_error
;
2929 bfd_seek (abfd
, position
, SEEK_SET
);
2930 return debug_section
;
2934 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
2935 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
2936 be \0-terminated. */
2938 DEFUN(copy_name
,(abfd
, name
, maxlen
),
2946 for (len
= 0; len
< maxlen
; ++len
) {
2947 if (name
[len
] == '\0') {
2952 if ((newname
= (PTR
) bfd_alloc(abfd
, len
+1)) == NULL
) {
2953 bfd_error
= no_memory
;
2956 strncpy(newname
, name
, len
);
2957 newname
[len
] = '\0';
2962 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
2963 knit the symbol names into a normalized form. By normalized here I
2964 mean that all symbols have an n_offset pointer that points to a null-
2965 terminated string. */
2967 #ifndef SYMNAME_IN_DEBUG
2968 #define SYMNAME_IN_DEBUG(x) 0
2971 static combined_entry_type
*
2972 DEFUN(get_normalized_symtab
,(abfd
),
2975 combined_entry_type
*internal
;
2976 combined_entry_type
*internal_ptr
;
2977 combined_entry_type
*symbol_ptr
;
2978 combined_entry_type
*internal_end
;
2982 char *string_table
= NULL
;
2983 char *debug_section
= NULL
;
2986 unsigned int raw_size
;
2987 if (obj_raw_syments(abfd
) != (combined_entry_type
*)NULL
) {
2988 return obj_raw_syments(abfd
);
2990 if ((size
= bfd_get_symcount(abfd
) * sizeof(combined_entry_type
)) == 0) {
2991 bfd_error
= no_symbols
;
2995 internal
= (combined_entry_type
*)bfd_alloc(abfd
, size
);
2996 internal_end
= internal
+ bfd_get_symcount(abfd
);
2998 raw_size
= bfd_get_symcount(abfd
) * SYMESZ
;
2999 raw
= (SYMENT
*)bfd_alloc(abfd
,raw_size
);
3001 if (bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
) == -1
3002 || bfd_read((PTR
)raw
, raw_size
, 1, abfd
) != raw_size
) {
3003 bfd_error
= system_call_error
;
3006 /* mark the end of the symbols */
3007 raw_end
= raw
+ bfd_get_symcount(abfd
);
3009 FIXME SOMEDAY. A string table size of zero is very weird, but
3010 probably possible. If one shows up, it will probably kill us.
3013 /* Swap all the raw entries */
3014 for (raw_src
= raw
, internal_ptr
= internal
;
3016 raw_src
++, internal_ptr
++) {
3019 coff_swap_sym_in(abfd
, (PTR
)raw_src
, (PTR
)&internal_ptr
->u
.syment
);
3020 internal_ptr
->fix_tag
= 0;
3021 internal_ptr
->fix_end
= 0;
3022 symbol_ptr
= internal_ptr
;
3025 i
< symbol_ptr
->u
.syment
.n_numaux
;
3031 internal_ptr
->fix_tag
= 0;
3032 internal_ptr
->fix_end
= 0;
3033 coff_swap_aux_in(abfd
, (char *)(raw_src
),
3034 symbol_ptr
->u
.syment
.n_type
,
3035 symbol_ptr
->u
.syment
.n_sclass
,
3036 &(internal_ptr
->u
.auxent
));
3037 /* Remember that bal entries arn't pointerized */
3038 if (i
!= 1 || symbol_ptr
->u
.syment
.n_sclass
!= C_LEAFPROC
)
3041 coff_pointerize_aux(abfd
,
3043 symbol_ptr
->u
.syment
.n_type
,
3044 symbol_ptr
->u
.syment
.n_sclass
,
3051 /* Free all the raw stuff */
3052 bfd_release(abfd
, raw
);
3054 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
3057 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
) {
3058 /* make a file symbol point to the name in the auxent, since
3059 the text ".file" is redundant */
3060 if ((internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_zeroes
== 0) {
3061 /* the filename is a long one, point into the string table */
3062 if (string_table
== NULL
) {
3063 string_table
= build_string_table(abfd
);
3066 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
3067 (int) (string_table
- 4 +
3068 (internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_offset
);
3071 /* ordinary short filename, put into memory anyway */
3072 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
3073 copy_name(abfd
, (internal_ptr
+1)->u
.auxent
.x_file
.x_fname
,
3078 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0) {
3079 /* This is a "short" name. Make it long. */
3080 unsigned long i
= 0;
3081 char *newstring
= NULL
;
3083 /* find the length of this string without walking into memory
3085 for (i
= 0; i
< 8; ++i
) {
3086 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0') {
3088 } /* if end of string */
3089 } /* possible lengths of this string. */
3091 if ((newstring
= (PTR
) bfd_alloc(abfd
, ++i
)) == NULL
) {
3092 bfd_error
= no_memory
;
3095 memset(newstring
, 0, i
);
3096 strncpy(newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
-1);
3097 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int) newstring
;
3098 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
3100 else if (!SYMNAME_IN_DEBUG(&internal_ptr
->u
.syment
)) {
3101 /* Long name already. Point symbol at the string in the table. */
3102 if (string_table
== NULL
) {
3103 string_table
= build_string_table(abfd
);
3105 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
3106 (string_table
- 4 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
3109 /* Long name in debug section. Very similar. */
3110 if (debug_section
== NULL
) {
3111 debug_section
= build_debug_section(abfd
);
3113 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
3114 (debug_section
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
3117 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
3120 obj_raw_syments(abfd
) = internal
;
3123 } /* get_normalized_symtab() */
3125 #endif /* NO_COFF_SYMBOLS */
3129 DEFUN(section_from_bfd_index
,(abfd
, index
),
3133 struct sec
*answer
= abfd
->sections
;
3137 return &bfd_abs_section
;
3139 if (index
== N_UNDEF
)
3141 return &bfd_und_section
;
3143 if(index
== N_DEBUG
)
3145 return &bfd_debug_section
;
3150 if (answer
->target_index
== index
)
3152 answer
= answer
->next
;
3155 return &bfd_und_section
; /* For gcc -W and lint. Never executed. */
3158 #ifndef NO_COFF_LINENOS
3164 Creating the linenumber table is done by reading in the entire
3165 coff linenumber table, and creating another table for internal use.
3167 A coff line number table is structured so that each function
3168 is marked as having a line number of 0. Each line within the
3169 function is an offset from the first line in the function. The
3170 base of the line number information for the table is stored in
3171 the symbol associated with the function.
3173 The information is copied from the external to the internal
3174 table, and each symbol which marks a function is marked by
3177 How does this work ?
3182 coff_slurp_line_table(abfd
, asect
)
3186 LINENO
*native_lineno
;
3187 alent
*lineno_cache
;
3189 BFD_ASSERT(asect
->lineno
== (alent
*) NULL
);
3191 native_lineno
= (LINENO
*) buy_and_read(abfd
,
3192 asect
->line_filepos
,
3195 asect
->lineno_count
));
3197 (alent
*) bfd_alloc(abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof(alent
)));
3198 if (lineno_cache
== NULL
) {
3199 bfd_error
= no_memory
;
3202 unsigned int counter
= 0;
3203 alent
*cache_ptr
= lineno_cache
;
3204 LINENO
*src
= native_lineno
;
3206 while (counter
< asect
->lineno_count
) {
3207 struct internal_lineno dst
;
3208 coff_swap_lineno_in(abfd
, src
, &dst
);
3209 cache_ptr
->line_number
= dst
.l_lnno
;
3211 if (cache_ptr
->line_number
== 0) {
3212 coff_symbol_type
*sym
=
3213 (coff_symbol_type
*) (dst
.l_addr
.l_symndx
3214 + obj_raw_syments(abfd
))->u
.syment
._n
._n_n
._n_zeroes
;
3215 cache_ptr
->u
.sym
= (asymbol
*) sym
;
3216 sym
->lineno
= cache_ptr
;
3219 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
3220 - bfd_section_vma(abfd
, asect
);
3221 } /* If no linenumber expect a symbol index */
3227 cache_ptr
->line_number
= 0;
3230 asect
->lineno
= lineno_cache
;
3231 /* FIXME, free native_lineno here, or use alloca or something. */
3233 } /* coff_slurp_line_table() */
3235 #endif /* NO_COFF_LINENOS */
3237 #ifndef NO_COFF_LINENOS
3240 DEFUN(coff_slurp_symbol_table
,(abfd
),
3243 combined_entry_type
*native_symbols
;
3244 coff_symbol_type
*cached_area
;
3245 unsigned int *table_ptr
;
3247 unsigned int number_of_symbols
= 0;
3248 if (obj_symbols(abfd
))
3250 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
3252 /* Read in the symbol table */
3253 if ((native_symbols
= get_normalized_symtab(abfd
)) == NULL
) {
3257 /* Allocate enough room for all the symbols in cached form */
3259 (coff_symbol_type
*)
3260 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(coff_symbol_type
)));
3262 if (cached_area
== NULL
) {
3263 bfd_error
= no_memory
;
3268 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(unsigned int)));
3270 if (table_ptr
== NULL
) {
3271 bfd_error
= no_memory
;
3276 coff_symbol_type
*dst
= cached_area
;
3277 unsigned int last_native_index
= bfd_get_symcount(abfd
);
3278 unsigned int this_index
= 0;
3279 while (this_index
< last_native_index
) {
3280 combined_entry_type
*src
= native_symbols
+ this_index
;
3281 table_ptr
[this_index
] = number_of_symbols
;
3282 dst
->symbol
.the_bfd
= abfd
;
3284 dst
->symbol
.name
= (char *)(src
->u
.syment
._n
._n_n
._n_offset
);
3286 We use the native name field to point to the cached field
3288 src
->u
.syment
._n
._n_n
._n_zeroes
= (int) dst
;
3289 dst
->symbol
.section
= section_from_bfd_index(abfd
,
3290 src
->u
.syment
.n_scnum
);
3291 dst
->symbol
.flags
= 0;
3292 dst
->done_lineno
= false;
3294 switch (src
->u
.syment
.n_sclass
) {
3298 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
3299 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
3300 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
3302 /* Fall through to next case */
3310 if ((src
->u
.syment
.n_scnum
) == 0) {
3311 if ((src
->u
.syment
.n_value
) == 0) {
3312 dst
->symbol
.section
= &bfd_und_section
;
3313 dst
->symbol
.value
= 0;
3316 dst
->symbol
.section
= &bfd_com_section
;
3317 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3322 Base the value as an index from the base of the
3326 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
3327 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
3329 if (ISFCN((src
->u
.syment
.n_type
))) {
3331 A function ext does not go at the end of a file
3333 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
3340 case C_STAT
: /* static */
3342 case C_LEAFSTAT
: /* static leaf procedure */
3344 case C_LABEL
: /* label */
3345 if (src
->u
.syment
.n_scnum
== -2)
3346 dst
->symbol
.flags
= BSF_DEBUGGING
;
3348 dst
->symbol
.flags
= BSF_LOCAL
;
3350 Base the value as an index from the base of the section, if
3353 if (dst
->symbol
.section
)
3354 dst
->symbol
.value
= (src
->u
.syment
.n_value
) -
3355 dst
->symbol
.section
->vma
;
3357 dst
->symbol
.value
= (src
->u
.syment
.n_value
) ;
3360 case C_MOS
: /* member of structure */
3361 case C_EOS
: /* end of structure */
3362 #ifdef NOTDEF /* C_AUTOARG has the same value */
3364 case C_GLBLREG
: /* A29k-specific storage class */
3367 case C_REGPARM
: /* register parameter */
3368 case C_REG
: /* register variable */
3370 case C_AUTOARG
: /* 960-specific storage class */
3372 case C_TPDEF
: /* type definition */
3374 case C_AUTO
: /* automatic variable */
3375 case C_FIELD
: /* bit field */
3376 case C_ENTAG
: /* enumeration tag */
3377 case C_MOE
: /* member of enumeration */
3378 case C_MOU
: /* member of union */
3379 case C_UNTAG
: /* union tag */
3380 dst
->symbol
.flags
= BSF_DEBUGGING
;
3381 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3384 case C_FILE
: /* file name */
3385 case C_STRTAG
: /* structure tag */
3387 case C_BINCL
: /* beginning of include file */
3388 case C_EINCL
: /* ending of include file */
3401 dst
->symbol
.flags
= BSF_DEBUGGING
;
3402 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3405 case C_BLOCK
: /* ".bb" or ".eb" */
3406 case C_FCN
: /* ".bf" or ".ef" */
3407 case C_EFCN
: /* physical end of function */
3408 dst
->symbol
.flags
= BSF_LOCAL
;
3410 Base the value as an index from the base of the section
3412 dst
->symbol
.value
= (src
->u
.syment
.n_value
) - dst
->symbol
.section
->vma
;
3416 case C_EXTDEF
: /* external definition */
3417 case C_ULABEL
: /* undefined label */
3418 case C_USTATIC
: /* undefined static */
3419 case C_LINE
: /* line # reformatted as symbol table entry */
3420 case C_ALIAS
: /* duplicate tag */
3421 case C_HIDDEN
: /* ext symbol in dmert public lib */
3424 fprintf(stderr
,"Unrecognized storage class %d\n",
3425 src
->u
.syment
.n_sclass
);
3427 dst
->symbol
.flags
= BSF_DEBUGGING
;
3428 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3432 /* BFD_ASSERT(dst->symbol.flags != 0);*/
3436 dst
->symbol
.udata
= 0;
3437 dst
->lineno
= (alent
*) NULL
;
3438 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
3440 number_of_symbols
++;
3441 } /* walk the native symtab */
3442 } /* bfdize the native symtab */
3444 obj_symbols(abfd
) = cached_area
;
3445 obj_raw_syments(abfd
) = native_symbols
;
3447 obj_conv_table_size (abfd
) = bfd_get_symcount (abfd
);
3448 bfd_get_symcount(abfd
) = number_of_symbols
;
3449 obj_convert(abfd
) = table_ptr
;
3450 /* Slurp the line tables for each section too */
3455 coff_slurp_line_table(abfd
, p
);
3460 } /* coff_slurp_symbol_table() */
3463 coff_get_symtab_upper_bound(abfd
)
3466 if (!coff_slurp_symbol_table(abfd
))
3469 return (bfd_get_symcount(abfd
) + 1) * (sizeof(coff_symbol_type
*));
3474 DEFUN(coff_get_symtab
, (abfd
, alocation
),
3476 asymbol
**alocation
)
3478 unsigned int counter
= 0;
3479 coff_symbol_type
*symbase
;
3480 coff_symbol_type
**location
= (coff_symbol_type
**) (alocation
);
3481 if (!coff_slurp_symbol_table(abfd
))
3484 symbase
= obj_symbols(abfd
);
3485 while (counter
< bfd_get_symcount(abfd
))
3487 /* This nasty code looks at the symbol to decide whether or
3488 not it is descibes a constructor/destructor entry point. It
3489 is structured this way to (hopefully) speed non matches */
3491 if (0 && symbase
->symbol
.name
[9] == '$')
3493 bfd_constructor_entry(abfd
,
3494 (asymbol
**)location
,
3495 symbase
->symbol
.name
[10] == 'I' ?
3499 *(location
++) = symbase
++;
3503 return bfd_get_symcount(abfd
);
3506 #endif /* NO_COFF_SYMBOLS */
3509 coff_get_reloc_upper_bound(abfd
, asect
)
3513 if (bfd_get_format(abfd
) != bfd_object
) {
3514 bfd_error
= invalid_operation
;
3517 return (asect
->reloc_count
+ 1) * sizeof(arelent
*);
3524 Coff relocations are easily transformed into the internal BFD form
3527 Reading a coff relocation table is done in the following stages:
3529 o The entire coff relocation table is read into memory.
3531 o Each relocation is processed in turn, first it is swapped from the
3532 external to the internal form.
3534 o The symbol referenced in the relocation's symbol index is
3535 turned intoa pointer into the canonical symbol table. Note
3536 that this table is the same as the one returned by a call to
3537 @code{bfd_canonicalize_symtab}. The back end will call the
3538 routine and save the result if a canonicalization hasn't been done.
3540 o The reloc index is turned into a pointer to a howto
3541 structure, in a back end specific way. For instance, the 386
3542 and 960 use the @code{r_type} to directly produce an index
3543 into a howto table vector; the 88k subtracts a number from the
3544 @code{r_type} field and creates an addend field.
3550 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
3551 if (ptr && ptr->the_bfd == abfd \
3552 && ((ptr->flags & BSF_OLD_COMMON)== 0)) \
3554 cache_ptr->addend = -(ptr->section->vma + ptr->value); \
3557 cache_ptr->addend = 0; \
3562 DEFUN(coff_slurp_reloc_table
,(abfd
, asect
, symbols
),
3567 RELOC
*native_relocs
;
3568 arelent
*reloc_cache
;
3573 if (asect
->relocation
)
3575 if (asect
->reloc_count
== 0)
3577 if (asect
->flags
& SEC_CONSTRUCTOR
)
3579 #ifndef NO_COFF_SYMBOLS
3580 if (!coff_slurp_symbol_table(abfd
))
3584 (RELOC
*) buy_and_read(abfd
,
3588 asect
->reloc_count
));
3589 reloc_cache
= (arelent
*)
3590 bfd_alloc(abfd
, (size_t) (asect
->reloc_count
* sizeof(arelent
)));
3592 if (reloc_cache
== NULL
) {
3593 bfd_error
= no_memory
;
3598 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
3600 #ifdef RELOC_PROCESSING
3601 struct internal_reloc dst
;
3602 struct external_reloc
*src
;
3604 cache_ptr
= reloc_cache
+ idx
;
3605 src
= native_relocs
+ idx
;
3606 bfd_swap_reloc_in(abfd
, src
, &dst
);
3608 RELOC_PROCESSING(cache_ptr
, &dst
, symbols
, abfd
, asect
);
3610 struct internal_reloc dst
;
3612 struct external_reloc
*src
;
3614 cache_ptr
= reloc_cache
+ idx
;
3615 src
= native_relocs
+ idx
;
3617 bfd_swap_reloc_in(abfd
, src
, &dst
);
3620 cache_ptr
->address
= dst
.r_vaddr
;
3622 if (dst
.r_symndx
!= -1)
3624 /* @@ Should never be greater than count of symbols! */
3625 if (dst
.r_symndx
>= obj_conv_table_size (abfd
))
3627 cache_ptr
->sym_ptr_ptr
= symbols
+ obj_convert(abfd
)[dst
.r_symndx
];
3628 ptr
= *(cache_ptr
->sym_ptr_ptr
);
3632 cache_ptr
->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
3637 The symbols definitions that we have read in have been
3638 relocated as if their sections started at 0. But the offsets
3639 refering to the symbols in the raw data have not been
3640 modified, so we have to have a negative addend to compensate.
3642 Note that symbols which used to be common must be left alone */
3644 /* Calculate any reloc addend by looking at the symbol */
3645 CALC_ADDEND(abfd
, ptr
, dst
, cache_ptr
);
3647 cache_ptr
->address
-= asect
->vma
;
3648 /* !! cache_ptr->section = (asection *) NULL;*/
3650 /* Fill in the cache_ptr->howto field from dst.r_type */
3651 RTYPE2HOWTO(cache_ptr
, &dst
);
3656 asect
->relocation
= reloc_cache
;
3661 /* This is stupid. This function should be a boolean predicate */
3663 DEFUN(coff_canonicalize_reloc
, (abfd
, section
, relptr
, symbols
),
3666 arelent
**relptr AND
3669 arelent
*tblptr
= section
->relocation
;
3670 unsigned int count
= 0;
3673 if (section
->flags
& SEC_CONSTRUCTOR
)
3675 /* this section has relocs made up by us, they are not in the
3676 file, so take them out of their chain and place them into
3677 the data area provided */
3678 arelent_chain
*chain
= section
->constructor_chain
;
3679 for (count
= 0; count
< section
->reloc_count
; count
++)
3681 *relptr
++ = &chain
->relent
;
3682 chain
= chain
->next
;
3688 coff_slurp_reloc_table(abfd
, section
, symbols
);
3691 tblptr
= section
->relocation
;
3695 for (; count
++ < section
->reloc_count
;)
3696 *relptr
++ = tblptr
++;
3701 return section
->reloc_count
;
3704 #ifndef NO_COFF_SYMBOLS
3707 provided a BFD, a section and an offset into the section, calculate and
3708 return the name of the source file and the line nearest to the wanted
3713 DEFUN(coff_find_nearest_line
,(abfd
,
3721 asection
*section AND
3722 asymbol
**ignore_symbols AND
3724 CONST
char **filename_ptr AND
3725 CONST
char **functionname_ptr AND
3726 unsigned int *line_ptr
)
3728 static bfd
*cache_abfd
;
3729 static asection
*cache_section
;
3730 static bfd_vma cache_offset
;
3731 static unsigned int cache_i
;
3732 static alent
*cache_l
;
3735 coff_data_type
*cof
= coff_data(abfd
);
3736 /* Run through the raw syments if available */
3737 combined_entry_type
*p
;
3739 unsigned int line_base
= 0;
3743 *functionname_ptr
= 0;
3746 /* Don't try and find line numbers in a non coff file */
3747 if (abfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
3753 p
= cof
->raw_syments
;
3755 for (i
= 0; i
< cof
->raw_syment_count
; i
++) {
3756 if (p
->u
.syment
.n_sclass
== C_FILE
) {
3757 /* File name has been moved into symbol */
3758 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
3761 p
+= 1 + p
->u
.syment
.n_numaux
;
3763 /* Now wander though the raw linenumbers of the section */
3765 If this is the same BFD as we were previously called with and this is
3766 the same section, and the offset we want is further down then we can
3767 prime the lookup loop
3769 if (abfd
== cache_abfd
&&
3770 section
== cache_section
&&
3771 offset
>= cache_offset
) {
3777 l
= section
->lineno
;
3780 for (; i
< section
->lineno_count
; i
++) {
3781 if (l
->line_number
== 0) {
3782 /* Get the symbol this line number points at */
3783 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
3784 *functionname_ptr
= coff
->symbol
.name
;
3786 combined_entry_type
*s
= coff
->native
;
3787 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
3789 S should now point to the .bf of the function
3791 if (s
->u
.syment
.n_numaux
) {
3793 The linenumber is stored in the auxent
3795 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
3796 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
3801 if (l
->u
.offset
> offset
)
3803 *line_ptr
= l
->line_number
+ line_base
+ 1;
3809 cache_section
= section
;
3810 cache_offset
= offset
;
3819 coff_sym_filepos(abfd
)
3822 return obj_sym_filepos(abfd
);
3826 #endif /* NO_COFF_SYMBOLS */
3830 DEFUN(coff_sizeof_headers
,(abfd
, reloc
),
3836 if (reloc
== false) {
3837 size
= FILHSZ
+ AOUTSZ
;
3843 size
+= abfd
->section_count
* SCNHSZ
;
3848 DEFUN(get_value
,(reloc
, seclet
),
3850 bfd_seclet_type
*seclet
)
3853 asymbol
*symbol
= *(reloc
->sym_ptr_ptr
);
3854 /* A symbol holds a pointer to a section, and an offset from the
3855 base of the section. To relocate, we find where the section will
3856 live in the output and add that in */
3858 if (symbol
->section
== &bfd_und_section
)
3860 /* Ouch, this is an undefined symbol.. */
3861 bfd_error_vector
.undefined_symbol(reloc
, seclet
);
3862 value
= symbol
->value
;
3866 value
= symbol
->value
+
3867 symbol
->section
->output_offset
+
3868 symbol
->section
->output_section
->vma
;
3872 /* Add the value contained in the relocation */
3873 value
+= (short)((reloc
->addend
) & 0xffff);
3879 DEFUN(perform_slip
,(s
, slip
, input_section
, value
),
3881 unsigned int slip AND
3882 asection
*input_section AND
3886 /* Find all symbols past this point, and make them know
3891 if (p
->section
== input_section
)
3893 /* This was pointing into this section, so mangle it */
3894 if (p
->value
> value
)
3904 DEFUN(movb1
,(input_section
, symbols
, r
, shrink
),
3905 asection
*input_section AND
3906 asymbol
**symbols AND
3908 unsigned int shrink
)
3910 bfd_vma value
= get_value(r
,0);
3912 if (value
>= 0xff00)
3915 /* Change the reloc type from 16bit, possible 8 to 8bit
3917 r
->howto
= r
->howto
+ 1;
3918 /* The place to relc moves back by one */
3921 /* This will be two bytes smaller in the long run */
3923 perform_slip(symbols
, 2, input_section
, r
->address
- shrink
+1);
3931 DEFUN(jmp1
,(input_section
, symbols
, r
, shrink
),
3932 asection
*input_section AND
3933 asymbol
**symbols AND
3935 unsigned int shrink
)
3939 bfd_vma value
= get_value(r
, 0);
3941 bfd_vma dot
= input_section
->output_section
->vma
+
3942 input_section
->output_offset
+ r
->address
;
3945 /* See if the address we're looking at within 127 bytes of where
3946 we are, if so then we can use a small branch rather than the
3947 jump we were going to */
3949 gap
= value
- (dot
- shrink
);
3952 if (-120 < (long)gap
&& (long)gap
< 120 )
3955 /* Change the reloc type from 16bit, possible 8 to 8bit
3957 r
->howto
= r
->howto
+ 1;
3958 /* The place to relc moves back by one */
3961 /* This will be two bytes smaller in the long run */
3963 perform_slip(symbols
, 2, input_section
, r
->address
-shrink
+1);
3971 DEFUN(bfd_coff_relax_section
,(abfd
, i
, symbols
),
3977 /* Get enough memory to hold the stuff */
3978 bfd
*input_bfd
= i
->owner
;
3979 asection
*input_section
= i
;
3981 boolean
new = false;
3983 bfd_size_type reloc_size
= bfd_get_reloc_upper_bound(input_bfd
,
3985 arelent
**reloc_vector
= (arelent
**)bfd_xmalloc(reloc_size
);
3987 /* Get the relocs and think about them */
3988 if (bfd_canonicalize_reloc(input_bfd
,
3994 for (parent
= reloc_vector
; *parent
; parent
++)
3996 arelent
*r
= *parent
;
3997 switch (r
->howto
->type
) {
4005 shrink
= movb1(input_section
, symbols
, r
, shrink
);
4010 shrink
= jmp1(input_section
, symbols
, r
, shrink
);
4018 input_section
->_cooked_size
-= shrink
;
4019 free((char *)reloc_vector
);
4024 DEFUN(bfd_coff_get_relocated_section_contents
,(in_abfd
, seclet
, data
),
4026 bfd_seclet_type
*seclet AND
4030 /* Get enough memory to hold the stuff */
4031 bfd
*input_bfd
= seclet
->u
.indirect
.section
->owner
;
4032 asection
*input_section
= seclet
->u
.indirect
.section
;
4033 bfd_size_type reloc_size
= bfd_get_reloc_upper_bound(input_bfd
,
4035 arelent
**reloc_vector
= (arelent
**)bfd_xmalloc(reloc_size
);
4037 /* read in the section */
4038 bfd_get_section_contents(input_bfd
,
4042 input_section
->_raw_size
);
4045 if (bfd_canonicalize_reloc(input_bfd
,
4048 seclet
->u
.indirect
.symbols
) )
4050 arelent
**parent
= reloc_vector
;
4055 unsigned int dst_address
= 0;
4056 unsigned int src_address
= 0;
4060 /* Find how long a run we can do */
4061 while (dst_address
< seclet
->size
)
4067 /* Note that the relaxing didn't tie up the addresses in the
4068 relocation, so we use the original address to work out the
4069 run of non-relocated data */
4070 run
= reloc
->address
- src_address
;
4076 run
= seclet
->size
- dst_address
;
4078 /* Copy the bytes */
4079 for (idx
= 0; idx
< run
; idx
++)
4081 data
[dst_address
++] = data
[src_address
++];
4084 /* Now do the relocation */
4088 switch (reloc
->howto
->type
)
4091 /* Speciial relaxed type */
4093 bfd_vma dot
= seclet
->offset
+ dst_address
+ seclet
->u
.indirect
.section
->output_section
->vma
;
4094 int gap
= get_value(reloc
,seclet
)-dot
-1;
4095 if ((gap
& ~0xff ) != 0 &&((gap
& 0xff00)!= 0xff00)) abort();
4097 bfd_put_8(in_abfd
,gap
, data
+dst_address
);
4099 switch (data
[dst_address
-1])
4104 bfd_put_8(in_abfd
, 0x55, data
+dst_address
-1);
4108 bfd_put_8(in_abfd
, 0x40, data
+dst_address
-1);
4127 /* Special relaxed type, there will be a gap between where we
4128 get stuff from and where we put stuff to now
4130 for a mov.b @aa:16 -> mov.b @aa:8
4131 opcode 0x6a 0x0y offset
4134 if (data
[dst_address
-1] != 0x6a)
4136 switch (data
[src_address
] & 0xf0)
4140 data
[dst_address
-1] = (data
[src_address
] & 0xf) | 0x20;
4144 data
[dst_address
-1] = (data
[src_address
] & 0xf) | 0x30;
4150 /* the offset must fit ! after all, what was all the relaxing
4153 bfd_put_8(in_abfd
, get_value(reloc
, seclet
), data
+ dst_address
);
4155 /* Note the magic - src goes up by two bytes, but dst by only
4164 bfd_vma dot
= seclet
->offset
+ dst_address
+ seclet
->u
.indirect
.section
->output_section
->vma
;
4165 int gap
= get_value(reloc
,seclet
)-dot
;
4166 if (gap
> 127 || gap
< -128)
4168 bfd_error_vector
.reloc_value_truncated(reloc
, seclet
);
4171 bfd_put_8(in_abfd
,gap
, data
+dst_address
);
4180 unsigned int gap
=get_value(reloc
,seclet
);
4181 if (gap
> 0xff && gap
< ~0xff)
4183 bfd_error_vector
.reloc_value_truncated(reloc
, seclet
);
4186 bfd_put_8(in_abfd
, gap
, data
+dst_address
);
4194 /* A relword which would have like to have been a pcrel */
4196 /* A relword which would like to have been modified but
4199 bfd_put_16(in_abfd
, get_value(reloc
,seclet
), data
+dst_address
);
4214 free((char *)reloc_vector
);
4220 #define coff_core_file_failing_command _bfd_dummy_core_file_failing_command
4221 #define coff_core_file_failing_signal _bfd_dummy_core_file_failing_signal
4222 #define coff_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
4223 #define coff_slurp_armap bfd_slurp_coff_armap
4224 #define coff_slurp_extended_name_table _bfd_slurp_extended_name_table
4225 #define coff_truncate_arname bfd_dont_truncate_arname
4226 #define coff_openr_next_archived_file bfd_generic_openr_next_archived_file
4227 #define coff_generic_stat_arch_elt bfd_generic_stat_arch_elt
4228 #define coff_get_section_contents bfd_generic_get_section_contents
4229 #define coff_close_and_cleanup bfd_generic_close_and_cleanup
4231 #define coff_bfd_debug_info_start bfd_void
4232 #define coff_bfd_debug_info_end bfd_void
4233 #define coff_bfd_debug_info_accumulate (PROTO(void,(*),(bfd*, struct sec *))) bfd_void
4234 #define coff_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
4235 #define coff_bfd_relax_section bfd_generic_relax_section