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
))
383 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
384 else if (styp_flags
& STYP_BSS
)
385 sec_flags
= SEC_ALLOC
;
387 #ifdef STYP_LIT /* A29k readonly text/data section type */
388 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
389 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
390 #endif /* STYP_LIT */
391 #ifdef STYP_OTHER_LOAD /* Other loaded sections */
392 if (styp_flags
& STYP_OTHER_LOAD
)
393 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
394 #endif /* STYP_SDATA */
399 #define get_index(symbol) ((int) (symbol)->value)
400 #define set_index(symbol, idx) ((symbol)->value = (idx))
402 /* **********************************************************************
403 Here are all the routines for swapping the structures seen in the
404 outside world into the internal forms.
409 DEFUN(bfd_swap_reloc_in
,(abfd
, reloc_src
, reloc_dst
),
412 struct internal_reloc
*reloc_dst
)
414 reloc_dst
->r_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*)reloc_src
->r_vaddr
);
415 reloc_dst
->r_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) reloc_src
->r_symndx
);
418 reloc_dst
->r_type
= bfd_h_get_8(abfd
, reloc_src
->r_type
);
419 reloc_dst
->r_size
= bfd_h_get_8(abfd
, reloc_src
->r_size
);
421 reloc_dst
->r_type
= bfd_h_get_16(abfd
, (bfd_byte
*) reloc_src
->r_type
);
424 #ifdef SWAP_IN_RELOC_OFFSET
425 reloc_dst
->r_offset
= SWAP_IN_RELOC_OFFSET(abfd
,
426 (bfd_byte
*) reloc_src
->r_offset
);
432 DEFUN(coff_swap_reloc_out
,(abfd
, src
, dst
),
437 struct internal_reloc
*reloc_src
= (struct internal_reloc
*)src
;
438 struct external_reloc
*reloc_dst
= (struct external_reloc
*)dst
;
439 bfd_h_put_32(abfd
, reloc_src
->r_vaddr
, (bfd_byte
*) reloc_dst
->r_vaddr
);
440 bfd_h_put_32(abfd
, reloc_src
->r_symndx
, (bfd_byte
*) reloc_dst
->r_symndx
);
441 bfd_h_put_16(abfd
, reloc_src
->r_type
, (bfd_byte
*)
444 #ifdef SWAP_OUT_RELOC_OFFSET
445 SWAP_OUT_RELOC_OFFSET(abfd
,
447 (bfd_byte
*) reloc_dst
->r_offset
);
449 #ifdef SWAP_OUT_RELOC_EXTRA
450 SWAP_OUT_RELOC_EXTRA(abfd
,reloc_src
, reloc_dst
);
453 return sizeof(struct external_reloc
);
457 DEFUN(bfd_swap_filehdr_in
,(abfd
, filehdr_src
, filehdr_dst
),
459 FILHDR
*filehdr_src AND
460 struct internal_filehdr
*filehdr_dst
)
462 filehdr_dst
->f_magic
= bfd_h_get_16(abfd
, (bfd_byte
*) filehdr_src
->f_magic
);
463 filehdr_dst
->f_nscns
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_nscns
);
464 filehdr_dst
->f_timdat
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_timdat
);
465 filehdr_dst
->f_symptr
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_symptr
);
466 filehdr_dst
->f_nsyms
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_nsyms
);
467 filehdr_dst
->f_opthdr
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_opthdr
);
468 filehdr_dst
->f_flags
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_flags
);
472 DEFUN(coff_swap_filehdr_out
,(abfd
, in
, out
),
477 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*)in
;
478 FILHDR
*filehdr_out
= (FILHDR
*)out
;
479 bfd_h_put_16(abfd
, filehdr_in
->f_magic
, (bfd_byte
*) filehdr_out
->f_magic
);
480 bfd_h_put_16(abfd
, filehdr_in
->f_nscns
, (bfd_byte
*) filehdr_out
->f_nscns
);
481 bfd_h_put_32(abfd
, filehdr_in
->f_timdat
, (bfd_byte
*) filehdr_out
->f_timdat
);
482 bfd_h_put_32(abfd
, filehdr_in
->f_symptr
, (bfd_byte
*) filehdr_out
->f_symptr
);
483 bfd_h_put_32(abfd
, filehdr_in
->f_nsyms
, (bfd_byte
*) filehdr_out
->f_nsyms
);
484 bfd_h_put_16(abfd
, filehdr_in
->f_opthdr
, (bfd_byte
*) filehdr_out
->f_opthdr
);
485 bfd_h_put_16(abfd
, filehdr_in
->f_flags
, (bfd_byte
*) filehdr_out
->f_flags
);
486 return sizeof(FILHDR
);
490 #ifndef NO_COFF_SYMBOLS
493 DEFUN(coff_swap_sym_in
,(abfd
, ext1
, in1
),
498 SYMENT
*ext
= (SYMENT
*)ext1
;
499 struct internal_syment
*in
= (struct internal_syment
*)in1
;
501 if( ext
->e
.e_name
[0] == 0) {
502 in
->_n
._n_n
._n_zeroes
= 0;
503 in
->_n
._n_n
._n_offset
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e
.e
.e_offset
);
506 #if SYMNMLEN != E_SYMNMLEN
507 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
509 memcpy(in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
512 in
->n_value
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_value
);
513 in
->n_scnum
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_scnum
);
514 if (sizeof(ext
->e_type
) == 2){
515 in
->n_type
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_type
);
518 in
->n_type
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_type
);
520 in
->n_sclass
= bfd_h_get_8(abfd
, ext
->e_sclass
);
521 in
->n_numaux
= bfd_h_get_8(abfd
, ext
->e_numaux
);
525 DEFUN(coff_swap_sym_out
,(abfd
, inp
, extp
),
530 struct internal_syment
*in
= (struct internal_syment
*)inp
;
531 SYMENT
*ext
=(SYMENT
*)extp
;
532 if(in
->_n
._n_name
[0] == 0) {
533 bfd_h_put_32(abfd
, 0, (bfd_byte
*) ext
->e
.e
.e_zeroes
);
534 bfd_h_put_32(abfd
, in
->_n
._n_n
._n_offset
, (bfd_byte
*) ext
->e
.e
.e_offset
);
537 #if SYMNMLEN != E_SYMNMLEN
538 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
540 memcpy(ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
543 bfd_h_put_32(abfd
, in
->n_value
, (bfd_byte
*) ext
->e_value
);
544 bfd_h_put_16(abfd
, in
->n_scnum
, (bfd_byte
*) ext
->e_scnum
);
545 if (sizeof(ext
->e_type
) == 2)
547 bfd_h_put_16(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
551 bfd_h_put_32(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
553 bfd_h_put_8(abfd
, in
->n_sclass
, ext
->e_sclass
);
554 bfd_h_put_8(abfd
, in
->n_numaux
, ext
->e_numaux
);
555 return sizeof(SYMENT
);
559 DEFUN(coff_swap_aux_in
,(abfd
, ext1
, type
, class, in1
),
566 AUXENT
*ext
= (AUXENT
*)ext1
;
567 union internal_auxent
*in
= (union internal_auxent
*)in1
;
570 if (ext
->x_file
.x_fname
[0] == 0) {
571 in
->x_file
.x_n
.x_zeroes
= 0;
572 in
->x_file
.x_n
.x_offset
=
573 bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
575 #if FILNMLEN != E_FILNMLEN
576 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
578 memcpy (in
->x_file
.x_fname
, ext
->x_file
.x_fname
, FILNMLEN
);
583 /* RS/6000 "csect" auxents */
587 in
->x_csect
.x_scnlen
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_scnlen
);
588 in
->x_csect
.x_parmhash
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_parmhash
);
589 in
->x_csect
.x_snhash
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snhash
);
590 /* We don't have to hack bitfields in x_smtyp because it's defined by
591 shifts-and-ands, which are equivalent on all byte orders. */
592 in
->x_csect
.x_smtyp
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smtyp
);
593 in
->x_csect
.x_smclas
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smclas
);
594 in
->x_csect
.x_stab
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_stab
);
595 in
->x_csect
.x_snstab
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snstab
);
604 if (type
== T_NULL
) {
605 in
->x_scn
.x_scnlen
= GET_SCN_SCNLEN(abfd
, ext
);
606 in
->x_scn
.x_nreloc
= GET_SCN_NRELOC(abfd
, ext
);
607 in
->x_scn
.x_nlinno
= GET_SCN_NLINNO(abfd
, ext
);
611 in
->x_sym
.x_tagndx
.l
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
613 in
->x_sym
.x_tvndx
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
616 if (ISARY(type
) || class == C_BLOCK
) {
617 #if DIMNUM != E_DIMNUM
618 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
620 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]);
621 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]);
622 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]);
623 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]);
626 in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= GET_FCN_LNNOPTR(abfd
, ext
);
627 in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= GET_FCN_ENDNDX(abfd
, ext
);
630 in
->x_sym
.x_misc
.x_fsize
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
633 in
->x_sym
.x_misc
.x_lnsz
.x_lnno
= GET_LNSZ_LNNO(abfd
, ext
);
634 in
->x_sym
.x_misc
.x_lnsz
.x_size
= GET_LNSZ_SIZE(abfd
, ext
);
640 DEFUN(coff_swap_aux_out
,(abfd
, inp
, type
, class, extp
),
647 union internal_auxent
*in
= (union internal_auxent
*)inp
;
648 AUXENT
*ext
= (AUXENT
*)extp
;
651 if (in
->x_file
.x_fname
[0] == 0) {
652 PUTWORD(abfd
, 0, (bfd_byte
*) ext
->x_file
.x_n
.x_zeroes
);
654 in
->x_file
.x_n
.x_offset
,
655 (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
658 #if FILNMLEN != E_FILNMLEN
659 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
661 memcpy (ext
->x_file
.x_fname
, in
->x_file
.x_fname
, FILNMLEN
);
667 /* RS/6000 "csect" auxents */
670 PUTWORD (abfd
, in
->x_csect
.x_scnlen
, ext
->x_csect
.x_scnlen
);
671 PUTWORD (abfd
, in
->x_csect
.x_parmhash
, ext
->x_csect
.x_parmhash
);
672 PUTHALF (abfd
, in
->x_csect
.x_snhash
, ext
->x_csect
.x_snhash
);
673 /* We don't have to hack bitfields in x_smtyp because it's defined by
674 shifts-and-ands, which are equivalent on all byte orders. */
675 PUTBYTE (abfd
, in
->x_csect
.x_smtyp
, ext
->x_csect
.x_smtyp
);
676 PUTBYTE (abfd
, in
->x_csect
.x_smclas
, ext
->x_csect
.x_smclas
);
677 PUTWORD (abfd
, in
->x_csect
.x_stab
, ext
->x_csect
.x_stab
);
678 PUTHALF (abfd
, in
->x_csect
.x_snstab
, ext
->x_csect
.x_snstab
);
687 if (type
== T_NULL
) {
688 PUT_SCN_SCNLEN(abfd
, in
->x_scn
.x_scnlen
, ext
);
689 PUT_SCN_NRELOC(abfd
, in
->x_scn
.x_nreloc
, ext
);
690 PUT_SCN_NLINNO(abfd
, in
->x_scn
.x_nlinno
, ext
);
694 PUTWORD(abfd
, in
->x_sym
.x_tagndx
.l
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
696 PUTWORD(abfd
, in
->x_sym
.x_tvndx
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
700 PUTWORD(abfd
, in
->x_sym
.x_misc
.x_fsize
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
701 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
702 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
706 if (ISARY(type
) || class == C_BLOCK
) {
707 #if DIMNUM != E_DIMNUM
708 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
710 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]);
711 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]);
712 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]);
713 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]);
716 PUT_LNSZ_LNNO(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
717 PUT_LNSZ_SIZE(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
719 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
720 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
725 return sizeof(AUXENT
);
728 #endif /* NO_COFF_SYMBOLS */
730 #ifndef NO_COFF_LINENOS
733 DEFUN(coff_swap_lineno_in
,(abfd
, ext1
, in1
),
738 LINENO
*ext
= (LINENO
*)ext1
;
739 struct internal_lineno
*in
= (struct internal_lineno
*)in1
;
741 in
->l_addr
.l_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->l_addr
.l_symndx
);
742 in
->l_lnno
= GET_LINENO_LNNO(abfd
, ext
);
746 DEFUN(coff_swap_lineno_out
,(abfd
, inp
, outp
),
751 struct internal_lineno
*in
= (struct internal_lineno
*)inp
;
752 struct external_lineno
*ext
= (struct external_lineno
*)outp
;
753 PUTWORD(abfd
, in
->l_addr
.l_symndx
, (bfd_byte
*)
754 ext
->l_addr
.l_symndx
);
756 PUT_LINENO_LNNO (abfd
, in
->l_lnno
, ext
);
757 return sizeof(struct external_lineno
);
760 #endif /* NO_COFF_LINENOS */
764 DEFUN(bfd_swap_aouthdr_in
,(abfd
, aouthdr_ext1
, aouthdr_int1
),
769 AOUTHDR
*aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
770 struct internal_aouthdr
*aouthdr_int
= (struct internal_aouthdr
*)aouthdr_int1
;
772 aouthdr_int
->magic
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->magic
);
773 aouthdr_int
->vstamp
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->vstamp
);
774 aouthdr_int
->tsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tsize
);
775 aouthdr_int
->dsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->dsize
);
776 aouthdr_int
->bsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->bsize
);
777 aouthdr_int
->entry
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->entry
);
778 aouthdr_int
->text_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->text_start
);
779 aouthdr_int
->data_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->data_start
);
781 aouthdr_int
->tagentries
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tagentries
);
785 aouthdr_int
->o_toc
= bfd_h_get_32(abfd
, aouthdr_ext
->o_toc
);
786 aouthdr_int
->o_snentry
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snentry
);
787 aouthdr_int
->o_sntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntext
);
788 aouthdr_int
->o_sndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sndata
);
789 aouthdr_int
->o_sntoc
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntoc
);
790 aouthdr_int
->o_snloader
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snloader
);
791 aouthdr_int
->o_snbss
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snbss
);
792 aouthdr_int
->o_algntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algntext
);
793 aouthdr_int
->o_algndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algndata
);
794 aouthdr_int
->o_modtype
= bfd_h_get_16(abfd
, aouthdr_ext
->o_modtype
);
795 aouthdr_int
->o_maxstack
= bfd_h_get_32(abfd
, aouthdr_ext
->o_maxstack
);
800 DEFUN(coff_swap_aouthdr_out
,(abfd
, in
, out
),
805 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*)in
;
806 AOUTHDR
*aouthdr_out
= (AOUTHDR
*)out
;
807 bfd_h_put_16(abfd
, aouthdr_in
->magic
, (bfd_byte
*) aouthdr_out
->magic
);
808 bfd_h_put_16(abfd
, aouthdr_in
->vstamp
, (bfd_byte
*) aouthdr_out
->vstamp
);
809 bfd_h_put_32(abfd
, aouthdr_in
->tsize
, (bfd_byte
*) aouthdr_out
->tsize
);
810 bfd_h_put_32(abfd
, aouthdr_in
->dsize
, (bfd_byte
*) aouthdr_out
->dsize
);
811 bfd_h_put_32(abfd
, aouthdr_in
->bsize
, (bfd_byte
*) aouthdr_out
->bsize
);
812 bfd_h_put_32(abfd
, aouthdr_in
->entry
, (bfd_byte
*) aouthdr_out
->entry
);
813 bfd_h_put_32(abfd
, aouthdr_in
->text_start
,
814 (bfd_byte
*) aouthdr_out
->text_start
);
815 bfd_h_put_32(abfd
, aouthdr_in
->data_start
, (bfd_byte
*) aouthdr_out
->data_start
);
817 bfd_h_put_32(abfd
, aouthdr_in
->tagentries
, (bfd_byte
*) aouthdr_out
->tagentries
);
819 return sizeof(AOUTHDR
);
823 DEFUN(coff_swap_scnhdr_in
,(abfd
, scnhdr_ext
, scnhdr_int
),
825 SCNHDR
*scnhdr_ext AND
826 struct internal_scnhdr
*scnhdr_int
)
828 memcpy(scnhdr_int
->s_name
, scnhdr_ext
->s_name
, sizeof(scnhdr_int
->s_name
));
829 scnhdr_int
->s_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
830 scnhdr_int
->s_paddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
831 scnhdr_int
->s_size
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_size
);
833 scnhdr_int
->s_scnptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
834 scnhdr_int
->s_relptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
835 scnhdr_int
->s_lnnoptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
836 scnhdr_int
->s_flags
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_flags
);
838 scnhdr_int
->s_nreloc
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
839 scnhdr_int
->s_nlnno
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
841 scnhdr_int
->s_nreloc
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
842 scnhdr_int
->s_nlnno
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
845 scnhdr_int
->s_align
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_align
);
850 DEFUN(coff_swap_scnhdr_out
,(abfd
, in
, out
),
855 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*)in
;
856 SCNHDR
*scnhdr_ext
= (SCNHDR
*)out
;
857 memcpy(scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof(scnhdr_int
->s_name
));
858 PUTWORD(abfd
, scnhdr_int
->s_vaddr
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
859 PUTWORD(abfd
, scnhdr_int
->s_paddr
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
860 PUTWORD(abfd
, scnhdr_int
->s_size
, (bfd_byte
*) scnhdr_ext
->s_size
);
861 PUTWORD(abfd
, scnhdr_int
->s_scnptr
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
862 PUTWORD(abfd
, scnhdr_int
->s_relptr
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
863 PUTWORD(abfd
, scnhdr_int
->s_lnnoptr
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
864 PUTWORD(abfd
, scnhdr_int
->s_flags
, (bfd_byte
*) scnhdr_ext
->s_flags
);
866 PUTWORD(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
867 PUTWORD(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
869 PUTHALF(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
870 PUTHALF(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
874 PUTWORD(abfd
, scnhdr_int
->s_align
, (bfd_byte
*) scnhdr_ext
->s_align
);
876 return sizeof(SCNHDR
);
881 initialize a section structure with information peculiar to this
882 particular implementation of coff
886 DEFUN(coff_new_section_hook
,(abfd_ignore
, section
),
890 section
->alignment_power
= abfd_ignore
->xvec
->align_power_min
;
894 static asection bfd_debug_section
=
900 DEFUN(make_abs_section
,(abfd
),
908 /* Take a section header read from a coff file (in HOST byte order),
909 and make a BFD "section" out of it. */
911 DEFUN(make_a_section_from_file
,(abfd
, hdr
, target_index
),
913 struct internal_scnhdr
*hdr AND
914 unsigned int target_index
)
916 asection
*return_section
;
919 /* Assorted wastage to null-terminate the name, thanks AT&T! */
920 name
= bfd_alloc(abfd
, sizeof (hdr
->s_name
)+1);
922 bfd_error
= no_memory
;
925 strncpy(name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
926 name
[sizeof (hdr
->s_name
)] = 0;
928 return_section
= bfd_make_section(abfd
, name
);
929 if (return_section
== NULL
)
932 /* s_paddr is presumed to be = to s_vaddr */
934 return_section
->vma
= hdr
->s_vaddr
;
935 return_section
->_raw_size
= hdr
->s_size
;
936 return_section
->filepos
= hdr
->s_scnptr
;
937 return_section
->rel_filepos
= hdr
->s_relptr
;
938 return_section
->reloc_count
= hdr
->s_nreloc
;
941 /* FIXME, use a temp var rather than alignment_power */
942 return_section
->alignment_power
= hdr
->s_align
;
945 for (i
= 0; i
< 32; i
++) {
946 if ((1 << i
) >= (int) (return_section
->alignment_power
)) {
947 return_section
->alignment_power
= i
;
954 return_section
->line_filepos
= hdr
->s_lnnoptr
;
956 return_section->linesize = hdr->s_nlnno * sizeof (struct lineno);
959 return_section
->lineno_count
= hdr
->s_nlnno
;
960 return_section
->userdata
= NULL
;
961 return_section
->next
= (asection
*) NULL
;
962 return_section
->flags
= styp_to_sec_flags(hdr
->s_flags
);
964 return_section
->target_index
= target_index
;
966 if (hdr
->s_nreloc
!= 0)
967 return_section
->flags
|= SEC_RELOC
;
968 /* FIXME: should this check 'hdr->s_size > 0' */
969 if (hdr
->s_scnptr
!= 0)
970 return_section
->flags
|= SEC_HAS_CONTENTS
;
974 DEFUN(coff_mkobject
,(abfd
),
977 abfd
->tdata
.coff_obj_data
= (struct coff_tdata
*)bfd_zalloc (abfd
,sizeof(coff_data_type
));
978 if (abfd
->tdata
.coff_obj_data
== 0){
979 bfd_error
= no_memory
;
982 coff_data(abfd
)->relocbase
= 0;
983 /* make_abs_section(abfd);*/
989 DEFUN(coff_real_object_p
,(abfd
, nscns
, internal_f
, internal_a
),
992 struct internal_filehdr
*internal_f AND
993 struct internal_aouthdr
*internal_a
)
995 coff_data_type
*coff
;
996 enum bfd_architecture arch
;
998 size_t readsize
; /* length of file_info */
999 SCNHDR
*external_sections
;
1001 /* Build a play area */
1002 if (coff_mkobject(abfd
) != true)
1005 coff
= coff_data(abfd
);
1008 external_sections
= (SCNHDR
*)bfd_alloc(abfd
, readsize
= (nscns
* SCNHSZ
));
1010 if (bfd_read((PTR
)external_sections
, 1, readsize
, abfd
) != readsize
) {
1015 /* Now copy data as required; construct all asections etc */
1016 coff
->symbol_index_slew
= 0;
1018 coff
->raw_syment_count
= 0;
1019 coff
->raw_linenos
= 0;
1020 coff
->raw_syments
= 0;
1021 coff
->sym_filepos
=0;
1022 coff
->flags
= internal_f
->f_flags
;
1025 for (i
= 0; i
< nscns
; i
++) {
1026 struct internal_scnhdr tmp
;
1027 coff_swap_scnhdr_in(abfd
, external_sections
+ i
, &tmp
);
1028 make_a_section_from_file(abfd
,&tmp
, i
+1);
1032 /* make_abs_section(abfd);*/
1034 /* Determine the machine architecture and type. */
1036 switch (internal_f
->f_magic
) {
1039 arch
= bfd_arch_i386
;
1044 #ifdef A29K_MAGIC_BIG
1045 case A29K_MAGIC_BIG
:
1046 case A29K_MAGIC_LITTLE
:
1047 arch
= bfd_arch_a29k
;
1056 arch
= bfd_arch_mips
;
1064 arch
= bfd_arch_m68k
;
1072 arch
= bfd_arch_m88k
;
1080 arch
= bfd_arch_i960
;
1081 switch (F_I960TYPE
& internal_f
->f_flags
)
1085 machine
= bfd_mach_i960_core
;
1088 machine
= bfd_mach_i960_kb_sb
;
1091 machine
= bfd_mach_i960_mc
;
1094 machine
= bfd_mach_i960_xa
;
1097 machine
= bfd_mach_i960_ca
;
1100 machine
= bfd_mach_i960_ka_sa
;
1111 arch
= bfd_arch_rs6000
;
1118 arch
= bfd_arch_h8300
;
1123 default: /* Unreadable input file type */
1124 arch
= bfd_arch_obscure
;
1128 bfd_default_set_arch_mach(abfd
, arch
, machine
);
1129 if (!(internal_f
->f_flags
& F_RELFLG
))
1130 abfd
->flags
|= HAS_RELOC
;
1131 if ((internal_f
->f_flags
& F_EXEC
))
1132 abfd
->flags
|= EXEC_P
;
1133 if (!(internal_f
->f_flags
& F_LNNO
))
1134 abfd
->flags
|= HAS_LINENO
;
1135 if (!(internal_f
->f_flags
& F_LSYMS
))
1136 abfd
->flags
|= HAS_LOCALS
;
1139 bfd_get_symcount(abfd
) = internal_f
->f_nsyms
;
1140 if (internal_f
->f_nsyms
)
1141 abfd
->flags
|= HAS_SYMS
;
1143 coff
->sym_filepos
= internal_f
->f_symptr
;
1145 /* These members communicate important constants about the symbol table
1146 to GDB's symbol-reading code. These `constants' unfortunately vary
1147 from coff implementation to implementation... */
1148 #ifndef NO_COFF_SYMBOLS
1149 coff
->local_n_btmask
= N_BTMASK
;
1150 coff
->local_n_btshft
= N_BTSHFT
;
1151 coff
->local_n_tmask
= N_TMASK
;
1152 coff
->local_n_tshift
= N_TSHIFT
;
1153 coff
->local_symesz
= SYMESZ
;
1154 coff
->local_auxesz
= AUXESZ
;
1155 coff
->local_linesz
= LINESZ
;
1158 coff
->symbols
= (coff_symbol_type
*) NULL
;
1159 bfd_get_start_address(abfd
) = internal_f
->f_opthdr
? internal_a
->entry
: 0;
1163 bfd_release(abfd
, coff
);
1164 return (bfd_target
*)NULL
;
1168 DEFUN(coff_object_p
,(abfd
),
1174 struct internal_filehdr internal_f
;
1175 struct internal_aouthdr internal_a
;
1177 bfd_error
= system_call_error
;
1179 /* figure out how much to read */
1180 if (bfd_read((PTR
) &filehdr
, 1, FILHSZ
, abfd
) != FILHSZ
)
1183 bfd_swap_filehdr_in(abfd
, &filehdr
, &internal_f
);
1185 if (BADMAG(internal_f
)) {
1186 bfd_error
= wrong_format
;
1189 nscns
=internal_f
.f_nscns
;
1191 if (internal_f
.f_opthdr
) {
1192 if (bfd_read((PTR
) &opthdr
, 1,AOUTSZ
, abfd
) != AOUTSZ
) {
1195 bfd_swap_aouthdr_in(abfd
, (char *)&opthdr
, (char *)&internal_a
);
1198 /* Seek past the opt hdr stuff */
1199 bfd_seek(abfd
, internal_f
.f_opthdr
+ FILHSZ
, SEEK_SET
);
1201 /* if the optional header is NULL or not the correct size then
1202 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1203 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1204 optional header is of a different size.
1206 But the mips keeps extra stuff in it's opthdr, so dont check
1210 #if defined(M88) || defined(I960)
1211 if (internal_f
.f_opthdr
!= 0 && AOUTSZ
!= internal_f
.f_opthdr
)
1212 return (bfd_target
*)NULL
;
1215 return coff_real_object_p(abfd
, nscns
, &internal_f
, &internal_a
);
1220 #ifndef NO_COFF_LINENOS
1223 DEFUN(coff_count_linenumbers
,(abfd
),
1226 unsigned int limit
= bfd_get_symcount(abfd
);
1230 asection
*s
= abfd
->sections
->output_section
;
1232 BFD_ASSERT(s
->lineno_count
== 0);
1238 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++) {
1239 asymbol
*q_maybe
= *p
;
1240 if (q_maybe
->the_bfd
->xvec
->flavour
== bfd_target_coff_flavour
) {
1241 coff_symbol_type
*q
= coffsymbol(q_maybe
);
1244 This symbol has a linenumber, increment the owning
1245 section's linenumber count
1247 alent
*l
= q
->lineno
;
1248 q
->symbol
.section
->output_section
->lineno_count
++;
1250 while (l
->line_number
) {
1251 q
->symbol
.section
->output_section
->lineno_count
++;
1259 #endif /* NO_COFF_LINENOS */
1261 #ifndef NO_COFF_SYMBOLS
1264 Takes a bfd and a symbol, returns a pointer to the coff specific area
1265 of the symbol if there is one.
1267 static coff_symbol_type
*
1268 DEFUN(coff_symbol_from
,(ignore_abfd
, symbol
),
1269 bfd
*ignore_abfd AND
1272 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
1273 return (coff_symbol_type
*)NULL
;
1275 if (symbol
->the_bfd
->tdata
.coff_obj_data
== (coff_data_type
*)NULL
)
1276 return (coff_symbol_type
*)NULL
;
1278 return (coff_symbol_type
*) symbol
;
1284 DEFUN(fixup_symbol_value
,(coff_symbol_ptr
, syment
),
1285 coff_symbol_type
*coff_symbol_ptr AND
1286 struct internal_syment
*syment
)
1289 /* Normalize the symbol flags */
1290 if (coff_symbol_ptr
->symbol
.section
== &bfd_com_section
) {
1291 /* a common symbol is undefined with a value */
1292 syment
->n_scnum
= N_UNDEF
;
1293 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1295 else if (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) {
1296 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1298 else if (coff_symbol_ptr
->symbol
.section
== & bfd_und_section
) {
1299 syment
->n_scnum
= N_UNDEF
;
1300 syment
->n_value
= 0;
1303 if (coff_symbol_ptr
->symbol
.section
) {
1305 coff_symbol_ptr
->symbol
.section
->output_section
->target_index
;
1308 coff_symbol_ptr
->symbol
.value
+
1309 coff_symbol_ptr
->symbol
.section
->output_offset
+
1310 coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
1314 /* This can happen, but I don't know why yet (steve@cygnus.com) */
1315 syment
->n_scnum
= N_ABS
;
1316 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1321 /* run through all the symbols in the symbol table and work out what
1322 their indexes into the symbol table will be when output
1324 Coff requires that each C_FILE symbol points to the next one in the
1325 chain, and that the last one points to the first external symbol. We
1330 DEFUN(coff_renumber_symbols
,(bfd_ptr
),
1333 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1334 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1335 unsigned int native_index
= 0;
1336 struct internal_syment
*last_file
= (struct internal_syment
*)NULL
;
1337 unsigned int symbol_index
;
1338 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1340 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1341 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1342 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1345 if (s
->u
.syment
.n_sclass
== C_FILE
)
1347 if (last_file
!= (struct internal_syment
*)NULL
) {
1348 last_file
->n_value
= native_index
;
1350 last_file
= &(s
->u
.syment
);
1354 /* Modify the symbol values according to their section and
1357 fixup_symbol_value(coff_symbol_ptr
, &(s
->u
.syment
));
1359 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++) {
1360 s
[i
].offset
= native_index
++;
1371 Run thorough the symbol table again, and fix it so that all pointers to
1372 entries are changed to the entries' index in the output symbol table.
1376 DEFUN(coff_mangle_symbols
,(bfd_ptr
),
1379 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1380 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1381 unsigned int symbol_index
;
1383 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1385 coff_symbol_type
*coff_symbol_ptr
=
1386 coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1388 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1390 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1392 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++) {
1393 combined_entry_type
*a
= s
+ i
+ 1;
1395 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
1396 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
1400 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
1401 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
1411 static int string_size
;
1413 DEFUN(coff_fix_symbol_name
,(ignore_abfd
, symbol
, native
),
1414 bfd
*ignore_abfd AND
1416 combined_entry_type
*native
)
1418 unsigned int name_length
;
1419 union internal_auxent
*auxent
;
1420 char * name
= ( char *)(symbol
->name
);
1422 if (name
== (char *) NULL
) {
1423 /* coff symbols always have names, so we'll make one up */
1424 symbol
->name
= "strange";
1425 name
= (char *)symbol
->name
;
1427 name_length
= strlen(name
);
1429 if (native
->u
.syment
.n_sclass
== C_FILE
) {
1430 strncpy(native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
1431 auxent
= &(native
+1)->u
.auxent
;
1433 #ifdef COFF_LONG_FILENAMES
1434 if (name_length
<= FILNMLEN
) {
1435 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1438 auxent
->x_file
.x_n
.x_offset
= string_size
+ 4;
1439 auxent
->x_file
.x_n
.x_zeroes
= 0;
1440 string_size
+= name_length
+ 1;
1443 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1444 if (name_length
> FILNMLEN
) {
1445 name
[FILNMLEN
] = '\0';
1450 { /* NOT A C_FILE SYMBOL */
1451 if (name_length
<= SYMNMLEN
) {
1452 /* This name will fit into the symbol neatly */
1453 strncpy(native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
1456 native
->u
.syment
._n
._n_n
._n_offset
= string_size
+ 4;
1457 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1458 string_size
+= name_length
+ 1;
1466 DEFUN(coff_write_symbol
,(abfd
, symbol
, native
, written
),
1469 combined_entry_type
*native AND
1470 unsigned int written
)
1472 unsigned int numaux
= native
->u
.syment
.n_numaux
;
1473 int type
= native
->u
.syment
.n_type
;
1474 int class = native
->u
.syment
.n_sclass
;
1477 if (symbol
->section
== &bfd_abs_section
)
1479 native
->u
.syment
.n_scnum
= N_ABS
;
1481 else if (symbol
->section
== &bfd_debug_section
)
1483 native
->u
.syment
.n_scnum
= N_DEBUG
;
1485 else if (symbol
->section
== &bfd_und_section
)
1487 native
->u
.syment
.n_scnum
= N_UNDEF
;
1491 native
->u
.syment
.n_scnum
=
1492 symbol
->section
->output_section
->target_index
;
1496 coff_fix_symbol_name(abfd
, symbol
, native
);
1498 coff_swap_sym_out(abfd
, &native
->u
.syment
, &buf
);
1499 bfd_write((PTR
)& buf
, 1, SYMESZ
, abfd
);
1500 for (j
= 0; j
!= native
->u
.syment
.n_numaux
; j
++)
1503 bzero((PTR
)&buf
, AUXESZ
);
1504 coff_swap_aux_out(abfd
,
1505 &( (native
+ j
+ 1)->u
.auxent
), type
, class, &buf1
);
1506 bfd_write((PTR
) (&buf1
), 1, AUXESZ
, abfd
);
1509 Reuse somewhere in the symbol to keep the index
1511 set_index(symbol
, written
);
1512 return written
+ 1 + numaux
;
1517 DEFUN(coff_write_alien_symbol
,(abfd
, symbol
, written
),
1520 unsigned int written
)
1523 This symbol has been created by the loader, or come from a non
1524 coff format. It has no native element to inherit, make our
1527 combined_entry_type
*native
;
1528 combined_entry_type dummy
;
1530 native
->u
.syment
.n_type
= T_NULL
;
1532 native
->u
.syment
.n_flags
= 0;
1534 if (symbol
->section
== &bfd_und_section
)
1536 native
->u
.syment
.n_scnum
= N_UNDEF
;
1537 native
->u
.syment
.n_value
= symbol
->value
;
1539 else if (symbol
->section
== &bfd_com_section
)
1541 native
->u
.syment
.n_scnum
= N_UNDEF
;
1542 native
->u
.syment
.n_value
= symbol
->value
;
1546 else if (symbol
->flags
& BSF_DEBUGGING
) {
1548 remove name so it doesn't take up any space
1553 native
->u
.syment
.n_scnum
= symbol
->section
->output_section
->target_index
;
1554 native
->u
.syment
.n_value
= symbol
->value
+
1555 symbol
->section
->output_section
->vma
+
1556 symbol
->section
->output_offset
;
1558 /* Copy the any flags from the the file hdr into the symbol */
1560 coff_symbol_type
*c
= coff_symbol_from(abfd
, symbol
);
1561 if (c
!= (coff_symbol_type
*)NULL
) {
1562 native
->u
.syment
.n_flags
= c
->symbol
.the_bfd
->flags
;
1569 native
->u
.syment
.pad1
[0] = 0;
1570 native
->u
.syment
.pad1
[0] = 0;
1573 native
->u
.syment
.n_type
= 0;
1574 if (symbol
->flags
& BSF_LOCAL
)
1575 native
->u
.syment
.n_sclass
= C_STAT
;
1577 native
->u
.syment
.n_sclass
= C_EXT
;
1578 native
->u
.syment
.n_numaux
= 0;
1580 return coff_write_symbol(abfd
, symbol
, native
, written
);
1584 DEFUN(coff_write_native_symbol
,(abfd
, symbol
, written
),
1586 coff_symbol_type
*symbol AND
1587 unsigned int written
)
1590 Does this symbol have an ascociated line number - if so then
1591 make it remember this symbol index. Also tag the auxent of
1592 this symbol to point to the right place in the lineno table
1594 combined_entry_type
*native
= symbol
->native
;
1596 alent
*lineno
= symbol
->lineno
;
1598 if (lineno
&& !symbol
->done_lineno
) {
1599 unsigned int count
= 0;
1600 lineno
[count
].u
.offset
= written
;
1601 if (native
->u
.syment
.n_numaux
) {
1602 union internal_auxent
*a
= &((native
+1)->u
.auxent
);
1604 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1605 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1608 And count and relocate all other linenumbers
1612 while (lineno
[count
].line_number
) {
1613 lineno
[count
].u
.offset
+=
1614 symbol
->symbol
.section
->output_section
->vma
+
1615 symbol
->symbol
.section
->output_offset
;
1618 symbol
->done_lineno
= true;
1620 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1623 return coff_write_symbol(abfd
, &( symbol
->symbol
), native
,written
);
1627 DEFUN(coff_write_symbols
,(abfd
),
1631 unsigned int limit
= bfd_get_symcount(abfd
);
1632 unsigned int written
= 0;
1639 /* Seek to the right place */
1640 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
1642 /* Output all the symbols we have */
1645 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1647 asymbol
*symbol
= *p
;
1648 coff_symbol_type
*c_symbol
= coff_symbol_from(abfd
, symbol
);
1650 if (c_symbol
== (coff_symbol_type
*) NULL
||
1651 c_symbol
->native
== (combined_entry_type
*)NULL
)
1653 written
= coff_write_alien_symbol(abfd
, symbol
, written
);
1657 written
= coff_write_native_symbol(abfd
, c_symbol
, written
);
1662 bfd_get_symcount(abfd
) = written
;
1664 /* Now write out strings */
1666 if (string_size
!= 0)
1668 unsigned int size
= string_size
+ 4;
1671 bfd_h_put_32(abfd
, size
, buffer
);
1672 bfd_write((PTR
) buffer
, 1, sizeof(buffer
), abfd
);
1673 for (p
= abfd
->outsymbols
, i
= 0;
1678 size_t name_length
= strlen(q
->name
);
1680 coff_symbol_type
* c_symbol
= coff_symbol_from(abfd
, q
);
1681 maxlen
= ((c_symbol
!= NULL
&& c_symbol
->native
!= NULL
) &&
1682 (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
)) ?
1683 FILNMLEN
: SYMNMLEN
;
1685 if (name_length
> maxlen
) {
1686 bfd_write((PTR
) (q
->name
), 1, name_length
+ 1, abfd
);
1691 /* We would normally not write anything here, but we'll write
1692 out 4 so that any stupid coff reader which tries to read
1693 the string table even when there isn't one won't croak.
1696 uint32e_type size
= 4;
1698 bfd_write((PTR
)&size
, 1, sizeof(size
), abfd
);
1707 To write relocations, all the back end does is step though the
1708 canonical relocation table, and create an
1709 @code{internal_reloc}. The symbol index to use is removed from
1710 the @code{offset} field in the symbol table supplied, the
1711 address comes directly from the sum of the section base
1712 address and the relocation offset and the type is dug directly
1713 from the howto field. Then the @code{internal_reloc} is
1714 swapped into the shape of an @code{external_reloc} and written
1720 DEFUN(coff_write_relocs
,(abfd
),
1724 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1726 struct external_reloc dst
;
1728 arelent
**p
= s
->orelocation
;
1729 bfd_seek(abfd
, s
->rel_filepos
, SEEK_SET
);
1730 for (i
= 0; i
< s
->reloc_count
; i
++) {
1731 struct internal_reloc n
;
1733 memset((PTR
)&n
, 0, sizeof(n
));
1734 n
.r_vaddr
= q
->address
+ s
->vma
;
1735 if (q
->sym_ptr_ptr
) {
1736 n
.r_symndx
= get_index((*(q
->sym_ptr_ptr
)));
1739 /* Work out reloc type from what is required */
1740 SELECT_RELOC(n
.r_type
, q
->howto
);
1742 n
.r_type
= q
->howto
->type
;
1744 coff_swap_reloc_out(abfd
, &n
, &dst
);
1745 bfd_write((PTR
) &n
, 1, RELSZ
, abfd
);
1749 #endif /* NO_COFF_SYMBOLS */
1751 #ifndef NO_COFF_LINENOS
1754 DEFUN(coff_write_linenumbers
,(abfd
),
1758 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1759 if (s
->lineno_count
) {
1760 asymbol
**q
= abfd
->outsymbols
;
1761 bfd_seek(abfd
, s
->line_filepos
, SEEK_SET
);
1762 /* Find all the linenumbers in this section */
1765 alent
*l
= BFD_SEND(p
->the_bfd
, _get_lineno
, (p
->the_bfd
, p
));
1767 /* Found a linenumber entry, output */
1768 struct internal_lineno out
;
1770 memset( (PTR
)&out
, 0, sizeof(out
));
1772 out
.l_addr
.l_symndx
= l
->u
.offset
;
1773 coff_swap_lineno_out(abfd
, &out
, &buff
);
1774 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1776 while (l
->line_number
) {
1777 out
.l_lnno
= l
->line_number
;
1778 out
.l_addr
.l_symndx
= l
->u
.offset
;
1779 coff_swap_lineno_out(abfd
, &out
, &buff
);
1780 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1791 DEFUN(coff_get_lineno
,(ignore_abfd
, symbol
),
1792 bfd
*ignore_abfd AND
1795 return coffsymbol(symbol
)->lineno
;
1798 #endif /* NO_COFF_LINENOS */
1801 coff_make_empty_symbol(abfd
)
1804 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc(abfd
, sizeof(coff_symbol_type
));
1806 bfd_error
= no_memory
;
1810 new->lineno
= (alent
*) NULL
;
1811 new->done_lineno
= false;
1812 new->symbol
.the_bfd
= abfd
;
1813 return &new->symbol
;
1816 #ifndef NO_COFF_SYMBOLS
1819 DEFUN(coff_print_symbol
,(ignore_abfd
, filep
, symbol
, how
),
1820 bfd
*ignore_abfd AND
1823 bfd_print_symbol_type how
)
1825 FILE *file
= (FILE *)filep
;
1827 case bfd_print_symbol_name
:
1828 fprintf(file
, "%s", symbol
->name
);
1830 case bfd_print_symbol_more
:
1831 fprintf(file
, "coff %lx %lx", (unsigned long) coffsymbol(symbol
)->native
,
1832 (unsigned long) coffsymbol(symbol
)->lineno
);
1834 case bfd_print_symbol_nm
:
1837 CONST
char *section_name
= symbol
->section
->name
;
1838 bfd_print_symbol_vandf((PTR
) file
, symbol
);
1841 fprintf(file
, " %-5s %s %s %s",
1843 coffsymbol(symbol
)->native
? "n" : "g",
1844 coffsymbol(symbol
)->lineno
? "l" : " ",
1850 case bfd_print_symbol_all
:
1851 /* Print out the symbols in a reasonable way */
1853 CONST
char *section_name
= symbol
->section
->name
;
1856 if (coffsymbol(symbol
)->native
)
1859 combined_entry_type
*combined
= coffsymbol(symbol
)->native
;
1860 combined_entry_type
*root
= obj_raw_syments(ignore_abfd
);
1862 fprintf(file
,"[%3d]",
1866 fprintf(file
, "(sc %2d)(fl%4x)(ty%3x)(sc%3d) nx(%d) %08x %s",
1867 combined
->u
.syment
.n_scnum
,
1868 combined
->u
.syment
.n_flags
,
1869 combined
->u
.syment
.n_type
,
1870 combined
->u
.syment
.n_sclass
,
1871 combined
->u
.syment
.n_numaux
,
1872 combined
->u
.syment
.n_value
,
1875 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
1878 switch (combined
->u
.syment
.n_sclass
) {
1880 fprintf(file
, "File ");
1883 fprintf(file
, "AUX lnno %x size %x",
1884 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
1885 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
);
1893 struct lineno_cache_entry
*l
= coffsymbol(symbol
)->lineno
;
1896 printf("\n%s :", l
->u
.sym
->name
);
1898 while (l
->line_number
)
1900 printf("\n%4d : %x",
1914 bfd_print_symbol_vandf((PTR
) file
, symbol
);
1915 fprintf(file
, " %-5s %s %s %s",
1917 coffsymbol(symbol
)->native
? "n" : "g",
1918 coffsymbol(symbol
)->lineno
? "l" : " ",
1927 #endif /* NO_COFF_SYMBOLS */
1929 /* Set flags and magic number of a coff file from architecture and machine
1930 type. Result is true if we can represent the arch&type, false if not. */
1933 DEFUN(coff_set_flags
,(abfd
, magicp
, flagsp
),
1935 unsigned *magicp AND
1936 unsigned short *flagsp
)
1938 switch (bfd_get_arch(abfd
)) {
1946 *magicp
= I960ROMAGIC
;
1948 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1949 I960RWMAGIC); FIXME???
1951 switch (bfd_get_mach(abfd
)) {
1952 case bfd_mach_i960_core
:
1955 case bfd_mach_i960_kb_sb
:
1958 case bfd_mach_i960_mc
:
1961 case bfd_mach_i960_xa
:
1964 case bfd_mach_i960_ca
:
1967 case bfd_mach_i960_ka_sa
:
1980 *magicp
= MIPS_MAGIC_2
;
1986 *magicp
= I386MAGIC
;
1991 *magicp
= MC68MAGIC
;
1997 *magicp
= MC88OMAGIC
;
2002 case bfd_arch_h8300
:
2003 *magicp
= H8300MAGIC
;
2007 #ifdef A29K_MAGIC_BIG
2009 if (abfd
->xvec
->byteorder_big_p
)
2010 *magicp
= A29K_MAGIC_BIG
;
2012 *magicp
= A29K_MAGIC_LITTLE
;
2018 case bfd_arch_rs6000
:
2019 *magicp
= U802TOCMAGIC
;
2023 default: /* Unknown architecture */
2024 /* return false; -- fall through to "return false" below, to avoid
2025 "statement never reached" errors on the one below. */
2034 DEFUN(coff_set_arch_mach
,(abfd
, arch
, machine
),
2036 enum bfd_architecture arch AND
2037 unsigned long machine
)
2040 unsigned short dummy2
;
2041 bfd_default_set_arch_mach(abfd
, arch
, machine
);
2043 if (arch
!= bfd_arch_unknown
&&
2044 coff_set_flags(abfd
, &dummy1
, &dummy2
) != true)
2045 return false; /* We can't represent this type */
2046 return true; /* We're easy ... */
2050 /* Calculate the file position for each section. */
2053 DEFUN(coff_compute_section_file_positions
,(abfd
),
2057 asection
*previous
= (asection
*)NULL
;
2058 file_ptr sofar
= FILHSZ
;
2060 if (bfd_get_start_address(abfd
))
2062 /* A start address may have been added to the original file. In this
2063 case it will need an optional header to record it. */
2064 abfd
->flags
|= EXEC_P
;
2067 if (abfd
->flags
& EXEC_P
)
2070 sofar
+= abfd
->section_count
* SCNHSZ
;
2071 for (current
= abfd
->sections
;
2072 current
!= (asection
*)NULL
;
2073 current
= current
->next
) {
2075 /* Only deal with sections which have contents */
2076 if (!(current
->flags
& SEC_HAS_CONTENTS
))
2079 /* Align the sections in the file to the same boundary on
2080 which they are aligned in virtual memory. I960 doesn't
2081 do this (FIXME) so we can stay in sync with Intel. 960
2082 doesn't yet page from files... */
2085 /* make sure this section is aligned on the right boundary - by
2086 padding the previous section up if necessary */
2089 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2090 if (previous
!= (asection
*)NULL
) {
2091 previous
->_raw_size
+= sofar
- old_sofar
;
2096 /* FIXME, in demand paged files, the low order bits of the file
2097 offset must match the low order bits of the virtual address.
2098 "Low order" is apparently implementation defined. Add code
2099 here to round sofar up to match the virtual address. */
2101 current
->filepos
= sofar
;
2103 /* make sure that this section is of the right size too */
2104 old_sofar
= sofar
+= current
->_raw_size
;
2105 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2106 current
->_raw_size
+= sofar
- old_sofar
;
2110 obj_relocbase(abfd
) = sofar
;
2119 DEFUN(coff_write_object_contents
,(abfd
),
2125 boolean hasrelocs
= false;
2126 boolean haslinno
= false;
2127 file_ptr reloc_base
;
2128 file_ptr lineno_base
;
2132 unsigned long reloc_size
= 0;
2133 unsigned long lnno_size
= 0;
2134 asection
*text_sec
= NULL
;
2135 asection
*data_sec
= NULL
;
2136 asection
*bss_sec
= NULL
;
2138 struct internal_filehdr internal_f
;
2139 struct internal_aouthdr internal_a
;
2142 bfd_error
= system_call_error
;
2143 /* Number the output sections, starting from one on the first section
2144 with a name which doesn't start with a * */
2146 for (current
= abfd
->sections
; current
!= (asection
*)NULL
;
2147 current
= current
->next
)
2149 current
->target_index
= count
;
2156 if(abfd
->output_has_begun
== false) {
2157 coff_compute_section_file_positions(abfd
);
2160 if (abfd
->sections
!= (asection
*)NULL
) {
2161 scn_base
= abfd
->sections
->filepos
;
2166 if (bfd_seek(abfd
, scn_base
, SEEK_SET
) != 0)
2168 reloc_base
= obj_relocbase(abfd
);
2170 /* Make a pass through the symbol table to count line number entries and
2171 put them into the correct asections */
2173 #ifndef NO_COFF_LINENOS
2174 coff_count_linenumbers(abfd
);
2176 data_base
= scn_base
;
2178 /* Work out the size of the reloc and linno areas */
2180 for (current
= abfd
->sections
; current
!= NULL
; current
=
2183 /* We give section headers to +ve indexes */
2184 if (current
->target_index
> 0)
2187 reloc_size
+= current
->reloc_count
* RELSZ
;
2188 #ifndef NO_COFF_LINENOS
2189 lnno_size
+= current
->lineno_count
* LINESZ
;
2191 data_base
+= SCNHSZ
;
2196 lineno_base
= reloc_base
+ reloc_size
;
2197 sym_base
= lineno_base
+ lnno_size
;
2199 /* Indicate in each section->line_filepos its actual file address */
2200 for (current
= abfd
->sections
; current
!= NULL
; current
=
2203 if (current
->target_index
> 0)
2206 if (current
->lineno_count
) {
2207 current
->line_filepos
= lineno_base
;
2208 current
->moving_line_filepos
= lineno_base
;
2209 #ifndef NO_COFF_LINENOS
2210 lineno_base
+= current
->lineno_count
* LINESZ
;
2214 current
->line_filepos
= 0;
2216 if (current
->reloc_count
) {
2217 current
->rel_filepos
= reloc_base
;
2218 reloc_base
+= current
->reloc_count
* sizeof(struct internal_reloc
);
2221 current
->rel_filepos
= 0;
2228 /* Write section headers to the file. */
2229 internal_f
.f_nscns
= 0;
2231 (file_ptr
) ((abfd
->flags
& EXEC_P
) ?
2232 (FILHSZ
+ AOUTSZ
) : FILHSZ
),
2237 unsigned int pad
= abfd
->flags
& D_PAGED
? data_base
: 0;
2239 unsigned int pad
= 0;
2241 for (current
= abfd
->sections
;
2243 current
= current
->next
) {
2244 struct internal_scnhdr section
;
2245 if (current
->target_index
> 0)
2247 internal_f
.f_nscns
++;
2248 strncpy(&(section
.s_name
[0]), current
->name
, 8);
2249 section
.s_vaddr
= current
->vma
+ pad
;
2250 section
.s_paddr
= current
->vma
+ pad
;
2251 section
.s_size
= current
->_raw_size
- pad
;
2253 If this section has no size or is unloadable then the scnptr
2256 if (current
->_raw_size
- pad
== 0 ||
2257 (current
->flags
& SEC_LOAD
) == 0) {
2258 section
.s_scnptr
= 0;
2261 section
.s_scnptr
= current
->filepos
;
2263 section
.s_relptr
= current
->rel_filepos
;
2264 section
.s_lnnoptr
= current
->line_filepos
;
2265 section
.s_nreloc
= current
->reloc_count
;
2266 section
.s_nlnno
= current
->lineno_count
;
2267 if (current
->reloc_count
!= 0)
2269 if (current
->lineno_count
!= 0)
2272 section
.s_flags
= sec_to_styp_flags(current
->name
,current
->flags
);
2274 if (!strcmp(current
->name
, _TEXT
)) {
2276 } else if (!strcmp(current
->name
, _DATA
)) {
2278 } else if (!strcmp(current
->name
, _BSS
)) {
2283 section
.s_align
= (current
->alignment_power
2284 ? 1 << current
->alignment_power
2291 coff_swap_scnhdr_out(abfd
, §ion
, &buff
);
2292 bfd_write((PTR
) (&buff
), 1, SCNHSZ
, abfd
);
2302 /* OK, now set up the filehdr... */
2304 /* Don't include the internal abs section in the section count */
2307 We will NOT put a fucking timestamp in the header here. Every time you
2308 put it back, I will come in and take it out again. I'm sorry. This
2309 field does not belong here. We fill it with a 0 so it compares the
2310 same but is not a reasonable time. -- gnu@cygnus.com
2313 Well, I like it, so I'm conditionally compiling it in.
2316 #ifdef COFF_TIMESTAMP
2317 internal_f
.f_timdat
= time(0);
2319 internal_f
.f_timdat
= 0;
2322 if (bfd_get_symcount(abfd
) != 0)
2323 internal_f
.f_symptr
= sym_base
;
2325 internal_f
.f_symptr
= 0;
2327 internal_f
.f_flags
= 0;
2329 if (abfd
->flags
& EXEC_P
)
2330 internal_f
.f_opthdr
= AOUTSZ
;
2332 internal_f
.f_opthdr
= 0;
2335 internal_f
.f_flags
|= F_RELFLG
;
2337 internal_f
.f_flags
|= F_LNNO
;
2338 if (0 == bfd_get_symcount(abfd
))
2339 internal_f
.f_flags
|= F_LSYMS
;
2340 if (abfd
->flags
& EXEC_P
)
2341 internal_f
.f_flags
|= F_EXEC
;
2343 internal_f
.f_flags
|= F_AR32W
;
2345 if (!abfd
->xvec
->byteorder_big_p
)
2346 internal_f
.f_flags
|= F_AR32WR
;
2349 FIXME, should do something about the other byte orders and
2353 /* Set up architecture-dependent stuff */
2355 { unsigned int magic
= 0;
2356 unsigned short flags
= 0;
2357 coff_set_flags(abfd
, &magic
, &flags
);
2358 internal_f
.f_magic
= magic
;
2359 internal_f
.f_flags
|= flags
;
2360 /* ...and the "opt"hdr... */
2363 # ifdef ULTRA3 /* NYU's machine */
2364 /* FIXME: This is a bogus check. I really want to see if there
2365 * is a .shbss or a .shdata section, if so then set the magic
2366 * number to indicate a shared data executable.
2368 if (internal_f
.f_nscns
>= 7)
2369 internal_a
.magic
= SHMAGIC
; /* Shared magic */
2371 # endif /* ULTRA3 */
2372 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
2373 #define __A_MAGIC_SET__
2376 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
2377 #define __A_MAGIC_SET__
2380 #define __A_MAGIC_SET__
2381 internal_a
.magic
= PAGEMAGICBCS
;
2384 #if M68 || I386 || MIPS
2385 #define __A_MAGIC_SET__
2386 /* Never was anything here for the 68k */
2390 #define __A_MAGIC_SET__
2391 internal_a
.magic
= (abfd
->flags
& D_PAGED
)? RS6K_AOUTHDR_ZMAGIC
:
2392 (abfd
->flags
& WP_TEXT
)? RS6K_AOUTHDR_NMAGIC
:
2393 RS6K_AOUTHDR_OMAGIC
;
2396 #ifndef __A_MAGIC_SET__
2397 # include "Your aouthdr magic number is not being set!"
2399 # undef __A_MAGIC_SET__
2402 /* Now should write relocs, strings, syms */
2403 obj_sym_filepos(abfd
) = sym_base
;
2405 #ifndef NO_COFF_SYMBOLS
2406 if (bfd_get_symcount(abfd
) != 0) {
2407 coff_renumber_symbols(abfd
);
2408 coff_mangle_symbols(abfd
);
2409 coff_write_symbols(abfd
);
2410 coff_write_linenumbers(abfd
);
2411 coff_write_relocs(abfd
);
2413 #endif /* NO_COFF_SYMBOLS */
2415 internal_a
.tsize
= bfd_get_section_size_before_reloc(text_sec
);
2416 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
2419 internal_a
.dsize
= bfd_get_section_size_before_reloc(data_sec
);
2420 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
2423 internal_a
.bsize
= bfd_get_section_size_before_reloc(bss_sec
);
2426 internal_a
.entry
= bfd_get_start_address(abfd
);
2427 internal_f
.f_nsyms
= bfd_get_symcount(abfd
);
2429 /* now write them */
2430 if (bfd_seek(abfd
, 0L, SEEK_SET
) != 0)
2434 coff_swap_filehdr_out(abfd
, &internal_f
, &buff
);
2435 bfd_write((PTR
) &buff
, 1, FILHSZ
, abfd
);
2437 if (abfd
->flags
& EXEC_P
) {
2439 coff_swap_aouthdr_out(abfd
, &internal_a
, &buff
);
2440 bfd_write((PTR
) &buff
, 1, AOUTSZ
, abfd
);
2445 #ifndef NO_COFF_SYMBOLS
2448 this function transforms the offsets into the symbol table into
2449 pointers to syments.
2454 DEFUN(coff_pointerize_aux
,(ignore_abfd
, table_base
, type
, class, auxent
),
2455 bfd
*ignore_abfd AND
2456 combined_entry_type
*table_base AND
2459 combined_entry_type
*auxent
)
2461 /* Don't bother if this is a file or a section */
2462 if (class == C_STAT
&& type
== T_NULL
) return;
2463 if (class == C_FILE
) return;
2465 /* Otherwise patch up */
2466 if (ISFCN(type
) || ISTAG(class) || class == C_BLOCK
) {
2467 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
= table_base
+
2468 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2469 auxent
->fix_end
= 1;
2471 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
!= 0) {
2472 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
=
2473 table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
2474 auxent
->fix_tag
= 1;
2478 #endif /* NO_COFF_SYMBOLS */
2481 DEFUN(coff_set_section_contents
,(abfd
, section
, location
, offset
, count
),
2486 bfd_size_type count
)
2488 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
2489 coff_compute_section_file_positions(abfd
);
2491 bfd_seek(abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
);
2494 return (bfd_write(location
, 1, count
, abfd
) == count
) ? true : false;
2500 coff_close_and_cleanup(abfd
)
2503 if (!bfd_read_p(abfd
))
2504 switch (abfd
->format
) {
2506 if (!_bfd_write_archive_contents(abfd
))
2510 if (!coff_write_object_contents(abfd
))
2514 bfd_error
= invalid_operation
;
2518 /* We depend on bfd_close to free all the memory on the obstack. */
2519 /* FIXME if bfd_release is not using obstacks! */
2525 buy_and_read(abfd
, where
, seek_direction
, size
)
2531 PTR area
= (PTR
) bfd_alloc(abfd
, size
);
2533 bfd_error
= no_memory
;
2536 bfd_seek(abfd
, where
, seek_direction
);
2537 if (bfd_read(area
, 1, size
, abfd
) != size
) {
2538 bfd_error
= system_call_error
;
2542 } /* buy_and_read() */
2545 #ifndef NO_COFF_SYMBOLS
2548 DEFUN(build_string_table
,(abfd
),
2551 char string_table_size_buffer
[4];
2552 unsigned int string_table_size
;
2555 /* At this point we should be "seek"'d to the end of the
2556 symbols === the symbol table size. */
2557 if (bfd_read((char *) string_table_size_buffer
,
2558 sizeof(string_table_size_buffer
),
2559 1, abfd
) != sizeof(string_table_size
)) {
2560 bfd_error
= system_call_error
;
2564 string_table_size
= bfd_h_get_32(abfd
, (bfd_byte
*) string_table_size_buffer
);
2566 if ((string_table
= (PTR
) bfd_alloc(abfd
, string_table_size
-= 4)) == NULL
) {
2567 bfd_error
= no_memory
;
2569 } /* on mallocation error */
2570 if (bfd_read(string_table
, string_table_size
, 1, abfd
) != string_table_size
) {
2571 bfd_error
= system_call_error
;
2574 return string_table
;
2577 /* Allocate space for the ".debug" section, and read it.
2578 We did not read the debug section until now, because
2579 we didn't want to go to the trouble until someone needed it. */
2582 DEFUN(build_debug_section
,(abfd
),
2585 char *debug_section
;
2588 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
2591 bfd_error
= no_debug_section
;
2595 debug_section
= (PTR
) bfd_alloc (abfd
,
2596 bfd_get_section_size_before_reloc (sect
));
2597 if (debug_section
== NULL
) {
2598 bfd_error
= no_memory
;
2602 /* Seek to the beginning of the `.debug' section and read it.
2603 Save the current position first; it is needed by our caller.
2604 Then read debug section and reset the file pointer. */
2606 position
= bfd_tell (abfd
);
2607 bfd_seek (abfd
, sect
->filepos
, SEEK_SET
);
2608 if (bfd_read (debug_section
,
2609 bfd_get_section_size_before_reloc (sect
), 1, abfd
)
2610 != bfd_get_section_size_before_reloc(sect
)) {
2611 bfd_error
= system_call_error
;
2614 bfd_seek (abfd
, position
, SEEK_SET
);
2615 return debug_section
;
2619 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
2620 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
2621 be \0-terminated. */
2623 DEFUN(copy_name
,(abfd
, name
, maxlen
),
2631 for (len
= 0; len
< maxlen
; ++len
) {
2632 if (name
[len
] == '\0') {
2637 if ((newname
= (PTR
) bfd_alloc(abfd
, len
+1)) == NULL
) {
2638 bfd_error
= no_memory
;
2641 strncpy(newname
, name
, len
);
2642 newname
[len
] = '\0';
2647 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
2648 knit the symbol names into a normalized form. By normalized here I
2649 mean that all symbols have an n_offset pointer that points to a null-
2650 terminated string. */
2652 #ifndef SYMNAME_IN_DEBUG
2653 #define SYMNAME_IN_DEBUG(x) 0
2656 static combined_entry_type
*
2657 DEFUN(get_normalized_symtab
,(abfd
),
2660 combined_entry_type
*internal
;
2661 combined_entry_type
*internal_ptr
;
2662 combined_entry_type
*internal_end
;
2666 char *string_table
= NULL
;
2667 char *debug_section
= NULL
;
2670 unsigned int raw_size
;
2671 if (obj_raw_syments(abfd
) != (combined_entry_type
*)NULL
) {
2672 return obj_raw_syments(abfd
);
2674 if ((size
= bfd_get_symcount(abfd
) * sizeof(combined_entry_type
)) == 0) {
2675 bfd_error
= no_symbols
;
2679 internal
= (combined_entry_type
*)bfd_alloc(abfd
, size
);
2680 internal_end
= internal
+ bfd_get_symcount(abfd
);
2682 raw_size
= bfd_get_symcount(abfd
) * SYMESZ
;
2683 raw
= (SYMENT
*)bfd_alloc(abfd
,raw_size
);
2685 if (bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
) == -1
2686 || bfd_read((PTR
)raw
, raw_size
, 1, abfd
) != raw_size
) {
2687 bfd_error
= system_call_error
;
2690 /* mark the end of the symbols */
2691 raw_end
= raw
+ bfd_get_symcount(abfd
);
2693 FIXME SOMEDAY. A string table size of zero is very weird, but
2694 probably possible. If one shows up, it will probably kill us.
2697 /* Swap all the raw entries */
2698 for (raw_src
= raw
, internal_ptr
= internal
;
2700 raw_src
++, internal_ptr
++) {
2703 coff_swap_sym_in(abfd
, (char *)raw_src
, (char *)&internal_ptr
->u
.syment
);
2704 internal_ptr
->fix_tag
= 0;
2705 internal_ptr
->fix_end
= 0;
2707 for (i
= internal_ptr
->u
.syment
.n_numaux
;
2709 --i
, raw_src
++, internal_ptr
++) {
2711 (internal_ptr
+1)->fix_tag
= 0;
2712 (internal_ptr
+1)->fix_end
= 0;
2714 coff_swap_aux_in(abfd
, (char *)(raw_src
+1),
2715 internal_ptr
->u
.syment
.n_type
,
2716 internal_ptr
->u
.syment
.n_sclass
,
2717 &(internal_ptr
+1)->u
.auxent
);
2719 coff_pointerize_aux(abfd
,
2721 internal_ptr
->u
.syment
.n_type
,
2722 internal_ptr
->u
.syment
.n_sclass
,
2727 /* Free all the raw stuff */
2728 bfd_release(abfd
, raw
);
2730 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
2733 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
) {
2734 /* make a file symbol point to the name in the auxent, since
2735 the text ".file" is redundant */
2736 if ((internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_zeroes
== 0) {
2737 /* the filename is a long one, point into the string table */
2738 if (string_table
== NULL
) {
2739 string_table
= build_string_table(abfd
);
2742 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
2743 (int) (string_table
- 4 +
2744 (internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_offset
);
2747 /* ordinary short filename, put into memory anyway */
2748 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2749 copy_name(abfd
, (internal_ptr
+1)->u
.auxent
.x_file
.x_fname
,
2754 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0) {
2755 /* This is a "short" name. Make it long. */
2756 unsigned long i
= 0;
2757 char *newstring
= NULL
;
2759 /* find the length of this string without walking into memory
2761 for (i
= 0; i
< 8; ++i
) {
2762 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0') {
2764 } /* if end of string */
2765 } /* possible lengths of this string. */
2767 if ((newstring
= (PTR
) bfd_alloc(abfd
, ++i
)) == NULL
) {
2768 bfd_error
= no_memory
;
2771 bzero(newstring
, i
);
2772 strncpy(newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
-1);
2773 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int) newstring
;
2774 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
2776 else if (!SYMNAME_IN_DEBUG(&internal_ptr
->u
.syment
)) {
2777 /* Long name already. Point symbol at the string in the table. */
2778 if (string_table
== NULL
) {
2779 string_table
= build_string_table(abfd
);
2781 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2782 (string_table
- 4 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
2785 /* Long name in debug section. Very similar. */
2786 if (debug_section
== NULL
) {
2787 debug_section
= build_debug_section(abfd
);
2789 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2790 (debug_section
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
2793 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
2796 obj_raw_syments(abfd
) = internal
;
2799 } /* get_normalized_symtab() */
2801 #endif /* NO_COFF_SYMBOLS */
2805 DEFUN(section_from_bfd_index
,(abfd
, index
),
2809 struct sec
*answer
= abfd
->sections
;
2813 return &bfd_abs_section
;
2815 if (index
== N_UNDEF
)
2817 return &bfd_und_section
;
2819 if(index
== N_DEBUG
)
2821 return &bfd_debug_section
;
2826 if (answer
->target_index
== index
)
2828 answer
= answer
->next
;
2833 #ifndef NO_COFF_LINENOS
2839 Creating the linenumber table is done by reading in the entire
2840 coff linenumber table, and creating another table for internal use.
2842 A coff line number table is structured so that each function
2843 is marked as having a line number of 0. Each line within the
2844 function is an offset from the first line in the function. The
2845 base of the line number information for the table is stored in
2846 the symbol associated with the function.
2848 The information is copied from the external to the internal
2849 table, and each symbol which marks a function is marked by
2852 How does this work ?
2857 coff_slurp_line_table(abfd
, asect
)
2861 LINENO
*native_lineno
;
2862 alent
*lineno_cache
;
2864 BFD_ASSERT(asect
->lineno
== (alent
*) NULL
);
2866 native_lineno
= (LINENO
*) buy_and_read(abfd
,
2867 asect
->line_filepos
,
2870 asect
->lineno_count
));
2872 (alent
*) bfd_alloc(abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof(alent
)));
2873 if (lineno_cache
== NULL
) {
2874 bfd_error
= no_memory
;
2877 unsigned int counter
= 0;
2878 alent
*cache_ptr
= lineno_cache
;
2879 LINENO
*src
= native_lineno
;
2881 while (counter
< asect
->lineno_count
) {
2882 struct internal_lineno dst
;
2883 coff_swap_lineno_in(abfd
, src
, &dst
);
2884 cache_ptr
->line_number
= dst
.l_lnno
;
2886 if (cache_ptr
->line_number
== 0) {
2887 coff_symbol_type
*sym
=
2888 (coff_symbol_type
*) (dst
.l_addr
.l_symndx
2889 + obj_raw_syments(abfd
))->u
.syment
._n
._n_n
._n_zeroes
;
2890 cache_ptr
->u
.sym
= (asymbol
*) sym
;
2891 sym
->lineno
= cache_ptr
;
2894 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
2895 - bfd_section_vma(abfd
, asect
);
2896 } /* If no linenumber expect a symbol index */
2902 cache_ptr
->line_number
= 0;
2905 asect
->lineno
= lineno_cache
;
2906 /* FIXME, free native_lineno here, or use alloca or something. */
2908 } /* coff_slurp_line_table() */
2910 #endif /* NO_COFF_LINENOS */
2912 #ifndef NO_COFF_LINENOS
2915 DEFUN(coff_slurp_symbol_table
,(abfd
),
2918 combined_entry_type
*native_symbols
;
2919 coff_symbol_type
*cached_area
;
2920 unsigned int *table_ptr
;
2922 unsigned int number_of_symbols
= 0;
2923 if (obj_symbols(abfd
))
2925 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
2927 /* Read in the symbol table */
2928 if ((native_symbols
= get_normalized_symtab(abfd
)) == NULL
) {
2932 /* Allocate enough room for all the symbols in cached form */
2934 (coff_symbol_type
*)
2935 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(coff_symbol_type
)));
2937 if (cached_area
== NULL
) {
2938 bfd_error
= no_memory
;
2943 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(unsigned int)));
2945 if (table_ptr
== NULL
) {
2946 bfd_error
= no_memory
;
2951 coff_symbol_type
*dst
= cached_area
;
2952 unsigned int last_native_index
= bfd_get_symcount(abfd
);
2953 unsigned int this_index
= 0;
2954 while (this_index
< last_native_index
) {
2955 combined_entry_type
*src
= native_symbols
+ this_index
;
2956 table_ptr
[this_index
] = number_of_symbols
;
2957 dst
->symbol
.the_bfd
= abfd
;
2959 dst
->symbol
.name
= (char *)(src
->u
.syment
._n
._n_n
._n_offset
);
2961 We use the native name field to point to the cached field
2963 src
->u
.syment
._n
._n_n
._n_zeroes
= (int) dst
;
2964 dst
->symbol
.section
= section_from_bfd_index(abfd
,
2965 src
->u
.syment
.n_scnum
);
2966 switch (src
->u
.syment
.n_sclass
) {
2970 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
2971 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2972 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
2974 /* Fall through to next case */
2982 if ((src
->u
.syment
.n_scnum
) == 0) {
2983 if ((src
->u
.syment
.n_value
) == 0) {
2984 dst
->symbol
.section
= &bfd_und_section
;
2985 dst
->symbol
.value
= 0;
2988 dst
->symbol
.section
= &bfd_com_section
;
2989 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
2994 Base the value as an index from the base of the
2998 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2999 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
3001 if (ISFCN((src
->u
.syment
.n_type
))) {
3003 A function ext does not go at the end of a file
3005 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
3012 case C_STAT
: /* static */
3014 case C_LEAFSTAT
: /* static leaf procedure */
3016 case C_LABEL
: /* label */
3017 if (src
->u
.syment
.n_scnum
== -2)
3018 dst
->symbol
.flags
= BSF_DEBUGGING
;
3020 dst
->symbol
.flags
= BSF_LOCAL
;
3022 Base the value as an index from the base of the section, if
3025 if (dst
->symbol
.section
)
3026 dst
->symbol
.value
= (src
->u
.syment
.n_value
) -
3027 dst
->symbol
.section
->vma
;
3029 dst
->symbol
.value
= (src
->u
.syment
.n_value
) ;
3032 case C_MOS
: /* member of structure */
3033 case C_EOS
: /* end of structure */
3034 #ifdef NOTDEF /* C_AUTOARG has the same value */
3036 case C_GLBLREG
: /* A29k-specific storage class */
3039 case C_REGPARM
: /* register parameter */
3040 case C_REG
: /* register variable */
3042 case C_AUTOARG
: /* 960-specific storage class */
3044 case C_TPDEF
: /* type definition */
3046 case C_AUTO
: /* automatic variable */
3047 case C_FIELD
: /* bit field */
3048 case C_ENTAG
: /* enumeration tag */
3049 case C_MOE
: /* member of enumeration */
3050 case C_MOU
: /* member of union */
3051 case C_UNTAG
: /* union tag */
3052 dst
->symbol
.flags
= BSF_DEBUGGING
;
3053 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3056 case C_FILE
: /* file name */
3057 case C_STRTAG
: /* structure tag */
3059 case C_BINCL
: /* beginning of include file */
3060 case C_EINCL
: /* ending of include file */
3073 dst
->symbol
.flags
= BSF_DEBUGGING
;
3074 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3077 case C_BLOCK
: /* ".bb" or ".eb" */
3078 case C_FCN
: /* ".bf" or ".ef" */
3079 case C_EFCN
: /* physical end of function */
3080 dst
->symbol
.flags
= BSF_LOCAL
;
3082 Base the value as an index from the base of the section
3084 dst
->symbol
.value
= (src
->u
.syment
.n_value
) - dst
->symbol
.section
->vma
;
3088 case C_EXTDEF
: /* external definition */
3089 case C_ULABEL
: /* undefined label */
3090 case C_USTATIC
: /* undefined static */
3091 case C_LINE
: /* line # reformatted as symbol table entry */
3092 case C_ALIAS
: /* duplicate tag */
3093 case C_HIDDEN
: /* ext symbol in dmert public lib */
3096 fprintf(stderr
,"Unrecognized storage class %d\n",
3097 src
->u
.syment
.n_sclass
);
3099 dst
->symbol
.flags
= BSF_DEBUGGING
;
3100 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3104 /* BFD_ASSERT(dst->symbol.flags != 0);*/
3108 dst
->symbol
.udata
= 0;
3109 dst
->lineno
= (alent
*) NULL
;
3110 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
3112 number_of_symbols
++;
3113 } /* walk the native symtab */
3114 } /* bfdize the native symtab */
3116 obj_symbols(abfd
) = cached_area
;
3117 obj_raw_syments(abfd
) = native_symbols
;
3119 bfd_get_symcount(abfd
) = number_of_symbols
;
3120 obj_convert(abfd
) = table_ptr
;
3121 /* Slurp the line tables for each section too */
3126 coff_slurp_line_table(abfd
, p
);
3131 } /* coff_slurp_symbol_table() */
3134 coff_get_symtab_upper_bound(abfd
)
3137 if (!coff_slurp_symbol_table(abfd
))
3140 return (bfd_get_symcount(abfd
) + 1) * (sizeof(coff_symbol_type
*));
3145 DEFUN(coff_get_symtab
, (abfd
, alocation
),
3147 asymbol
**alocation
)
3149 unsigned int counter
= 0;
3150 coff_symbol_type
*symbase
;
3151 coff_symbol_type
**location
= (coff_symbol_type
**) (alocation
);
3152 if (!coff_slurp_symbol_table(abfd
))
3155 symbase
= obj_symbols(abfd
);
3156 while (counter
< bfd_get_symcount(abfd
))
3158 /* This nasty code looks at the symbol to decide whether or
3159 not it is descibes a constructor/destructor entry point. It
3160 is structured this way to (hopefully) speed non matches */
3162 if (0 && symbase
->symbol
.name
[9] == '$')
3164 bfd_constructor_entry(abfd
,
3165 (asymbol
**)location
,
3166 symbase
->symbol
.name
[10] == 'I' ?
3170 *(location
++) = symbase
++;
3174 return bfd_get_symcount(abfd
);
3177 #endif /* NO_COFF_SYMBOLS */
3180 coff_get_reloc_upper_bound(abfd
, asect
)
3184 if (bfd_get_format(abfd
) != bfd_object
) {
3185 bfd_error
= invalid_operation
;
3188 return (asect
->reloc_count
+ 1) * sizeof(arelent
*);
3195 Coff relocations are easily transformed into the internal BFD form
3198 Reading a coff relocation table is done in the following stages:
3200 o The entire coff relocation table is read into memory.
3202 o Each relocation is processed in turn, first it is swapped from the
3203 external to the internal form.
3205 o The symbol referenced in the relocation's symbol index is
3206 turned intoa pointer into the canonical symbol table. Note
3207 that this table is the same as the one returned by a call to
3208 @code{bfd_canonicalize_symtab}. The back end will call the
3209 routine and save the result if a canonicalization hasn't been done.
3211 o The reloc index is turned into a pointer to a howto
3212 structure, in a back end specific way. For instance, the 386
3213 and 960 use the @code{r_type} to directly produce an index
3214 into a howto table vector; the 88k subtracts a number from the
3215 @code{r_type} field and creates an addend field.
3221 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
3222 if (ptr && ptr->the_bfd == abfd \
3223 && ptr->section != (asection *) NULL \
3224 && ((ptr->flags & BSF_OLD_COMMON)== 0)) \
3226 cache_ptr->addend = -(ptr->section->vma + ptr->value); \
3229 cache_ptr->addend = 0; \
3234 DEFUN(coff_slurp_reloc_table
,(abfd
, asect
, symbols
),
3239 RELOC
*native_relocs
;
3240 arelent
*reloc_cache
;
3245 if (asect
->relocation
)
3247 if (asect
->reloc_count
== 0)
3249 if (asect
->flags
& SEC_CONSTRUCTOR
)
3251 #ifndef NO_COFF_SYMBOLS
3252 if (!coff_slurp_symbol_table(abfd
))
3256 (RELOC
*) buy_and_read(abfd
,
3260 asect
->reloc_count
));
3261 reloc_cache
= (arelent
*)
3262 bfd_alloc(abfd
, (size_t) (asect
->reloc_count
* sizeof(arelent
)));
3264 if (reloc_cache
== NULL
) {
3265 bfd_error
= no_memory
;
3270 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
3272 #ifdef RELOC_PROCESSING
3273 struct internal_reloc dst
;
3274 struct external_reloc
*src
;
3276 cache_ptr
= reloc_cache
+ idx
;
3277 src
= native_relocs
+ idx
;
3278 bfd_swap_reloc_in(abfd
, src
, &dst
);
3280 RELOC_PROCESSING(cache_ptr
, &dst
, symbols
, abfd
, asect
);
3282 struct internal_reloc dst
;
3284 struct external_reloc
*src
;
3286 cache_ptr
= reloc_cache
+ idx
;
3287 src
= native_relocs
+ idx
;
3289 bfd_swap_reloc_in(abfd
, src
, &dst
);
3292 cache_ptr
->address
= dst
.r_vaddr
;
3294 if (dst
.r_symndx
!= -1)
3296 cache_ptr
->sym_ptr_ptr
= symbols
+ obj_convert(abfd
)[dst
.r_symndx
];
3297 ptr
= *(cache_ptr
->sym_ptr_ptr
);
3301 cache_ptr
->sym_ptr_ptr
= 0;
3307 The symbols definitions that we have read in have been
3308 relocated as if their sections started at 0. But the offsets
3309 refering to the symbols in the raw data have not been
3310 modified, so we have to have a negative addend to compensate.
3312 Note that symbols which used to be common must be left alone */
3314 /* Calculate any reloc addend by looking at the symbol */
3315 CALC_ADDEND(abfd
, ptr
, dst
, cache_ptr
);
3317 cache_ptr
->address
-= asect
->vma
;
3318 /* !! cache_ptr->section = (asection *) NULL;*/
3320 /* Fill in the cache_ptr->howto field from dst.r_type */
3321 RTYPE2HOWTO(cache_ptr
, &dst
);
3326 asect
->relocation
= reloc_cache
;
3331 /* This is stupid. This function should be a boolean predicate */
3333 DEFUN(coff_canonicalize_reloc
, (abfd
, section
, relptr
, symbols
),
3336 arelent
**relptr AND
3339 arelent
*tblptr
= section
->relocation
;
3340 unsigned int count
= 0;
3343 if (section
->flags
& SEC_CONSTRUCTOR
)
3345 /* this section has relocs made up by us, they are not in the
3346 file, so take them out of their chain and place them into
3347 the data area provided */
3348 arelent_chain
*chain
= section
->constructor_chain
;
3349 for (count
= 0; count
< section
->reloc_count
; count
++)
3351 *relptr
++ = &chain
->relent
;
3352 chain
= chain
->next
;
3358 coff_slurp_reloc_table(abfd
, section
, symbols
);
3361 tblptr
= section
->relocation
;
3365 for (; count
++ < section
->reloc_count
;)
3366 *relptr
++ = tblptr
++;
3371 return section
->reloc_count
;
3374 #ifndef NO_COFF_SYMBOLS
3377 provided a BFD, a section and an offset into the section, calculate and
3378 return the name of the source file and the line nearest to the wanted
3383 DEFUN(coff_find_nearest_line
,(abfd
,
3391 asection
*section AND
3392 asymbol
**ignore_symbols AND
3394 CONST
char **filename_ptr AND
3395 CONST
char **functionname_ptr AND
3396 unsigned int *line_ptr
)
3398 static bfd
*cache_abfd
;
3399 static asection
*cache_section
;
3400 static bfd_vma cache_offset
;
3401 static unsigned int cache_i
;
3402 static alent
*cache_l
;
3405 coff_data_type
*cof
= coff_data(abfd
);
3406 /* Run through the raw syments if available */
3407 combined_entry_type
*p
;
3409 unsigned int line_base
= 0;
3413 *functionname_ptr
= 0;
3416 /* Don't try and find line numbers in a non coff file */
3417 if (abfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
3423 p
= cof
->raw_syments
;
3425 for (i
= 0; i
< cof
->raw_syment_count
; i
++) {
3426 if (p
->u
.syment
.n_sclass
== C_FILE
) {
3427 /* File name has been moved into symbol */
3428 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
3431 p
+= 1 + p
->u
.syment
.n_numaux
;
3433 /* Now wander though the raw linenumbers of the section */
3435 If this is the same BFD as we were previously called with and this is
3436 the same section, and the offset we want is further down then we can
3437 prime the lookup loop
3439 if (abfd
== cache_abfd
&&
3440 section
== cache_section
&&
3441 offset
>= cache_offset
) {
3447 l
= section
->lineno
;
3450 for (; i
< section
->lineno_count
; i
++) {
3451 if (l
->line_number
== 0) {
3452 /* Get the symbol this line number points at */
3453 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
3454 *functionname_ptr
= coff
->symbol
.name
;
3456 combined_entry_type
*s
= coff
->native
;
3457 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
3459 S should now point to the .bf of the function
3461 if (s
->u
.syment
.n_numaux
) {
3463 The linenumber is stored in the auxent
3465 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
3466 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
3471 if (l
->u
.offset
> offset
)
3473 *line_ptr
= l
->line_number
+ line_base
+ 1;
3479 cache_section
= section
;
3480 cache_offset
= offset
;
3489 coff_sym_filepos(abfd
)
3492 return obj_sym_filepos(abfd
);
3496 #endif /* NO_COFF_SYMBOLS */
3500 DEFUN(coff_sizeof_headers
,(abfd
, reloc
),
3506 if (reloc
== false) {
3507 size
= FILHSZ
+ AOUTSZ
;
3513 size
+= abfd
->section_count
* SCNHSZ
;
3518 DEFUN(get_value
,(reloc
, seclet
),
3520 bfd_seclet_type
*seclet
)
3523 asymbol
*symbol
= *(reloc
->sym_ptr_ptr
);
3524 /* A symbol holds a pointer to a section, and an offset from the
3525 base of the section. To relocate, we find where the section will
3526 live in the output and add that in */
3528 if (symbol
->section
== &bfd_und_section
)
3530 /* Ouch, this is an undefined symbol.. */
3531 bfd_error_vector
.undefined_symbol(reloc
, seclet
);
3532 value
= symbol
->value
;
3536 value
= symbol
->value
+
3537 symbol
->section
->output_offset
+
3538 symbol
->section
->output_section
->vma
;
3542 /* Add the value contained in the relocation */
3543 value
+= (short)((reloc
->addend
) & 0xffff);
3549 DEFUN(perform_slip
,(s
, slip
, input_section
, value
),
3551 unsigned int slip AND
3552 asection
*input_section AND
3556 /* Find all symbols past this point, and make them know
3561 if (p
->section
== input_section
)
3563 /* This was pointing into this section, so mangle it */
3564 if (p
->value
> value
)
3574 DEFUN(movb1
,(input_section
, symbols
, r
, shrink
),
3575 asection
*input_section AND
3576 asymbol
**symbols AND
3578 unsigned int shrink
)
3580 bfd_vma value
= get_value(r
,0);
3582 if (value
>= 0xff00)
3585 /* Change the reloc type from 16bit, possible 8 to 8bit
3587 r
->howto
= r
->howto
+ 1;
3588 /* The place to relc moves back by one */
3591 /* This will be two bytes smaller in the long run */
3593 perform_slip(symbols
, 2, input_section
, r
->address
- shrink
+1);
3601 DEFUN(jmp1
,(input_section
, symbols
, r
, shrink
),
3602 asection
*input_section AND
3603 asymbol
**symbols AND
3605 unsigned int shrink
)
3609 bfd_vma value
= get_value(r
, 0);
3611 bfd_vma dot
= input_section
->output_section
->vma
+
3612 input_section
->output_offset
+ r
->address
;
3615 /* See if the address we're looking at within 127 bytes of where
3616 we are, if so then we can use a small branch rather than the
3617 jump we were going to */
3619 gap
= value
- (dot
- shrink
);
3622 if (-120 < (long)gap
&& (long)gap
< 120 )
3625 /* Change the reloc type from 16bit, possible 8 to 8bit
3627 r
->howto
= r
->howto
+ 1;
3628 /* The place to relc moves back by one */
3631 /* This will be two bytes smaller in the long run */
3633 perform_slip(symbols
, 2, input_section
, r
->address
-shrink
+1);
3641 DEFUN(bfd_coff_relax_section
,(abfd
, i
, symbols
, seclet
),
3644 asymbol
**symbols AND
3645 bfd_seclet_type
*seclet
)
3648 /* Get enough memory to hold the stuff */
3649 bfd
*input_bfd
= i
->owner
;
3650 asection
*input_section
= i
;
3652 boolean
new = false;
3654 bfd_size_type reloc_size
= bfd_get_reloc_upper_bound(input_bfd
,
3656 arelent
**reloc_vector
= (arelent
**)bfd_xmalloc(reloc_size
);
3658 /* Get the relocs and think about them */
3659 if (bfd_canonicalize_reloc(input_bfd
,
3665 for (parent
= reloc_vector
; *parent
; parent
++)
3667 arelent
*r
= *parent
;
3668 switch (r
->howto
->type
) {
3676 shrink
= movb1(input_section
, symbols
, r
, shrink
);
3681 shrink
= jmp1(input_section
, symbols
, r
, shrink
);
3689 input_section
->_cooked_size
-= shrink
;
3690 free((char *)reloc_vector
);
3695 DEFUN(bfd_coff_get_relocated_section_contents
,(in_abfd
, seclet
),
3697 bfd_seclet_type
*seclet
)
3700 asymbol
**symbols
= 0;
3701 extern bfd
*output_bfd
;
3703 /* Get enough memory to hold the stuff */
3704 bfd
*input_bfd
= seclet
->u
.indirect
.section
->owner
;
3705 asection
*input_section
= seclet
->u
.indirect
.section
;
3707 bfd_byte
*data
= (bfd_byte
*)malloc(input_section
->_raw_size
);
3708 bfd_byte
*dst
= data
;
3709 bfd_byte
*prev_dst
= data
;
3711 unsigned int gap
= 0;
3713 bfd_size_type reloc_size
= bfd_get_reloc_upper_bound(input_bfd
,
3715 arelent
**reloc_vector
= (arelent
**)bfd_xmalloc(reloc_size
);
3717 /* read in the section */
3718 bfd_get_section_contents(input_bfd
,
3722 input_section
->_raw_size
);
3725 if (bfd_canonicalize_reloc(input_bfd
,
3728 seclet
->u
.indirect
.symbols
) )
3730 arelent
**parent
= reloc_vector
;
3735 unsigned int dst_address
= 0;
3736 unsigned int src_address
= 0;
3740 /* Find how long a run we can do */
3741 while (dst_address
< seclet
->size
)
3747 /* Note that the relaxing didn't tie up the addresses in the
3748 relocation, so we use the original address to work out the
3749 run of non-relocated data */
3750 run
= reloc
->address
- src_address
;
3756 run
= seclet
->size
- dst_address
;
3758 /* Copy the bytes */
3759 for (idx
= 0; idx
< run
; idx
++)
3761 data
[dst_address
++] = data
[src_address
++];
3764 /* Now do the relocation */
3768 switch (reloc
->howto
->type
)
3771 /* Speciial relaxed type */
3773 bfd_vma dot
= seclet
->offset
+ dst_address
+ seclet
->u
.indirect
.section
->output_section
->vma
;
3774 int gap
= get_value(reloc
,seclet
)-dot
-1;
3775 if ((gap
& ~0xff ) != 0 &&((gap
& 0xff00)!= 0xff00)) abort();
3777 bfd_put_8(in_abfd
,gap
, data
+dst_address
);
3779 switch (data
[dst_address
-1])
3784 bfd_put_8(in_abfd
, 0x55, data
+dst_address
-1);
3788 bfd_put_8(in_abfd
, 0x40, data
+dst_address
-1);
3807 /* Special relaxed type, there will be a gap between where we
3808 get stuff from and where we put stuff to now
3810 for a mov.b @aa:16 -> mov.b @aa:8
3811 opcode 0x6a 0x0y offset
3814 if (data
[dst_address
-1] != 0x6a)
3816 switch (data
[dst_address
] & 0xf0)
3820 data
[dst_address
-1] = (data
[src_address
] & 0xf) | 0x20;
3824 data
[dst_address
-1] = (data
[src_address
] & 0xf) | 0x30;
3830 /* the offset must fit ! after all, what was all the relaxing
3833 bfd_put_8(in_abfd
, get_value(reloc
, seclet
), data
+ dst_address
);
3835 /* Note the magic - src goes up by two bytes, but dst by only
3844 bfd_vma dot
= seclet
->offset
+ dst_address
+ seclet
->u
.indirect
.section
->output_section
->vma
;
3845 int gap
= get_value(reloc
,seclet
)-dot
;
3846 if (gap
> 127 || gap
< -128)
3848 bfd_error_vector
.reloc_value_truncated(reloc
, seclet
);
3851 bfd_put_8(in_abfd
,gap
, data
+dst_address
);
3860 unsigned int gap
=get_value(reloc
,seclet
);
3863 bfd_error_vector
.reloc_value_truncated(reloc
, seclet
);
3866 bfd_put_8(in_abfd
, gap
, data
+dst_address
);
3874 /* A relword which would have like to have been a pcrel */
3876 /* A relword which would like to have been modified but
3879 bfd_put_16(in_abfd
, get_value(reloc
,seclet
), data
+dst_address
);
3890 free((char *)reloc_vector
);
3896 #define coff_core_file_failing_command _bfd_dummy_core_file_failing_command
3897 #define coff_core_file_failing_signal _bfd_dummy_core_file_failing_signal
3898 #define coff_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
3899 #define coff_slurp_armap bfd_slurp_coff_armap
3900 #define coff_slurp_extended_name_table _bfd_slurp_extended_name_table
3901 #define coff_truncate_arname bfd_dont_truncate_arname
3902 #define coff_openr_next_archived_file bfd_generic_openr_next_archived_file
3903 #define coff_generic_stat_arch_elt bfd_generic_stat_arch_elt
3904 #define coff_get_section_contents bfd_generic_get_section_contents
3905 #define coff_close_and_cleanup bfd_generic_close_and_cleanup
3907 #define coff_bfd_debug_info_start bfd_void
3908 #define coff_bfd_debug_info_end bfd_void
3909 #define coff_bfd_debug_info_accumulate (PROTO(void,(*),(bfd*, struct sec *))) bfd_void
3910 #define coff_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
3911 #define coff_bfd_relax_section bfd_generic_relax_section