1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright (C) 1990-1991 Free Software Foundation, Inc.
3 Written by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
22 Most of this hacked by Steve Chamberlain,
30 BFD supports a number of different flavours of coff format.
31 The major difference between formats are the sizes and
32 alignments of fields in structures on disk, and the occasional
35 Coff in all its varieties is implimented with a few common
36 files and a number of implementation specific files. For
37 example, The 88k bcs coff format is implemented in the file
38 @code{coff-m88k.c}. This file @code{#include}s
39 @code{coff-m88k.h} which defines the external structure of the
40 coff format for the 88k, and @code{internalcoff.h} which
41 defines the internal structure. @code{coff-m88k.c} also
42 defines pthe relocations used by the 88k format
43 @xref{Relocations}. Then the major portion of coff code is
44 included (@code{coffcode.h}) which defines the methods used to
45 act upon the types defined in @code{coff-m88k.h} and
46 @code{internalcoff.h}.
49 The Intel i960 processor version of coff is implemented in
50 @code{coff-i960.c}. This file has the same structure as
51 @code{coff-m88k.c}, except that it includes @code{coff-i960.h}
52 rather than @code{coff-m88k.h}.
55 Porting To A New Version of Coff
57 The recommended method is to select from the existing
58 implimentations the version of coff which is most like the one
59 you want to use, for our purposes, we'll say that i386 coff is
60 the one you select, and that your coff flavour is called foo.
61 Copy the @code{i386coff.c} to @code{foocoff.c}, copy
62 @code{../include/i386coff.h} to @code{../include/foocoff.h}
63 and add the lines to @code{targets.c} and @code{Makefile.in}
64 so that your new back end is used. Alter the shapes of the
65 structures in @code{../include/foocoff.h} so that they match
66 what you need. You will probably also have to add
67 @code{#ifdef}s to the code in @code{internalcoff.h} and
68 @code{coffcode.h} if your version of coff is too wild.
70 You can verify that your new BFD backend works quite simply by
71 building @code{objdump} from the @code{binutils} directory,
72 and making sure that its version of what's going on at your
73 host systems idea (assuming it has the pretty standard coff
74 dump utility (usually called @code{att-dump} or just
75 @code{dump})) are the same. Then clean up your code, and send
76 what you've done to Cygnus. Then your stuff will be in the
77 next release, and you won't have to keep integrating it.
80 How The Coff Backend Works
85 Each flavour of coff supported in BFD has its own header file
86 descibing the external layout of the structures. There is also
87 an internal description of the coff layout (in
88 @code{internalcoff.h}) file (@code{}). A major function of the
89 coff backend is swapping the bytes and twiddling the bits to
90 translate the external form of the structures into the normal
91 internal form. This is all performed in the
92 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
93 elements are different sizes between different versions of
94 coff, it is the duty of the coff version specific include file
95 to override the definitions of various packing routines in
96 @code{coffcode.h}. Eg the size of line number entry in coff is
97 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
98 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
99 correct one. No doubt, some day someone will find a version of
100 coff which has a varying field size not catered for at the
101 moment. To port BFD, that person will have to add more @code{#defines}.
102 Three of the bit twiddling routines are exported to
103 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
104 and @code{coff_swap_linno_in}. @code{GDB} reads the symbol
105 table on its own, but uses BFD to fix things up. More of the
106 bit twiddlers are exported for @code{gas};
107 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
108 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
109 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
110 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
111 of all the symbol table and reloc drudgery itself, thereby
112 saving the internal BFD overhead, but uses BFD to swap things
113 on the way out, making cross ports much safer. This also
114 allows BFD (and thus the linker) to use the same header files
115 as @code{gas}, which makes one avenue to disaster disappear.
120 The simple canonical form for symbols used by BFD is not rich
121 enough to keep all the information available in a coff symbol
122 table. The back end gets around this by keeping the original
123 symbol table around, "behind the scenes".
125 When a symbol table is requested (through a call to
126 @code{bfd_canonicalize_symtab}, a request gets through to
127 @code{get_normalized_symtab}. This reads the symbol table from
128 the coff file and swaps all the structures inside into the
129 internal form. It also fixes up all the pointers in the table
130 (represented in the file by offsets from the first symbol in
131 the table) into physical pointers to elements in the new
132 internal table. This involves some work since the meanings of
133 fields changes depending upon context; a field that is a
134 pointer to another structure in the symbol table at one moment
135 may be the size in bytes of a structure in the next. Another
136 pass is made over the table. All symbols which mark file names
137 (<<C_FILE>> symbols) are modified so that the internal
138 string points to the value in the auxent (the real filename)
139 rather than the normal text associated with the symbol
142 At this time the symbol names are moved around. Coff stores
143 all symbols less than nine characters long physically
144 within the symbol table, longer strings are kept at the end of
145 the file in the string table. This pass moves all strings
146 into memory, and replaces them with pointers to the strings.
149 The symbol table is massaged once again, this time to create
150 the canonical table used by the BFD application. Each symbol
151 is inspected in turn, and a decision made (using the
152 @code{sclass} field) about the various flags to set in the
153 @code{asymbol} @xref{Symbols}. The generated canonical table
154 shares strings with the hidden internal symbol table.
156 Any linenumbers are read from the coff file too, and attached
157 to the symbols which own the functions the linenumbers belong to.
162 Writing a symbol to a coff file which didn't come from a coff
163 file will lose any debugging information. The @code{asymbol}
164 structure remembers the BFD from which was born, and on output
165 the back end makes sure that the same destination target as
166 source target is present.
168 When the symbols have come from a coff file then all the
169 debugging information is preserved.
171 Symbol tables are provided for writing to the back end in a
172 vector of pointers to pointers. This allows applications like
173 the linker to accumulate and output large symbol tables
174 without having to do too much byte copying.
176 This function runs through the provided symbol table and
177 patches each symbol marked as a file place holder
178 (@code{C_FILE}) to point to the next file place holder in the
179 list. It also marks each @code{offset} field in the list with
180 the offset from the first symbol of the current symbol.
182 Another function of this procedure is to turn the canonical
183 value form of BFD into the form used by coff. Internally, BFD
184 expects symbol values to be offsets from a section base; so a
185 symbol physically at 0x120, but in a section starting at
186 0x100, would have the value 0x20. Coff expects symbols to
187 contain their final value, so symbols have their values
188 changed at this point to reflect their sum with their owning
189 section. Note that this transformation uses the
190 <<output_section>> field of the @code{asymbol}'s
191 @code{asection} @xref{Sections}.
193 o coff_mangle_symbols
195 This routine runs though the provided symbol table and uses
196 the offsets generated by the previous pass and the pointers
197 generated when the symbol table was read in to create the
198 structured hierachy required by coff. It changes each pointer
199 to a symbol to an index into the symbol table of the symbol
204 This routine runs through the symbol table and patches up the
205 symbols from their internal form into the coff way, calls the
206 bit twiddlers and writes out the tabel to the file.
215 The hidden information for an asymbol is described in a
216 coff_ptr_struct, which is typedefed to a combined_entry_type
220 .typedef struct coff_ptr_struct
223 . {* Remembers the offset from the first symbol in the file for
224 . this symbol. Generated by coff_renumber_symbols. *}
225 .unsigned int offset;
227 . {* Should the tag field of this symbol be renumbered.
228 . Created by coff_pointerize_aux. *}
231 . {* Should the endidx field of this symbol be renumbered.
232 . Created by coff_pointerize_aux. *}
235 . {* The container for the symbol structure as read and translated
239 . union internal_auxent auxent;
240 . struct internal_syment syment;
242 .} combined_entry_type;
245 .{* Each canonical asymbol really looks like this: *}
247 .typedef struct coff_symbol_struct
249 . {* The actual symbol which the rest of BFD works with *}
252 . {* A pointer to the hidden information for this symbol *}
253 .combined_entry_type *native;
255 . {* A pointer to the linenumber information for this symbol *}
256 .struct lineno_cache_entry *lineno;
258 . {* Have the line numbers been relocated yet ? *}
259 .boolean done_lineno;
266 extern bfd_error_vector_type bfd_error_vector
;
271 #define PUTWORD bfd_h_put_32
272 #define PUTHALF bfd_h_put_16
273 #define PUTBYTE bfd_h_put_8
275 #ifndef GET_FCN_LNNOPTR
276 #define GET_FCN_LNNOPTR(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
279 #ifndef GET_FCN_ENDNDX
280 #define GET_FCN_ENDNDX(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
283 #ifndef PUT_FCN_LNNOPTR
284 #define PUT_FCN_LNNOPTR(abfd, in, ext) PUTWORD(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
286 #ifndef PUT_FCN_ENDNDX
287 #define PUT_FCN_ENDNDX(abfd, in, ext) PUTWORD(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
289 #ifndef GET_LNSZ_LNNO
290 #define GET_LNSZ_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_lnno)
292 #ifndef GET_LNSZ_SIZE
293 #define GET_LNSZ_SIZE(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_size)
295 #ifndef PUT_LNSZ_LNNO
296 #define PUT_LNSZ_LNNO(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_sym.x_misc.x_lnsz.x_lnno)
298 #ifndef PUT_LNSZ_SIZE
299 #define PUT_LNSZ_SIZE(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte*) ext->x_sym.x_misc.x_lnsz.x_size)
301 #ifndef GET_SCN_SCNLEN
302 #define GET_SCN_SCNLEN(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_scn.x_scnlen)
304 #ifndef GET_SCN_NRELOC
305 #define GET_SCN_NRELOC(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nreloc)
307 #ifndef GET_SCN_NLINNO
308 #define GET_SCN_NLINNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nlinno)
310 #ifndef PUT_SCN_SCNLEN
311 #define PUT_SCN_SCNLEN(abfd,in, ext) bfd_h_put_32(abfd, in, (bfd_byte *) ext->x_scn.x_scnlen)
313 #ifndef PUT_SCN_NRELOC
314 #define PUT_SCN_NRELOC(abfd,in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_scn.x_nreloc)
316 #ifndef PUT_SCN_NLINNO
317 #define PUT_SCN_NLINNO(abfd,in, ext) bfd_h_put_16(abfd,in, (bfd_byte *) ext->x_scn.x_nlinno)
319 #ifndef GET_LINENO_LNNO
320 #define GET_LINENO_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) (ext->l_lnno));
322 #ifndef PUT_LINENO_LNNO
323 #define PUT_LINENO_LNNO(abfd,val, ext) bfd_h_put_16(abfd,val, (bfd_byte *) (ext->l_lnno));
327 /* void warning(); */
330 * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the
331 * incoming SEC_* flags. The inverse of this function is styp_to_sec_flags().
332 * NOTE: If you add to/change this routine, you should mirror the changes
333 * in styp_to_sec_flags().
336 DEFUN(sec_to_styp_flags
, (sec_name
, sec_flags
),
337 CONST
char * sec_name AND
342 if (!strcmp(sec_name
, _TEXT
)) {
343 return((long)STYP_TEXT
);
344 } else if (!strcmp(sec_name
, _DATA
)) {
345 return((long)STYP_DATA
);
346 } else if (!strcmp(sec_name
, _BSS
)) {
347 return((long)STYP_BSS
);
349 } else if (!strcmp(sec_name
, _COMMENT
)) {
350 return((long)STYP_INFO
);
351 #endif /* _COMMENT */
354 /* Try and figure out what it should be */
355 if (sec_flags
& SEC_CODE
) styp_flags
= STYP_TEXT
;
356 if (sec_flags
& SEC_DATA
) styp_flags
= STYP_DATA
;
357 else if (sec_flags
& SEC_READONLY
)
358 #ifdef STYP_LIT /* 29k readonly text/data section */
359 styp_flags
= STYP_LIT
;
361 styp_flags
= STYP_TEXT
;
362 #endif /* STYP_LIT */
363 else if (sec_flags
& SEC_LOAD
) styp_flags
= STYP_TEXT
;
365 if (styp_flags
== 0) styp_flags
= STYP_BSS
;
370 * Return a word with SEC_* flags set to represent the incoming
371 * STYP_* flags (from scnhdr.s_flags). The inverse of this
372 * function is sec_to_styp_flags().
373 * NOTE: If you add to/change this routine, you should mirror the changes
374 * in sec_to_styp_flags().
377 DEFUN(styp_to_sec_flags
, (styp_flags
),
380 flagword sec_flags
=0;
382 if ((styp_flags
& STYP_TEXT
) || (styp_flags
& STYP_DATA
))
384 sec_flags
= SEC_LOAD
| SEC_ALLOC
;
386 else if (styp_flags
& STYP_BSS
)
388 sec_flags
= SEC_ALLOC
;
390 else if (styp_flags
& STYP_INFO
)
392 sec_flags
= SEC_NEVER_LOAD
;
396 sec_flags
= SEC_ALLOC
| SEC_LOAD
;
398 #ifdef STYP_LIT /* A29k readonly text/data section type */
399 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
401 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
403 #endif /* STYP_LIT */
404 #ifdef STYP_OTHER_LOAD /* Other loaded sections */
405 if (styp_flags
& STYP_OTHER_LOAD
)
407 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
409 #endif /* STYP_SDATA */
414 #define get_index(symbol) ((int) (symbol)->udata)
415 #define set_index(symbol, idx) ((symbol)->udata =(PTR) (idx))
417 /* **********************************************************************
418 Here are all the routines for swapping the structures seen in the
419 outside world into the internal forms.
424 DEFUN(bfd_swap_reloc_in
,(abfd
, reloc_src
, reloc_dst
),
427 struct internal_reloc
*reloc_dst
)
429 reloc_dst
->r_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*)reloc_src
->r_vaddr
);
430 reloc_dst
->r_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) reloc_src
->r_symndx
);
433 reloc_dst
->r_type
= bfd_h_get_8(abfd
, reloc_src
->r_type
);
434 reloc_dst
->r_size
= bfd_h_get_8(abfd
, reloc_src
->r_size
);
436 reloc_dst
->r_type
= bfd_h_get_16(abfd
, (bfd_byte
*) reloc_src
->r_type
);
439 #ifdef SWAP_IN_RELOC_OFFSET
440 reloc_dst
->r_offset
= SWAP_IN_RELOC_OFFSET(abfd
,
441 (bfd_byte
*) reloc_src
->r_offset
);
447 DEFUN(coff_swap_reloc_out
,(abfd
, src
, dst
),
452 struct internal_reloc
*reloc_src
= (struct internal_reloc
*)src
;
453 struct external_reloc
*reloc_dst
= (struct external_reloc
*)dst
;
454 bfd_h_put_32(abfd
, reloc_src
->r_vaddr
, (bfd_byte
*) reloc_dst
->r_vaddr
);
455 bfd_h_put_32(abfd
, reloc_src
->r_symndx
, (bfd_byte
*) reloc_dst
->r_symndx
);
456 bfd_h_put_16(abfd
, reloc_src
->r_type
, (bfd_byte
*)
459 #ifdef SWAP_OUT_RELOC_OFFSET
460 SWAP_OUT_RELOC_OFFSET(abfd
,
462 (bfd_byte
*) reloc_dst
->r_offset
);
464 #ifdef SWAP_OUT_RELOC_EXTRA
465 SWAP_OUT_RELOC_EXTRA(abfd
,reloc_src
, reloc_dst
);
468 return sizeof(struct external_reloc
);
472 DEFUN(bfd_swap_filehdr_in
,(abfd
, filehdr_src
, filehdr_dst
),
474 FILHDR
*filehdr_src AND
475 struct internal_filehdr
*filehdr_dst
)
477 filehdr_dst
->f_magic
= bfd_h_get_16(abfd
, (bfd_byte
*) filehdr_src
->f_magic
);
478 filehdr_dst
->f_nscns
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_nscns
);
479 filehdr_dst
->f_timdat
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_timdat
);
480 filehdr_dst
->f_symptr
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_symptr
);
481 filehdr_dst
->f_nsyms
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_nsyms
);
482 filehdr_dst
->f_opthdr
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_opthdr
);
483 filehdr_dst
->f_flags
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_flags
);
487 DEFUN(coff_swap_filehdr_out
,(abfd
, in
, out
),
492 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*)in
;
493 FILHDR
*filehdr_out
= (FILHDR
*)out
;
494 bfd_h_put_16(abfd
, filehdr_in
->f_magic
, (bfd_byte
*) filehdr_out
->f_magic
);
495 bfd_h_put_16(abfd
, filehdr_in
->f_nscns
, (bfd_byte
*) filehdr_out
->f_nscns
);
496 bfd_h_put_32(abfd
, filehdr_in
->f_timdat
, (bfd_byte
*) filehdr_out
->f_timdat
);
497 bfd_h_put_32(abfd
, filehdr_in
->f_symptr
, (bfd_byte
*) filehdr_out
->f_symptr
);
498 bfd_h_put_32(abfd
, filehdr_in
->f_nsyms
, (bfd_byte
*) filehdr_out
->f_nsyms
);
499 bfd_h_put_16(abfd
, filehdr_in
->f_opthdr
, (bfd_byte
*) filehdr_out
->f_opthdr
);
500 bfd_h_put_16(abfd
, filehdr_in
->f_flags
, (bfd_byte
*) filehdr_out
->f_flags
);
501 return sizeof(FILHDR
);
505 #ifndef NO_COFF_SYMBOLS
508 DEFUN(coff_swap_sym_in
,(abfd
, ext1
, in1
),
513 SYMENT
*ext
= (SYMENT
*)ext1
;
514 struct internal_syment
*in
= (struct internal_syment
*)in1
;
516 if( ext
->e
.e_name
[0] == 0) {
517 in
->_n
._n_n
._n_zeroes
= 0;
518 in
->_n
._n_n
._n_offset
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e
.e
.e_offset
);
521 #if SYMNMLEN != E_SYMNMLEN
522 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
524 memcpy(in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
527 in
->n_value
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_value
);
528 in
->n_scnum
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_scnum
);
529 if (sizeof(ext
->e_type
) == 2){
530 in
->n_type
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_type
);
533 in
->n_type
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_type
);
535 in
->n_sclass
= bfd_h_get_8(abfd
, ext
->e_sclass
);
536 in
->n_numaux
= bfd_h_get_8(abfd
, ext
->e_numaux
);
540 DEFUN(coff_swap_sym_out
,(abfd
, inp
, extp
),
545 struct internal_syment
*in
= (struct internal_syment
*)inp
;
546 SYMENT
*ext
=(SYMENT
*)extp
;
547 if(in
->_n
._n_name
[0] == 0) {
548 bfd_h_put_32(abfd
, 0, (bfd_byte
*) ext
->e
.e
.e_zeroes
);
549 bfd_h_put_32(abfd
, in
->_n
._n_n
._n_offset
, (bfd_byte
*) ext
->e
.e
.e_offset
);
552 #if SYMNMLEN != E_SYMNMLEN
553 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
555 memcpy(ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
558 bfd_h_put_32(abfd
, in
->n_value
, (bfd_byte
*) ext
->e_value
);
559 bfd_h_put_16(abfd
, in
->n_scnum
, (bfd_byte
*) ext
->e_scnum
);
560 if (sizeof(ext
->e_type
) == 2)
562 bfd_h_put_16(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
566 bfd_h_put_32(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
568 bfd_h_put_8(abfd
, in
->n_sclass
, ext
->e_sclass
);
569 bfd_h_put_8(abfd
, in
->n_numaux
, ext
->e_numaux
);
570 return sizeof(SYMENT
);
574 DEFUN(coff_swap_aux_in
,(abfd
, ext1
, type
, class, in1
),
581 AUXENT
*ext
= (AUXENT
*)ext1
;
582 union internal_auxent
*in
= (union internal_auxent
*)in1
;
586 if (ext
->x_file
.x_fname
[0] == 0) {
587 in
->x_file
.x_n
.x_zeroes
= 0;
588 in
->x_file
.x_n
.x_offset
=
589 bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
591 #if FILNMLEN != E_FILNMLEN
592 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
594 memcpy (in
->x_file
.x_fname
, ext
->x_file
.x_fname
, FILNMLEN
);
599 /* RS/6000 "csect" auxents */
603 in
->x_csect
.x_scnlen
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_scnlen
);
604 in
->x_csect
.x_parmhash
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_parmhash
);
605 in
->x_csect
.x_snhash
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snhash
);
606 /* We don't have to hack bitfields in x_smtyp because it's defined by
607 shifts-and-ands, which are equivalent on all byte orders. */
608 in
->x_csect
.x_smtyp
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smtyp
);
609 in
->x_csect
.x_smclas
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smclas
);
610 in
->x_csect
.x_stab
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_stab
);
611 in
->x_csect
.x_snstab
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snstab
);
620 if (type
== T_NULL
) {
621 in
->x_scn
.x_scnlen
= GET_SCN_SCNLEN(abfd
, ext
);
622 in
->x_scn
.x_nreloc
= GET_SCN_NRELOC(abfd
, ext
);
623 in
->x_scn
.x_nlinno
= GET_SCN_NLINNO(abfd
, ext
);
627 in
->x_sym
.x_tagndx
.l
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
629 in
->x_sym
.x_tvndx
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
632 if (ISARY(type
) || class == C_BLOCK
) {
633 #if DIMNUM != E_DIMNUM
634 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
636 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0] = bfd_h_get_16(abfd
, (bfd_byte
*) ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0]);
637 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1] = bfd_h_get_16(abfd
, (bfd_byte
*) ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1]);
638 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2] = bfd_h_get_16(abfd
, (bfd_byte
*) ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2]);
639 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3] = bfd_h_get_16(abfd
, (bfd_byte
*) ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3]);
642 in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= GET_FCN_LNNOPTR(abfd
, ext
);
643 in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= GET_FCN_ENDNDX(abfd
, ext
);
646 in
->x_sym
.x_misc
.x_fsize
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
649 in
->x_sym
.x_misc
.x_lnsz
.x_lnno
= GET_LNSZ_LNNO(abfd
, ext
);
650 in
->x_sym
.x_misc
.x_lnsz
.x_size
= GET_LNSZ_SIZE(abfd
, ext
);
656 DEFUN(coff_swap_aux_out
,(abfd
, inp
, type
, class, extp
),
663 union internal_auxent
*in
= (union internal_auxent
*)inp
;
664 AUXENT
*ext
= (AUXENT
*)extp
;
667 if (in
->x_file
.x_fname
[0] == 0) {
668 PUTWORD(abfd
, 0, (bfd_byte
*) ext
->x_file
.x_n
.x_zeroes
);
670 in
->x_file
.x_n
.x_offset
,
671 (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
674 #if FILNMLEN != E_FILNMLEN
675 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
677 memcpy (ext
->x_file
.x_fname
, in
->x_file
.x_fname
, FILNMLEN
);
683 /* RS/6000 "csect" auxents */
686 PUTWORD (abfd
, in
->x_csect
.x_scnlen
, ext
->x_csect
.x_scnlen
);
687 PUTWORD (abfd
, in
->x_csect
.x_parmhash
, ext
->x_csect
.x_parmhash
);
688 PUTHALF (abfd
, in
->x_csect
.x_snhash
, ext
->x_csect
.x_snhash
);
689 /* We don't have to hack bitfields in x_smtyp because it's defined by
690 shifts-and-ands, which are equivalent on all byte orders. */
691 PUTBYTE (abfd
, in
->x_csect
.x_smtyp
, ext
->x_csect
.x_smtyp
);
692 PUTBYTE (abfd
, in
->x_csect
.x_smclas
, ext
->x_csect
.x_smclas
);
693 PUTWORD (abfd
, in
->x_csect
.x_stab
, ext
->x_csect
.x_stab
);
694 PUTHALF (abfd
, in
->x_csect
.x_snstab
, ext
->x_csect
.x_snstab
);
703 if (type
== T_NULL
) {
704 PUT_SCN_SCNLEN(abfd
, in
->x_scn
.x_scnlen
, ext
);
705 PUT_SCN_NRELOC(abfd
, in
->x_scn
.x_nreloc
, ext
);
706 PUT_SCN_NLINNO(abfd
, in
->x_scn
.x_nlinno
, ext
);
710 PUTWORD(abfd
, in
->x_sym
.x_tagndx
.l
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
712 bfd_h_put_16(abfd
, in
->x_sym
.x_tvndx
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
716 PUTWORD(abfd
, in
->x_sym
.x_misc
.x_fsize
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
717 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
718 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
722 if (ISARY(type
) || class == C_BLOCK
) {
723 #if DIMNUM != E_DIMNUM
724 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
726 bfd_h_put_16(abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0], (bfd_byte
*)ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0]);
727 bfd_h_put_16(abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1], (bfd_byte
*)ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1]);
728 bfd_h_put_16(abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2], (bfd_byte
*)ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2]);
729 bfd_h_put_16(abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3], (bfd_byte
*)ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3]);
732 PUT_LNSZ_LNNO(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
733 PUT_LNSZ_SIZE(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
735 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
736 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
741 return sizeof(AUXENT
);
744 #endif /* NO_COFF_SYMBOLS */
746 #ifndef NO_COFF_LINENOS
749 DEFUN(coff_swap_lineno_in
,(abfd
, ext1
, in1
),
754 LINENO
*ext
= (LINENO
*)ext1
;
755 struct internal_lineno
*in
= (struct internal_lineno
*)in1
;
757 in
->l_addr
.l_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->l_addr
.l_symndx
);
758 in
->l_lnno
= GET_LINENO_LNNO(abfd
, ext
);
762 DEFUN(coff_swap_lineno_out
,(abfd
, inp
, outp
),
767 struct internal_lineno
*in
= (struct internal_lineno
*)inp
;
768 struct external_lineno
*ext
= (struct external_lineno
*)outp
;
769 PUTWORD(abfd
, in
->l_addr
.l_symndx
, (bfd_byte
*)
770 ext
->l_addr
.l_symndx
);
772 PUT_LINENO_LNNO (abfd
, in
->l_lnno
, ext
);
773 return sizeof(struct external_lineno
);
776 #endif /* NO_COFF_LINENOS */
780 DEFUN(bfd_swap_aouthdr_in
,(abfd
, aouthdr_ext1
, aouthdr_int1
),
785 AOUTHDR
*aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
786 struct internal_aouthdr
*aouthdr_int
= (struct internal_aouthdr
*)aouthdr_int1
;
788 aouthdr_int
->magic
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->magic
);
789 aouthdr_int
->vstamp
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->vstamp
);
790 aouthdr_int
->tsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tsize
);
791 aouthdr_int
->dsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->dsize
);
792 aouthdr_int
->bsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->bsize
);
793 aouthdr_int
->entry
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->entry
);
794 aouthdr_int
->text_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->text_start
);
795 aouthdr_int
->data_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->data_start
);
797 aouthdr_int
->tagentries
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tagentries
);
801 aouthdr_int
->o_toc
= bfd_h_get_32(abfd
, aouthdr_ext
->o_toc
);
802 aouthdr_int
->o_snentry
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snentry
);
803 aouthdr_int
->o_sntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntext
);
804 aouthdr_int
->o_sndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sndata
);
805 aouthdr_int
->o_sntoc
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntoc
);
806 aouthdr_int
->o_snloader
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snloader
);
807 aouthdr_int
->o_snbss
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snbss
);
808 aouthdr_int
->o_algntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algntext
);
809 aouthdr_int
->o_algndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algndata
);
810 aouthdr_int
->o_modtype
= bfd_h_get_16(abfd
, aouthdr_ext
->o_modtype
);
811 aouthdr_int
->o_maxstack
= bfd_h_get_32(abfd
, aouthdr_ext
->o_maxstack
);
816 DEFUN(coff_swap_aouthdr_out
,(abfd
, in
, out
),
821 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*)in
;
822 AOUTHDR
*aouthdr_out
= (AOUTHDR
*)out
;
823 bfd_h_put_16(abfd
, aouthdr_in
->magic
, (bfd_byte
*) aouthdr_out
->magic
);
824 bfd_h_put_16(abfd
, aouthdr_in
->vstamp
, (bfd_byte
*) aouthdr_out
->vstamp
);
825 bfd_h_put_32(abfd
, aouthdr_in
->tsize
, (bfd_byte
*) aouthdr_out
->tsize
);
826 bfd_h_put_32(abfd
, aouthdr_in
->dsize
, (bfd_byte
*) aouthdr_out
->dsize
);
827 bfd_h_put_32(abfd
, aouthdr_in
->bsize
, (bfd_byte
*) aouthdr_out
->bsize
);
828 bfd_h_put_32(abfd
, aouthdr_in
->entry
, (bfd_byte
*) aouthdr_out
->entry
);
829 bfd_h_put_32(abfd
, aouthdr_in
->text_start
,
830 (bfd_byte
*) aouthdr_out
->text_start
);
831 bfd_h_put_32(abfd
, aouthdr_in
->data_start
, (bfd_byte
*) aouthdr_out
->data_start
);
833 bfd_h_put_32(abfd
, aouthdr_in
->tagentries
, (bfd_byte
*) aouthdr_out
->tagentries
);
835 return sizeof(AOUTHDR
);
839 DEFUN(coff_swap_scnhdr_in
,(abfd
, scnhdr_ext
, scnhdr_int
),
841 SCNHDR
*scnhdr_ext AND
842 struct internal_scnhdr
*scnhdr_int
)
844 memcpy(scnhdr_int
->s_name
, scnhdr_ext
->s_name
, sizeof(scnhdr_int
->s_name
));
845 scnhdr_int
->s_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
846 scnhdr_int
->s_paddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
847 scnhdr_int
->s_size
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_size
);
849 scnhdr_int
->s_scnptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
850 scnhdr_int
->s_relptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
851 scnhdr_int
->s_lnnoptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
852 scnhdr_int
->s_flags
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_flags
);
854 scnhdr_int
->s_nreloc
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
855 scnhdr_int
->s_nlnno
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
857 scnhdr_int
->s_nreloc
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
858 scnhdr_int
->s_nlnno
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
861 scnhdr_int
->s_align
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_align
);
866 DEFUN(coff_swap_scnhdr_out
,(abfd
, in
, out
),
871 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*)in
;
872 SCNHDR
*scnhdr_ext
= (SCNHDR
*)out
;
873 memcpy(scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof(scnhdr_int
->s_name
));
874 PUTWORD(abfd
, scnhdr_int
->s_vaddr
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
875 PUTWORD(abfd
, scnhdr_int
->s_paddr
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
876 PUTWORD(abfd
, scnhdr_int
->s_size
, (bfd_byte
*) scnhdr_ext
->s_size
);
877 PUTWORD(abfd
, scnhdr_int
->s_scnptr
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
878 PUTWORD(abfd
, scnhdr_int
->s_relptr
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
879 PUTWORD(abfd
, scnhdr_int
->s_lnnoptr
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
880 PUTWORD(abfd
, scnhdr_int
->s_flags
, (bfd_byte
*) scnhdr_ext
->s_flags
);
882 PUTWORD(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
883 PUTWORD(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
885 PUTHALF(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
886 PUTHALF(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
890 PUTWORD(abfd
, scnhdr_int
->s_align
, (bfd_byte
*) scnhdr_ext
->s_align
);
892 return sizeof(SCNHDR
);
897 initialize a section structure with information peculiar to this
898 particular implementation of coff
902 DEFUN(coff_new_section_hook
,(abfd
, section
),
906 section
->alignment_power
= abfd
->xvec
->align_power_min
;
907 /* Allocate aux records for section symbols, to store size and
910 @@ Shouldn't use constant multiplier here! */
911 coffsymbol (section
->symbol
)->native
=
912 (combined_entry_type
*) bfd_zalloc (abfd
,
913 sizeof (combined_entry_type
) * 10);
917 static asection bfd_debug_section
= { "*DEBUG*" };
919 /* Take a section header read from a coff file (in HOST byte order),
920 and make a BFD "section" out of it. */
922 DEFUN(make_a_section_from_file
,(abfd
, hdr
, target_index
),
924 struct internal_scnhdr
*hdr AND
925 unsigned int target_index
)
927 asection
*return_section
;
930 /* Assorted wastage to null-terminate the name, thanks AT&T! */
931 name
= bfd_alloc(abfd
, sizeof (hdr
->s_name
)+1);
933 bfd_error
= no_memory
;
936 strncpy(name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
937 name
[sizeof (hdr
->s_name
)] = 0;
939 return_section
= bfd_make_section(abfd
, name
);
940 if (return_section
== NULL
)
943 /* s_paddr is presumed to be = to s_vaddr */
945 return_section
->vma
= hdr
->s_vaddr
;
946 return_section
->_raw_size
= hdr
->s_size
;
947 return_section
->filepos
= hdr
->s_scnptr
;
948 return_section
->rel_filepos
= hdr
->s_relptr
;
949 return_section
->reloc_count
= hdr
->s_nreloc
;
952 /* FIXME, use a temp var rather than alignment_power */
953 return_section
->alignment_power
= hdr
->s_align
;
956 for (i
= 0; i
< 32; i
++) {
957 if ((1 << i
) >= (int) (return_section
->alignment_power
)) {
958 return_section
->alignment_power
= i
;
965 return_section
->line_filepos
= hdr
->s_lnnoptr
;
967 return_section->linesize = hdr->s_nlnno * sizeof (struct lineno);
970 return_section
->lineno_count
= hdr
->s_nlnno
;
971 return_section
->userdata
= NULL
;
972 return_section
->next
= (asection
*) NULL
;
973 return_section
->flags
= styp_to_sec_flags(hdr
->s_flags
);
975 return_section
->target_index
= target_index
;
977 if (hdr
->s_nreloc
!= 0)
978 return_section
->flags
|= SEC_RELOC
;
979 /* FIXME: should this check 'hdr->s_size > 0' */
980 if (hdr
->s_scnptr
!= 0)
981 return_section
->flags
|= SEC_HAS_CONTENTS
;
985 DEFUN(coff_mkobject
,(abfd
),
988 abfd
->tdata
.coff_obj_data
= (struct coff_tdata
*)bfd_zalloc (abfd
,sizeof(coff_data_type
));
989 if (abfd
->tdata
.coff_obj_data
== 0){
990 bfd_error
= no_memory
;
993 coff_data(abfd
)->relocbase
= 0;
994 /* make_abs_section(abfd);*/
1000 DEFUN(coff_real_object_p
,(abfd
, nscns
, internal_f
, internal_a
),
1003 struct internal_filehdr
*internal_f AND
1004 struct internal_aouthdr
*internal_a
)
1006 coff_data_type
*coff
;
1007 enum bfd_architecture arch
;
1009 size_t readsize
; /* length of file_info */
1010 SCNHDR
*external_sections
;
1012 /* Build a play area */
1013 if (coff_mkobject(abfd
) != true)
1016 coff
= coff_data(abfd
);
1019 external_sections
= (SCNHDR
*)bfd_alloc(abfd
, readsize
= (nscns
* SCNHSZ
));
1021 if (bfd_read((PTR
)external_sections
, 1, readsize
, abfd
) != readsize
) {
1026 /* Now copy data as required; construct all asections etc */
1027 coff
->symbol_index_slew
= 0;
1029 coff
->raw_syment_count
= 0;
1030 coff
->raw_linenos
= 0;
1031 coff
->raw_syments
= 0;
1032 coff
->sym_filepos
=0;
1033 coff
->flags
= internal_f
->f_flags
;
1036 for (i
= 0; i
< nscns
; i
++) {
1037 struct internal_scnhdr tmp
;
1038 coff_swap_scnhdr_in(abfd
, external_sections
+ i
, &tmp
);
1039 make_a_section_from_file(abfd
,&tmp
, i
+1);
1043 /* make_abs_section(abfd);*/
1045 /* Determine the machine architecture and type. */
1047 switch (internal_f
->f_magic
) {
1050 arch
= bfd_arch_i386
;
1055 #ifdef A29K_MAGIC_BIG
1056 case A29K_MAGIC_BIG
:
1057 case A29K_MAGIC_LITTLE
:
1058 arch
= bfd_arch_a29k
;
1067 arch
= bfd_arch_mips
;
1075 arch
= bfd_arch_m68k
;
1083 arch
= bfd_arch_m88k
;
1091 arch
= bfd_arch_i960
;
1092 switch (F_I960TYPE
& internal_f
->f_flags
)
1096 machine
= bfd_mach_i960_core
;
1099 machine
= bfd_mach_i960_kb_sb
;
1102 machine
= bfd_mach_i960_mc
;
1105 machine
= bfd_mach_i960_xa
;
1108 machine
= bfd_mach_i960_ca
;
1111 machine
= bfd_mach_i960_ka_sa
;
1122 arch
= bfd_arch_rs6000
;
1129 arch
= bfd_arch_h8300
;
1134 default: /* Unreadable input file type */
1135 arch
= bfd_arch_obscure
;
1139 bfd_default_set_arch_mach(abfd
, arch
, machine
);
1140 if (!(internal_f
->f_flags
& F_RELFLG
))
1141 abfd
->flags
|= HAS_RELOC
;
1142 if ((internal_f
->f_flags
& F_EXEC
))
1143 abfd
->flags
|= EXEC_P
;
1144 if (!(internal_f
->f_flags
& F_LNNO
))
1145 abfd
->flags
|= HAS_LINENO
;
1146 if (!(internal_f
->f_flags
& F_LSYMS
))
1147 abfd
->flags
|= HAS_LOCALS
;
1150 bfd_get_symcount(abfd
) = internal_f
->f_nsyms
;
1151 if (internal_f
->f_nsyms
)
1152 abfd
->flags
|= HAS_SYMS
;
1154 coff
->sym_filepos
= internal_f
->f_symptr
;
1156 /* These members communicate important constants about the symbol table
1157 to GDB's symbol-reading code. These `constants' unfortunately vary
1158 from coff implementation to implementation... */
1159 #ifndef NO_COFF_SYMBOLS
1160 coff
->local_n_btmask
= N_BTMASK
;
1161 coff
->local_n_btshft
= N_BTSHFT
;
1162 coff
->local_n_tmask
= N_TMASK
;
1163 coff
->local_n_tshift
= N_TSHIFT
;
1164 coff
->local_symesz
= SYMESZ
;
1165 coff
->local_auxesz
= AUXESZ
;
1166 coff
->local_linesz
= LINESZ
;
1169 coff
->symbols
= (coff_symbol_type
*) NULL
;
1170 bfd_get_start_address(abfd
) = internal_f
->f_opthdr
? internal_a
->entry
: 0;
1174 bfd_release(abfd
, coff
);
1175 return (bfd_target
*)NULL
;
1179 DEFUN(coff_object_p
,(abfd
),
1185 struct internal_filehdr internal_f
;
1186 struct internal_aouthdr internal_a
;
1188 bfd_error
= system_call_error
;
1190 /* figure out how much to read */
1191 if (bfd_read((PTR
) &filehdr
, 1, FILHSZ
, abfd
) != FILHSZ
)
1194 bfd_swap_filehdr_in(abfd
, &filehdr
, &internal_f
);
1196 if (BADMAG(internal_f
)) {
1197 bfd_error
= wrong_format
;
1200 nscns
=internal_f
.f_nscns
;
1202 if (internal_f
.f_opthdr
) {
1203 if (bfd_read((PTR
) &opthdr
, 1,AOUTSZ
, abfd
) != AOUTSZ
) {
1206 bfd_swap_aouthdr_in(abfd
, (char *)&opthdr
, (char *)&internal_a
);
1209 /* Seek past the opt hdr stuff */
1210 bfd_seek(abfd
, internal_f
.f_opthdr
+ FILHSZ
, SEEK_SET
);
1212 /* if the optional header is NULL or not the correct size then
1213 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1214 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1215 optional header is of a different size.
1217 But the mips keeps extra stuff in it's opthdr, so dont check
1221 #if defined(M88) || defined(I960)
1222 if (internal_f
.f_opthdr
!= 0 && AOUTSZ
!= internal_f
.f_opthdr
)
1223 return (bfd_target
*)NULL
;
1226 return coff_real_object_p(abfd
, nscns
, &internal_f
, &internal_a
);
1231 #ifndef NO_COFF_LINENOS
1234 DEFUN(coff_count_linenumbers
,(abfd
),
1237 unsigned int limit
= bfd_get_symcount(abfd
);
1241 asection
*s
= abfd
->sections
->output_section
;
1243 BFD_ASSERT(s
->lineno_count
== 0);
1249 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++) {
1250 asymbol
*q_maybe
= *p
;
1251 if (q_maybe
->the_bfd
->xvec
->flavour
== bfd_target_coff_flavour
) {
1252 coff_symbol_type
*q
= coffsymbol(q_maybe
);
1255 This symbol has a linenumber, increment the owning
1256 section's linenumber count
1258 alent
*l
= q
->lineno
;
1259 q
->symbol
.section
->output_section
->lineno_count
++;
1261 while (l
->line_number
) {
1262 q
->symbol
.section
->output_section
->lineno_count
++;
1270 #endif /* NO_COFF_LINENOS */
1272 #ifndef NO_COFF_SYMBOLS
1275 Takes a bfd and a symbol, returns a pointer to the coff specific area
1276 of the symbol if there is one.
1278 static coff_symbol_type
*
1279 DEFUN(coff_symbol_from
,(ignore_abfd
, symbol
),
1280 bfd
*ignore_abfd AND
1283 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
1284 return (coff_symbol_type
*)NULL
;
1286 if (symbol
->the_bfd
->tdata
.coff_obj_data
== (coff_data_type
*)NULL
)
1287 return (coff_symbol_type
*)NULL
;
1289 return (coff_symbol_type
*) symbol
;
1295 DEFUN(fixup_symbol_value
,(coff_symbol_ptr
, syment
),
1296 coff_symbol_type
*coff_symbol_ptr AND
1297 struct internal_syment
*syment
)
1300 /* Normalize the symbol flags */
1301 if (coff_symbol_ptr
->symbol
.section
== &bfd_com_section
) {
1302 /* a common symbol is undefined with a value */
1303 syment
->n_scnum
= N_UNDEF
;
1304 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1306 else if (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) {
1307 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1309 else if (coff_symbol_ptr
->symbol
.section
== & bfd_und_section
) {
1310 syment
->n_scnum
= N_UNDEF
;
1311 syment
->n_value
= 0;
1314 if (coff_symbol_ptr
->symbol
.section
) {
1316 coff_symbol_ptr
->symbol
.section
->output_section
->target_index
;
1319 coff_symbol_ptr
->symbol
.value
+
1320 coff_symbol_ptr
->symbol
.section
->output_offset
+
1321 coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
1325 /* This can happen, but I don't know why yet (steve@cygnus.com) */
1326 syment
->n_scnum
= N_ABS
;
1327 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1332 /* run through all the symbols in the symbol table and work out what
1333 their indexes into the symbol table will be when output
1335 Coff requires that each C_FILE symbol points to the next one in the
1336 chain, and that the last one points to the first external symbol. We
1341 DEFUN(coff_renumber_symbols
,(bfd_ptr
),
1344 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1345 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1346 unsigned int native_index
= 0;
1347 struct internal_syment
*last_file
= (struct internal_syment
*)NULL
;
1348 unsigned int symbol_index
;
1350 /* COFF demands that undefined symbols come after all other symbols.
1351 Since we don't need to impose this extra knowledge on all our client
1352 programs, deal with that here. Sort the symbol table; just move the
1353 undefined symbols to the end, leaving the rest alone. */
1354 /* @@ Do we have some condition we could test for, so we don't always
1355 have to do this? I don't think relocatability is quite right, but
1356 I'm not certain. [raeburn:19920508.1711EST] */
1361 newsyms
= (asymbol
**) bfd_alloc_by_size_t (bfd_ptr
,
1362 sizeof (asymbol
*) * symbol_count
);
1363 bfd_ptr
->outsymbols
= newsyms
;
1364 for (i
= 0; i
< symbol_count
; i
++)
1365 if (symbol_ptr_ptr
[i
]->section
!= &bfd_und_section
)
1366 *newsyms
++ = symbol_ptr_ptr
[i
];
1367 for (i
= 0; i
< symbol_count
; i
++)
1368 if (symbol_ptr_ptr
[i
]->section
== &bfd_und_section
)
1369 *newsyms
++ = symbol_ptr_ptr
[i
];
1370 symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1373 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1375 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1376 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1377 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1380 if (s
->u
.syment
.n_sclass
== C_FILE
)
1382 if (last_file
!= (struct internal_syment
*)NULL
) {
1383 last_file
->n_value
= native_index
;
1385 last_file
= &(s
->u
.syment
);
1389 /* Modify the symbol values according to their section and
1392 fixup_symbol_value(coff_symbol_ptr
, &(s
->u
.syment
));
1394 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++) {
1395 s
[i
].offset
= native_index
++;
1402 obj_conv_table_size (bfd_ptr
) = native_index
;
1407 Run thorough the symbol table again, and fix it so that all pointers to
1408 entries are changed to the entries' index in the output symbol table.
1412 DEFUN(coff_mangle_symbols
,(bfd_ptr
),
1415 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1416 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1417 unsigned int symbol_index
;
1419 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1421 coff_symbol_type
*coff_symbol_ptr
=
1422 coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1424 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1426 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1428 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++) {
1429 combined_entry_type
*a
= s
+ i
+ 1;
1431 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
1432 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
1436 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
1437 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
1447 static int string_size
;
1449 DEFUN(coff_fix_symbol_name
,(ignore_abfd
, symbol
, native
),
1450 bfd
*ignore_abfd AND
1452 combined_entry_type
*native
)
1454 unsigned int name_length
;
1455 union internal_auxent
*auxent
;
1456 char * name
= ( char *)(symbol
->name
);
1458 if (name
== (char *) NULL
) {
1459 /* coff symbols always have names, so we'll make one up */
1460 symbol
->name
= "strange";
1461 name
= (char *)symbol
->name
;
1463 name_length
= strlen(name
);
1465 if (native
->u
.syment
.n_sclass
== C_FILE
) {
1466 strncpy(native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
1467 auxent
= &(native
+1)->u
.auxent
;
1469 #ifdef COFF_LONG_FILENAMES
1470 if (name_length
<= FILNMLEN
) {
1471 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1474 auxent
->x_file
.x_n
.x_offset
= string_size
+ 4;
1475 auxent
->x_file
.x_n
.x_zeroes
= 0;
1476 string_size
+= name_length
+ 1;
1479 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1480 if (name_length
> FILNMLEN
) {
1481 name
[FILNMLEN
] = '\0';
1486 { /* NOT A C_FILE SYMBOL */
1487 if (name_length
<= SYMNMLEN
) {
1488 /* This name will fit into the symbol neatly */
1489 strncpy(native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
1492 native
->u
.syment
._n
._n_n
._n_offset
= string_size
+ 4;
1493 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1494 string_size
+= name_length
+ 1;
1502 DEFUN(coff_write_symbol
,(abfd
, symbol
, native
, written
),
1505 combined_entry_type
*native AND
1506 unsigned int written
)
1508 unsigned int numaux
= native
->u
.syment
.n_numaux
;
1509 int type
= native
->u
.syment
.n_type
;
1510 int class = native
->u
.syment
.n_sclass
;
1514 /* @@ bfd_debug_section isn't accessible outside this file, but we know
1515 that C_FILE symbols belong there. So move them. */
1516 if (native
->u
.syment
.n_sclass
== C_FILE
)
1517 symbol
->section
= &bfd_debug_section
;
1519 if (symbol
->section
== &bfd_abs_section
)
1521 native
->u
.syment
.n_scnum
= N_ABS
;
1523 else if (symbol
->section
== &bfd_debug_section
)
1525 native
->u
.syment
.n_scnum
= N_DEBUG
;
1527 else if (symbol
->section
== &bfd_und_section
)
1529 native
->u
.syment
.n_scnum
= N_UNDEF
;
1533 native
->u
.syment
.n_scnum
=
1534 symbol
->section
->output_section
->target_index
;
1538 coff_fix_symbol_name(abfd
, symbol
, native
);
1540 coff_swap_sym_out(abfd
, &native
->u
.syment
, &buf
);
1541 bfd_write((PTR
)& buf
, 1, SYMESZ
, abfd
);
1542 for (j
= 0; j
< native
->u
.syment
.n_numaux
; j
++)
1545 bzero((PTR
)&buf
, AUXESZ
);
1546 coff_swap_aux_out(abfd
,
1547 &( (native
+ j
+ 1)->u
.auxent
), type
, class, &buf1
);
1548 bfd_write((PTR
) (&buf1
), 1, AUXESZ
, abfd
);
1551 Reuse somewhere in the symbol to keep the index
1553 set_index(symbol
, written
);
1554 return written
+ 1 + numaux
;
1559 DEFUN(coff_write_alien_symbol
,(abfd
, symbol
, written
),
1562 unsigned int written
)
1565 This symbol has been created by the loader, or come from a non
1566 coff format. It has no native element to inherit, make our
1569 combined_entry_type
*native
;
1570 combined_entry_type dummy
;
1572 native
->u
.syment
.n_type
= T_NULL
;
1574 native
->u
.syment
.n_flags
= 0;
1576 if (symbol
->section
== &bfd_und_section
)
1578 native
->u
.syment
.n_scnum
= N_UNDEF
;
1579 native
->u
.syment
.n_value
= symbol
->value
;
1581 else if (symbol
->section
== &bfd_com_section
)
1583 native
->u
.syment
.n_scnum
= N_UNDEF
;
1584 native
->u
.syment
.n_value
= symbol
->value
;
1588 else if (symbol
->flags
& BSF_DEBUGGING
) {
1590 remove name so it doesn't take up any space
1595 native
->u
.syment
.n_scnum
= symbol
->section
->output_section
->target_index
;
1596 native
->u
.syment
.n_value
= symbol
->value
+
1597 symbol
->section
->output_section
->vma
+
1598 symbol
->section
->output_offset
;
1600 /* Copy the any flags from the the file hdr into the symbol */
1602 coff_symbol_type
*c
= coff_symbol_from(abfd
, symbol
);
1603 if (c
!= (coff_symbol_type
*)NULL
) {
1604 native
->u
.syment
.n_flags
= c
->symbol
.the_bfd
->flags
;
1611 native
->u
.syment
.pad1
[0] = 0;
1612 native
->u
.syment
.pad1
[0] = 0;
1615 native
->u
.syment
.n_type
= 0;
1616 if (symbol
->flags
& BSF_LOCAL
)
1617 native
->u
.syment
.n_sclass
= C_STAT
;
1619 native
->u
.syment
.n_sclass
= C_EXT
;
1620 native
->u
.syment
.n_numaux
= 0;
1622 return coff_write_symbol(abfd
, symbol
, native
, written
);
1626 DEFUN(coff_write_native_symbol
,(abfd
, symbol
, written
),
1628 coff_symbol_type
*symbol AND
1629 unsigned int written
)
1632 Does this symbol have an ascociated line number - if so then
1633 make it remember this symbol index. Also tag the auxent of
1634 this symbol to point to the right place in the lineno table
1636 combined_entry_type
*native
= symbol
->native
;
1638 alent
*lineno
= symbol
->lineno
;
1640 if (lineno
&& !symbol
->done_lineno
) {
1641 unsigned int count
= 0;
1642 lineno
[count
].u
.offset
= written
;
1643 if (native
->u
.syment
.n_numaux
) {
1644 union internal_auxent
*a
= &((native
+1)->u
.auxent
);
1646 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1647 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1650 And count and relocate all other linenumbers
1654 while (lineno
[count
].line_number
) {
1657 I've been told this, but still need proof:
1658 > The second bug is also in `bfd/coffcode.h'. This bug causes the linker to screw
1659 > up the pc-relocations for all the line numbers in COFF code. This bug isn't
1660 > only specific to A29K implementations, but affects all systems using COFF
1661 > format binaries. Note that in COFF object files, the line number core offsets
1662 > output by the assembler are relative to the start of each procedure, not
1663 > to the start of the .text section. This patch relocates the line numbers
1664 > relative to the `native->u.syment.n_value' instead of the section virtual
1665 > address. modular!olson@cs.arizona.edu (Jon Olson)
1667 lineno
[count
].u
.offset
+= native
->u
.syment
.n_value
;
1670 lineno
[count
].u
.offset
+=
1671 symbol
->symbol
.section
->output_section
->vma
+
1672 symbol
->symbol
.section
->output_offset
;
1676 symbol
->done_lineno
= true;
1678 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1681 return coff_write_symbol(abfd
, &( symbol
->symbol
), native
,written
);
1685 DEFUN(coff_write_symbols
,(abfd
),
1689 unsigned int limit
= bfd_get_symcount(abfd
);
1690 unsigned int written
= 0;
1697 /* Seek to the right place */
1698 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
1700 /* Output all the symbols we have */
1703 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1705 asymbol
*symbol
= *p
;
1706 coff_symbol_type
*c_symbol
= coff_symbol_from(abfd
, symbol
);
1708 if (c_symbol
== (coff_symbol_type
*) NULL
||
1709 c_symbol
->native
== (combined_entry_type
*)NULL
)
1711 written
= coff_write_alien_symbol(abfd
, symbol
, written
);
1715 written
= coff_write_native_symbol(abfd
, c_symbol
, written
);
1720 bfd_get_symcount(abfd
) = written
;
1722 /* Now write out strings */
1724 if (string_size
!= 0)
1726 unsigned int size
= string_size
+ 4;
1729 bfd_h_put_32(abfd
, size
, buffer
);
1730 bfd_write((PTR
) buffer
, 1, sizeof(buffer
), abfd
);
1731 for (p
= abfd
->outsymbols
, i
= 0;
1736 size_t name_length
= strlen(q
->name
);
1738 coff_symbol_type
* c_symbol
= coff_symbol_from(abfd
, q
);
1739 maxlen
= ((c_symbol
!= NULL
&& c_symbol
->native
!= NULL
) &&
1740 (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
)) ?
1741 FILNMLEN
: SYMNMLEN
;
1743 if (name_length
> maxlen
) {
1744 bfd_write((PTR
) (q
->name
), 1, name_length
+ 1, abfd
);
1749 /* We would normally not write anything here, but we'll write
1750 out 4 so that any stupid coff reader which tries to read
1751 the string table even when there isn't one won't croak.
1754 uint32e_type size
= 4;
1756 bfd_write((PTR
)&size
, 1, sizeof(size
), abfd
);
1765 To write relocations, all the back end does is step though the
1766 canonical relocation table, and create an
1767 @code{internal_reloc}. The symbol index to use is removed from
1768 the @code{offset} field in the symbol table supplied, the
1769 address comes directly from the sum of the section base
1770 address and the relocation offset and the type is dug directly
1771 from the howto field. Then the @code{internal_reloc} is
1772 swapped into the shape of an @code{external_reloc} and written
1778 DEFUN(coff_write_relocs
,(abfd
),
1782 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1784 struct external_reloc dst
;
1786 arelent
**p
= s
->orelocation
;
1787 bfd_seek(abfd
, s
->rel_filepos
, SEEK_SET
);
1788 for (i
= 0; i
< s
->reloc_count
; i
++) {
1789 struct internal_reloc n
;
1791 memset((PTR
)&n
, 0, sizeof(n
));
1794 #ifndef SWAP_OUT_RELOC_OFFSET
1795 /* @@FIXME COFF relocs don't support addends. Code should probably be
1796 in the target-independent code, using a target flag to decide whether
1797 to fold the addend into the section contents. */
1803 n
.r_vaddr
= q
->address
+ s
->vma
;
1804 /* The 29k const/consth reloc pair is a real kludge - the consth
1805 part doesn't have a symbol - it has an offset. So rebuilt
1808 if (q
->howto
->type
== R_IHCONST
)
1809 n
.r_symndx
= q
->addend
;
1813 if (q
->sym_ptr_ptr
) {
1814 n
.r_symndx
= get_index((*(q
->sym_ptr_ptr
)));
1815 /* Take notice if the symbol reloc points to a symbol we don't have
1816 in our symbol table. What should we do for this?? */
1817 if (n
.r_symndx
> obj_conv_table_size (abfd
))
1821 /* Work out reloc type from what is required */
1822 SELECT_RELOC(n
.r_type
, q
->howto
);
1824 n
.r_type
= q
->howto
->type
;
1826 coff_swap_reloc_out(abfd
, &n
, &dst
);
1827 bfd_write((PTR
) &dst
, 1, RELSZ
, abfd
);
1831 #endif /* NO_COFF_SYMBOLS */
1833 #ifndef NO_COFF_LINENOS
1836 DEFUN(coff_write_linenumbers
,(abfd
),
1840 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1841 if (s
->lineno_count
) {
1842 asymbol
**q
= abfd
->outsymbols
;
1843 bfd_seek(abfd
, s
->line_filepos
, SEEK_SET
);
1844 /* Find all the linenumbers in this section */
1847 alent
*l
= BFD_SEND(p
->the_bfd
, _get_lineno
, (p
->the_bfd
, p
));
1849 /* Found a linenumber entry, output */
1850 struct internal_lineno out
;
1852 memset( (PTR
)&out
, 0, sizeof(out
));
1854 out
.l_addr
.l_symndx
= l
->u
.offset
;
1855 coff_swap_lineno_out(abfd
, &out
, &buff
);
1856 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1858 while (l
->line_number
) {
1859 out
.l_lnno
= l
->line_number
;
1860 out
.l_addr
.l_symndx
= l
->u
.offset
;
1861 coff_swap_lineno_out(abfd
, &out
, &buff
);
1862 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1873 DEFUN(coff_get_lineno
,(ignore_abfd
, symbol
),
1874 bfd
*ignore_abfd AND
1877 return coffsymbol(symbol
)->lineno
;
1880 #endif /* NO_COFF_LINENOS */
1883 coff_make_empty_symbol(abfd
)
1886 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc(abfd
, sizeof(coff_symbol_type
));
1888 bfd_error
= no_memory
;
1891 new->symbol
.section
= 0;
1893 new->lineno
= (alent
*) NULL
;
1894 new->done_lineno
= false;
1895 new->symbol
.the_bfd
= abfd
;
1896 return &new->symbol
;
1899 #ifndef NO_COFF_SYMBOLS
1902 DEFUN (coff_make_debug_symbol
, (abfd
, ptr
, sz
),
1907 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc(abfd
, sizeof(coff_symbol_type
));
1909 bfd_error
= no_memory
;
1912 /* @@ This shouldn't be using a constant multiplier. */
1913 new->native
= (combined_entry_type
*) bfd_zalloc (abfd
, sizeof (combined_entry_type
) * 10);
1914 new->symbol
.section
= &bfd_debug_section
;
1915 new->lineno
= (alent
*) NULL
;
1916 new->done_lineno
= false;
1917 new->symbol
.the_bfd
= abfd
;
1918 return &new->symbol
;
1922 DEFUN(coff_print_symbol
,(ignore_abfd
, filep
, symbol
, how
),
1923 bfd
*ignore_abfd AND
1926 bfd_print_symbol_type how
)
1928 FILE *file
= (FILE *)filep
;
1930 case bfd_print_symbol_name
:
1931 fprintf(file
, "%s", symbol
->name
);
1933 case bfd_print_symbol_more
:
1934 fprintf(file
, "coff %lx %lx", (unsigned long) coffsymbol(symbol
)->native
,
1935 (unsigned long) coffsymbol(symbol
)->lineno
);
1937 case bfd_print_symbol_nm
:
1940 CONST
char *section_name
= symbol
->section
->name
;
1941 bfd_print_symbol_vandf((PTR
) file
, symbol
);
1944 fprintf(file
, " %-5s %s %s %s",
1946 coffsymbol(symbol
)->native
? "n" : "g",
1947 coffsymbol(symbol
)->lineno
? "l" : " ",
1953 case bfd_print_symbol_all
:
1954 /* Print out the symbols in a reasonable way */
1956 CONST
char *section_name
= symbol
->section
->name
;
1959 if (coffsymbol(symbol
)->native
)
1962 combined_entry_type
*combined
= coffsymbol(symbol
)->native
;
1963 combined_entry_type
*root
= obj_raw_syments(ignore_abfd
);
1965 fprintf(file
,"[%3d]",
1969 fprintf(file
, "(sc %2d)(fl%4x)(ty%3x)(sc%3d) nx(%d) %08x %s",
1970 combined
->u
.syment
.n_scnum
,
1971 combined
->u
.syment
.n_flags
,
1972 combined
->u
.syment
.n_type
,
1973 combined
->u
.syment
.n_sclass
,
1974 combined
->u
.syment
.n_numaux
,
1975 combined
->u
.syment
.n_value
,
1978 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
1981 switch (combined
->u
.syment
.n_sclass
) {
1983 fprintf(file
, "File ");
1986 fprintf(file
, "AUX lnno %x size %x tagndx %x",
1987 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
1988 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
1989 combined
[aux
+1].u
.auxent
.x_sym
.x_tagndx
.l
);
1997 struct lineno_cache_entry
*l
= coffsymbol(symbol
)->lineno
;
2000 printf("\n%s :", l
->u
.sym
->name
);
2002 while (l
->line_number
)
2004 printf("\n%4d : %x",
2018 bfd_print_symbol_vandf((PTR
) file
, symbol
);
2019 fprintf(file
, " %-5s %s %s %s",
2021 coffsymbol(symbol
)->native
? "n" : "g",
2022 coffsymbol(symbol
)->lineno
? "l" : " ",
2031 #endif /* NO_COFF_SYMBOLS */
2033 /* Set flags and magic number of a coff file from architecture and machine
2034 type. Result is true if we can represent the arch&type, false if not. */
2037 DEFUN(coff_set_flags
,(abfd
, magicp
, flagsp
),
2039 unsigned *magicp AND
2040 unsigned short *flagsp
)
2042 switch (bfd_get_arch(abfd
)) {
2050 *magicp
= I960ROMAGIC
;
2052 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2053 I960RWMAGIC); FIXME???
2055 switch (bfd_get_mach(abfd
)) {
2056 case bfd_mach_i960_core
:
2059 case bfd_mach_i960_kb_sb
:
2062 case bfd_mach_i960_mc
:
2065 case bfd_mach_i960_xa
:
2068 case bfd_mach_i960_ca
:
2071 case bfd_mach_i960_ka_sa
:
2084 *magicp
= MIPS_MAGIC_2
;
2090 *magicp
= I386MAGIC
;
2095 *magicp
= MC68MAGIC
;
2101 *magicp
= MC88OMAGIC
;
2106 case bfd_arch_h8300
:
2107 *magicp
= H8300MAGIC
;
2111 #ifdef A29K_MAGIC_BIG
2113 if (abfd
->xvec
->byteorder_big_p
)
2114 *magicp
= A29K_MAGIC_BIG
;
2116 *magicp
= A29K_MAGIC_LITTLE
;
2122 case bfd_arch_rs6000
:
2123 *magicp
= U802TOCMAGIC
;
2127 default: /* Unknown architecture */
2128 /* return false; -- fall through to "return false" below, to avoid
2129 "statement never reached" errors on the one below. */
2138 DEFUN(coff_set_arch_mach
,(abfd
, arch
, machine
),
2140 enum bfd_architecture arch AND
2141 unsigned long machine
)
2144 unsigned short dummy2
;
2145 bfd_default_set_arch_mach(abfd
, arch
, machine
);
2147 if (arch
!= bfd_arch_unknown
&&
2148 coff_set_flags(abfd
, &dummy1
, &dummy2
) != true)
2149 return false; /* We can't represent this type */
2150 return true; /* We're easy ... */
2154 /* Calculate the file position for each section. */
2157 DEFUN(coff_compute_section_file_positions
,(abfd
),
2161 asection
*previous
= (asection
*)NULL
;
2162 file_ptr sofar
= FILHSZ
;
2164 if (bfd_get_start_address(abfd
))
2166 /* A start address may have been added to the original file. In this
2167 case it will need an optional header to record it. */
2168 abfd
->flags
|= EXEC_P
;
2171 if (abfd
->flags
& EXEC_P
)
2174 sofar
+= abfd
->section_count
* SCNHSZ
;
2175 for (current
= abfd
->sections
;
2176 current
!= (asection
*)NULL
;
2177 current
= current
->next
) {
2179 /* Only deal with sections which have contents */
2180 if (!(current
->flags
& SEC_HAS_CONTENTS
))
2183 /* Align the sections in the file to the same boundary on
2184 which they are aligned in virtual memory. I960 doesn't
2185 do this (FIXME) so we can stay in sync with Intel. 960
2186 doesn't yet page from files... */
2189 /* make sure this section is aligned on the right boundary - by
2190 padding the previous section up if necessary */
2193 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2194 if (previous
!= (asection
*)NULL
) {
2195 previous
->_raw_size
+= sofar
- old_sofar
;
2200 /* FIXME, in demand paged files, the low order bits of the file
2201 offset must match the low order bits of the virtual address.
2202 "Low order" is apparently implementation defined. Add code
2203 here to round sofar up to match the virtual address. */
2205 current
->filepos
= sofar
;
2207 sofar
+= current
->_raw_size
;
2209 /* make sure that this section is of the right size too */
2211 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2212 current
->_raw_size
+= sofar
- old_sofar
;
2217 obj_relocbase(abfd
) = sofar
;
2220 #ifndef NO_COFF_SYMBOLS
2222 coff_section_symbol (abfd
, name
)
2226 asection
*sec
= bfd_get_section_by_name (abfd
, name
);
2228 combined_entry_type
*csym
;
2232 /* create empty symbol */
2236 if (coff_symbol_from (abfd
, sym
))
2237 csym
= coff_symbol_from (abfd
, sym
)->native
;
2240 /* Make sure back-end COFF stuff is there. */
2244 coff_symbol_type sym
;
2245 /* @@FIXME This shouldn't use a fixed size!! */
2246 combined_entry_type e
[10];
2249 f
= (struct foo
*) bfd_alloc_by_size_t (abfd
, sizeof (*f
));
2250 bzero ((char *) f
, sizeof (*f
));
2251 coff_symbol_from (abfd
, sym
)->native
= csym
= f
->e
;
2253 csym
[0].u
.syment
.n_sclass
= C_STAT
;
2254 csym
[0].u
.syment
.n_numaux
= 1;
2255 /* SF_SET_STATICS (sym); @@ ??? */
2258 csym
[1].u
.auxent
.x_scn
.x_scnlen
= sec
->_raw_size
;
2259 csym
[1].u
.auxent
.x_scn
.x_nreloc
= sec
->reloc_count
;
2260 csym
[1].u
.auxent
.x_scn
.x_nlinno
= sec
->lineno_count
;
2264 csym
[1].u
.auxent
.x_scn
.x_scnlen
= 0;
2265 csym
[1].u
.auxent
.x_scn
.x_nreloc
= 0;
2266 csym
[1].u
.auxent
.x_scn
.x_nlinno
= 0;
2271 /* If .file, .text, .data, .bss symbols are missing, add them. */
2272 /* @@ Should we only be adding missing symbols, or overriding the aux
2273 values for existing section symbols? */
2275 coff_add_missing_symbols (abfd
)
2278 unsigned int nsyms
= bfd_get_symcount (abfd
);
2279 asymbol
**sympp
= abfd
->outsymbols
;
2282 int need_text
= 1, need_data
= 1, need_bss
= 1, need_file
= 1;
2283 coff_data_type
*cdata
= coff_data (abfd
);
2285 for (i
= 0; i
< nsyms
; i
++)
2287 coff_symbol_type
*csym
= coff_symbol_from (abfd
, sympp
[i
]);
2291 /* only do this if there is a coff representation of the input
2293 if (csym
->native
&& csym
->native
->u
.syment
.n_sclass
== C_FILE
)
2298 name
= csym
->symbol
.name
;
2301 if (!strcmp (name
, _TEXT
))
2303 else if (!strcmp (name
, _DATA
))
2305 else if (!strcmp (name
, _BSS
))
2309 /* Now i == bfd_get_symcount (abfd). */
2310 /* @@ For now, don't deal with .file symbol. */
2313 if (!need_text
&& !need_data
&& !need_bss
&& !need_file
)
2315 nsyms
+= need_text
+ need_data
+ need_bss
+ need_file
;
2316 sympp2
= (asymbol
**) bfd_alloc_by_size_t (abfd
, nsyms
* sizeof (asymbol
*));
2317 memcpy (sympp2
, sympp
, i
* sizeof (asymbol
*));
2320 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
2324 sympp2
[i
++] = coff_section_symbol (abfd
, _TEXT
);
2326 sympp2
[i
++] = coff_section_symbol (abfd
, _DATA
);
2328 sympp2
[i
++] = coff_section_symbol (abfd
, _BSS
);
2329 BFD_ASSERT (i
== nsyms
);
2330 bfd_set_symtab (abfd
, sympp2
, nsyms
);
2332 #endif /* NO_COFF_SYMBOLS */
2337 DEFUN(coff_write_object_contents
,(abfd
),
2343 boolean hasrelocs
= false;
2344 boolean haslinno
= false;
2345 file_ptr reloc_base
;
2346 file_ptr lineno_base
;
2350 unsigned long reloc_size
= 0;
2351 unsigned long lnno_size
= 0;
2352 asection
*text_sec
= NULL
;
2353 asection
*data_sec
= NULL
;
2354 asection
*bss_sec
= NULL
;
2356 struct internal_filehdr internal_f
;
2357 struct internal_aouthdr internal_a
;
2360 bfd_error
= system_call_error
;
2361 /* Number the output sections, starting from one on the first section
2362 with a name which doesn't start with a *.
2363 @@ The code doesn't make this check. Is it supposed to be done,
2366 for (current
= abfd
->sections
; current
!= (asection
*)NULL
;
2367 current
= current
->next
)
2369 current
->target_index
= count
;
2377 if(abfd
->output_has_begun
== false) {
2378 coff_compute_section_file_positions(abfd
);
2381 if (abfd
->sections
!= (asection
*)NULL
) {
2382 scn_base
= abfd
->sections
->filepos
;
2387 if (bfd_seek(abfd
, scn_base
, SEEK_SET
) != 0)
2389 reloc_base
= obj_relocbase(abfd
);
2391 /* Make a pass through the symbol table to count line number entries and
2392 put them into the correct asections */
2394 #ifndef NO_COFF_LINENOS
2395 coff_count_linenumbers(abfd
);
2397 data_base
= scn_base
;
2399 /* Work out the size of the reloc and linno areas */
2401 for (current
= abfd
->sections
; current
!= NULL
; current
=
2404 /* We give section headers to +ve indexes */
2405 if (current
->target_index
> 0)
2408 reloc_size
+= current
->reloc_count
* RELSZ
;
2409 #ifndef NO_COFF_LINENOS
2410 lnno_size
+= current
->lineno_count
* LINESZ
;
2412 data_base
+= SCNHSZ
;
2417 lineno_base
= reloc_base
+ reloc_size
;
2418 sym_base
= lineno_base
+ lnno_size
;
2420 /* Indicate in each section->line_filepos its actual file address */
2421 for (current
= abfd
->sections
; current
!= NULL
; current
=
2424 if (current
->target_index
> 0)
2427 if (current
->lineno_count
) {
2428 current
->line_filepos
= lineno_base
;
2429 current
->moving_line_filepos
= lineno_base
;
2430 #ifndef NO_COFF_LINENOS
2431 lineno_base
+= current
->lineno_count
* LINESZ
;
2435 current
->line_filepos
= 0;
2437 if (current
->reloc_count
) {
2438 current
->rel_filepos
= reloc_base
;
2439 reloc_base
+= current
->reloc_count
* RELSZ
;
2442 current
->rel_filepos
= 0;
2449 /* Write section headers to the file. */
2450 internal_f
.f_nscns
= 0;
2452 (file_ptr
) ((abfd
->flags
& EXEC_P
) ?
2453 (FILHSZ
+ AOUTSZ
) : FILHSZ
),
2458 unsigned int pad
= abfd
->flags
& D_PAGED
? data_base
: 0;
2460 unsigned int pad
= 0;
2462 for (current
= abfd
->sections
;
2464 current
= current
->next
) {
2465 struct internal_scnhdr section
;
2466 if (current
->target_index
> 0)
2468 internal_f
.f_nscns
++;
2469 strncpy(&(section
.s_name
[0]), current
->name
, 8);
2470 section
.s_vaddr
= current
->vma
+ pad
;
2471 section
.s_paddr
= current
->vma
+ pad
;
2472 section
.s_size
= current
->_raw_size
- pad
;
2474 If this section has no size or is unloadable then the scnptr
2477 if (current
->_raw_size
- pad
== 0 ||
2478 (current
->flags
& SEC_LOAD
) == 0) {
2479 section
.s_scnptr
= 0;
2482 section
.s_scnptr
= current
->filepos
;
2484 section
.s_relptr
= current
->rel_filepos
;
2485 section
.s_lnnoptr
= current
->line_filepos
;
2486 section
.s_nreloc
= current
->reloc_count
;
2487 section
.s_nlnno
= current
->lineno_count
;
2488 if (current
->reloc_count
!= 0)
2490 if (current
->lineno_count
!= 0)
2493 section
.s_flags
= sec_to_styp_flags(current
->name
,current
->flags
);
2495 if (!strcmp(current
->name
, _TEXT
)) {
2497 } else if (!strcmp(current
->name
, _DATA
)) {
2499 } else if (!strcmp(current
->name
, _BSS
)) {
2504 section
.s_align
= (current
->alignment_power
2505 ? 1 << current
->alignment_power
2512 coff_swap_scnhdr_out(abfd
, §ion
, &buff
);
2513 bfd_write((PTR
) (&buff
), 1, SCNHSZ
, abfd
);
2523 /* OK, now set up the filehdr... */
2525 /* Don't include the internal abs section in the section count */
2528 We will NOT put a fucking timestamp in the header here. Every time you
2529 put it back, I will come in and take it out again. I'm sorry. This
2530 field does not belong here. We fill it with a 0 so it compares the
2531 same but is not a reasonable time. -- gnu@cygnus.com
2534 Well, I like it, and now we have *customers* who have requested it,
2535 so I'm conditionally compiling it in.
2539 #ifndef NOCOFF_TIMESTAMP
2540 internal_f
.f_timdat
= time(0);
2542 internal_f
.f_timdat
= 0;
2545 if (bfd_get_symcount(abfd
) != 0)
2546 internal_f
.f_symptr
= sym_base
;
2548 internal_f
.f_symptr
= 0;
2550 internal_f
.f_flags
= 0;
2552 if (abfd
->flags
& EXEC_P
)
2553 internal_f
.f_opthdr
= AOUTSZ
;
2555 internal_f
.f_opthdr
= 0;
2558 internal_f
.f_flags
|= F_RELFLG
;
2560 internal_f
.f_flags
|= F_LNNO
;
2561 if (0 == bfd_get_symcount(abfd
))
2562 internal_f
.f_flags
|= F_LSYMS
;
2563 if (abfd
->flags
& EXEC_P
)
2564 internal_f
.f_flags
|= F_EXEC
;
2566 if (!abfd
->xvec
->byteorder_big_p
)
2567 internal_f
.f_flags
|= F_AR32WR
;
2569 internal_f
.f_flags
|= F_AR32W
;
2572 FIXME, should do something about the other byte orders and
2576 /* Set up architecture-dependent stuff */
2578 { unsigned int magic
= 0;
2579 unsigned short flags
= 0;
2580 coff_set_flags(abfd
, &magic
, &flags
);
2581 internal_f
.f_magic
= magic
;
2582 internal_f
.f_flags
|= flags
;
2583 /* ...and the "opt"hdr... */
2586 # ifdef ULTRA3 /* NYU's machine */
2587 /* FIXME: This is a bogus check. I really want to see if there
2588 * is a .shbss or a .shdata section, if so then set the magic
2589 * number to indicate a shared data executable.
2591 if (internal_f
.f_nscns
>= 7)
2592 internal_a
.magic
= SHMAGIC
; /* Shared magic */
2594 # endif /* ULTRA3 */
2595 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
2596 #define __A_MAGIC_SET__
2599 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
2600 #define __A_MAGIC_SET__
2603 #define __A_MAGIC_SET__
2604 internal_a
.magic
= PAGEMAGICBCS
;
2607 #if M68 || I386 || MIPS
2608 #define __A_MAGIC_SET__
2609 /* Never was anything here for the 68k */
2613 #define __A_MAGIC_SET__
2614 internal_a
.magic
= (abfd
->flags
& D_PAGED
)? RS6K_AOUTHDR_ZMAGIC
:
2615 (abfd
->flags
& WP_TEXT
)? RS6K_AOUTHDR_NMAGIC
:
2616 RS6K_AOUTHDR_OMAGIC
;
2619 #ifndef __A_MAGIC_SET__
2620 # include "Your aouthdr magic number is not being set!"
2622 # undef __A_MAGIC_SET__
2625 /* Now should write relocs, strings, syms */
2626 obj_sym_filepos(abfd
) = sym_base
;
2628 #ifndef NO_COFF_SYMBOLS
2629 if (bfd_get_symcount(abfd
) != 0) {
2630 coff_add_missing_symbols (abfd
);
2631 coff_renumber_symbols(abfd
);
2632 coff_mangle_symbols(abfd
);
2633 coff_write_symbols(abfd
);
2634 coff_write_linenumbers(abfd
);
2635 coff_write_relocs(abfd
);
2637 #endif /* NO_COFF_SYMBOLS */
2639 internal_a
.tsize
= bfd_get_section_size_before_reloc(text_sec
);
2640 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
2643 internal_a
.dsize
= bfd_get_section_size_before_reloc(data_sec
);
2644 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
2647 internal_a
.bsize
= bfd_get_section_size_before_reloc(bss_sec
);
2650 internal_a
.entry
= bfd_get_start_address(abfd
);
2651 internal_f
.f_nsyms
= bfd_get_symcount(abfd
);
2653 /* now write them */
2654 if (bfd_seek(abfd
, 0L, SEEK_SET
) != 0)
2658 coff_swap_filehdr_out(abfd
, (PTR
)&internal_f
, (PTR
)&buff
);
2659 bfd_write((PTR
) &buff
, 1, FILHSZ
, abfd
);
2661 if (abfd
->flags
& EXEC_P
) {
2663 coff_swap_aouthdr_out(abfd
, (PTR
)&internal_a
, (PTR
)&buff
);
2664 bfd_write((PTR
) &buff
, 1, AOUTSZ
, abfd
);
2669 #ifndef NO_COFF_SYMBOLS
2672 this function transforms the offsets into the symbol table into
2673 pointers to syments.
2678 DEFUN(coff_pointerize_aux
,(ignore_abfd
, table_base
, type
, class, auxent
),
2679 bfd
*ignore_abfd AND
2680 combined_entry_type
*table_base AND
2683 combined_entry_type
*auxent
)
2685 /* Don't bother if this is a file or a section */
2686 if (class == C_STAT
&& type
== T_NULL
) return;
2687 if (class == C_FILE
) return;
2689 /* Otherwise patch up */
2690 if (ISFCN(type
) || ISTAG(class) || class == C_BLOCK
) {
2691 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
= table_base
+
2692 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2693 auxent
->fix_end
= 1;
2695 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
!= 0) {
2696 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
=
2697 table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
2698 auxent
->fix_tag
= 1;
2702 #endif /* NO_COFF_SYMBOLS */
2705 DEFUN(coff_set_section_contents
,(abfd
, section
, location
, offset
, count
),
2710 bfd_size_type count
)
2712 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
2713 coff_compute_section_file_positions(abfd
);
2715 bfd_seek(abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
);
2718 return (bfd_write(location
, 1, count
, abfd
) == count
) ? true : false;
2724 coff_close_and_cleanup(abfd
)
2727 if (!bfd_read_p(abfd
))
2728 switch (abfd
->format
) {
2730 if (!_bfd_write_archive_contents(abfd
))
2734 if (!coff_write_object_contents(abfd
))
2738 bfd_error
= invalid_operation
;
2742 /* We depend on bfd_close to free all the memory on the obstack. */
2743 /* FIXME if bfd_release is not using obstacks! */
2749 buy_and_read(abfd
, where
, seek_direction
, size
)
2755 PTR area
= (PTR
) bfd_alloc(abfd
, size
);
2757 bfd_error
= no_memory
;
2760 bfd_seek(abfd
, where
, seek_direction
);
2761 if (bfd_read(area
, 1, size
, abfd
) != size
) {
2762 bfd_error
= system_call_error
;
2766 } /* buy_and_read() */
2769 #ifndef NO_COFF_SYMBOLS
2772 DEFUN(build_string_table
,(abfd
),
2775 char string_table_size_buffer
[4];
2776 unsigned int string_table_size
;
2779 /* At this point we should be "seek"'d to the end of the
2780 symbols === the symbol table size. */
2781 if (bfd_read((char *) string_table_size_buffer
,
2782 sizeof(string_table_size_buffer
),
2783 1, abfd
) != sizeof(string_table_size
)) {
2784 bfd_error
= system_call_error
;
2788 string_table_size
= bfd_h_get_32(abfd
, (bfd_byte
*) string_table_size_buffer
);
2790 if ((string_table
= (PTR
) bfd_alloc(abfd
, string_table_size
-= 4)) == NULL
) {
2791 bfd_error
= no_memory
;
2793 } /* on mallocation error */
2794 if (bfd_read(string_table
, string_table_size
, 1, abfd
) != string_table_size
) {
2795 bfd_error
= system_call_error
;
2798 return string_table
;
2801 /* Allocate space for the ".debug" section, and read it.
2802 We did not read the debug section until now, because
2803 we didn't want to go to the trouble until someone needed it. */
2806 DEFUN(build_debug_section
,(abfd
),
2809 char *debug_section
;
2812 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
2815 bfd_error
= no_debug_section
;
2819 debug_section
= (PTR
) bfd_alloc (abfd
,
2820 bfd_get_section_size_before_reloc (sect
));
2821 if (debug_section
== NULL
) {
2822 bfd_error
= no_memory
;
2826 /* Seek to the beginning of the `.debug' section and read it.
2827 Save the current position first; it is needed by our caller.
2828 Then read debug section and reset the file pointer. */
2830 position
= bfd_tell (abfd
);
2831 bfd_seek (abfd
, sect
->filepos
, SEEK_SET
);
2832 if (bfd_read (debug_section
,
2833 bfd_get_section_size_before_reloc (sect
), 1, abfd
)
2834 != bfd_get_section_size_before_reloc(sect
)) {
2835 bfd_error
= system_call_error
;
2838 bfd_seek (abfd
, position
, SEEK_SET
);
2839 return debug_section
;
2843 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
2844 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
2845 be \0-terminated. */
2847 DEFUN(copy_name
,(abfd
, name
, maxlen
),
2855 for (len
= 0; len
< maxlen
; ++len
) {
2856 if (name
[len
] == '\0') {
2861 if ((newname
= (PTR
) bfd_alloc(abfd
, len
+1)) == NULL
) {
2862 bfd_error
= no_memory
;
2865 strncpy(newname
, name
, len
);
2866 newname
[len
] = '\0';
2871 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
2872 knit the symbol names into a normalized form. By normalized here I
2873 mean that all symbols have an n_offset pointer that points to a null-
2874 terminated string. */
2876 #ifndef SYMNAME_IN_DEBUG
2877 #define SYMNAME_IN_DEBUG(x) 0
2880 static combined_entry_type
*
2881 DEFUN(get_normalized_symtab
,(abfd
),
2884 combined_entry_type
*internal
;
2885 combined_entry_type
*internal_ptr
;
2886 combined_entry_type
*symbol_ptr
;
2887 combined_entry_type
*internal_end
;
2891 char *string_table
= NULL
;
2892 char *debug_section
= NULL
;
2895 unsigned int raw_size
;
2896 if (obj_raw_syments(abfd
) != (combined_entry_type
*)NULL
) {
2897 return obj_raw_syments(abfd
);
2899 if ((size
= bfd_get_symcount(abfd
) * sizeof(combined_entry_type
)) == 0) {
2900 bfd_error
= no_symbols
;
2904 internal
= (combined_entry_type
*)bfd_alloc(abfd
, size
);
2905 internal_end
= internal
+ bfd_get_symcount(abfd
);
2907 raw_size
= bfd_get_symcount(abfd
) * SYMESZ
;
2908 raw
= (SYMENT
*)bfd_alloc(abfd
,raw_size
);
2910 if (bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
) == -1
2911 || bfd_read((PTR
)raw
, raw_size
, 1, abfd
) != raw_size
) {
2912 bfd_error
= system_call_error
;
2915 /* mark the end of the symbols */
2916 raw_end
= raw
+ bfd_get_symcount(abfd
);
2918 FIXME SOMEDAY. A string table size of zero is very weird, but
2919 probably possible. If one shows up, it will probably kill us.
2922 /* Swap all the raw entries */
2923 for (raw_src
= raw
, internal_ptr
= internal
;
2925 raw_src
++, internal_ptr
++) {
2928 coff_swap_sym_in(abfd
, (PTR
)raw_src
, (PTR
)&internal_ptr
->u
.syment
);
2929 internal_ptr
->fix_tag
= 0;
2930 internal_ptr
->fix_end
= 0;
2931 symbol_ptr
= internal_ptr
;
2934 i
< symbol_ptr
->u
.syment
.n_numaux
;
2940 internal_ptr
->fix_tag
= 0;
2941 internal_ptr
->fix_end
= 0;
2942 coff_swap_aux_in(abfd
, (char *)(raw_src
),
2943 symbol_ptr
->u
.syment
.n_type
,
2944 symbol_ptr
->u
.syment
.n_sclass
,
2945 &(internal_ptr
->u
.auxent
));
2946 /* Remember that bal entries arn't pointerized */
2947 if (i
!= 1 || symbol_ptr
->u
.syment
.n_sclass
!= C_LEAFPROC
)
2950 coff_pointerize_aux(abfd
,
2952 symbol_ptr
->u
.syment
.n_type
,
2953 symbol_ptr
->u
.syment
.n_sclass
,
2960 /* Free all the raw stuff */
2961 bfd_release(abfd
, raw
);
2963 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
2966 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
) {
2967 /* make a file symbol point to the name in the auxent, since
2968 the text ".file" is redundant */
2969 if ((internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_zeroes
== 0) {
2970 /* the filename is a long one, point into the string table */
2971 if (string_table
== NULL
) {
2972 string_table
= build_string_table(abfd
);
2975 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
2976 (int) (string_table
- 4 +
2977 (internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_offset
);
2980 /* ordinary short filename, put into memory anyway */
2981 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2982 copy_name(abfd
, (internal_ptr
+1)->u
.auxent
.x_file
.x_fname
,
2987 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0) {
2988 /* This is a "short" name. Make it long. */
2989 unsigned long i
= 0;
2990 char *newstring
= NULL
;
2992 /* find the length of this string without walking into memory
2994 for (i
= 0; i
< 8; ++i
) {
2995 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0') {
2997 } /* if end of string */
2998 } /* possible lengths of this string. */
3000 if ((newstring
= (PTR
) bfd_alloc(abfd
, ++i
)) == NULL
) {
3001 bfd_error
= no_memory
;
3004 bzero(newstring
, i
);
3005 strncpy(newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
-1);
3006 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int) newstring
;
3007 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
3009 else if (!SYMNAME_IN_DEBUG(&internal_ptr
->u
.syment
)) {
3010 /* Long name already. Point symbol at the string in the table. */
3011 if (string_table
== NULL
) {
3012 string_table
= build_string_table(abfd
);
3014 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
3015 (string_table
- 4 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
3018 /* Long name in debug section. Very similar. */
3019 if (debug_section
== NULL
) {
3020 debug_section
= build_debug_section(abfd
);
3022 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
3023 (debug_section
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
3026 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
3029 obj_raw_syments(abfd
) = internal
;
3032 } /* get_normalized_symtab() */
3034 #endif /* NO_COFF_SYMBOLS */
3038 DEFUN(section_from_bfd_index
,(abfd
, index
),
3042 struct sec
*answer
= abfd
->sections
;
3046 return &bfd_abs_section
;
3048 if (index
== N_UNDEF
)
3050 return &bfd_und_section
;
3052 if(index
== N_DEBUG
)
3054 return &bfd_debug_section
;
3059 if (answer
->target_index
== index
)
3061 answer
= answer
->next
;
3064 return &bfd_und_section
; /* For gcc -W and lint. Never executed. */
3067 #ifndef NO_COFF_LINENOS
3073 Creating the linenumber table is done by reading in the entire
3074 coff linenumber table, and creating another table for internal use.
3076 A coff line number table is structured so that each function
3077 is marked as having a line number of 0. Each line within the
3078 function is an offset from the first line in the function. The
3079 base of the line number information for the table is stored in
3080 the symbol associated with the function.
3082 The information is copied from the external to the internal
3083 table, and each symbol which marks a function is marked by
3086 How does this work ?
3091 coff_slurp_line_table(abfd
, asect
)
3095 LINENO
*native_lineno
;
3096 alent
*lineno_cache
;
3098 BFD_ASSERT(asect
->lineno
== (alent
*) NULL
);
3100 native_lineno
= (LINENO
*) buy_and_read(abfd
,
3101 asect
->line_filepos
,
3104 asect
->lineno_count
));
3106 (alent
*) bfd_alloc(abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof(alent
)));
3107 if (lineno_cache
== NULL
) {
3108 bfd_error
= no_memory
;
3111 unsigned int counter
= 0;
3112 alent
*cache_ptr
= lineno_cache
;
3113 LINENO
*src
= native_lineno
;
3115 while (counter
< asect
->lineno_count
) {
3116 struct internal_lineno dst
;
3117 coff_swap_lineno_in(abfd
, src
, &dst
);
3118 cache_ptr
->line_number
= dst
.l_lnno
;
3120 if (cache_ptr
->line_number
== 0) {
3121 coff_symbol_type
*sym
=
3122 (coff_symbol_type
*) (dst
.l_addr
.l_symndx
3123 + obj_raw_syments(abfd
))->u
.syment
._n
._n_n
._n_zeroes
;
3124 cache_ptr
->u
.sym
= (asymbol
*) sym
;
3125 sym
->lineno
= cache_ptr
;
3128 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
3129 - bfd_section_vma(abfd
, asect
);
3130 } /* If no linenumber expect a symbol index */
3136 cache_ptr
->line_number
= 0;
3139 asect
->lineno
= lineno_cache
;
3140 /* FIXME, free native_lineno here, or use alloca or something. */
3142 } /* coff_slurp_line_table() */
3144 #endif /* NO_COFF_LINENOS */
3146 #ifndef NO_COFF_LINENOS
3149 DEFUN(coff_slurp_symbol_table
,(abfd
),
3152 combined_entry_type
*native_symbols
;
3153 coff_symbol_type
*cached_area
;
3154 unsigned int *table_ptr
;
3156 unsigned int number_of_symbols
= 0;
3157 if (obj_symbols(abfd
))
3159 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
3161 /* Read in the symbol table */
3162 if ((native_symbols
= get_normalized_symtab(abfd
)) == NULL
) {
3166 /* Allocate enough room for all the symbols in cached form */
3168 (coff_symbol_type
*)
3169 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(coff_symbol_type
)));
3171 if (cached_area
== NULL
) {
3172 bfd_error
= no_memory
;
3177 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(unsigned int)));
3179 if (table_ptr
== NULL
) {
3180 bfd_error
= no_memory
;
3185 coff_symbol_type
*dst
= cached_area
;
3186 unsigned int last_native_index
= bfd_get_symcount(abfd
);
3187 unsigned int this_index
= 0;
3188 while (this_index
< last_native_index
) {
3189 combined_entry_type
*src
= native_symbols
+ this_index
;
3190 table_ptr
[this_index
] = number_of_symbols
;
3191 dst
->symbol
.the_bfd
= abfd
;
3193 dst
->symbol
.name
= (char *)(src
->u
.syment
._n
._n_n
._n_offset
);
3195 We use the native name field to point to the cached field
3197 src
->u
.syment
._n
._n_n
._n_zeroes
= (int) dst
;
3198 dst
->symbol
.section
= section_from_bfd_index(abfd
,
3199 src
->u
.syment
.n_scnum
);
3200 dst
->symbol
.flags
= 0;
3201 dst
->done_lineno
= false;
3203 switch (src
->u
.syment
.n_sclass
) {
3207 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
3208 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
3209 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
3211 /* Fall through to next case */
3219 if ((src
->u
.syment
.n_scnum
) == 0) {
3220 if ((src
->u
.syment
.n_value
) == 0) {
3221 dst
->symbol
.section
= &bfd_und_section
;
3222 dst
->symbol
.value
= 0;
3225 dst
->symbol
.section
= &bfd_com_section
;
3226 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3231 Base the value as an index from the base of the
3235 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
3236 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
3238 if (ISFCN((src
->u
.syment
.n_type
))) {
3240 A function ext does not go at the end of a file
3242 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
3249 case C_STAT
: /* static */
3251 case C_LEAFSTAT
: /* static leaf procedure */
3253 case C_LABEL
: /* label */
3254 if (src
->u
.syment
.n_scnum
== -2)
3255 dst
->symbol
.flags
= BSF_DEBUGGING
;
3257 dst
->symbol
.flags
= BSF_LOCAL
;
3259 Base the value as an index from the base of the section, if
3262 if (dst
->symbol
.section
)
3263 dst
->symbol
.value
= (src
->u
.syment
.n_value
) -
3264 dst
->symbol
.section
->vma
;
3266 dst
->symbol
.value
= (src
->u
.syment
.n_value
) ;
3269 case C_MOS
: /* member of structure */
3270 case C_EOS
: /* end of structure */
3271 #ifdef NOTDEF /* C_AUTOARG has the same value */
3273 case C_GLBLREG
: /* A29k-specific storage class */
3276 case C_REGPARM
: /* register parameter */
3277 case C_REG
: /* register variable */
3279 case C_AUTOARG
: /* 960-specific storage class */
3281 case C_TPDEF
: /* type definition */
3283 case C_AUTO
: /* automatic variable */
3284 case C_FIELD
: /* bit field */
3285 case C_ENTAG
: /* enumeration tag */
3286 case C_MOE
: /* member of enumeration */
3287 case C_MOU
: /* member of union */
3288 case C_UNTAG
: /* union tag */
3289 dst
->symbol
.flags
= BSF_DEBUGGING
;
3290 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3293 case C_FILE
: /* file name */
3294 case C_STRTAG
: /* structure tag */
3296 case C_BINCL
: /* beginning of include file */
3297 case C_EINCL
: /* ending of include file */
3310 dst
->symbol
.flags
= BSF_DEBUGGING
;
3311 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3314 case C_BLOCK
: /* ".bb" or ".eb" */
3315 case C_FCN
: /* ".bf" or ".ef" */
3316 case C_EFCN
: /* physical end of function */
3317 dst
->symbol
.flags
= BSF_LOCAL
;
3319 Base the value as an index from the base of the section
3321 dst
->symbol
.value
= (src
->u
.syment
.n_value
) - dst
->symbol
.section
->vma
;
3325 case C_EXTDEF
: /* external definition */
3326 case C_ULABEL
: /* undefined label */
3327 case C_USTATIC
: /* undefined static */
3328 case C_LINE
: /* line # reformatted as symbol table entry */
3329 case C_ALIAS
: /* duplicate tag */
3330 case C_HIDDEN
: /* ext symbol in dmert public lib */
3333 fprintf(stderr
,"Unrecognized storage class %d\n",
3334 src
->u
.syment
.n_sclass
);
3336 dst
->symbol
.flags
= BSF_DEBUGGING
;
3337 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3341 /* BFD_ASSERT(dst->symbol.flags != 0);*/
3345 dst
->symbol
.udata
= 0;
3346 dst
->lineno
= (alent
*) NULL
;
3347 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
3349 number_of_symbols
++;
3350 } /* walk the native symtab */
3351 } /* bfdize the native symtab */
3353 obj_symbols(abfd
) = cached_area
;
3354 obj_raw_syments(abfd
) = native_symbols
;
3356 obj_conv_table_size (abfd
) = bfd_get_symcount (abfd
);
3357 bfd_get_symcount(abfd
) = number_of_symbols
;
3358 obj_convert(abfd
) = table_ptr
;
3359 /* Slurp the line tables for each section too */
3364 coff_slurp_line_table(abfd
, p
);
3369 } /* coff_slurp_symbol_table() */
3372 coff_get_symtab_upper_bound(abfd
)
3375 if (!coff_slurp_symbol_table(abfd
))
3378 return (bfd_get_symcount(abfd
) + 1) * (sizeof(coff_symbol_type
*));
3383 DEFUN(coff_get_symtab
, (abfd
, alocation
),
3385 asymbol
**alocation
)
3387 unsigned int counter
= 0;
3388 coff_symbol_type
*symbase
;
3389 coff_symbol_type
**location
= (coff_symbol_type
**) (alocation
);
3390 if (!coff_slurp_symbol_table(abfd
))
3393 symbase
= obj_symbols(abfd
);
3394 while (counter
< bfd_get_symcount(abfd
))
3396 /* This nasty code looks at the symbol to decide whether or
3397 not it is descibes a constructor/destructor entry point. It
3398 is structured this way to (hopefully) speed non matches */
3400 if (0 && symbase
->symbol
.name
[9] == '$')
3402 bfd_constructor_entry(abfd
,
3403 (asymbol
**)location
,
3404 symbase
->symbol
.name
[10] == 'I' ?
3408 *(location
++) = symbase
++;
3412 return bfd_get_symcount(abfd
);
3415 #endif /* NO_COFF_SYMBOLS */
3418 coff_get_reloc_upper_bound(abfd
, asect
)
3422 if (bfd_get_format(abfd
) != bfd_object
) {
3423 bfd_error
= invalid_operation
;
3426 return (asect
->reloc_count
+ 1) * sizeof(arelent
*);
3433 Coff relocations are easily transformed into the internal BFD form
3436 Reading a coff relocation table is done in the following stages:
3438 o The entire coff relocation table is read into memory.
3440 o Each relocation is processed in turn, first it is swapped from the
3441 external to the internal form.
3443 o The symbol referenced in the relocation's symbol index is
3444 turned intoa pointer into the canonical symbol table. Note
3445 that this table is the same as the one returned by a call to
3446 @code{bfd_canonicalize_symtab}. The back end will call the
3447 routine and save the result if a canonicalization hasn't been done.
3449 o The reloc index is turned into a pointer to a howto
3450 structure, in a back end specific way. For instance, the 386
3451 and 960 use the @code{r_type} to directly produce an index
3452 into a howto table vector; the 88k subtracts a number from the
3453 @code{r_type} field and creates an addend field.
3459 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
3460 if (ptr && ptr->the_bfd == abfd \
3461 && ((ptr->flags & BSF_OLD_COMMON)== 0)) \
3463 cache_ptr->addend = -(ptr->section->vma + ptr->value); \
3466 cache_ptr->addend = 0; \
3471 DEFUN(coff_slurp_reloc_table
,(abfd
, asect
, symbols
),
3476 RELOC
*native_relocs
;
3477 arelent
*reloc_cache
;
3482 if (asect
->relocation
)
3484 if (asect
->reloc_count
== 0)
3486 if (asect
->flags
& SEC_CONSTRUCTOR
)
3488 #ifndef NO_COFF_SYMBOLS
3489 if (!coff_slurp_symbol_table(abfd
))
3493 (RELOC
*) buy_and_read(abfd
,
3497 asect
->reloc_count
));
3498 reloc_cache
= (arelent
*)
3499 bfd_alloc(abfd
, (size_t) (asect
->reloc_count
* sizeof(arelent
)));
3501 if (reloc_cache
== NULL
) {
3502 bfd_error
= no_memory
;
3507 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
3509 #ifdef RELOC_PROCESSING
3510 struct internal_reloc dst
;
3511 struct external_reloc
*src
;
3513 cache_ptr
= reloc_cache
+ idx
;
3514 src
= native_relocs
+ idx
;
3515 bfd_swap_reloc_in(abfd
, src
, &dst
);
3517 RELOC_PROCESSING(cache_ptr
, &dst
, symbols
, abfd
, asect
);
3519 struct internal_reloc dst
;
3521 struct external_reloc
*src
;
3523 cache_ptr
= reloc_cache
+ idx
;
3524 src
= native_relocs
+ idx
;
3526 bfd_swap_reloc_in(abfd
, src
, &dst
);
3529 cache_ptr
->address
= dst
.r_vaddr
;
3531 if (dst
.r_symndx
!= -1)
3533 /* @@ Should never be greater than count of symbols! */
3534 if (dst
.r_symndx
>= obj_conv_table_size (abfd
))
3536 cache_ptr
->sym_ptr_ptr
= symbols
+ obj_convert(abfd
)[dst
.r_symndx
];
3537 ptr
= *(cache_ptr
->sym_ptr_ptr
);
3541 cache_ptr
->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
3546 The symbols definitions that we have read in have been
3547 relocated as if their sections started at 0. But the offsets
3548 refering to the symbols in the raw data have not been
3549 modified, so we have to have a negative addend to compensate.
3551 Note that symbols which used to be common must be left alone */
3553 /* Calculate any reloc addend by looking at the symbol */
3554 CALC_ADDEND(abfd
, ptr
, dst
, cache_ptr
);
3556 cache_ptr
->address
-= asect
->vma
;
3557 /* !! cache_ptr->section = (asection *) NULL;*/
3559 /* Fill in the cache_ptr->howto field from dst.r_type */
3560 RTYPE2HOWTO(cache_ptr
, &dst
);
3565 asect
->relocation
= reloc_cache
;
3570 /* This is stupid. This function should be a boolean predicate */
3572 DEFUN(coff_canonicalize_reloc
, (abfd
, section
, relptr
, symbols
),
3575 arelent
**relptr AND
3578 arelent
*tblptr
= section
->relocation
;
3579 unsigned int count
= 0;
3582 if (section
->flags
& SEC_CONSTRUCTOR
)
3584 /* this section has relocs made up by us, they are not in the
3585 file, so take them out of their chain and place them into
3586 the data area provided */
3587 arelent_chain
*chain
= section
->constructor_chain
;
3588 for (count
= 0; count
< section
->reloc_count
; count
++)
3590 *relptr
++ = &chain
->relent
;
3591 chain
= chain
->next
;
3597 coff_slurp_reloc_table(abfd
, section
, symbols
);
3600 tblptr
= section
->relocation
;
3604 for (; count
++ < section
->reloc_count
;)
3605 *relptr
++ = tblptr
++;
3610 return section
->reloc_count
;
3613 #ifndef NO_COFF_SYMBOLS
3616 provided a BFD, a section and an offset into the section, calculate and
3617 return the name of the source file and the line nearest to the wanted
3622 DEFUN(coff_find_nearest_line
,(abfd
,
3630 asection
*section AND
3631 asymbol
**ignore_symbols AND
3633 CONST
char **filename_ptr AND
3634 CONST
char **functionname_ptr AND
3635 unsigned int *line_ptr
)
3637 static bfd
*cache_abfd
;
3638 static asection
*cache_section
;
3639 static bfd_vma cache_offset
;
3640 static unsigned int cache_i
;
3641 static alent
*cache_l
;
3644 coff_data_type
*cof
= coff_data(abfd
);
3645 /* Run through the raw syments if available */
3646 combined_entry_type
*p
;
3648 unsigned int line_base
= 0;
3652 *functionname_ptr
= 0;
3655 /* Don't try and find line numbers in a non coff file */
3656 if (abfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
3662 p
= cof
->raw_syments
;
3664 for (i
= 0; i
< cof
->raw_syment_count
; i
++) {
3665 if (p
->u
.syment
.n_sclass
== C_FILE
) {
3666 /* File name has been moved into symbol */
3667 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
3670 p
+= 1 + p
->u
.syment
.n_numaux
;
3672 /* Now wander though the raw linenumbers of the section */
3674 If this is the same BFD as we were previously called with and this is
3675 the same section, and the offset we want is further down then we can
3676 prime the lookup loop
3678 if (abfd
== cache_abfd
&&
3679 section
== cache_section
&&
3680 offset
>= cache_offset
) {
3686 l
= section
->lineno
;
3689 for (; i
< section
->lineno_count
; i
++) {
3690 if (l
->line_number
== 0) {
3691 /* Get the symbol this line number points at */
3692 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
3693 *functionname_ptr
= coff
->symbol
.name
;
3695 combined_entry_type
*s
= coff
->native
;
3696 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
3698 S should now point to the .bf of the function
3700 if (s
->u
.syment
.n_numaux
) {
3702 The linenumber is stored in the auxent
3704 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
3705 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
3710 if (l
->u
.offset
> offset
)
3712 *line_ptr
= l
->line_number
+ line_base
+ 1;
3718 cache_section
= section
;
3719 cache_offset
= offset
;
3728 coff_sym_filepos(abfd
)
3731 return obj_sym_filepos(abfd
);
3735 #endif /* NO_COFF_SYMBOLS */
3739 DEFUN(coff_sizeof_headers
,(abfd
, reloc
),
3745 if (reloc
== false) {
3746 size
= FILHSZ
+ AOUTSZ
;
3752 size
+= abfd
->section_count
* SCNHSZ
;
3757 DEFUN(get_value
,(reloc
, seclet
),
3759 bfd_seclet_type
*seclet
)
3762 asymbol
*symbol
= *(reloc
->sym_ptr_ptr
);
3763 /* A symbol holds a pointer to a section, and an offset from the
3764 base of the section. To relocate, we find where the section will
3765 live in the output and add that in */
3767 if (symbol
->section
== &bfd_und_section
)
3769 /* Ouch, this is an undefined symbol.. */
3770 bfd_error_vector
.undefined_symbol(reloc
, seclet
);
3771 value
= symbol
->value
;
3775 value
= symbol
->value
+
3776 symbol
->section
->output_offset
+
3777 symbol
->section
->output_section
->vma
;
3781 /* Add the value contained in the relocation */
3782 value
+= (short)((reloc
->addend
) & 0xffff);
3788 DEFUN(perform_slip
,(s
, slip
, input_section
, value
),
3790 unsigned int slip AND
3791 asection
*input_section AND
3795 /* Find all symbols past this point, and make them know
3800 if (p
->section
== input_section
)
3802 /* This was pointing into this section, so mangle it */
3803 if (p
->value
> value
)
3813 DEFUN(movb1
,(input_section
, symbols
, r
, shrink
),
3814 asection
*input_section AND
3815 asymbol
**symbols AND
3817 unsigned int shrink
)
3819 bfd_vma value
= get_value(r
,0);
3821 if (value
>= 0xff00)
3824 /* Change the reloc type from 16bit, possible 8 to 8bit
3826 r
->howto
= r
->howto
+ 1;
3827 /* The place to relc moves back by one */
3830 /* This will be two bytes smaller in the long run */
3832 perform_slip(symbols
, 2, input_section
, r
->address
- shrink
+1);
3840 DEFUN(jmp1
,(input_section
, symbols
, r
, shrink
),
3841 asection
*input_section AND
3842 asymbol
**symbols AND
3844 unsigned int shrink
)
3848 bfd_vma value
= get_value(r
, 0);
3850 bfd_vma dot
= input_section
->output_section
->vma
+
3851 input_section
->output_offset
+ r
->address
;
3854 /* See if the address we're looking at within 127 bytes of where
3855 we are, if so then we can use a small branch rather than the
3856 jump we were going to */
3858 gap
= value
- (dot
- shrink
);
3861 if (-120 < (long)gap
&& (long)gap
< 120 )
3864 /* Change the reloc type from 16bit, possible 8 to 8bit
3866 r
->howto
= r
->howto
+ 1;
3867 /* The place to relc moves back by one */
3870 /* This will be two bytes smaller in the long run */
3872 perform_slip(symbols
, 2, input_section
, r
->address
-shrink
+1);
3880 DEFUN(bfd_coff_relax_section
,(abfd
, i
, symbols
),
3886 /* Get enough memory to hold the stuff */
3887 bfd
*input_bfd
= i
->owner
;
3888 asection
*input_section
= i
;
3890 boolean
new = false;
3892 bfd_size_type reloc_size
= bfd_get_reloc_upper_bound(input_bfd
,
3894 arelent
**reloc_vector
= (arelent
**)bfd_xmalloc(reloc_size
);
3896 /* Get the relocs and think about them */
3897 if (bfd_canonicalize_reloc(input_bfd
,
3903 for (parent
= reloc_vector
; *parent
; parent
++)
3905 arelent
*r
= *parent
;
3906 switch (r
->howto
->type
) {
3914 shrink
= movb1(input_section
, symbols
, r
, shrink
);
3919 shrink
= jmp1(input_section
, symbols
, r
, shrink
);
3927 input_section
->_cooked_size
-= shrink
;
3928 free((char *)reloc_vector
);
3933 DEFUN(bfd_coff_get_relocated_section_contents
,(in_abfd
, seclet
, data
),
3935 bfd_seclet_type
*seclet AND
3939 /* Get enough memory to hold the stuff */
3940 bfd
*input_bfd
= seclet
->u
.indirect
.section
->owner
;
3941 asection
*input_section
= seclet
->u
.indirect
.section
;
3942 bfd_size_type reloc_size
= bfd_get_reloc_upper_bound(input_bfd
,
3944 arelent
**reloc_vector
= (arelent
**)bfd_xmalloc(reloc_size
);
3946 /* read in the section */
3947 bfd_get_section_contents(input_bfd
,
3951 input_section
->_raw_size
);
3954 if (bfd_canonicalize_reloc(input_bfd
,
3957 seclet
->u
.indirect
.symbols
) )
3959 arelent
**parent
= reloc_vector
;
3964 unsigned int dst_address
= 0;
3965 unsigned int src_address
= 0;
3969 /* Find how long a run we can do */
3970 while (dst_address
< seclet
->size
)
3976 /* Note that the relaxing didn't tie up the addresses in the
3977 relocation, so we use the original address to work out the
3978 run of non-relocated data */
3979 run
= reloc
->address
- src_address
;
3985 run
= seclet
->size
- dst_address
;
3987 /* Copy the bytes */
3988 for (idx
= 0; idx
< run
; idx
++)
3990 data
[dst_address
++] = data
[src_address
++];
3993 /* Now do the relocation */
3997 switch (reloc
->howto
->type
)
4000 /* Speciial relaxed type */
4002 bfd_vma dot
= seclet
->offset
+ dst_address
+ seclet
->u
.indirect
.section
->output_section
->vma
;
4003 int gap
= get_value(reloc
,seclet
)-dot
-1;
4004 if ((gap
& ~0xff ) != 0 &&((gap
& 0xff00)!= 0xff00)) abort();
4006 bfd_put_8(in_abfd
,gap
, data
+dst_address
);
4008 switch (data
[dst_address
-1])
4013 bfd_put_8(in_abfd
, 0x55, data
+dst_address
-1);
4017 bfd_put_8(in_abfd
, 0x40, data
+dst_address
-1);
4036 /* Special relaxed type, there will be a gap between where we
4037 get stuff from and where we put stuff to now
4039 for a mov.b @aa:16 -> mov.b @aa:8
4040 opcode 0x6a 0x0y offset
4043 if (data
[dst_address
-1] != 0x6a)
4045 switch (data
[src_address
] & 0xf0)
4049 data
[dst_address
-1] = (data
[src_address
] & 0xf) | 0x20;
4053 data
[dst_address
-1] = (data
[src_address
] & 0xf) | 0x30;
4059 /* the offset must fit ! after all, what was all the relaxing
4062 bfd_put_8(in_abfd
, get_value(reloc
, seclet
), data
+ dst_address
);
4064 /* Note the magic - src goes up by two bytes, but dst by only
4073 bfd_vma dot
= seclet
->offset
+ dst_address
+ seclet
->u
.indirect
.section
->output_section
->vma
;
4074 int gap
= get_value(reloc
,seclet
)-dot
;
4075 if (gap
> 127 || gap
< -128)
4077 bfd_error_vector
.reloc_value_truncated(reloc
, seclet
);
4080 bfd_put_8(in_abfd
,gap
, data
+dst_address
);
4089 unsigned int gap
=get_value(reloc
,seclet
);
4090 if (gap
> 0xff && gap
< ~0xff)
4092 bfd_error_vector
.reloc_value_truncated(reloc
, seclet
);
4095 bfd_put_8(in_abfd
, gap
, data
+dst_address
);
4103 /* A relword which would have like to have been a pcrel */
4105 /* A relword which would like to have been modified but
4108 bfd_put_16(in_abfd
, get_value(reloc
,seclet
), data
+dst_address
);
4119 free((char *)reloc_vector
);
4125 #define coff_core_file_failing_command _bfd_dummy_core_file_failing_command
4126 #define coff_core_file_failing_signal _bfd_dummy_core_file_failing_signal
4127 #define coff_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
4128 #define coff_slurp_armap bfd_slurp_coff_armap
4129 #define coff_slurp_extended_name_table _bfd_slurp_extended_name_table
4130 #define coff_truncate_arname bfd_dont_truncate_arname
4131 #define coff_openr_next_archived_file bfd_generic_openr_next_archived_file
4132 #define coff_generic_stat_arch_elt bfd_generic_stat_arch_elt
4133 #define coff_get_section_contents bfd_generic_get_section_contents
4134 #define coff_close_and_cleanup bfd_generic_close_and_cleanup
4136 #define coff_bfd_debug_info_start bfd_void
4137 #define coff_bfd_debug_info_end bfd_void
4138 #define coff_bfd_debug_info_accumulate (PROTO(void,(*),(bfd*, struct sec *))) bfd_void
4139 #define coff_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
4140 #define coff_bfd_relax_section bfd_generic_relax_section