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
;
571 if (ext
->x_file
.x_fname
[0] == 0) {
572 in
->x_file
.x_n
.x_zeroes
= 0;
573 in
->x_file
.x_n
.x_offset
=
574 bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
576 #if FILNMLEN != E_FILNMLEN
577 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
579 memcpy (in
->x_file
.x_fname
, ext
->x_file
.x_fname
, FILNMLEN
);
584 /* RS/6000 "csect" auxents */
588 in
->x_csect
.x_scnlen
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_scnlen
);
589 in
->x_csect
.x_parmhash
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_parmhash
);
590 in
->x_csect
.x_snhash
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snhash
);
591 /* We don't have to hack bitfields in x_smtyp because it's defined by
592 shifts-and-ands, which are equivalent on all byte orders. */
593 in
->x_csect
.x_smtyp
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smtyp
);
594 in
->x_csect
.x_smclas
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smclas
);
595 in
->x_csect
.x_stab
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_stab
);
596 in
->x_csect
.x_snstab
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snstab
);
605 if (type
== T_NULL
) {
606 in
->x_scn
.x_scnlen
= GET_SCN_SCNLEN(abfd
, ext
);
607 in
->x_scn
.x_nreloc
= GET_SCN_NRELOC(abfd
, ext
);
608 in
->x_scn
.x_nlinno
= GET_SCN_NLINNO(abfd
, ext
);
612 in
->x_sym
.x_tagndx
.l
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
614 in
->x_sym
.x_tvndx
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
617 if (ISARY(type
) || class == C_BLOCK
) {
618 #if DIMNUM != E_DIMNUM
619 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
621 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]);
622 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]);
623 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]);
624 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]);
627 in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= GET_FCN_LNNOPTR(abfd
, ext
);
628 in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= GET_FCN_ENDNDX(abfd
, ext
);
631 in
->x_sym
.x_misc
.x_fsize
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
634 in
->x_sym
.x_misc
.x_lnsz
.x_lnno
= GET_LNSZ_LNNO(abfd
, ext
);
635 in
->x_sym
.x_misc
.x_lnsz
.x_size
= GET_LNSZ_SIZE(abfd
, ext
);
641 DEFUN(coff_swap_aux_out
,(abfd
, inp
, type
, class, extp
),
648 union internal_auxent
*in
= (union internal_auxent
*)inp
;
649 AUXENT
*ext
= (AUXENT
*)extp
;
652 if (in
->x_file
.x_fname
[0] == 0) {
653 PUTWORD(abfd
, 0, (bfd_byte
*) ext
->x_file
.x_n
.x_zeroes
);
655 in
->x_file
.x_n
.x_offset
,
656 (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
659 #if FILNMLEN != E_FILNMLEN
660 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
662 memcpy (ext
->x_file
.x_fname
, in
->x_file
.x_fname
, FILNMLEN
);
668 /* RS/6000 "csect" auxents */
671 PUTWORD (abfd
, in
->x_csect
.x_scnlen
, ext
->x_csect
.x_scnlen
);
672 PUTWORD (abfd
, in
->x_csect
.x_parmhash
, ext
->x_csect
.x_parmhash
);
673 PUTHALF (abfd
, in
->x_csect
.x_snhash
, ext
->x_csect
.x_snhash
);
674 /* We don't have to hack bitfields in x_smtyp because it's defined by
675 shifts-and-ands, which are equivalent on all byte orders. */
676 PUTBYTE (abfd
, in
->x_csect
.x_smtyp
, ext
->x_csect
.x_smtyp
);
677 PUTBYTE (abfd
, in
->x_csect
.x_smclas
, ext
->x_csect
.x_smclas
);
678 PUTWORD (abfd
, in
->x_csect
.x_stab
, ext
->x_csect
.x_stab
);
679 PUTHALF (abfd
, in
->x_csect
.x_snstab
, ext
->x_csect
.x_snstab
);
688 if (type
== T_NULL
) {
689 PUT_SCN_SCNLEN(abfd
, in
->x_scn
.x_scnlen
, ext
);
690 PUT_SCN_NRELOC(abfd
, in
->x_scn
.x_nreloc
, ext
);
691 PUT_SCN_NLINNO(abfd
, in
->x_scn
.x_nlinno
, ext
);
695 PUTWORD(abfd
, in
->x_sym
.x_tagndx
.l
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
697 bfd_h_put_16(abfd
, in
->x_sym
.x_tvndx
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
701 PUTWORD(abfd
, in
->x_sym
.x_misc
.x_fsize
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
702 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
703 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
707 if (ISARY(type
) || class == C_BLOCK
) {
708 #if DIMNUM != E_DIMNUM
709 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
711 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]);
712 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]);
713 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]);
714 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]);
717 PUT_LNSZ_LNNO(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
718 PUT_LNSZ_SIZE(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
720 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
721 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
726 return sizeof(AUXENT
);
729 #endif /* NO_COFF_SYMBOLS */
731 #ifndef NO_COFF_LINENOS
734 DEFUN(coff_swap_lineno_in
,(abfd
, ext1
, in1
),
739 LINENO
*ext
= (LINENO
*)ext1
;
740 struct internal_lineno
*in
= (struct internal_lineno
*)in1
;
742 in
->l_addr
.l_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->l_addr
.l_symndx
);
743 in
->l_lnno
= GET_LINENO_LNNO(abfd
, ext
);
747 DEFUN(coff_swap_lineno_out
,(abfd
, inp
, outp
),
752 struct internal_lineno
*in
= (struct internal_lineno
*)inp
;
753 struct external_lineno
*ext
= (struct external_lineno
*)outp
;
754 PUTWORD(abfd
, in
->l_addr
.l_symndx
, (bfd_byte
*)
755 ext
->l_addr
.l_symndx
);
757 PUT_LINENO_LNNO (abfd
, in
->l_lnno
, ext
);
758 return sizeof(struct external_lineno
);
761 #endif /* NO_COFF_LINENOS */
765 DEFUN(bfd_swap_aouthdr_in
,(abfd
, aouthdr_ext1
, aouthdr_int1
),
770 AOUTHDR
*aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
771 struct internal_aouthdr
*aouthdr_int
= (struct internal_aouthdr
*)aouthdr_int1
;
773 aouthdr_int
->magic
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->magic
);
774 aouthdr_int
->vstamp
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->vstamp
);
775 aouthdr_int
->tsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tsize
);
776 aouthdr_int
->dsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->dsize
);
777 aouthdr_int
->bsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->bsize
);
778 aouthdr_int
->entry
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->entry
);
779 aouthdr_int
->text_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->text_start
);
780 aouthdr_int
->data_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->data_start
);
782 aouthdr_int
->tagentries
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tagentries
);
786 aouthdr_int
->o_toc
= bfd_h_get_32(abfd
, aouthdr_ext
->o_toc
);
787 aouthdr_int
->o_snentry
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snentry
);
788 aouthdr_int
->o_sntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntext
);
789 aouthdr_int
->o_sndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sndata
);
790 aouthdr_int
->o_sntoc
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntoc
);
791 aouthdr_int
->o_snloader
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snloader
);
792 aouthdr_int
->o_snbss
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snbss
);
793 aouthdr_int
->o_algntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algntext
);
794 aouthdr_int
->o_algndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algndata
);
795 aouthdr_int
->o_modtype
= bfd_h_get_16(abfd
, aouthdr_ext
->o_modtype
);
796 aouthdr_int
->o_maxstack
= bfd_h_get_32(abfd
, aouthdr_ext
->o_maxstack
);
801 DEFUN(coff_swap_aouthdr_out
,(abfd
, in
, out
),
806 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*)in
;
807 AOUTHDR
*aouthdr_out
= (AOUTHDR
*)out
;
808 bfd_h_put_16(abfd
, aouthdr_in
->magic
, (bfd_byte
*) aouthdr_out
->magic
);
809 bfd_h_put_16(abfd
, aouthdr_in
->vstamp
, (bfd_byte
*) aouthdr_out
->vstamp
);
810 bfd_h_put_32(abfd
, aouthdr_in
->tsize
, (bfd_byte
*) aouthdr_out
->tsize
);
811 bfd_h_put_32(abfd
, aouthdr_in
->dsize
, (bfd_byte
*) aouthdr_out
->dsize
);
812 bfd_h_put_32(abfd
, aouthdr_in
->bsize
, (bfd_byte
*) aouthdr_out
->bsize
);
813 bfd_h_put_32(abfd
, aouthdr_in
->entry
, (bfd_byte
*) aouthdr_out
->entry
);
814 bfd_h_put_32(abfd
, aouthdr_in
->text_start
,
815 (bfd_byte
*) aouthdr_out
->text_start
);
816 bfd_h_put_32(abfd
, aouthdr_in
->data_start
, (bfd_byte
*) aouthdr_out
->data_start
);
818 bfd_h_put_32(abfd
, aouthdr_in
->tagentries
, (bfd_byte
*) aouthdr_out
->tagentries
);
820 return sizeof(AOUTHDR
);
824 DEFUN(coff_swap_scnhdr_in
,(abfd
, scnhdr_ext
, scnhdr_int
),
826 SCNHDR
*scnhdr_ext AND
827 struct internal_scnhdr
*scnhdr_int
)
829 memcpy(scnhdr_int
->s_name
, scnhdr_ext
->s_name
, sizeof(scnhdr_int
->s_name
));
830 scnhdr_int
->s_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
831 scnhdr_int
->s_paddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
832 scnhdr_int
->s_size
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_size
);
834 scnhdr_int
->s_scnptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
835 scnhdr_int
->s_relptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
836 scnhdr_int
->s_lnnoptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
837 scnhdr_int
->s_flags
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_flags
);
839 scnhdr_int
->s_nreloc
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
840 scnhdr_int
->s_nlnno
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
842 scnhdr_int
->s_nreloc
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
843 scnhdr_int
->s_nlnno
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
846 scnhdr_int
->s_align
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_align
);
851 DEFUN(coff_swap_scnhdr_out
,(abfd
, in
, out
),
856 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*)in
;
857 SCNHDR
*scnhdr_ext
= (SCNHDR
*)out
;
858 memcpy(scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof(scnhdr_int
->s_name
));
859 PUTWORD(abfd
, scnhdr_int
->s_vaddr
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
860 PUTWORD(abfd
, scnhdr_int
->s_paddr
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
861 PUTWORD(abfd
, scnhdr_int
->s_size
, (bfd_byte
*) scnhdr_ext
->s_size
);
862 PUTWORD(abfd
, scnhdr_int
->s_scnptr
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
863 PUTWORD(abfd
, scnhdr_int
->s_relptr
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
864 PUTWORD(abfd
, scnhdr_int
->s_lnnoptr
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
865 PUTWORD(abfd
, scnhdr_int
->s_flags
, (bfd_byte
*) scnhdr_ext
->s_flags
);
867 PUTWORD(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
868 PUTWORD(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
870 PUTHALF(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
871 PUTHALF(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
875 PUTWORD(abfd
, scnhdr_int
->s_align
, (bfd_byte
*) scnhdr_ext
->s_align
);
877 return sizeof(SCNHDR
);
882 initialize a section structure with information peculiar to this
883 particular implementation of coff
887 DEFUN(coff_new_section_hook
,(abfd_ignore
, section
),
891 section
->alignment_power
= abfd_ignore
->xvec
->align_power_min
;
895 static asection bfd_debug_section
=
901 DEFUN(make_abs_section
,(abfd
),
909 /* Take a section header read from a coff file (in HOST byte order),
910 and make a BFD "section" out of it. */
912 DEFUN(make_a_section_from_file
,(abfd
, hdr
, target_index
),
914 struct internal_scnhdr
*hdr AND
915 unsigned int target_index
)
917 asection
*return_section
;
920 /* Assorted wastage to null-terminate the name, thanks AT&T! */
921 name
= bfd_alloc(abfd
, sizeof (hdr
->s_name
)+1);
923 bfd_error
= no_memory
;
926 strncpy(name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
927 name
[sizeof (hdr
->s_name
)] = 0;
929 return_section
= bfd_make_section(abfd
, name
);
930 if (return_section
== NULL
)
933 /* s_paddr is presumed to be = to s_vaddr */
935 return_section
->vma
= hdr
->s_vaddr
;
936 return_section
->_raw_size
= hdr
->s_size
;
937 return_section
->filepos
= hdr
->s_scnptr
;
938 return_section
->rel_filepos
= hdr
->s_relptr
;
939 return_section
->reloc_count
= hdr
->s_nreloc
;
942 /* FIXME, use a temp var rather than alignment_power */
943 return_section
->alignment_power
= hdr
->s_align
;
946 for (i
= 0; i
< 32; i
++) {
947 if ((1 << i
) >= (int) (return_section
->alignment_power
)) {
948 return_section
->alignment_power
= i
;
955 return_section
->line_filepos
= hdr
->s_lnnoptr
;
957 return_section->linesize = hdr->s_nlnno * sizeof (struct lineno);
960 return_section
->lineno_count
= hdr
->s_nlnno
;
961 return_section
->userdata
= NULL
;
962 return_section
->next
= (asection
*) NULL
;
963 return_section
->flags
= styp_to_sec_flags(hdr
->s_flags
);
965 return_section
->target_index
= target_index
;
967 if (hdr
->s_nreloc
!= 0)
968 return_section
->flags
|= SEC_RELOC
;
969 /* FIXME: should this check 'hdr->s_size > 0' */
970 if (hdr
->s_scnptr
!= 0)
971 return_section
->flags
|= SEC_HAS_CONTENTS
;
975 DEFUN(coff_mkobject
,(abfd
),
978 abfd
->tdata
.coff_obj_data
= (struct coff_tdata
*)bfd_zalloc (abfd
,sizeof(coff_data_type
));
979 if (abfd
->tdata
.coff_obj_data
== 0){
980 bfd_error
= no_memory
;
983 coff_data(abfd
)->relocbase
= 0;
984 /* make_abs_section(abfd);*/
990 DEFUN(coff_real_object_p
,(abfd
, nscns
, internal_f
, internal_a
),
993 struct internal_filehdr
*internal_f AND
994 struct internal_aouthdr
*internal_a
)
996 coff_data_type
*coff
;
997 enum bfd_architecture arch
;
999 size_t readsize
; /* length of file_info */
1000 SCNHDR
*external_sections
;
1002 /* Build a play area */
1003 if (coff_mkobject(abfd
) != true)
1006 coff
= coff_data(abfd
);
1009 external_sections
= (SCNHDR
*)bfd_alloc(abfd
, readsize
= (nscns
* SCNHSZ
));
1011 if (bfd_read((PTR
)external_sections
, 1, readsize
, abfd
) != readsize
) {
1016 /* Now copy data as required; construct all asections etc */
1017 coff
->symbol_index_slew
= 0;
1019 coff
->raw_syment_count
= 0;
1020 coff
->raw_linenos
= 0;
1021 coff
->raw_syments
= 0;
1022 coff
->sym_filepos
=0;
1023 coff
->flags
= internal_f
->f_flags
;
1026 for (i
= 0; i
< nscns
; i
++) {
1027 struct internal_scnhdr tmp
;
1028 coff_swap_scnhdr_in(abfd
, external_sections
+ i
, &tmp
);
1029 make_a_section_from_file(abfd
,&tmp
, i
+1);
1033 /* make_abs_section(abfd);*/
1035 /* Determine the machine architecture and type. */
1037 switch (internal_f
->f_magic
) {
1040 arch
= bfd_arch_i386
;
1045 #ifdef A29K_MAGIC_BIG
1046 case A29K_MAGIC_BIG
:
1047 case A29K_MAGIC_LITTLE
:
1048 arch
= bfd_arch_a29k
;
1057 arch
= bfd_arch_mips
;
1065 arch
= bfd_arch_m68k
;
1073 arch
= bfd_arch_m88k
;
1081 arch
= bfd_arch_i960
;
1082 switch (F_I960TYPE
& internal_f
->f_flags
)
1086 machine
= bfd_mach_i960_core
;
1089 machine
= bfd_mach_i960_kb_sb
;
1092 machine
= bfd_mach_i960_mc
;
1095 machine
= bfd_mach_i960_xa
;
1098 machine
= bfd_mach_i960_ca
;
1101 machine
= bfd_mach_i960_ka_sa
;
1112 arch
= bfd_arch_rs6000
;
1119 arch
= bfd_arch_h8300
;
1124 default: /* Unreadable input file type */
1125 arch
= bfd_arch_obscure
;
1129 bfd_default_set_arch_mach(abfd
, arch
, machine
);
1130 if (!(internal_f
->f_flags
& F_RELFLG
))
1131 abfd
->flags
|= HAS_RELOC
;
1132 if ((internal_f
->f_flags
& F_EXEC
))
1133 abfd
->flags
|= EXEC_P
;
1134 if (!(internal_f
->f_flags
& F_LNNO
))
1135 abfd
->flags
|= HAS_LINENO
;
1136 if (!(internal_f
->f_flags
& F_LSYMS
))
1137 abfd
->flags
|= HAS_LOCALS
;
1140 bfd_get_symcount(abfd
) = internal_f
->f_nsyms
;
1141 if (internal_f
->f_nsyms
)
1142 abfd
->flags
|= HAS_SYMS
;
1144 coff
->sym_filepos
= internal_f
->f_symptr
;
1146 /* These members communicate important constants about the symbol table
1147 to GDB's symbol-reading code. These `constants' unfortunately vary
1148 from coff implementation to implementation... */
1149 #ifndef NO_COFF_SYMBOLS
1150 coff
->local_n_btmask
= N_BTMASK
;
1151 coff
->local_n_btshft
= N_BTSHFT
;
1152 coff
->local_n_tmask
= N_TMASK
;
1153 coff
->local_n_tshift
= N_TSHIFT
;
1154 coff
->local_symesz
= SYMESZ
;
1155 coff
->local_auxesz
= AUXESZ
;
1156 coff
->local_linesz
= LINESZ
;
1159 coff
->symbols
= (coff_symbol_type
*) NULL
;
1160 bfd_get_start_address(abfd
) = internal_f
->f_opthdr
? internal_a
->entry
: 0;
1164 bfd_release(abfd
, coff
);
1165 return (bfd_target
*)NULL
;
1169 DEFUN(coff_object_p
,(abfd
),
1175 struct internal_filehdr internal_f
;
1176 struct internal_aouthdr internal_a
;
1178 bfd_error
= system_call_error
;
1180 /* figure out how much to read */
1181 if (bfd_read((PTR
) &filehdr
, 1, FILHSZ
, abfd
) != FILHSZ
)
1184 bfd_swap_filehdr_in(abfd
, &filehdr
, &internal_f
);
1186 if (BADMAG(internal_f
)) {
1187 bfd_error
= wrong_format
;
1190 nscns
=internal_f
.f_nscns
;
1192 if (internal_f
.f_opthdr
) {
1193 if (bfd_read((PTR
) &opthdr
, 1,AOUTSZ
, abfd
) != AOUTSZ
) {
1196 bfd_swap_aouthdr_in(abfd
, (char *)&opthdr
, (char *)&internal_a
);
1199 /* Seek past the opt hdr stuff */
1200 bfd_seek(abfd
, internal_f
.f_opthdr
+ FILHSZ
, SEEK_SET
);
1202 /* if the optional header is NULL or not the correct size then
1203 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1204 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1205 optional header is of a different size.
1207 But the mips keeps extra stuff in it's opthdr, so dont check
1211 #if defined(M88) || defined(I960)
1212 if (internal_f
.f_opthdr
!= 0 && AOUTSZ
!= internal_f
.f_opthdr
)
1213 return (bfd_target
*)NULL
;
1216 return coff_real_object_p(abfd
, nscns
, &internal_f
, &internal_a
);
1221 #ifndef NO_COFF_LINENOS
1224 DEFUN(coff_count_linenumbers
,(abfd
),
1227 unsigned int limit
= bfd_get_symcount(abfd
);
1231 asection
*s
= abfd
->sections
->output_section
;
1233 BFD_ASSERT(s
->lineno_count
== 0);
1239 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++) {
1240 asymbol
*q_maybe
= *p
;
1241 if (q_maybe
->the_bfd
->xvec
->flavour
== bfd_target_coff_flavour
) {
1242 coff_symbol_type
*q
= coffsymbol(q_maybe
);
1245 This symbol has a linenumber, increment the owning
1246 section's linenumber count
1248 alent
*l
= q
->lineno
;
1249 q
->symbol
.section
->output_section
->lineno_count
++;
1251 while (l
->line_number
) {
1252 q
->symbol
.section
->output_section
->lineno_count
++;
1260 #endif /* NO_COFF_LINENOS */
1262 #ifndef NO_COFF_SYMBOLS
1265 Takes a bfd and a symbol, returns a pointer to the coff specific area
1266 of the symbol if there is one.
1268 static coff_symbol_type
*
1269 DEFUN(coff_symbol_from
,(ignore_abfd
, symbol
),
1270 bfd
*ignore_abfd AND
1273 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
1274 return (coff_symbol_type
*)NULL
;
1276 if (symbol
->the_bfd
->tdata
.coff_obj_data
== (coff_data_type
*)NULL
)
1277 return (coff_symbol_type
*)NULL
;
1279 return (coff_symbol_type
*) symbol
;
1285 DEFUN(fixup_symbol_value
,(coff_symbol_ptr
, syment
),
1286 coff_symbol_type
*coff_symbol_ptr AND
1287 struct internal_syment
*syment
)
1290 /* Normalize the symbol flags */
1291 if (coff_symbol_ptr
->symbol
.section
== &bfd_com_section
) {
1292 /* a common symbol is undefined with a value */
1293 syment
->n_scnum
= N_UNDEF
;
1294 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1296 else if (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) {
1297 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1299 else if (coff_symbol_ptr
->symbol
.section
== & bfd_und_section
) {
1300 syment
->n_scnum
= N_UNDEF
;
1301 syment
->n_value
= 0;
1304 if (coff_symbol_ptr
->symbol
.section
) {
1306 coff_symbol_ptr
->symbol
.section
->output_section
->target_index
;
1309 coff_symbol_ptr
->symbol
.value
+
1310 coff_symbol_ptr
->symbol
.section
->output_offset
+
1311 coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
1315 /* This can happen, but I don't know why yet (steve@cygnus.com) */
1316 syment
->n_scnum
= N_ABS
;
1317 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1322 /* run through all the symbols in the symbol table and work out what
1323 their indexes into the symbol table will be when output
1325 Coff requires that each C_FILE symbol points to the next one in the
1326 chain, and that the last one points to the first external symbol. We
1331 DEFUN(coff_renumber_symbols
,(bfd_ptr
),
1334 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1335 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1336 unsigned int native_index
= 0;
1337 struct internal_syment
*last_file
= (struct internal_syment
*)NULL
;
1338 unsigned int symbol_index
;
1339 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1341 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1342 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1343 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1346 if (s
->u
.syment
.n_sclass
== C_FILE
)
1348 if (last_file
!= (struct internal_syment
*)NULL
) {
1349 last_file
->n_value
= native_index
;
1351 last_file
= &(s
->u
.syment
);
1355 /* Modify the symbol values according to their section and
1358 fixup_symbol_value(coff_symbol_ptr
, &(s
->u
.syment
));
1360 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++) {
1361 s
[i
].offset
= native_index
++;
1372 Run thorough the symbol table again, and fix it so that all pointers to
1373 entries are changed to the entries' index in the output symbol table.
1377 DEFUN(coff_mangle_symbols
,(bfd_ptr
),
1380 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1381 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1382 unsigned int symbol_index
;
1384 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1386 coff_symbol_type
*coff_symbol_ptr
=
1387 coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1389 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1391 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1393 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++) {
1394 combined_entry_type
*a
= s
+ i
+ 1;
1396 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
1397 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
1401 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
1402 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
1412 static int string_size
;
1414 DEFUN(coff_fix_symbol_name
,(ignore_abfd
, symbol
, native
),
1415 bfd
*ignore_abfd AND
1417 combined_entry_type
*native
)
1419 unsigned int name_length
;
1420 union internal_auxent
*auxent
;
1421 char * name
= ( char *)(symbol
->name
);
1423 if (name
== (char *) NULL
) {
1424 /* coff symbols always have names, so we'll make one up */
1425 symbol
->name
= "strange";
1426 name
= (char *)symbol
->name
;
1428 name_length
= strlen(name
);
1430 if (native
->u
.syment
.n_sclass
== C_FILE
) {
1431 strncpy(native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
1432 auxent
= &(native
+1)->u
.auxent
;
1434 #ifdef COFF_LONG_FILENAMES
1435 if (name_length
<= FILNMLEN
) {
1436 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1439 auxent
->x_file
.x_n
.x_offset
= string_size
+ 4;
1440 auxent
->x_file
.x_n
.x_zeroes
= 0;
1441 string_size
+= name_length
+ 1;
1444 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1445 if (name_length
> FILNMLEN
) {
1446 name
[FILNMLEN
] = '\0';
1451 { /* NOT A C_FILE SYMBOL */
1452 if (name_length
<= SYMNMLEN
) {
1453 /* This name will fit into the symbol neatly */
1454 strncpy(native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
1457 native
->u
.syment
._n
._n_n
._n_offset
= string_size
+ 4;
1458 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1459 string_size
+= name_length
+ 1;
1467 DEFUN(coff_write_symbol
,(abfd
, symbol
, native
, written
),
1470 combined_entry_type
*native AND
1471 unsigned int written
)
1473 unsigned int numaux
= native
->u
.syment
.n_numaux
;
1474 int type
= native
->u
.syment
.n_type
;
1475 int class = native
->u
.syment
.n_sclass
;
1478 if (symbol
->section
== &bfd_abs_section
)
1480 native
->u
.syment
.n_scnum
= N_ABS
;
1482 else if (symbol
->section
== &bfd_debug_section
)
1484 native
->u
.syment
.n_scnum
= N_DEBUG
;
1486 else if (symbol
->section
== &bfd_und_section
)
1488 native
->u
.syment
.n_scnum
= N_UNDEF
;
1492 native
->u
.syment
.n_scnum
=
1493 symbol
->section
->output_section
->target_index
;
1497 coff_fix_symbol_name(abfd
, symbol
, native
);
1499 coff_swap_sym_out(abfd
, &native
->u
.syment
, &buf
);
1500 bfd_write((PTR
)& buf
, 1, SYMESZ
, abfd
);
1501 for (j
= 0; j
< native
->u
.syment
.n_numaux
; j
++)
1504 bzero((PTR
)&buf
, AUXESZ
);
1505 coff_swap_aux_out(abfd
,
1506 &( (native
+ j
+ 1)->u
.auxent
), type
, class, &buf1
);
1507 bfd_write((PTR
) (&buf1
), 1, AUXESZ
, abfd
);
1510 Reuse somewhere in the symbol to keep the index
1512 set_index(symbol
, written
);
1513 return written
+ 1 + numaux
;
1518 DEFUN(coff_write_alien_symbol
,(abfd
, symbol
, written
),
1521 unsigned int written
)
1524 This symbol has been created by the loader, or come from a non
1525 coff format. It has no native element to inherit, make our
1528 combined_entry_type
*native
;
1529 combined_entry_type dummy
;
1531 native
->u
.syment
.n_type
= T_NULL
;
1533 native
->u
.syment
.n_flags
= 0;
1535 if (symbol
->section
== &bfd_und_section
)
1537 native
->u
.syment
.n_scnum
= N_UNDEF
;
1538 native
->u
.syment
.n_value
= symbol
->value
;
1540 else if (symbol
->section
== &bfd_com_section
)
1542 native
->u
.syment
.n_scnum
= N_UNDEF
;
1543 native
->u
.syment
.n_value
= symbol
->value
;
1547 else if (symbol
->flags
& BSF_DEBUGGING
) {
1549 remove name so it doesn't take up any space
1554 native
->u
.syment
.n_scnum
= symbol
->section
->output_section
->target_index
;
1555 native
->u
.syment
.n_value
= symbol
->value
+
1556 symbol
->section
->output_section
->vma
+
1557 symbol
->section
->output_offset
;
1559 /* Copy the any flags from the the file hdr into the symbol */
1561 coff_symbol_type
*c
= coff_symbol_from(abfd
, symbol
);
1562 if (c
!= (coff_symbol_type
*)NULL
) {
1563 native
->u
.syment
.n_flags
= c
->symbol
.the_bfd
->flags
;
1570 native
->u
.syment
.pad1
[0] = 0;
1571 native
->u
.syment
.pad1
[0] = 0;
1574 native
->u
.syment
.n_type
= 0;
1575 if (symbol
->flags
& BSF_LOCAL
)
1576 native
->u
.syment
.n_sclass
= C_STAT
;
1578 native
->u
.syment
.n_sclass
= C_EXT
;
1579 native
->u
.syment
.n_numaux
= 0;
1581 return coff_write_symbol(abfd
, symbol
, native
, written
);
1585 DEFUN(coff_write_native_symbol
,(abfd
, symbol
, written
),
1587 coff_symbol_type
*symbol AND
1588 unsigned int written
)
1591 Does this symbol have an ascociated line number - if so then
1592 make it remember this symbol index. Also tag the auxent of
1593 this symbol to point to the right place in the lineno table
1595 combined_entry_type
*native
= symbol
->native
;
1597 alent
*lineno
= symbol
->lineno
;
1599 if (lineno
&& !symbol
->done_lineno
) {
1600 unsigned int count
= 0;
1601 lineno
[count
].u
.offset
= written
;
1602 if (native
->u
.syment
.n_numaux
) {
1603 union internal_auxent
*a
= &((native
+1)->u
.auxent
);
1605 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1606 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1609 And count and relocate all other linenumbers
1613 while (lineno
[count
].line_number
) {
1614 lineno
[count
].u
.offset
+=
1615 symbol
->symbol
.section
->output_section
->vma
+
1616 symbol
->symbol
.section
->output_offset
;
1619 symbol
->done_lineno
= true;
1621 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1624 return coff_write_symbol(abfd
, &( symbol
->symbol
), native
,written
);
1628 DEFUN(coff_write_symbols
,(abfd
),
1632 unsigned int limit
= bfd_get_symcount(abfd
);
1633 unsigned int written
= 0;
1640 /* Seek to the right place */
1641 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
1643 /* Output all the symbols we have */
1646 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1648 asymbol
*symbol
= *p
;
1649 coff_symbol_type
*c_symbol
= coff_symbol_from(abfd
, symbol
);
1651 if (c_symbol
== (coff_symbol_type
*) NULL
||
1652 c_symbol
->native
== (combined_entry_type
*)NULL
)
1654 written
= coff_write_alien_symbol(abfd
, symbol
, written
);
1658 written
= coff_write_native_symbol(abfd
, c_symbol
, written
);
1663 bfd_get_symcount(abfd
) = written
;
1665 /* Now write out strings */
1667 if (string_size
!= 0)
1669 unsigned int size
= string_size
+ 4;
1672 bfd_h_put_32(abfd
, size
, buffer
);
1673 bfd_write((PTR
) buffer
, 1, sizeof(buffer
), abfd
);
1674 for (p
= abfd
->outsymbols
, i
= 0;
1679 size_t name_length
= strlen(q
->name
);
1681 coff_symbol_type
* c_symbol
= coff_symbol_from(abfd
, q
);
1682 maxlen
= ((c_symbol
!= NULL
&& c_symbol
->native
!= NULL
) &&
1683 (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
)) ?
1684 FILNMLEN
: SYMNMLEN
;
1686 if (name_length
> maxlen
) {
1687 bfd_write((PTR
) (q
->name
), 1, name_length
+ 1, abfd
);
1692 /* We would normally not write anything here, but we'll write
1693 out 4 so that any stupid coff reader which tries to read
1694 the string table even when there isn't one won't croak.
1697 uint32e_type size
= 4;
1699 bfd_write((PTR
)&size
, 1, sizeof(size
), abfd
);
1708 To write relocations, all the back end does is step though the
1709 canonical relocation table, and create an
1710 @code{internal_reloc}. The symbol index to use is removed from
1711 the @code{offset} field in the symbol table supplied, the
1712 address comes directly from the sum of the section base
1713 address and the relocation offset and the type is dug directly
1714 from the howto field. Then the @code{internal_reloc} is
1715 swapped into the shape of an @code{external_reloc} and written
1721 DEFUN(coff_write_relocs
,(abfd
),
1725 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1727 struct external_reloc dst
;
1729 arelent
**p
= s
->orelocation
;
1730 bfd_seek(abfd
, s
->rel_filepos
, SEEK_SET
);
1731 for (i
= 0; i
< s
->reloc_count
; i
++) {
1732 struct internal_reloc n
;
1734 memset((PTR
)&n
, 0, sizeof(n
));
1735 n
.r_vaddr
= q
->address
+ s
->vma
;
1736 if (q
->sym_ptr_ptr
) {
1737 n
.r_symndx
= get_index((*(q
->sym_ptr_ptr
)));
1740 /* Work out reloc type from what is required */
1741 SELECT_RELOC(n
.r_type
, q
->howto
);
1743 n
.r_type
= q
->howto
->type
;
1745 coff_swap_reloc_out(abfd
, &n
, &dst
);
1746 bfd_write((PTR
) &n
, 1, RELSZ
, abfd
);
1750 #endif /* NO_COFF_SYMBOLS */
1752 #ifndef NO_COFF_LINENOS
1755 DEFUN(coff_write_linenumbers
,(abfd
),
1759 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1760 if (s
->lineno_count
) {
1761 asymbol
**q
= abfd
->outsymbols
;
1762 bfd_seek(abfd
, s
->line_filepos
, SEEK_SET
);
1763 /* Find all the linenumbers in this section */
1766 alent
*l
= BFD_SEND(p
->the_bfd
, _get_lineno
, (p
->the_bfd
, p
));
1768 /* Found a linenumber entry, output */
1769 struct internal_lineno out
;
1771 memset( (PTR
)&out
, 0, sizeof(out
));
1773 out
.l_addr
.l_symndx
= l
->u
.offset
;
1774 coff_swap_lineno_out(abfd
, &out
, &buff
);
1775 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1777 while (l
->line_number
) {
1778 out
.l_lnno
= l
->line_number
;
1779 out
.l_addr
.l_symndx
= l
->u
.offset
;
1780 coff_swap_lineno_out(abfd
, &out
, &buff
);
1781 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
1792 DEFUN(coff_get_lineno
,(ignore_abfd
, symbol
),
1793 bfd
*ignore_abfd AND
1796 return coffsymbol(symbol
)->lineno
;
1799 #endif /* NO_COFF_LINENOS */
1802 coff_make_empty_symbol(abfd
)
1805 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc(abfd
, sizeof(coff_symbol_type
));
1807 bfd_error
= no_memory
;
1811 new->lineno
= (alent
*) NULL
;
1812 new->done_lineno
= false;
1813 new->symbol
.the_bfd
= abfd
;
1814 return &new->symbol
;
1817 #ifndef NO_COFF_SYMBOLS
1820 DEFUN(coff_print_symbol
,(ignore_abfd
, filep
, symbol
, how
),
1821 bfd
*ignore_abfd AND
1824 bfd_print_symbol_type how
)
1826 FILE *file
= (FILE *)filep
;
1828 case bfd_print_symbol_name
:
1829 fprintf(file
, "%s", symbol
->name
);
1831 case bfd_print_symbol_more
:
1832 fprintf(file
, "coff %lx %lx", (unsigned long) coffsymbol(symbol
)->native
,
1833 (unsigned long) coffsymbol(symbol
)->lineno
);
1835 case bfd_print_symbol_nm
:
1838 CONST
char *section_name
= symbol
->section
->name
;
1839 bfd_print_symbol_vandf((PTR
) file
, symbol
);
1842 fprintf(file
, " %-5s %s %s %s",
1844 coffsymbol(symbol
)->native
? "n" : "g",
1845 coffsymbol(symbol
)->lineno
? "l" : " ",
1851 case bfd_print_symbol_all
:
1852 /* Print out the symbols in a reasonable way */
1854 CONST
char *section_name
= symbol
->section
->name
;
1857 if (coffsymbol(symbol
)->native
)
1860 combined_entry_type
*combined
= coffsymbol(symbol
)->native
;
1861 combined_entry_type
*root
= obj_raw_syments(ignore_abfd
);
1863 fprintf(file
,"[%3d]",
1867 fprintf(file
, "(sc %2d)(fl%4x)(ty%3x)(sc%3d) nx(%d) %08x %s",
1868 combined
->u
.syment
.n_scnum
,
1869 combined
->u
.syment
.n_flags
,
1870 combined
->u
.syment
.n_type
,
1871 combined
->u
.syment
.n_sclass
,
1872 combined
->u
.syment
.n_numaux
,
1873 combined
->u
.syment
.n_value
,
1876 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
1879 switch (combined
->u
.syment
.n_sclass
) {
1881 fprintf(file
, "File ");
1884 fprintf(file
, "AUX lnno %x size %x tagndx %x",
1885 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
1886 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
1887 combined
[aux
+1].u
.auxent
.x_sym
.x_tagndx
.l
);
1895 struct lineno_cache_entry
*l
= coffsymbol(symbol
)->lineno
;
1898 printf("\n%s :", l
->u
.sym
->name
);
1900 while (l
->line_number
)
1902 printf("\n%4d : %x",
1916 bfd_print_symbol_vandf((PTR
) file
, symbol
);
1917 fprintf(file
, " %-5s %s %s %s",
1919 coffsymbol(symbol
)->native
? "n" : "g",
1920 coffsymbol(symbol
)->lineno
? "l" : " ",
1929 #endif /* NO_COFF_SYMBOLS */
1931 /* Set flags and magic number of a coff file from architecture and machine
1932 type. Result is true if we can represent the arch&type, false if not. */
1935 DEFUN(coff_set_flags
,(abfd
, magicp
, flagsp
),
1937 unsigned *magicp AND
1938 unsigned short *flagsp
)
1940 switch (bfd_get_arch(abfd
)) {
1948 *magicp
= I960ROMAGIC
;
1950 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1951 I960RWMAGIC); FIXME???
1953 switch (bfd_get_mach(abfd
)) {
1954 case bfd_mach_i960_core
:
1957 case bfd_mach_i960_kb_sb
:
1960 case bfd_mach_i960_mc
:
1963 case bfd_mach_i960_xa
:
1966 case bfd_mach_i960_ca
:
1969 case bfd_mach_i960_ka_sa
:
1982 *magicp
= MIPS_MAGIC_2
;
1988 *magicp
= I386MAGIC
;
1993 *magicp
= MC68MAGIC
;
1999 *magicp
= MC88OMAGIC
;
2004 case bfd_arch_h8300
:
2005 *magicp
= H8300MAGIC
;
2009 #ifdef A29K_MAGIC_BIG
2011 if (abfd
->xvec
->byteorder_big_p
)
2012 *magicp
= A29K_MAGIC_BIG
;
2014 *magicp
= A29K_MAGIC_LITTLE
;
2020 case bfd_arch_rs6000
:
2021 *magicp
= U802TOCMAGIC
;
2025 default: /* Unknown architecture */
2026 /* return false; -- fall through to "return false" below, to avoid
2027 "statement never reached" errors on the one below. */
2036 DEFUN(coff_set_arch_mach
,(abfd
, arch
, machine
),
2038 enum bfd_architecture arch AND
2039 unsigned long machine
)
2042 unsigned short dummy2
;
2043 bfd_default_set_arch_mach(abfd
, arch
, machine
);
2045 if (arch
!= bfd_arch_unknown
&&
2046 coff_set_flags(abfd
, &dummy1
, &dummy2
) != true)
2047 return false; /* We can't represent this type */
2048 return true; /* We're easy ... */
2052 /* Calculate the file position for each section. */
2055 DEFUN(coff_compute_section_file_positions
,(abfd
),
2059 asection
*previous
= (asection
*)NULL
;
2060 file_ptr sofar
= FILHSZ
;
2062 if (bfd_get_start_address(abfd
))
2064 /* A start address may have been added to the original file. In this
2065 case it will need an optional header to record it. */
2066 abfd
->flags
|= EXEC_P
;
2069 if (abfd
->flags
& EXEC_P
)
2072 sofar
+= abfd
->section_count
* SCNHSZ
;
2073 for (current
= abfd
->sections
;
2074 current
!= (asection
*)NULL
;
2075 current
= current
->next
) {
2077 /* Only deal with sections which have contents */
2078 if (!(current
->flags
& SEC_HAS_CONTENTS
))
2081 /* Align the sections in the file to the same boundary on
2082 which they are aligned in virtual memory. I960 doesn't
2083 do this (FIXME) so we can stay in sync with Intel. 960
2084 doesn't yet page from files... */
2087 /* make sure this section is aligned on the right boundary - by
2088 padding the previous section up if necessary */
2091 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2092 if (previous
!= (asection
*)NULL
) {
2093 previous
->_raw_size
+= sofar
- old_sofar
;
2098 /* FIXME, in demand paged files, the low order bits of the file
2099 offset must match the low order bits of the virtual address.
2100 "Low order" is apparently implementation defined. Add code
2101 here to round sofar up to match the virtual address. */
2103 current
->filepos
= sofar
;
2105 /* make sure that this section is of the right size too */
2106 old_sofar
= sofar
+= current
->_raw_size
;
2107 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2108 current
->_raw_size
+= sofar
- old_sofar
;
2112 obj_relocbase(abfd
) = sofar
;
2121 DEFUN(coff_write_object_contents
,(abfd
),
2127 boolean hasrelocs
= false;
2128 boolean haslinno
= false;
2129 file_ptr reloc_base
;
2130 file_ptr lineno_base
;
2134 unsigned long reloc_size
= 0;
2135 unsigned long lnno_size
= 0;
2136 asection
*text_sec
= NULL
;
2137 asection
*data_sec
= NULL
;
2138 asection
*bss_sec
= NULL
;
2140 struct internal_filehdr internal_f
;
2141 struct internal_aouthdr internal_a
;
2144 bfd_error
= system_call_error
;
2145 /* Number the output sections, starting from one on the first section
2146 with a name which doesn't start with a * */
2148 for (current
= abfd
->sections
; current
!= (asection
*)NULL
;
2149 current
= current
->next
)
2151 current
->target_index
= count
;
2158 if(abfd
->output_has_begun
== false) {
2159 coff_compute_section_file_positions(abfd
);
2162 if (abfd
->sections
!= (asection
*)NULL
) {
2163 scn_base
= abfd
->sections
->filepos
;
2168 if (bfd_seek(abfd
, scn_base
, SEEK_SET
) != 0)
2170 reloc_base
= obj_relocbase(abfd
);
2172 /* Make a pass through the symbol table to count line number entries and
2173 put them into the correct asections */
2175 #ifndef NO_COFF_LINENOS
2176 coff_count_linenumbers(abfd
);
2178 data_base
= scn_base
;
2180 /* Work out the size of the reloc and linno areas */
2182 for (current
= abfd
->sections
; current
!= NULL
; current
=
2185 /* We give section headers to +ve indexes */
2186 if (current
->target_index
> 0)
2189 reloc_size
+= current
->reloc_count
* RELSZ
;
2190 #ifndef NO_COFF_LINENOS
2191 lnno_size
+= current
->lineno_count
* LINESZ
;
2193 data_base
+= SCNHSZ
;
2198 lineno_base
= reloc_base
+ reloc_size
;
2199 sym_base
= lineno_base
+ lnno_size
;
2201 /* Indicate in each section->line_filepos its actual file address */
2202 for (current
= abfd
->sections
; current
!= NULL
; current
=
2205 if (current
->target_index
> 0)
2208 if (current
->lineno_count
) {
2209 current
->line_filepos
= lineno_base
;
2210 current
->moving_line_filepos
= lineno_base
;
2211 #ifndef NO_COFF_LINENOS
2212 lineno_base
+= current
->lineno_count
* LINESZ
;
2216 current
->line_filepos
= 0;
2218 if (current
->reloc_count
) {
2219 current
->rel_filepos
= reloc_base
;
2220 reloc_base
+= current
->reloc_count
* sizeof(struct internal_reloc
);
2223 current
->rel_filepos
= 0;
2230 /* Write section headers to the file. */
2231 internal_f
.f_nscns
= 0;
2233 (file_ptr
) ((abfd
->flags
& EXEC_P
) ?
2234 (FILHSZ
+ AOUTSZ
) : FILHSZ
),
2239 unsigned int pad
= abfd
->flags
& D_PAGED
? data_base
: 0;
2241 unsigned int pad
= 0;
2243 for (current
= abfd
->sections
;
2245 current
= current
->next
) {
2246 struct internal_scnhdr section
;
2247 if (current
->target_index
> 0)
2249 internal_f
.f_nscns
++;
2250 strncpy(&(section
.s_name
[0]), current
->name
, 8);
2251 section
.s_vaddr
= current
->vma
+ pad
;
2252 section
.s_paddr
= current
->vma
+ pad
;
2253 section
.s_size
= current
->_raw_size
- pad
;
2255 If this section has no size or is unloadable then the scnptr
2258 if (current
->_raw_size
- pad
== 0 ||
2259 (current
->flags
& SEC_LOAD
) == 0) {
2260 section
.s_scnptr
= 0;
2263 section
.s_scnptr
= current
->filepos
;
2265 section
.s_relptr
= current
->rel_filepos
;
2266 section
.s_lnnoptr
= current
->line_filepos
;
2267 section
.s_nreloc
= current
->reloc_count
;
2268 section
.s_nlnno
= current
->lineno_count
;
2269 if (current
->reloc_count
!= 0)
2271 if (current
->lineno_count
!= 0)
2274 section
.s_flags
= sec_to_styp_flags(current
->name
,current
->flags
);
2276 if (!strcmp(current
->name
, _TEXT
)) {
2278 } else if (!strcmp(current
->name
, _DATA
)) {
2280 } else if (!strcmp(current
->name
, _BSS
)) {
2285 section
.s_align
= (current
->alignment_power
2286 ? 1 << current
->alignment_power
2293 coff_swap_scnhdr_out(abfd
, §ion
, &buff
);
2294 bfd_write((PTR
) (&buff
), 1, SCNHSZ
, abfd
);
2304 /* OK, now set up the filehdr... */
2306 /* Don't include the internal abs section in the section count */
2309 We will NOT put a fucking timestamp in the header here. Every time you
2310 put it back, I will come in and take it out again. I'm sorry. This
2311 field does not belong here. We fill it with a 0 so it compares the
2312 same but is not a reasonable time. -- gnu@cygnus.com
2315 Well, I like it, and now we have *customers* who have requested it,
2316 so I'm conditionally compiling it in.
2320 #ifndef NOCOFF_TIMESTAMP
2321 internal_f
.f_timdat
= time(0);
2323 internal_f
.f_timdat
= 0;
2326 if (bfd_get_symcount(abfd
) != 0)
2327 internal_f
.f_symptr
= sym_base
;
2329 internal_f
.f_symptr
= 0;
2331 internal_f
.f_flags
= 0;
2333 if (abfd
->flags
& EXEC_P
)
2334 internal_f
.f_opthdr
= AOUTSZ
;
2336 internal_f
.f_opthdr
= 0;
2339 internal_f
.f_flags
|= F_RELFLG
;
2341 internal_f
.f_flags
|= F_LNNO
;
2342 if (0 == bfd_get_symcount(abfd
))
2343 internal_f
.f_flags
|= F_LSYMS
;
2344 if (abfd
->flags
& EXEC_P
)
2345 internal_f
.f_flags
|= F_EXEC
;
2347 if (!abfd
->xvec
->byteorder_big_p
)
2348 internal_f
.f_flags
|= F_AR32WR
;
2350 internal_f
.f_flags
|= F_AR32W
;
2353 FIXME, should do something about the other byte orders and
2357 /* Set up architecture-dependent stuff */
2359 { unsigned int magic
= 0;
2360 unsigned short flags
= 0;
2361 coff_set_flags(abfd
, &magic
, &flags
);
2362 internal_f
.f_magic
= magic
;
2363 internal_f
.f_flags
|= flags
;
2364 /* ...and the "opt"hdr... */
2367 # ifdef ULTRA3 /* NYU's machine */
2368 /* FIXME: This is a bogus check. I really want to see if there
2369 * is a .shbss or a .shdata section, if so then set the magic
2370 * number to indicate a shared data executable.
2372 if (internal_f
.f_nscns
>= 7)
2373 internal_a
.magic
= SHMAGIC
; /* Shared magic */
2375 # endif /* ULTRA3 */
2376 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
2377 #define __A_MAGIC_SET__
2380 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
2381 #define __A_MAGIC_SET__
2384 #define __A_MAGIC_SET__
2385 internal_a
.magic
= PAGEMAGICBCS
;
2388 #if M68 || I386 || MIPS
2389 #define __A_MAGIC_SET__
2390 /* Never was anything here for the 68k */
2394 #define __A_MAGIC_SET__
2395 internal_a
.magic
= (abfd
->flags
& D_PAGED
)? RS6K_AOUTHDR_ZMAGIC
:
2396 (abfd
->flags
& WP_TEXT
)? RS6K_AOUTHDR_NMAGIC
:
2397 RS6K_AOUTHDR_OMAGIC
;
2400 #ifndef __A_MAGIC_SET__
2401 # include "Your aouthdr magic number is not being set!"
2403 # undef __A_MAGIC_SET__
2406 /* Now should write relocs, strings, syms */
2407 obj_sym_filepos(abfd
) = sym_base
;
2409 #ifndef NO_COFF_SYMBOLS
2410 if (bfd_get_symcount(abfd
) != 0) {
2411 coff_renumber_symbols(abfd
);
2412 coff_mangle_symbols(abfd
);
2413 coff_write_symbols(abfd
);
2414 coff_write_linenumbers(abfd
);
2415 coff_write_relocs(abfd
);
2417 #endif /* NO_COFF_SYMBOLS */
2419 internal_a
.tsize
= bfd_get_section_size_before_reloc(text_sec
);
2420 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
2423 internal_a
.dsize
= bfd_get_section_size_before_reloc(data_sec
);
2424 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
2427 internal_a
.bsize
= bfd_get_section_size_before_reloc(bss_sec
);
2430 internal_a
.entry
= bfd_get_start_address(abfd
);
2431 internal_f
.f_nsyms
= bfd_get_symcount(abfd
);
2433 /* now write them */
2434 if (bfd_seek(abfd
, 0L, SEEK_SET
) != 0)
2438 coff_swap_filehdr_out(abfd
, (PTR
)&internal_f
, (PTR
)&buff
);
2439 bfd_write((PTR
) &buff
, 1, FILHSZ
, abfd
);
2441 if (abfd
->flags
& EXEC_P
) {
2443 coff_swap_aouthdr_out(abfd
, (PTR
)&internal_a
, (PTR
)&buff
);
2444 bfd_write((PTR
) &buff
, 1, AOUTSZ
, abfd
);
2449 #ifndef NO_COFF_SYMBOLS
2452 this function transforms the offsets into the symbol table into
2453 pointers to syments.
2458 DEFUN(coff_pointerize_aux
,(ignore_abfd
, table_base
, type
, class, auxent
),
2459 bfd
*ignore_abfd AND
2460 combined_entry_type
*table_base AND
2463 combined_entry_type
*auxent
)
2465 /* Don't bother if this is a file or a section */
2466 if (class == C_STAT
&& type
== T_NULL
) return;
2467 if (class == C_FILE
) return;
2469 /* Otherwise patch up */
2470 if (ISFCN(type
) || ISTAG(class) || class == C_BLOCK
) {
2471 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
= table_base
+
2472 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2473 auxent
->fix_end
= 1;
2475 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
!= 0) {
2476 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
=
2477 table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
2478 auxent
->fix_tag
= 1;
2482 #endif /* NO_COFF_SYMBOLS */
2485 DEFUN(coff_set_section_contents
,(abfd
, section
, location
, offset
, count
),
2490 bfd_size_type count
)
2492 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
2493 coff_compute_section_file_positions(abfd
);
2495 bfd_seek(abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
);
2498 return (bfd_write(location
, 1, count
, abfd
) == count
) ? true : false;
2504 coff_close_and_cleanup(abfd
)
2507 if (!bfd_read_p(abfd
))
2508 switch (abfd
->format
) {
2510 if (!_bfd_write_archive_contents(abfd
))
2514 if (!coff_write_object_contents(abfd
))
2518 bfd_error
= invalid_operation
;
2522 /* We depend on bfd_close to free all the memory on the obstack. */
2523 /* FIXME if bfd_release is not using obstacks! */
2529 buy_and_read(abfd
, where
, seek_direction
, size
)
2535 PTR area
= (PTR
) bfd_alloc(abfd
, size
);
2537 bfd_error
= no_memory
;
2540 bfd_seek(abfd
, where
, seek_direction
);
2541 if (bfd_read(area
, 1, size
, abfd
) != size
) {
2542 bfd_error
= system_call_error
;
2546 } /* buy_and_read() */
2549 #ifndef NO_COFF_SYMBOLS
2552 DEFUN(build_string_table
,(abfd
),
2555 char string_table_size_buffer
[4];
2556 unsigned int string_table_size
;
2559 /* At this point we should be "seek"'d to the end of the
2560 symbols === the symbol table size. */
2561 if (bfd_read((char *) string_table_size_buffer
,
2562 sizeof(string_table_size_buffer
),
2563 1, abfd
) != sizeof(string_table_size
)) {
2564 bfd_error
= system_call_error
;
2568 string_table_size
= bfd_h_get_32(abfd
, (bfd_byte
*) string_table_size_buffer
);
2570 if ((string_table
= (PTR
) bfd_alloc(abfd
, string_table_size
-= 4)) == NULL
) {
2571 bfd_error
= no_memory
;
2573 } /* on mallocation error */
2574 if (bfd_read(string_table
, string_table_size
, 1, abfd
) != string_table_size
) {
2575 bfd_error
= system_call_error
;
2578 return string_table
;
2581 /* Allocate space for the ".debug" section, and read it.
2582 We did not read the debug section until now, because
2583 we didn't want to go to the trouble until someone needed it. */
2586 DEFUN(build_debug_section
,(abfd
),
2589 char *debug_section
;
2592 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
2595 bfd_error
= no_debug_section
;
2599 debug_section
= (PTR
) bfd_alloc (abfd
,
2600 bfd_get_section_size_before_reloc (sect
));
2601 if (debug_section
== NULL
) {
2602 bfd_error
= no_memory
;
2606 /* Seek to the beginning of the `.debug' section and read it.
2607 Save the current position first; it is needed by our caller.
2608 Then read debug section and reset the file pointer. */
2610 position
= bfd_tell (abfd
);
2611 bfd_seek (abfd
, sect
->filepos
, SEEK_SET
);
2612 if (bfd_read (debug_section
,
2613 bfd_get_section_size_before_reloc (sect
), 1, abfd
)
2614 != bfd_get_section_size_before_reloc(sect
)) {
2615 bfd_error
= system_call_error
;
2618 bfd_seek (abfd
, position
, SEEK_SET
);
2619 return debug_section
;
2623 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
2624 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
2625 be \0-terminated. */
2627 DEFUN(copy_name
,(abfd
, name
, maxlen
),
2635 for (len
= 0; len
< maxlen
; ++len
) {
2636 if (name
[len
] == '\0') {
2641 if ((newname
= (PTR
) bfd_alloc(abfd
, len
+1)) == NULL
) {
2642 bfd_error
= no_memory
;
2645 strncpy(newname
, name
, len
);
2646 newname
[len
] = '\0';
2651 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
2652 knit the symbol names into a normalized form. By normalized here I
2653 mean that all symbols have an n_offset pointer that points to a null-
2654 terminated string. */
2656 #ifndef SYMNAME_IN_DEBUG
2657 #define SYMNAME_IN_DEBUG(x) 0
2660 static combined_entry_type
*
2661 DEFUN(get_normalized_symtab
,(abfd
),
2664 combined_entry_type
*internal
;
2665 combined_entry_type
*internal_ptr
;
2666 combined_entry_type
*symbol_ptr
;
2667 combined_entry_type
*internal_end
;
2671 char *string_table
= NULL
;
2672 char *debug_section
= NULL
;
2675 unsigned int raw_size
;
2676 if (obj_raw_syments(abfd
) != (combined_entry_type
*)NULL
) {
2677 return obj_raw_syments(abfd
);
2679 if ((size
= bfd_get_symcount(abfd
) * sizeof(combined_entry_type
)) == 0) {
2680 bfd_error
= no_symbols
;
2684 internal
= (combined_entry_type
*)bfd_alloc(abfd
, size
);
2685 internal_end
= internal
+ bfd_get_symcount(abfd
);
2687 raw_size
= bfd_get_symcount(abfd
) * SYMESZ
;
2688 raw
= (SYMENT
*)bfd_alloc(abfd
,raw_size
);
2690 if (bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
) == -1
2691 || bfd_read((PTR
)raw
, raw_size
, 1, abfd
) != raw_size
) {
2692 bfd_error
= system_call_error
;
2695 /* mark the end of the symbols */
2696 raw_end
= raw
+ bfd_get_symcount(abfd
);
2698 FIXME SOMEDAY. A string table size of zero is very weird, but
2699 probably possible. If one shows up, it will probably kill us.
2702 /* Swap all the raw entries */
2703 for (raw_src
= raw
, internal_ptr
= internal
;
2705 raw_src
++, internal_ptr
++) {
2708 coff_swap_sym_in(abfd
, (PTR
)raw_src
, (PTR
)&internal_ptr
->u
.syment
);
2709 internal_ptr
->fix_tag
= 0;
2710 internal_ptr
->fix_end
= 0;
2711 symbol_ptr
= internal_ptr
;
2714 i
< symbol_ptr
->u
.syment
.n_numaux
;
2720 internal_ptr
->fix_tag
= 0;
2721 internal_ptr
->fix_end
= 0;
2722 coff_swap_aux_in(abfd
, (char *)(raw_src
),
2723 symbol_ptr
->u
.syment
.n_type
,
2724 symbol_ptr
->u
.syment
.n_sclass
,
2725 &(internal_ptr
->u
.auxent
));
2726 /* Remember that bal entries arn't pointerized */
2727 if (i
!= 1 || symbol_ptr
->u
.syment
.n_sclass
!= C_LEAFPROC
)
2730 coff_pointerize_aux(abfd
,
2732 symbol_ptr
->u
.syment
.n_type
,
2733 symbol_ptr
->u
.syment
.n_sclass
,
2740 /* Free all the raw stuff */
2741 bfd_release(abfd
, raw
);
2743 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
2746 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
) {
2747 /* make a file symbol point to the name in the auxent, since
2748 the text ".file" is redundant */
2749 if ((internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_zeroes
== 0) {
2750 /* the filename is a long one, point into the string table */
2751 if (string_table
== NULL
) {
2752 string_table
= build_string_table(abfd
);
2755 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
2756 (int) (string_table
- 4 +
2757 (internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_offset
);
2760 /* ordinary short filename, put into memory anyway */
2761 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2762 copy_name(abfd
, (internal_ptr
+1)->u
.auxent
.x_file
.x_fname
,
2767 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0) {
2768 /* This is a "short" name. Make it long. */
2769 unsigned long i
= 0;
2770 char *newstring
= NULL
;
2772 /* find the length of this string without walking into memory
2774 for (i
= 0; i
< 8; ++i
) {
2775 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0') {
2777 } /* if end of string */
2778 } /* possible lengths of this string. */
2780 if ((newstring
= (PTR
) bfd_alloc(abfd
, ++i
)) == NULL
) {
2781 bfd_error
= no_memory
;
2784 bzero(newstring
, i
);
2785 strncpy(newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
-1);
2786 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int) newstring
;
2787 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
2789 else if (!SYMNAME_IN_DEBUG(&internal_ptr
->u
.syment
)) {
2790 /* Long name already. Point symbol at the string in the table. */
2791 if (string_table
== NULL
) {
2792 string_table
= build_string_table(abfd
);
2794 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2795 (string_table
- 4 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
2798 /* Long name in debug section. Very similar. */
2799 if (debug_section
== NULL
) {
2800 debug_section
= build_debug_section(abfd
);
2802 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
2803 (debug_section
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
2806 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
2809 obj_raw_syments(abfd
) = internal
;
2812 } /* get_normalized_symtab() */
2814 #endif /* NO_COFF_SYMBOLS */
2818 DEFUN(section_from_bfd_index
,(abfd
, index
),
2822 struct sec
*answer
= abfd
->sections
;
2826 return &bfd_abs_section
;
2828 if (index
== N_UNDEF
)
2830 return &bfd_und_section
;
2832 if(index
== N_DEBUG
)
2834 return &bfd_debug_section
;
2839 if (answer
->target_index
== index
)
2841 answer
= answer
->next
;
2844 return &bfd_und_section
; /* For gcc -W and lint. Never executed. */
2847 #ifndef NO_COFF_LINENOS
2853 Creating the linenumber table is done by reading in the entire
2854 coff linenumber table, and creating another table for internal use.
2856 A coff line number table is structured so that each function
2857 is marked as having a line number of 0. Each line within the
2858 function is an offset from the first line in the function. The
2859 base of the line number information for the table is stored in
2860 the symbol associated with the function.
2862 The information is copied from the external to the internal
2863 table, and each symbol which marks a function is marked by
2866 How does this work ?
2871 coff_slurp_line_table(abfd
, asect
)
2875 LINENO
*native_lineno
;
2876 alent
*lineno_cache
;
2878 BFD_ASSERT(asect
->lineno
== (alent
*) NULL
);
2880 native_lineno
= (LINENO
*) buy_and_read(abfd
,
2881 asect
->line_filepos
,
2884 asect
->lineno_count
));
2886 (alent
*) bfd_alloc(abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof(alent
)));
2887 if (lineno_cache
== NULL
) {
2888 bfd_error
= no_memory
;
2891 unsigned int counter
= 0;
2892 alent
*cache_ptr
= lineno_cache
;
2893 LINENO
*src
= native_lineno
;
2895 while (counter
< asect
->lineno_count
) {
2896 struct internal_lineno dst
;
2897 coff_swap_lineno_in(abfd
, src
, &dst
);
2898 cache_ptr
->line_number
= dst
.l_lnno
;
2900 if (cache_ptr
->line_number
== 0) {
2901 coff_symbol_type
*sym
=
2902 (coff_symbol_type
*) (dst
.l_addr
.l_symndx
2903 + obj_raw_syments(abfd
))->u
.syment
._n
._n_n
._n_zeroes
;
2904 cache_ptr
->u
.sym
= (asymbol
*) sym
;
2905 sym
->lineno
= cache_ptr
;
2908 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
2909 - bfd_section_vma(abfd
, asect
);
2910 } /* If no linenumber expect a symbol index */
2916 cache_ptr
->line_number
= 0;
2919 asect
->lineno
= lineno_cache
;
2920 /* FIXME, free native_lineno here, or use alloca or something. */
2922 } /* coff_slurp_line_table() */
2924 #endif /* NO_COFF_LINENOS */
2926 #ifndef NO_COFF_LINENOS
2929 DEFUN(coff_slurp_symbol_table
,(abfd
),
2932 combined_entry_type
*native_symbols
;
2933 coff_symbol_type
*cached_area
;
2934 unsigned int *table_ptr
;
2936 unsigned int number_of_symbols
= 0;
2937 if (obj_symbols(abfd
))
2939 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
2941 /* Read in the symbol table */
2942 if ((native_symbols
= get_normalized_symtab(abfd
)) == NULL
) {
2946 /* Allocate enough room for all the symbols in cached form */
2948 (coff_symbol_type
*)
2949 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(coff_symbol_type
)));
2951 if (cached_area
== NULL
) {
2952 bfd_error
= no_memory
;
2957 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(unsigned int)));
2959 if (table_ptr
== NULL
) {
2960 bfd_error
= no_memory
;
2965 coff_symbol_type
*dst
= cached_area
;
2966 unsigned int last_native_index
= bfd_get_symcount(abfd
);
2967 unsigned int this_index
= 0;
2968 while (this_index
< last_native_index
) {
2969 combined_entry_type
*src
= native_symbols
+ this_index
;
2970 table_ptr
[this_index
] = number_of_symbols
;
2971 dst
->symbol
.the_bfd
= abfd
;
2973 dst
->symbol
.name
= (char *)(src
->u
.syment
._n
._n_n
._n_offset
);
2975 We use the native name field to point to the cached field
2977 src
->u
.syment
._n
._n_n
._n_zeroes
= (int) dst
;
2978 dst
->symbol
.section
= section_from_bfd_index(abfd
,
2979 src
->u
.syment
.n_scnum
);
2980 dst
->symbol
.flags
= 0;
2981 dst
->done_lineno
= false;
2983 switch (src
->u
.syment
.n_sclass
) {
2987 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
2988 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
2989 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
2991 /* Fall through to next case */
2999 if ((src
->u
.syment
.n_scnum
) == 0) {
3000 if ((src
->u
.syment
.n_value
) == 0) {
3001 dst
->symbol
.section
= &bfd_und_section
;
3002 dst
->symbol
.value
= 0;
3005 dst
->symbol
.section
= &bfd_com_section
;
3006 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3011 Base the value as an index from the base of the
3015 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
3016 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
3018 if (ISFCN((src
->u
.syment
.n_type
))) {
3020 A function ext does not go at the end of a file
3022 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
3029 case C_STAT
: /* static */
3031 case C_LEAFSTAT
: /* static leaf procedure */
3033 case C_LABEL
: /* label */
3034 if (src
->u
.syment
.n_scnum
== -2)
3035 dst
->symbol
.flags
= BSF_DEBUGGING
;
3037 dst
->symbol
.flags
= BSF_LOCAL
;
3039 Base the value as an index from the base of the section, if
3042 if (dst
->symbol
.section
)
3043 dst
->symbol
.value
= (src
->u
.syment
.n_value
) -
3044 dst
->symbol
.section
->vma
;
3046 dst
->symbol
.value
= (src
->u
.syment
.n_value
) ;
3049 case C_MOS
: /* member of structure */
3050 case C_EOS
: /* end of structure */
3051 #ifdef NOTDEF /* C_AUTOARG has the same value */
3053 case C_GLBLREG
: /* A29k-specific storage class */
3056 case C_REGPARM
: /* register parameter */
3057 case C_REG
: /* register variable */
3059 case C_AUTOARG
: /* 960-specific storage class */
3061 case C_TPDEF
: /* type definition */
3063 case C_AUTO
: /* automatic variable */
3064 case C_FIELD
: /* bit field */
3065 case C_ENTAG
: /* enumeration tag */
3066 case C_MOE
: /* member of enumeration */
3067 case C_MOU
: /* member of union */
3068 case C_UNTAG
: /* union tag */
3069 dst
->symbol
.flags
= BSF_DEBUGGING
;
3070 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3073 case C_FILE
: /* file name */
3074 case C_STRTAG
: /* structure tag */
3076 case C_BINCL
: /* beginning of include file */
3077 case C_EINCL
: /* ending of include file */
3090 dst
->symbol
.flags
= BSF_DEBUGGING
;
3091 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3094 case C_BLOCK
: /* ".bb" or ".eb" */
3095 case C_FCN
: /* ".bf" or ".ef" */
3096 case C_EFCN
: /* physical end of function */
3097 dst
->symbol
.flags
= BSF_LOCAL
;
3099 Base the value as an index from the base of the section
3101 dst
->symbol
.value
= (src
->u
.syment
.n_value
) - dst
->symbol
.section
->vma
;
3105 case C_EXTDEF
: /* external definition */
3106 case C_ULABEL
: /* undefined label */
3107 case C_USTATIC
: /* undefined static */
3108 case C_LINE
: /* line # reformatted as symbol table entry */
3109 case C_ALIAS
: /* duplicate tag */
3110 case C_HIDDEN
: /* ext symbol in dmert public lib */
3113 fprintf(stderr
,"Unrecognized storage class %d\n",
3114 src
->u
.syment
.n_sclass
);
3116 dst
->symbol
.flags
= BSF_DEBUGGING
;
3117 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3121 /* BFD_ASSERT(dst->symbol.flags != 0);*/
3125 dst
->symbol
.udata
= 0;
3126 dst
->lineno
= (alent
*) NULL
;
3127 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
3129 number_of_symbols
++;
3130 } /* walk the native symtab */
3131 } /* bfdize the native symtab */
3133 obj_symbols(abfd
) = cached_area
;
3134 obj_raw_syments(abfd
) = native_symbols
;
3136 bfd_get_symcount(abfd
) = number_of_symbols
;
3137 obj_convert(abfd
) = table_ptr
;
3138 /* Slurp the line tables for each section too */
3143 coff_slurp_line_table(abfd
, p
);
3148 } /* coff_slurp_symbol_table() */
3151 coff_get_symtab_upper_bound(abfd
)
3154 if (!coff_slurp_symbol_table(abfd
))
3157 return (bfd_get_symcount(abfd
) + 1) * (sizeof(coff_symbol_type
*));
3162 DEFUN(coff_get_symtab
, (abfd
, alocation
),
3164 asymbol
**alocation
)
3166 unsigned int counter
= 0;
3167 coff_symbol_type
*symbase
;
3168 coff_symbol_type
**location
= (coff_symbol_type
**) (alocation
);
3169 if (!coff_slurp_symbol_table(abfd
))
3172 symbase
= obj_symbols(abfd
);
3173 while (counter
< bfd_get_symcount(abfd
))
3175 /* This nasty code looks at the symbol to decide whether or
3176 not it is descibes a constructor/destructor entry point. It
3177 is structured this way to (hopefully) speed non matches */
3179 if (0 && symbase
->symbol
.name
[9] == '$')
3181 bfd_constructor_entry(abfd
,
3182 (asymbol
**)location
,
3183 symbase
->symbol
.name
[10] == 'I' ?
3187 *(location
++) = symbase
++;
3191 return bfd_get_symcount(abfd
);
3194 #endif /* NO_COFF_SYMBOLS */
3197 coff_get_reloc_upper_bound(abfd
, asect
)
3201 if (bfd_get_format(abfd
) != bfd_object
) {
3202 bfd_error
= invalid_operation
;
3205 return (asect
->reloc_count
+ 1) * sizeof(arelent
*);
3212 Coff relocations are easily transformed into the internal BFD form
3215 Reading a coff relocation table is done in the following stages:
3217 o The entire coff relocation table is read into memory.
3219 o Each relocation is processed in turn, first it is swapped from the
3220 external to the internal form.
3222 o The symbol referenced in the relocation's symbol index is
3223 turned intoa pointer into the canonical symbol table. Note
3224 that this table is the same as the one returned by a call to
3225 @code{bfd_canonicalize_symtab}. The back end will call the
3226 routine and save the result if a canonicalization hasn't been done.
3228 o The reloc index is turned into a pointer to a howto
3229 structure, in a back end specific way. For instance, the 386
3230 and 960 use the @code{r_type} to directly produce an index
3231 into a howto table vector; the 88k subtracts a number from the
3232 @code{r_type} field and creates an addend field.
3238 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
3239 if (ptr && ptr->the_bfd == abfd \
3240 && ((ptr->flags & BSF_OLD_COMMON)== 0)) \
3242 cache_ptr->addend = -(ptr->section->vma + ptr->value); \
3245 cache_ptr->addend = 0; \
3250 DEFUN(coff_slurp_reloc_table
,(abfd
, asect
, symbols
),
3255 RELOC
*native_relocs
;
3256 arelent
*reloc_cache
;
3261 if (asect
->relocation
)
3263 if (asect
->reloc_count
== 0)
3265 if (asect
->flags
& SEC_CONSTRUCTOR
)
3267 #ifndef NO_COFF_SYMBOLS
3268 if (!coff_slurp_symbol_table(abfd
))
3272 (RELOC
*) buy_and_read(abfd
,
3276 asect
->reloc_count
));
3277 reloc_cache
= (arelent
*)
3278 bfd_alloc(abfd
, (size_t) (asect
->reloc_count
* sizeof(arelent
)));
3280 if (reloc_cache
== NULL
) {
3281 bfd_error
= no_memory
;
3286 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
3288 #ifdef RELOC_PROCESSING
3289 struct internal_reloc dst
;
3290 struct external_reloc
*src
;
3292 cache_ptr
= reloc_cache
+ idx
;
3293 src
= native_relocs
+ idx
;
3294 bfd_swap_reloc_in(abfd
, src
, &dst
);
3296 RELOC_PROCESSING(cache_ptr
, &dst
, symbols
, abfd
, asect
);
3298 struct internal_reloc dst
;
3300 struct external_reloc
*src
;
3302 cache_ptr
= reloc_cache
+ idx
;
3303 src
= native_relocs
+ idx
;
3305 bfd_swap_reloc_in(abfd
, src
, &dst
);
3308 cache_ptr
->address
= dst
.r_vaddr
;
3310 if (dst
.r_symndx
!= -1)
3312 cache_ptr
->sym_ptr_ptr
= symbols
+ obj_convert(abfd
)[dst
.r_symndx
];
3313 ptr
= *(cache_ptr
->sym_ptr_ptr
);
3317 cache_ptr
->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
3323 The symbols definitions that we have read in have been
3324 relocated as if their sections started at 0. But the offsets
3325 refering to the symbols in the raw data have not been
3326 modified, so we have to have a negative addend to compensate.
3328 Note that symbols which used to be common must be left alone */
3330 /* Calculate any reloc addend by looking at the symbol */
3331 CALC_ADDEND(abfd
, ptr
, dst
, cache_ptr
);
3333 cache_ptr
->address
-= asect
->vma
;
3334 /* !! cache_ptr->section = (asection *) NULL;*/
3336 /* Fill in the cache_ptr->howto field from dst.r_type */
3337 RTYPE2HOWTO(cache_ptr
, &dst
);
3342 asect
->relocation
= reloc_cache
;
3347 /* This is stupid. This function should be a boolean predicate */
3349 DEFUN(coff_canonicalize_reloc
, (abfd
, section
, relptr
, symbols
),
3352 arelent
**relptr AND
3355 arelent
*tblptr
= section
->relocation
;
3356 unsigned int count
= 0;
3359 if (section
->flags
& SEC_CONSTRUCTOR
)
3361 /* this section has relocs made up by us, they are not in the
3362 file, so take them out of their chain and place them into
3363 the data area provided */
3364 arelent_chain
*chain
= section
->constructor_chain
;
3365 for (count
= 0; count
< section
->reloc_count
; count
++)
3367 *relptr
++ = &chain
->relent
;
3368 chain
= chain
->next
;
3374 coff_slurp_reloc_table(abfd
, section
, symbols
);
3377 tblptr
= section
->relocation
;
3381 for (; count
++ < section
->reloc_count
;)
3382 *relptr
++ = tblptr
++;
3387 return section
->reloc_count
;
3390 #ifndef NO_COFF_SYMBOLS
3393 provided a BFD, a section and an offset into the section, calculate and
3394 return the name of the source file and the line nearest to the wanted
3399 DEFUN(coff_find_nearest_line
,(abfd
,
3407 asection
*section AND
3408 asymbol
**ignore_symbols AND
3410 CONST
char **filename_ptr AND
3411 CONST
char **functionname_ptr AND
3412 unsigned int *line_ptr
)
3414 static bfd
*cache_abfd
;
3415 static asection
*cache_section
;
3416 static bfd_vma cache_offset
;
3417 static unsigned int cache_i
;
3418 static alent
*cache_l
;
3421 coff_data_type
*cof
= coff_data(abfd
);
3422 /* Run through the raw syments if available */
3423 combined_entry_type
*p
;
3425 unsigned int line_base
= 0;
3429 *functionname_ptr
= 0;
3432 /* Don't try and find line numbers in a non coff file */
3433 if (abfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
3439 p
= cof
->raw_syments
;
3441 for (i
= 0; i
< cof
->raw_syment_count
; i
++) {
3442 if (p
->u
.syment
.n_sclass
== C_FILE
) {
3443 /* File name has been moved into symbol */
3444 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
3447 p
+= 1 + p
->u
.syment
.n_numaux
;
3449 /* Now wander though the raw linenumbers of the section */
3451 If this is the same BFD as we were previously called with and this is
3452 the same section, and the offset we want is further down then we can
3453 prime the lookup loop
3455 if (abfd
== cache_abfd
&&
3456 section
== cache_section
&&
3457 offset
>= cache_offset
) {
3463 l
= section
->lineno
;
3466 for (; i
< section
->lineno_count
; i
++) {
3467 if (l
->line_number
== 0) {
3468 /* Get the symbol this line number points at */
3469 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
3470 *functionname_ptr
= coff
->symbol
.name
;
3472 combined_entry_type
*s
= coff
->native
;
3473 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
3475 S should now point to the .bf of the function
3477 if (s
->u
.syment
.n_numaux
) {
3479 The linenumber is stored in the auxent
3481 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
3482 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
3487 if (l
->u
.offset
> offset
)
3489 *line_ptr
= l
->line_number
+ line_base
+ 1;
3495 cache_section
= section
;
3496 cache_offset
= offset
;
3505 coff_sym_filepos(abfd
)
3508 return obj_sym_filepos(abfd
);
3512 #endif /* NO_COFF_SYMBOLS */
3516 DEFUN(coff_sizeof_headers
,(abfd
, reloc
),
3522 if (reloc
== false) {
3523 size
= FILHSZ
+ AOUTSZ
;
3529 size
+= abfd
->section_count
* SCNHSZ
;
3534 DEFUN(get_value
,(reloc
, seclet
),
3536 bfd_seclet_type
*seclet
)
3539 asymbol
*symbol
= *(reloc
->sym_ptr_ptr
);
3540 /* A symbol holds a pointer to a section, and an offset from the
3541 base of the section. To relocate, we find where the section will
3542 live in the output and add that in */
3544 if (symbol
->section
== &bfd_und_section
)
3546 /* Ouch, this is an undefined symbol.. */
3547 bfd_error_vector
.undefined_symbol(reloc
, seclet
);
3548 value
= symbol
->value
;
3552 value
= symbol
->value
+
3553 symbol
->section
->output_offset
+
3554 symbol
->section
->output_section
->vma
;
3558 /* Add the value contained in the relocation */
3559 value
+= (short)((reloc
->addend
) & 0xffff);
3565 DEFUN(perform_slip
,(s
, slip
, input_section
, value
),
3567 unsigned int slip AND
3568 asection
*input_section AND
3572 /* Find all symbols past this point, and make them know
3577 if (p
->section
== input_section
)
3579 /* This was pointing into this section, so mangle it */
3580 if (p
->value
> value
)
3590 DEFUN(movb1
,(input_section
, symbols
, r
, shrink
),
3591 asection
*input_section AND
3592 asymbol
**symbols AND
3594 unsigned int shrink
)
3596 bfd_vma value
= get_value(r
,0);
3598 if (value
>= 0xff00)
3601 /* Change the reloc type from 16bit, possible 8 to 8bit
3603 r
->howto
= r
->howto
+ 1;
3604 /* The place to relc moves back by one */
3607 /* This will be two bytes smaller in the long run */
3609 perform_slip(symbols
, 2, input_section
, r
->address
- shrink
+1);
3617 DEFUN(jmp1
,(input_section
, symbols
, r
, shrink
),
3618 asection
*input_section AND
3619 asymbol
**symbols AND
3621 unsigned int shrink
)
3625 bfd_vma value
= get_value(r
, 0);
3627 bfd_vma dot
= input_section
->output_section
->vma
+
3628 input_section
->output_offset
+ r
->address
;
3631 /* See if the address we're looking at within 127 bytes of where
3632 we are, if so then we can use a small branch rather than the
3633 jump we were going to */
3635 gap
= value
- (dot
- shrink
);
3638 if (-120 < (long)gap
&& (long)gap
< 120 )
3641 /* Change the reloc type from 16bit, possible 8 to 8bit
3643 r
->howto
= r
->howto
+ 1;
3644 /* The place to relc moves back by one */
3647 /* This will be two bytes smaller in the long run */
3649 perform_slip(symbols
, 2, input_section
, r
->address
-shrink
+1);
3657 DEFUN(bfd_coff_relax_section
,(abfd
, i
, symbols
),
3663 /* Get enough memory to hold the stuff */
3664 bfd
*input_bfd
= i
->owner
;
3665 asection
*input_section
= i
;
3667 boolean
new = false;
3669 bfd_size_type reloc_size
= bfd_get_reloc_upper_bound(input_bfd
,
3671 arelent
**reloc_vector
= (arelent
**)bfd_xmalloc(reloc_size
);
3673 /* Get the relocs and think about them */
3674 if (bfd_canonicalize_reloc(input_bfd
,
3680 for (parent
= reloc_vector
; *parent
; parent
++)
3682 arelent
*r
= *parent
;
3683 switch (r
->howto
->type
) {
3691 shrink
= movb1(input_section
, symbols
, r
, shrink
);
3696 shrink
= jmp1(input_section
, symbols
, r
, shrink
);
3704 input_section
->_cooked_size
-= shrink
;
3705 free((char *)reloc_vector
);
3710 DEFUN(bfd_coff_get_relocated_section_contents
,(in_abfd
, seclet
),
3712 bfd_seclet_type
*seclet
)
3715 /* Get enough memory to hold the stuff */
3716 bfd
*input_bfd
= seclet
->u
.indirect
.section
->owner
;
3717 asection
*input_section
= seclet
->u
.indirect
.section
;
3718 bfd_byte
*data
= (bfd_byte
*)malloc(input_section
->_raw_size
);
3719 bfd_size_type reloc_size
= bfd_get_reloc_upper_bound(input_bfd
,
3721 arelent
**reloc_vector
= (arelent
**)bfd_xmalloc(reloc_size
);
3723 /* read in the section */
3724 bfd_get_section_contents(input_bfd
,
3728 input_section
->_raw_size
);
3731 if (bfd_canonicalize_reloc(input_bfd
,
3734 seclet
->u
.indirect
.symbols
) )
3736 arelent
**parent
= reloc_vector
;
3741 unsigned int dst_address
= 0;
3742 unsigned int src_address
= 0;
3746 /* Find how long a run we can do */
3747 while (dst_address
< seclet
->size
)
3753 /* Note that the relaxing didn't tie up the addresses in the
3754 relocation, so we use the original address to work out the
3755 run of non-relocated data */
3756 run
= reloc
->address
- src_address
;
3762 run
= seclet
->size
- dst_address
;
3764 /* Copy the bytes */
3765 for (idx
= 0; idx
< run
; idx
++)
3767 data
[dst_address
++] = data
[src_address
++];
3770 /* Now do the relocation */
3774 switch (reloc
->howto
->type
)
3777 /* Speciial relaxed type */
3779 bfd_vma dot
= seclet
->offset
+ dst_address
+ seclet
->u
.indirect
.section
->output_section
->vma
;
3780 int gap
= get_value(reloc
,seclet
)-dot
-1;
3781 if ((gap
& ~0xff ) != 0 &&((gap
& 0xff00)!= 0xff00)) abort();
3783 bfd_put_8(in_abfd
,gap
, data
+dst_address
);
3785 switch (data
[dst_address
-1])
3790 bfd_put_8(in_abfd
, 0x55, data
+dst_address
-1);
3794 bfd_put_8(in_abfd
, 0x40, data
+dst_address
-1);
3813 /* Special relaxed type, there will be a gap between where we
3814 get stuff from and where we put stuff to now
3816 for a mov.b @aa:16 -> mov.b @aa:8
3817 opcode 0x6a 0x0y offset
3820 if (data
[dst_address
-1] != 0x6a)
3822 switch (data
[dst_address
] & 0xf0)
3826 data
[dst_address
-1] = (data
[src_address
] & 0xf) | 0x20;
3830 data
[dst_address
-1] = (data
[src_address
] & 0xf) | 0x30;
3836 /* the offset must fit ! after all, what was all the relaxing
3839 bfd_put_8(in_abfd
, get_value(reloc
, seclet
), data
+ dst_address
);
3841 /* Note the magic - src goes up by two bytes, but dst by only
3850 bfd_vma dot
= seclet
->offset
+ dst_address
+ seclet
->u
.indirect
.section
->output_section
->vma
;
3851 int gap
= get_value(reloc
,seclet
)-dot
;
3852 if (gap
> 127 || gap
< -128)
3854 bfd_error_vector
.reloc_value_truncated(reloc
, seclet
);
3857 bfd_put_8(in_abfd
,gap
, data
+dst_address
);
3866 unsigned int gap
=get_value(reloc
,seclet
);
3869 bfd_error_vector
.reloc_value_truncated(reloc
, seclet
);
3872 bfd_put_8(in_abfd
, gap
, data
+dst_address
);
3880 /* A relword which would have like to have been a pcrel */
3882 /* A relword which would like to have been modified but
3885 bfd_put_16(in_abfd
, get_value(reloc
,seclet
), data
+dst_address
);
3896 free((char *)reloc_vector
);
3902 #define coff_core_file_failing_command _bfd_dummy_core_file_failing_command
3903 #define coff_core_file_failing_signal _bfd_dummy_core_file_failing_signal
3904 #define coff_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
3905 #define coff_slurp_armap bfd_slurp_coff_armap
3906 #define coff_slurp_extended_name_table _bfd_slurp_extended_name_table
3907 #define coff_truncate_arname bfd_dont_truncate_arname
3908 #define coff_openr_next_archived_file bfd_generic_openr_next_archived_file
3909 #define coff_generic_stat_arch_elt bfd_generic_stat_arch_elt
3910 #define coff_get_section_contents bfd_generic_get_section_contents
3911 #define coff_close_and_cleanup bfd_generic_close_and_cleanup
3913 #define coff_bfd_debug_info_start bfd_void
3914 #define coff_bfd_debug_info_end bfd_void
3915 #define coff_bfd_debug_info_accumulate (PROTO(void,(*),(bfd*, struct sec *))) bfd_void
3916 #define coff_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
3917 #define coff_bfd_relax_section bfd_generic_relax_section