1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
3 Written by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
22 Most of this hacked by Steve Chamberlain,
30 BFD supports a number of different flavours of coff format.
31 The major difference between formats are the sizes and
32 alignments of fields in structures on disk, and the occasional
35 Coff in all its varieties is implimented with a few common
36 files and a number of implementation specific files. For
37 example, The 88k bcs coff format is implemented in the file
38 @code{coff-m88k.c}. This file @code{#include}s
39 @code{coff-m88k.h} which defines the external structure of the
40 coff format for the 88k, and @code{internalcoff.h} which
41 defines the internal structure. @code{coff-m88k.c} also
42 defines pthe relocations used by the 88k format
43 @xref{Relocations}. Then the major portion of coff code is
44 included (@code{coffcode.h}) which defines the methods used to
45 act upon the types defined in @code{coff-m88k.h} and
46 @code{internalcoff.h}.
49 The Intel i960 processor version of coff is implemented in
50 @code{coff-i960.c}. This file has the same structure as
51 @code{coff-m88k.c}, except that it includes @code{coff-i960.h}
52 rather than @code{coff-m88k.h}.
55 Porting To A New Version of Coff
57 The recommended method is to select from the existing
58 implimentations the version of coff which is most like the one
59 you want to use, for our purposes, we'll say that i386 coff is
60 the one you select, and that your coff flavour is called foo.
61 Copy the @code{i386coff.c} to @code{foocoff.c}, copy
62 @code{../include/i386coff.h} to @code{../include/foocoff.h}
63 and add the lines to @code{targets.c} and @code{Makefile.in}
64 so that your new back end is used. Alter the shapes of the
65 structures in @code{../include/foocoff.h} so that they match
66 what you need. You will probably also have to add
67 @code{#ifdef}s to the code in @code{internalcoff.h} and
68 @code{coffcode.h} if your version of coff is too wild.
70 You can verify that your new BFD backend works quite simply by
71 building @code{objdump} from the @code{binutils} directory,
72 and making sure that its version of what's going on at your
73 host systems idea (assuming it has the pretty standard coff
74 dump utility (usually called @code{att-dump} or just
75 @code{dump})) are the same. Then clean up your code, and send
76 what you've done to Cygnus. Then your stuff will be in the
77 next release, and you won't have to keep integrating it.
80 How The Coff Backend Works
85 Each flavour of coff supported in BFD has its own header file
86 descibing the external layout of the structures. There is also
87 an internal description of the coff layout (in
88 @code{internalcoff.h}). A major function of the
89 coff backend is swapping the bytes and twiddling the bits to
90 translate the external form of the structures into the normal
91 internal form. This is all performed in the
92 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
93 elements are different sizes between different versions of
94 coff, it is the duty of the coff version specific include file
95 to override the definitions of various packing routines in
96 @code{coffcode.h}. Eg the size of line number entry in coff is
97 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
98 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
99 correct one. No doubt, some day someone will find a version of
100 coff which has a varying field size not catered for at the
101 moment. To port BFD, that person will have to add more @code{#defines}.
102 Three of the bit twiddling routines are exported to
103 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
104 and @code{coff_swap_linno_in}. @code{GDB} reads the symbol
105 table on its own, but uses BFD to fix things up. More of the
106 bit twiddlers are exported for @code{gas};
107 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
108 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
109 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
110 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
111 of all the symbol table and reloc drudgery itself, thereby
112 saving the internal BFD overhead, but uses BFD to swap things
113 on the way out, making cross ports much safer. This also
114 allows BFD (and thus the linker) to use the same header files
115 as @code{gas}, which makes one avenue to disaster disappear.
120 The simple canonical form for symbols used by BFD is not rich
121 enough to keep all the information available in a coff symbol
122 table. The back end gets around this by keeping the original
123 symbol table around, "behind the scenes".
125 When a symbol table is requested (through a call to
126 @code{bfd_canonicalize_symtab}, a request gets through to
127 @code{get_normalized_symtab}. This reads the symbol table from
128 the coff file and swaps all the structures inside into the
129 internal form. It also fixes up all the pointers in the table
130 (represented in the file by offsets from the first symbol in
131 the table) into physical pointers to elements in the new
132 internal table. This involves some work since the meanings of
133 fields changes depending upon context; a field that is a
134 pointer to another structure in the symbol table at one moment
135 may be the size in bytes of a structure in the next. Another
136 pass is made over the table. All symbols which mark file names
137 (<<C_FILE>> symbols) are modified so that the internal
138 string points to the value in the auxent (the real filename)
139 rather than the normal text associated with the symbol
142 At this time the symbol names are moved around. Coff stores
143 all symbols less than nine characters long physically
144 within the symbol table, longer strings are kept at the end of
145 the file in the string table. This pass moves all strings
146 into memory, and replaces them with pointers to the strings.
149 The symbol table is massaged once again, this time to create
150 the canonical table used by the BFD application. Each symbol
151 is inspected in turn, and a decision made (using the
152 @code{sclass} field) about the various flags to set in the
153 @code{asymbol} @xref{Symbols}. The generated canonical table
154 shares strings with the hidden internal symbol table.
156 Any linenumbers are read from the coff file too, and attached
157 to the symbols which own the functions the linenumbers belong to.
162 Writing a symbol to a coff file which didn't come from a coff
163 file will lose any debugging information. The @code{asymbol}
164 structure remembers the BFD from which was born, and on output
165 the back end makes sure that the same destination target as
166 source target is present.
168 When the symbols have come from a coff file then all the
169 debugging information is preserved.
171 Symbol tables are provided for writing to the back end in a
172 vector of pointers to pointers. This allows applications like
173 the linker to accumulate and output large symbol tables
174 without having to do too much byte copying.
176 This function runs through the provided symbol table and
177 patches each symbol marked as a file place holder
178 (@code{C_FILE}) to point to the next file place holder in the
179 list. It also marks each @code{offset} field in the list with
180 the offset from the first symbol of the current symbol.
182 Another function of this procedure is to turn the canonical
183 value form of BFD into the form used by coff. Internally, BFD
184 expects symbol values to be offsets from a section base; so a
185 symbol physically at 0x120, but in a section starting at
186 0x100, would have the value 0x20. Coff expects symbols to
187 contain their final value, so symbols have their values
188 changed at this point to reflect their sum with their owning
189 section. Note that this transformation uses the
190 <<output_section>> field of the @code{asymbol}'s
191 @code{asection} @xref{Sections}.
193 o coff_mangle_symbols
195 This routine runs though the provided symbol table and uses
196 the offsets generated by the previous pass and the pointers
197 generated when the symbol table was read in to create the
198 structured hierachy required by coff. It changes each pointer
199 to a symbol to an index into the symbol table of the symbol
204 This routine runs through the symbol table and patches up the
205 symbols from their internal form into the coff way, calls the
206 bit twiddlers and writes out the tabel to the file.
215 The hidden information for an asymbol is described in a
216 coff_ptr_struct, which is typedefed to a combined_entry_type
220 .typedef struct coff_ptr_struct
223 . {* Remembers the offset from the first symbol in the file for
224 . this symbol. Generated by coff_renumber_symbols. *}
225 .unsigned int offset;
227 . {* Should the tag field of this symbol be renumbered.
228 . Created by coff_pointerize_aux. *}
231 . {* Should the endidx field of this symbol be renumbered.
232 . Created by coff_pointerize_aux. *}
235 . {* The container for the symbol structure as read and translated
239 . union internal_auxent auxent;
240 . struct internal_syment syment;
242 .} combined_entry_type;
245 .{* Each canonical asymbol really looks like this: *}
247 .typedef struct coff_symbol_struct
249 . {* The actual symbol which the rest of BFD works with *}
252 . {* A pointer to the hidden information for this symbol *}
253 .combined_entry_type *native;
255 . {* A pointer to the linenumber information for this symbol *}
256 .struct lineno_cache_entry *lineno;
258 . {* Have the line numbers been relocated yet ? *}
259 .boolean done_lineno;
266 extern bfd_error_vector_type bfd_error_vector
;
271 #define PUTWORD bfd_h_put_32
272 #define PUTHALF bfd_h_put_16
273 #define PUTBYTE bfd_h_put_8
275 #ifndef GET_FCN_LNNOPTR
276 #define GET_FCN_LNNOPTR(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
279 #ifndef GET_FCN_ENDNDX
280 #define GET_FCN_ENDNDX(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
283 #ifndef PUT_FCN_LNNOPTR
284 #define PUT_FCN_LNNOPTR(abfd, in, ext) PUTWORD(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
286 #ifndef PUT_FCN_ENDNDX
287 #define PUT_FCN_ENDNDX(abfd, in, ext) PUTWORD(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
289 #ifndef GET_LNSZ_LNNO
290 #define GET_LNSZ_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_lnno)
292 #ifndef GET_LNSZ_SIZE
293 #define GET_LNSZ_SIZE(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_size)
295 #ifndef PUT_LNSZ_LNNO
296 #define PUT_LNSZ_LNNO(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_sym.x_misc.x_lnsz.x_lnno)
298 #ifndef PUT_LNSZ_SIZE
299 #define PUT_LNSZ_SIZE(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte*) ext->x_sym.x_misc.x_lnsz.x_size)
301 #ifndef GET_SCN_SCNLEN
302 #define GET_SCN_SCNLEN(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_scn.x_scnlen)
304 #ifndef GET_SCN_NRELOC
305 #define GET_SCN_NRELOC(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nreloc)
307 #ifndef GET_SCN_NLINNO
308 #define GET_SCN_NLINNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nlinno)
310 #ifndef PUT_SCN_SCNLEN
311 #define PUT_SCN_SCNLEN(abfd,in, ext) bfd_h_put_32(abfd, in, (bfd_byte *) ext->x_scn.x_scnlen)
313 #ifndef PUT_SCN_NRELOC
314 #define PUT_SCN_NRELOC(abfd,in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_scn.x_nreloc)
316 #ifndef PUT_SCN_NLINNO
317 #define PUT_SCN_NLINNO(abfd,in, ext) bfd_h_put_16(abfd,in, (bfd_byte *) ext->x_scn.x_nlinno)
319 #ifndef GET_LINENO_LNNO
320 #define GET_LINENO_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) (ext->l_lnno));
322 #ifndef PUT_LINENO_LNNO
323 #define PUT_LINENO_LNNO(abfd,val, ext) bfd_h_put_16(abfd,val, (bfd_byte *) (ext->l_lnno));
327 /* void warning(); */
330 * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the
331 * incoming SEC_* flags. The inverse of this function is styp_to_sec_flags().
332 * NOTE: If you add to/change this routine, you should mirror the changes
333 * in styp_to_sec_flags().
336 DEFUN(sec_to_styp_flags
, (sec_name
, sec_flags
),
337 CONST
char * sec_name AND
342 if (!strcmp(sec_name
, _TEXT
)) {
343 return((long)STYP_TEXT
);
344 } else if (!strcmp(sec_name
, _DATA
)) {
345 return((long)STYP_DATA
);
347 } else if (!strcmp(sec_name
, ".data2")) {
348 return((long)STYP_DATA
);
349 #endif /* TWO_DATA_SECS */
350 } else if (!strcmp(sec_name
, _BSS
)) {
351 return((long)STYP_BSS
);
353 } else if (!strcmp(sec_name
, _COMMENT
)) {
354 return((long)STYP_INFO
);
355 #endif /* _COMMENT */
357 } else if (!strcmp(sec_name
, _LIB
)) {
358 return((long)STYP_LIB
);
362 /* Try and figure out what it should be */
363 if (sec_flags
& SEC_CODE
) styp_flags
= STYP_TEXT
;
364 if (sec_flags
& SEC_DATA
) styp_flags
= STYP_DATA
;
365 else if (sec_flags
& SEC_READONLY
)
366 #ifdef STYP_LIT /* 29k readonly text/data section */
367 styp_flags
= STYP_LIT
;
369 styp_flags
= STYP_TEXT
;
370 #endif /* STYP_LIT */
371 else if (sec_flags
& SEC_LOAD
) styp_flags
= STYP_TEXT
;
373 if (styp_flags
== 0) styp_flags
= STYP_BSS
;
376 if (sec_flags
& SEC_NEVER_LOAD
)
377 styp_flags
|= STYP_NOLOAD
;
383 * Return a word with SEC_* flags set to represent the incoming
384 * STYP_* flags (from scnhdr.s_flags). The inverse of this
385 * function is sec_to_styp_flags().
386 * NOTE: If you add to/change this routine, you should mirror the changes
387 * in sec_to_styp_flags().
390 DEFUN(styp_to_sec_flags
, (styp_flags
),
393 flagword sec_flags
=0;
396 if (styp_flags
& STYP_NOLOAD
)
398 sec_flags
|= SEC_NEVER_LOAD
;
400 #endif /* STYP_NOLOAD */
402 /* For 386 COFF, at least, an unloadable text or data section is
403 actually a shared library section. */
404 if (styp_flags
& STYP_TEXT
)
406 if (sec_flags
& SEC_NEVER_LOAD
)
407 sec_flags
|= SEC_CODE
| SEC_SHARED_LIBRARY
;
409 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
411 else if (styp_flags
& STYP_DATA
)
413 if (sec_flags
& SEC_NEVER_LOAD
)
414 sec_flags
|= SEC_DATA
| SEC_SHARED_LIBRARY
;
416 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
418 else if (styp_flags
& STYP_BSS
)
420 sec_flags
|= SEC_ALLOC
;
422 else if (styp_flags
& STYP_INFO
)
424 sec_flags
|= SEC_NEVER_LOAD
;
428 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
431 #ifdef STYP_LIT /* A29k readonly text/data section type */
432 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
434 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
436 #endif /* STYP_LIT */
437 #ifdef STYP_OTHER_LOAD /* Other loaded sections */
438 if (styp_flags
& STYP_OTHER_LOAD
)
440 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
442 #endif /* STYP_SDATA */
447 #define get_index(symbol) ((int) (symbol)->udata)
448 #define set_index(symbol, idx) ((symbol)->udata =(PTR) (idx))
450 /* **********************************************************************
451 Here are all the routines for swapping the structures seen in the
452 outside world into the internal forms.
457 bfd_coff_backend_data
461 Special entry points for gdb to swap in coff symbol table parts
464 . void (*_bfd_coff_swap_aux_in) PARAMS ((
471 . void (*_bfd_coff_swap_sym_in) PARAMS ((
476 . void (*_bfd_coff_swap_lineno_in) PARAMS ((
482 Special entry points for gas to swap coff parts
484 . unsigned int (*_bfd_coff_swap_aux_out) PARAMS ((
491 . unsigned int (*_bfd_coff_swap_sym_out) PARAMS ((
496 . unsigned int (*_bfd_coff_swap_lineno_out) PARAMS ((
501 . unsigned int (*_bfd_coff_swap_reloc_out) PARAMS ((
506 . unsigned int (*_bfd_coff_swap_filehdr_out) PARAMS ((
511 . unsigned int (*_bfd_coff_swap_aouthdr_out) PARAMS ((
516 . unsigned int (*_bfd_coff_swap_scnhdr_out) PARAMS ((
521 .} bfd_coff_backend_data;
523 .#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
525 .#define bfd_coff_swap_aux_in(a,e,t,c,i) \
526 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,i))
528 .#define bfd_coff_swap_sym_in(a,e,i) \
529 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
531 .#define bfd_coff_swap_lineno_in(a,e,i) \
532 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
534 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
535 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
537 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
538 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
540 .#define bfd_coff_swap_aux_out(abfd, i, t,c,o) \
541 . ((coff_backend_info (abfd)->_bfd_coff_swap_aux_out) (abfd, i,t,c, o))
543 .#define bfd_coff_swap_sym_out(abfd, i,o) \
544 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
546 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
547 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
549 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
550 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
552 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
553 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
558 DEFUN(bfd_swap_reloc_in
,(abfd
, reloc_src
, reloc_dst
),
561 struct internal_reloc
*reloc_dst
)
563 reloc_dst
->r_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*)reloc_src
->r_vaddr
);
564 reloc_dst
->r_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) reloc_src
->r_symndx
);
567 reloc_dst
->r_type
= bfd_h_get_8(abfd
, reloc_src
->r_type
);
568 reloc_dst
->r_size
= bfd_h_get_8(abfd
, reloc_src
->r_size
);
570 reloc_dst
->r_type
= bfd_h_get_16(abfd
, (bfd_byte
*) reloc_src
->r_type
);
573 #ifdef SWAP_IN_RELOC_OFFSET
574 reloc_dst
->r_offset
= SWAP_IN_RELOC_OFFSET(abfd
,
575 (bfd_byte
*) reloc_src
->r_offset
);
581 DEFUN(coff_swap_reloc_out
,(abfd
, src
, dst
),
586 struct internal_reloc
*reloc_src
= (struct internal_reloc
*)src
;
587 struct external_reloc
*reloc_dst
= (struct external_reloc
*)dst
;
588 bfd_h_put_32(abfd
, reloc_src
->r_vaddr
, (bfd_byte
*) reloc_dst
->r_vaddr
);
589 bfd_h_put_32(abfd
, reloc_src
->r_symndx
, (bfd_byte
*) reloc_dst
->r_symndx
);
590 bfd_h_put_16(abfd
, reloc_src
->r_type
, (bfd_byte
*)
593 #ifdef SWAP_OUT_RELOC_OFFSET
594 SWAP_OUT_RELOC_OFFSET(abfd
,
596 (bfd_byte
*) reloc_dst
->r_offset
);
598 #ifdef SWAP_OUT_RELOC_EXTRA
599 SWAP_OUT_RELOC_EXTRA(abfd
,reloc_src
, reloc_dst
);
602 return sizeof(struct external_reloc
);
606 DEFUN(bfd_swap_filehdr_in
,(abfd
, filehdr_src
, filehdr_dst
),
608 FILHDR
*filehdr_src AND
609 struct internal_filehdr
*filehdr_dst
)
611 filehdr_dst
->f_magic
= bfd_h_get_16(abfd
, (bfd_byte
*) filehdr_src
->f_magic
);
612 filehdr_dst
->f_nscns
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_nscns
);
613 filehdr_dst
->f_timdat
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_timdat
);
614 filehdr_dst
->f_symptr
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_symptr
);
615 filehdr_dst
->f_nsyms
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_nsyms
);
616 filehdr_dst
->f_opthdr
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_opthdr
);
617 filehdr_dst
->f_flags
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_flags
);
621 DEFUN(coff_swap_filehdr_out
,(abfd
, in
, out
),
626 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*)in
;
627 FILHDR
*filehdr_out
= (FILHDR
*)out
;
628 bfd_h_put_16(abfd
, filehdr_in
->f_magic
, (bfd_byte
*) filehdr_out
->f_magic
);
629 bfd_h_put_16(abfd
, filehdr_in
->f_nscns
, (bfd_byte
*) filehdr_out
->f_nscns
);
630 bfd_h_put_32(abfd
, filehdr_in
->f_timdat
, (bfd_byte
*) filehdr_out
->f_timdat
);
631 bfd_h_put_32(abfd
, filehdr_in
->f_symptr
, (bfd_byte
*) filehdr_out
->f_symptr
);
632 bfd_h_put_32(abfd
, filehdr_in
->f_nsyms
, (bfd_byte
*) filehdr_out
->f_nsyms
);
633 bfd_h_put_16(abfd
, filehdr_in
->f_opthdr
, (bfd_byte
*) filehdr_out
->f_opthdr
);
634 bfd_h_put_16(abfd
, filehdr_in
->f_flags
, (bfd_byte
*) filehdr_out
->f_flags
);
635 return sizeof(FILHDR
);
639 #ifndef NO_COFF_SYMBOLS
642 DEFUN(coff_swap_sym_in
,(abfd
, ext1
, in1
),
647 SYMENT
*ext
= (SYMENT
*)ext1
;
648 struct internal_syment
*in
= (struct internal_syment
*)in1
;
650 if( ext
->e
.e_name
[0] == 0) {
651 in
->_n
._n_n
._n_zeroes
= 0;
652 in
->_n
._n_n
._n_offset
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e
.e
.e_offset
);
655 #if SYMNMLEN != E_SYMNMLEN
656 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
658 memcpy(in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
661 in
->n_value
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_value
);
662 in
->n_scnum
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_scnum
);
663 if (sizeof(ext
->e_type
) == 2){
664 in
->n_type
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_type
);
667 in
->n_type
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_type
);
669 in
->n_sclass
= bfd_h_get_8(abfd
, ext
->e_sclass
);
670 in
->n_numaux
= bfd_h_get_8(abfd
, ext
->e_numaux
);
674 DEFUN(coff_swap_sym_out
,(abfd
, inp
, extp
),
679 struct internal_syment
*in
= (struct internal_syment
*)inp
;
680 SYMENT
*ext
=(SYMENT
*)extp
;
681 if(in
->_n
._n_name
[0] == 0) {
682 bfd_h_put_32(abfd
, 0, (bfd_byte
*) ext
->e
.e
.e_zeroes
);
683 bfd_h_put_32(abfd
, in
->_n
._n_n
._n_offset
, (bfd_byte
*) ext
->e
.e
.e_offset
);
686 #if SYMNMLEN != E_SYMNMLEN
687 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
689 memcpy(ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
692 bfd_h_put_32(abfd
, in
->n_value
, (bfd_byte
*) ext
->e_value
);
693 bfd_h_put_16(abfd
, in
->n_scnum
, (bfd_byte
*) ext
->e_scnum
);
694 if (sizeof(ext
->e_type
) == 2)
696 bfd_h_put_16(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
700 bfd_h_put_32(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
702 bfd_h_put_8(abfd
, in
->n_sclass
, ext
->e_sclass
);
703 bfd_h_put_8(abfd
, in
->n_numaux
, ext
->e_numaux
);
704 return sizeof(SYMENT
);
708 DEFUN(coff_swap_aux_in
,(abfd
, ext1
, type
, class, in1
),
715 AUXENT
*ext
= (AUXENT
*)ext1
;
716 union internal_auxent
*in
= (union internal_auxent
*)in1
;
720 if (ext
->x_file
.x_fname
[0] == 0) {
721 in
->x_file
.x_n
.x_zeroes
= 0;
722 in
->x_file
.x_n
.x_offset
=
723 bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
725 #if FILNMLEN != E_FILNMLEN
726 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
728 memcpy (in
->x_file
.x_fname
, ext
->x_file
.x_fname
, FILNMLEN
);
733 /* RS/6000 "csect" auxents */
737 in
->x_csect
.x_scnlen
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_scnlen
);
738 in
->x_csect
.x_parmhash
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_parmhash
);
739 in
->x_csect
.x_snhash
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snhash
);
740 /* We don't have to hack bitfields in x_smtyp because it's defined by
741 shifts-and-ands, which are equivalent on all byte orders. */
742 in
->x_csect
.x_smtyp
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smtyp
);
743 in
->x_csect
.x_smclas
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smclas
);
744 in
->x_csect
.x_stab
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_stab
);
745 in
->x_csect
.x_snstab
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snstab
);
754 if (type
== T_NULL
) {
755 in
->x_scn
.x_scnlen
= GET_SCN_SCNLEN(abfd
, ext
);
756 in
->x_scn
.x_nreloc
= GET_SCN_NRELOC(abfd
, ext
);
757 in
->x_scn
.x_nlinno
= GET_SCN_NLINNO(abfd
, ext
);
761 in
->x_sym
.x_tagndx
.l
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
763 in
->x_sym
.x_tvndx
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
767 #if DIMNUM != E_DIMNUM
768 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
770 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]);
771 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]);
772 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]);
773 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]);
776 if (class == C_BLOCK
|| ISFCN(type
) || ISTAG(class)) {
777 in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= GET_FCN_LNNOPTR(abfd
, ext
);
778 in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= GET_FCN_ENDNDX(abfd
, ext
);
782 in
->x_sym
.x_misc
.x_fsize
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
785 in
->x_sym
.x_misc
.x_lnsz
.x_lnno
= GET_LNSZ_LNNO(abfd
, ext
);
786 in
->x_sym
.x_misc
.x_lnsz
.x_size
= GET_LNSZ_SIZE(abfd
, ext
);
792 DEFUN(coff_swap_aux_out
,(abfd
, inp
, type
, class, extp
),
799 union internal_auxent
*in
= (union internal_auxent
*)inp
;
800 AUXENT
*ext
= (AUXENT
*)extp
;
802 memset((PTR
)ext
, 0, AUXESZ
);
805 if (in
->x_file
.x_fname
[0] == 0) {
806 PUTWORD(abfd
, 0, (bfd_byte
*) ext
->x_file
.x_n
.x_zeroes
);
808 in
->x_file
.x_n
.x_offset
,
809 (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
812 #if FILNMLEN != E_FILNMLEN
813 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
815 memcpy (ext
->x_file
.x_fname
, in
->x_file
.x_fname
, FILNMLEN
);
821 /* RS/6000 "csect" auxents */
824 PUTWORD (abfd
, in
->x_csect
.x_scnlen
, ext
->x_csect
.x_scnlen
);
825 PUTWORD (abfd
, in
->x_csect
.x_parmhash
, ext
->x_csect
.x_parmhash
);
826 PUTHALF (abfd
, in
->x_csect
.x_snhash
, ext
->x_csect
.x_snhash
);
827 /* We don't have to hack bitfields in x_smtyp because it's defined by
828 shifts-and-ands, which are equivalent on all byte orders. */
829 PUTBYTE (abfd
, in
->x_csect
.x_smtyp
, ext
->x_csect
.x_smtyp
);
830 PUTBYTE (abfd
, in
->x_csect
.x_smclas
, ext
->x_csect
.x_smclas
);
831 PUTWORD (abfd
, in
->x_csect
.x_stab
, ext
->x_csect
.x_stab
);
832 PUTHALF (abfd
, in
->x_csect
.x_snstab
, ext
->x_csect
.x_snstab
);
841 if (type
== T_NULL
) {
842 PUT_SCN_SCNLEN(abfd
, in
->x_scn
.x_scnlen
, ext
);
843 PUT_SCN_NRELOC(abfd
, in
->x_scn
.x_nreloc
, ext
);
844 PUT_SCN_NLINNO(abfd
, in
->x_scn
.x_nlinno
, ext
);
848 PUTWORD(abfd
, in
->x_sym
.x_tagndx
.l
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
850 bfd_h_put_16(abfd
, in
->x_sym
.x_tvndx
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
853 if (class == C_BLOCK
|| ISFCN(type
) || ISTAG(class)) {
854 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
855 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
859 PUTWORD(abfd
, in
->x_sym
.x_misc
.x_fsize
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
863 #if DIMNUM != E_DIMNUM
864 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
866 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]);
867 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]);
868 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]);
869 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]);
872 PUT_LNSZ_LNNO(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
873 PUT_LNSZ_SIZE(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
876 return sizeof(AUXENT
);
879 #endif /* NO_COFF_SYMBOLS */
881 #ifndef NO_COFF_LINENOS
884 DEFUN(coff_swap_lineno_in
,(abfd
, ext1
, in1
),
889 LINENO
*ext
= (LINENO
*)ext1
;
890 struct internal_lineno
*in
= (struct internal_lineno
*)in1
;
892 in
->l_addr
.l_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->l_addr
.l_symndx
);
893 in
->l_lnno
= GET_LINENO_LNNO(abfd
, ext
);
897 DEFUN(coff_swap_lineno_out
,(abfd
, inp
, outp
),
902 struct internal_lineno
*in
= (struct internal_lineno
*)inp
;
903 struct external_lineno
*ext
= (struct external_lineno
*)outp
;
904 PUTWORD(abfd
, in
->l_addr
.l_symndx
, (bfd_byte
*)
905 ext
->l_addr
.l_symndx
);
907 PUT_LINENO_LNNO (abfd
, in
->l_lnno
, ext
);
908 return sizeof(struct external_lineno
);
911 #endif /* NO_COFF_LINENOS */
915 DEFUN(bfd_swap_aouthdr_in
,(abfd
, aouthdr_ext1
, aouthdr_int1
),
920 AOUTHDR
*aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
921 struct internal_aouthdr
*aouthdr_int
= (struct internal_aouthdr
*)aouthdr_int1
;
923 aouthdr_int
->magic
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->magic
);
924 aouthdr_int
->vstamp
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->vstamp
);
925 aouthdr_int
->tsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tsize
);
926 aouthdr_int
->dsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->dsize
);
927 aouthdr_int
->bsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->bsize
);
928 aouthdr_int
->entry
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->entry
);
929 aouthdr_int
->text_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->text_start
);
930 aouthdr_int
->data_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->data_start
);
932 aouthdr_int
->tagentries
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tagentries
);
936 aouthdr_int
->o_toc
= bfd_h_get_32(abfd
, aouthdr_ext
->o_toc
);
937 aouthdr_int
->o_snentry
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snentry
);
938 aouthdr_int
->o_sntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntext
);
939 aouthdr_int
->o_sndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sndata
);
940 aouthdr_int
->o_sntoc
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntoc
);
941 aouthdr_int
->o_snloader
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snloader
);
942 aouthdr_int
->o_snbss
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snbss
);
943 aouthdr_int
->o_algntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algntext
);
944 aouthdr_int
->o_algndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algndata
);
945 aouthdr_int
->o_modtype
= bfd_h_get_16(abfd
, aouthdr_ext
->o_modtype
);
946 aouthdr_int
->o_maxstack
= bfd_h_get_32(abfd
, aouthdr_ext
->o_maxstack
);
951 DEFUN(coff_swap_aouthdr_out
,(abfd
, in
, out
),
956 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*)in
;
957 AOUTHDR
*aouthdr_out
= (AOUTHDR
*)out
;
958 bfd_h_put_16(abfd
, aouthdr_in
->magic
, (bfd_byte
*) aouthdr_out
->magic
);
959 bfd_h_put_16(abfd
, aouthdr_in
->vstamp
, (bfd_byte
*) aouthdr_out
->vstamp
);
960 bfd_h_put_32(abfd
, aouthdr_in
->tsize
, (bfd_byte
*) aouthdr_out
->tsize
);
961 bfd_h_put_32(abfd
, aouthdr_in
->dsize
, (bfd_byte
*) aouthdr_out
->dsize
);
962 bfd_h_put_32(abfd
, aouthdr_in
->bsize
, (bfd_byte
*) aouthdr_out
->bsize
);
963 bfd_h_put_32(abfd
, aouthdr_in
->entry
, (bfd_byte
*) aouthdr_out
->entry
);
964 bfd_h_put_32(abfd
, aouthdr_in
->text_start
,
965 (bfd_byte
*) aouthdr_out
->text_start
);
966 bfd_h_put_32(abfd
, aouthdr_in
->data_start
, (bfd_byte
*) aouthdr_out
->data_start
);
968 bfd_h_put_32(abfd
, aouthdr_in
->tagentries
, (bfd_byte
*) aouthdr_out
->tagentries
);
970 return sizeof(AOUTHDR
);
974 DEFUN(coff_swap_scnhdr_in
,(abfd
, scnhdr_ext
, scnhdr_int
),
976 SCNHDR
*scnhdr_ext AND
977 struct internal_scnhdr
*scnhdr_int
)
979 memcpy(scnhdr_int
->s_name
, scnhdr_ext
->s_name
, sizeof(scnhdr_int
->s_name
));
980 scnhdr_int
->s_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
981 scnhdr_int
->s_paddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
982 scnhdr_int
->s_size
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_size
);
984 scnhdr_int
->s_scnptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
985 scnhdr_int
->s_relptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
986 scnhdr_int
->s_lnnoptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
987 scnhdr_int
->s_flags
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_flags
);
989 scnhdr_int
->s_nreloc
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
990 scnhdr_int
->s_nlnno
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
992 scnhdr_int
->s_nreloc
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
993 scnhdr_int
->s_nlnno
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
996 scnhdr_int
->s_align
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_align
);
1001 DEFUN(coff_swap_scnhdr_out
,(abfd
, in
, out
),
1006 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*)in
;
1007 SCNHDR
*scnhdr_ext
= (SCNHDR
*)out
;
1008 memcpy(scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof(scnhdr_int
->s_name
));
1009 PUTWORD(abfd
, scnhdr_int
->s_vaddr
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
1010 PUTWORD(abfd
, scnhdr_int
->s_paddr
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
1011 PUTWORD(abfd
, scnhdr_int
->s_size
, (bfd_byte
*) scnhdr_ext
->s_size
);
1012 PUTWORD(abfd
, scnhdr_int
->s_scnptr
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
1013 PUTWORD(abfd
, scnhdr_int
->s_relptr
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
1014 PUTWORD(abfd
, scnhdr_int
->s_lnnoptr
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
1015 PUTWORD(abfd
, scnhdr_int
->s_flags
, (bfd_byte
*) scnhdr_ext
->s_flags
);
1017 PUTWORD(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
1018 PUTWORD(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
1020 PUTHALF(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
1021 PUTHALF(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
1025 PUTWORD(abfd
, scnhdr_int
->s_align
, (bfd_byte
*) scnhdr_ext
->s_align
);
1027 return sizeof(SCNHDR
);
1032 initialize a section structure with information peculiar to this
1033 particular implementation of coff
1037 DEFUN(coff_new_section_hook
,(abfd
, section
),
1041 section
->alignment_power
= abfd
->xvec
->align_power_min
;
1042 /* Allocate aux records for section symbols, to store size and
1045 @@ Shouldn't use constant multiplier here! */
1046 coffsymbol (section
->symbol
)->native
=
1047 (combined_entry_type
*) bfd_zalloc (abfd
,
1048 sizeof (combined_entry_type
) * 10);
1052 static asection bfd_debug_section
= { "*DEBUG*" };
1054 /* Take a section header read from a coff file (in HOST byte order),
1055 and make a BFD "section" out of it. */
1057 DEFUN(make_a_section_from_file
,(abfd
, hdr
, target_index
),
1059 struct internal_scnhdr
*hdr AND
1060 unsigned int target_index
)
1062 asection
*return_section
;
1065 /* Assorted wastage to null-terminate the name, thanks AT&T! */
1066 name
= bfd_alloc(abfd
, sizeof (hdr
->s_name
)+1);
1068 bfd_error
= no_memory
;
1071 strncpy(name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
1072 name
[sizeof (hdr
->s_name
)] = 0;
1074 return_section
= bfd_make_section(abfd
, name
);
1075 #ifdef TWO_DATA_SECS
1076 /* On SCO a file created by the Microsoft assembler can have two
1077 .data sections. We use .data2 for the second one. */
1078 if (return_section
== NULL
&& strcmp(name
, _DATA
) == 0)
1079 return_section
= bfd_make_section(abfd
, ".data2");
1080 #endif /* TWO_DATA_SECS */
1081 if (return_section
== NULL
)
1084 /* s_paddr is presumed to be = to s_vaddr */
1086 return_section
->vma
= hdr
->s_vaddr
;
1087 return_section
->_raw_size
= hdr
->s_size
;
1088 return_section
->filepos
= hdr
->s_scnptr
;
1089 return_section
->rel_filepos
= hdr
->s_relptr
;
1090 return_section
->reloc_count
= hdr
->s_nreloc
;
1093 /* FIXME, use a temp var rather than alignment_power */
1094 return_section
->alignment_power
= hdr
->s_align
;
1097 for (i
= 0; i
< 32; i
++) {
1098 if ((1 << i
) >= (int) (return_section
->alignment_power
)) {
1099 return_section
->alignment_power
= i
;
1106 return_section
->line_filepos
= hdr
->s_lnnoptr
;
1108 return_section->linesize = hdr->s_nlnno * sizeof (struct lineno);
1111 return_section
->lineno_count
= hdr
->s_nlnno
;
1112 return_section
->userdata
= NULL
;
1113 return_section
->next
= (asection
*) NULL
;
1114 return_section
->flags
= styp_to_sec_flags(hdr
->s_flags
);
1116 return_section
->target_index
= target_index
;
1118 if (hdr
->s_nreloc
!= 0)
1119 return_section
->flags
|= SEC_RELOC
;
1120 /* FIXME: should this check 'hdr->s_size > 0' */
1121 if (hdr
->s_scnptr
!= 0)
1122 return_section
->flags
|= SEC_HAS_CONTENTS
;
1126 DEFUN(coff_mkobject
,(abfd
),
1129 abfd
->tdata
.coff_obj_data
= (struct coff_tdata
*)bfd_zalloc (abfd
,sizeof(coff_data_type
));
1130 if (abfd
->tdata
.coff_obj_data
== 0){
1131 bfd_error
= no_memory
;
1134 coff_data(abfd
)->relocbase
= 0;
1135 /* make_abs_section(abfd);*/
1141 DEFUN(coff_real_object_p
,(abfd
, nscns
, internal_f
, internal_a
),
1144 struct internal_filehdr
*internal_f AND
1145 struct internal_aouthdr
*internal_a
)
1147 coff_data_type
*coff
;
1148 enum bfd_architecture arch
;
1150 size_t readsize
; /* length of file_info */
1151 SCNHDR
*external_sections
;
1153 /* Build a play area */
1154 if (coff_mkobject(abfd
) != true)
1157 coff
= coff_data(abfd
);
1160 external_sections
= (SCNHDR
*)bfd_alloc(abfd
, readsize
= (nscns
* SCNHSZ
));
1162 if (bfd_read((PTR
)external_sections
, 1, readsize
, abfd
) != readsize
) {
1167 /* Now copy data as required; construct all asections etc */
1168 coff
->symbol_index_slew
= 0;
1170 coff
->raw_syment_count
= 0;
1171 coff
->raw_linenos
= 0;
1172 coff
->raw_syments
= 0;
1173 coff
->sym_filepos
=0;
1174 coff
->flags
= internal_f
->f_flags
;
1177 for (i
= 0; i
< nscns
; i
++) {
1178 struct internal_scnhdr tmp
;
1179 coff_swap_scnhdr_in(abfd
, external_sections
+ i
, &tmp
);
1180 make_a_section_from_file(abfd
,&tmp
, i
+1);
1184 /* make_abs_section(abfd);*/
1186 /* Determine the machine architecture and type. */
1188 switch (internal_f
->f_magic
) {
1192 case I386SVMAGIC
: /* System V C Compiler aix ps2 */
1194 arch
= bfd_arch_i386
;
1199 #ifdef A29K_MAGIC_BIG
1200 case A29K_MAGIC_BIG
:
1201 case A29K_MAGIC_LITTLE
:
1202 arch
= bfd_arch_a29k
;
1211 arch
= bfd_arch_mips
;
1219 arch
= bfd_arch_m68k
;
1227 arch
= bfd_arch_m88k
;
1233 arch
= bfd_arch_z8k
;
1234 switch (internal_f
->f_flags
& F_MACHMASK
)
1237 machine
= bfd_mach_z8001
;
1240 machine
= bfd_mach_z8002
;
1251 arch
= bfd_arch_i960
;
1252 switch (F_I960TYPE
& internal_f
->f_flags
)
1256 machine
= bfd_mach_i960_core
;
1259 machine
= bfd_mach_i960_kb_sb
;
1262 machine
= bfd_mach_i960_mc
;
1265 machine
= bfd_mach_i960_xa
;
1268 machine
= bfd_mach_i960_ca
;
1271 machine
= bfd_mach_i960_ka_sa
;
1282 arch
= bfd_arch_rs6000
;
1289 arch
= bfd_arch_we32k
;
1296 arch
= bfd_arch_h8300
;
1301 default: /* Unreadable input file type */
1302 arch
= bfd_arch_obscure
;
1306 bfd_default_set_arch_mach(abfd
, arch
, machine
);
1307 if (!(internal_f
->f_flags
& F_RELFLG
))
1308 abfd
->flags
|= HAS_RELOC
;
1309 if ((internal_f
->f_flags
& F_EXEC
))
1310 abfd
->flags
|= EXEC_P
;
1311 if (!(internal_f
->f_flags
& F_LNNO
))
1312 abfd
->flags
|= HAS_LINENO
;
1313 if (!(internal_f
->f_flags
& F_LSYMS
))
1314 abfd
->flags
|= HAS_LOCALS
;
1317 bfd_get_symcount(abfd
) = internal_f
->f_nsyms
;
1318 if (internal_f
->f_nsyms
)
1319 abfd
->flags
|= HAS_SYMS
;
1321 coff
->sym_filepos
= internal_f
->f_symptr
;
1323 /* These members communicate important constants about the symbol table
1324 to GDB's symbol-reading code. These `constants' unfortunately vary
1325 from coff implementation to implementation... */
1326 #ifndef NO_COFF_SYMBOLS
1327 coff
->local_n_btmask
= N_BTMASK
;
1328 coff
->local_n_btshft
= N_BTSHFT
;
1329 coff
->local_n_tmask
= N_TMASK
;
1330 coff
->local_n_tshift
= N_TSHIFT
;
1331 coff
->local_symesz
= SYMESZ
;
1332 coff
->local_auxesz
= AUXESZ
;
1333 coff
->local_linesz
= LINESZ
;
1336 coff
->symbols
= (coff_symbol_type
*) NULL
;
1337 bfd_get_start_address(abfd
) = internal_f
->f_opthdr
? internal_a
->entry
: 0;
1341 bfd_release(abfd
, coff
);
1342 return (bfd_target
*)NULL
;
1346 DEFUN(coff_object_p
,(abfd
),
1352 struct internal_filehdr internal_f
;
1353 struct internal_aouthdr internal_a
;
1355 bfd_error
= system_call_error
;
1357 /* figure out how much to read */
1358 if (bfd_read((PTR
) &filehdr
, 1, FILHSZ
, abfd
) != FILHSZ
)
1361 bfd_swap_filehdr_in(abfd
, &filehdr
, &internal_f
);
1363 if (BADMAG(internal_f
)) {
1364 bfd_error
= wrong_format
;
1367 nscns
=internal_f
.f_nscns
;
1369 if (internal_f
.f_opthdr
) {
1370 if (bfd_read((PTR
) &opthdr
, 1,AOUTSZ
, abfd
) != AOUTSZ
) {
1373 bfd_swap_aouthdr_in(abfd
, (char *)&opthdr
, (char *)&internal_a
);
1376 /* Seek past the opt hdr stuff */
1377 bfd_seek(abfd
, (file_ptr
) (internal_f
.f_opthdr
+ FILHSZ
), SEEK_SET
);
1379 /* if the optional header is NULL or not the correct size then
1380 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1381 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1382 optional header is of a different size.
1384 But the mips keeps extra stuff in it's opthdr, so dont check
1388 #if defined(M88) || defined(I960)
1389 if (internal_f
.f_opthdr
!= 0 && AOUTSZ
!= internal_f
.f_opthdr
)
1390 return (bfd_target
*)NULL
;
1393 return coff_real_object_p(abfd
, nscns
, &internal_f
, &internal_a
);
1398 #ifndef NO_COFF_LINENOS
1401 DEFUN(coff_count_linenumbers
,(abfd
),
1404 unsigned int limit
= bfd_get_symcount(abfd
);
1408 asection
*s
= abfd
->sections
->output_section
;
1410 BFD_ASSERT(s
->lineno_count
== 0);
1416 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++) {
1417 asymbol
*q_maybe
= *p
;
1418 if (bfd_asymbol_flavour(q_maybe
) == bfd_target_coff_flavour
) {
1419 coff_symbol_type
*q
= coffsymbol(q_maybe
);
1422 This symbol has a linenumber, increment the owning
1423 section's linenumber count
1425 alent
*l
= q
->lineno
;
1426 q
->symbol
.section
->output_section
->lineno_count
++;
1428 while (l
->line_number
) {
1429 q
->symbol
.section
->output_section
->lineno_count
++;
1437 #endif /* NO_COFF_LINENOS */
1439 #ifndef NO_COFF_SYMBOLS
1442 Takes a bfd and a symbol, returns a pointer to the coff specific area
1443 of the symbol if there is one.
1445 static coff_symbol_type
*
1446 DEFUN(coff_symbol_from
,(ignore_abfd
, symbol
),
1447 bfd
*ignore_abfd AND
1450 if (bfd_asymbol_flavour(symbol
) != bfd_target_coff_flavour
)
1451 return (coff_symbol_type
*)NULL
;
1453 if (bfd_asymbol_bfd(symbol
)->tdata
.coff_obj_data
== (coff_data_type
*)NULL
)
1454 return (coff_symbol_type
*)NULL
;
1456 return (coff_symbol_type
*) symbol
;
1462 DEFUN(fixup_symbol_value
,(coff_symbol_ptr
, syment
),
1463 coff_symbol_type
*coff_symbol_ptr AND
1464 struct internal_syment
*syment
)
1467 /* Normalize the symbol flags */
1468 if (coff_symbol_ptr
->symbol
.section
== &bfd_com_section
) {
1469 /* a common symbol is undefined with a value */
1470 syment
->n_scnum
= N_UNDEF
;
1471 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1473 else if (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) {
1474 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1476 else if (coff_symbol_ptr
->symbol
.section
== & bfd_und_section
) {
1477 syment
->n_scnum
= N_UNDEF
;
1478 syment
->n_value
= 0;
1481 if (coff_symbol_ptr
->symbol
.section
) {
1483 coff_symbol_ptr
->symbol
.section
->output_section
->target_index
;
1486 coff_symbol_ptr
->symbol
.value
+
1487 coff_symbol_ptr
->symbol
.section
->output_offset
+
1488 coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
1492 /* This can happen, but I don't know why yet (steve@cygnus.com) */
1493 syment
->n_scnum
= N_ABS
;
1494 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1499 /* run through all the symbols in the symbol table and work out what
1500 their indexes into the symbol table will be when output
1502 Coff requires that each C_FILE symbol points to the next one in the
1503 chain, and that the last one points to the first external symbol. We
1508 DEFUN(coff_renumber_symbols
,(bfd_ptr
),
1511 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1512 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1513 unsigned int native_index
= 0;
1514 struct internal_syment
*last_file
= (struct internal_syment
*)NULL
;
1515 unsigned int symbol_index
;
1517 /* COFF demands that undefined symbols come after all other symbols.
1518 Since we don't need to impose this extra knowledge on all our client
1519 programs, deal with that here. Sort the symbol table; just move the
1520 undefined symbols to the end, leaving the rest alone. */
1521 /* @@ Do we have some condition we could test for, so we don't always
1522 have to do this? I don't think relocatability is quite right, but
1523 I'm not certain. [raeburn:19920508.1711EST] */
1528 newsyms
= (asymbol
**) bfd_alloc_by_size_t (bfd_ptr
,
1530 * (symbol_count
+ 1));
1531 bfd_ptr
->outsymbols
= newsyms
;
1532 for (i
= 0; i
< symbol_count
; i
++)
1533 if (symbol_ptr_ptr
[i
]->section
!= &bfd_und_section
)
1534 *newsyms
++ = symbol_ptr_ptr
[i
];
1535 for (i
= 0; i
< symbol_count
; i
++)
1536 if (symbol_ptr_ptr
[i
]->section
== &bfd_und_section
)
1537 *newsyms
++ = symbol_ptr_ptr
[i
];
1538 *newsyms
= (asymbol
*) NULL
;
1539 symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1542 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1544 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1545 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1546 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1549 if (s
->u
.syment
.n_sclass
== C_FILE
)
1551 if (last_file
!= (struct internal_syment
*)NULL
) {
1552 last_file
->n_value
= native_index
;
1554 last_file
= &(s
->u
.syment
);
1558 /* Modify the symbol values according to their section and
1561 fixup_symbol_value(coff_symbol_ptr
, &(s
->u
.syment
));
1563 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++) {
1564 s
[i
].offset
= native_index
++;
1571 obj_conv_table_size (bfd_ptr
) = native_index
;
1576 Run thorough the symbol table again, and fix it so that all pointers to
1577 entries are changed to the entries' index in the output symbol table.
1581 DEFUN(coff_mangle_symbols
,(bfd_ptr
),
1584 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1585 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1586 unsigned int symbol_index
;
1588 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1590 coff_symbol_type
*coff_symbol_ptr
=
1591 coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1593 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1595 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1597 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++) {
1598 combined_entry_type
*a
= s
+ i
+ 1;
1600 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
1601 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
1605 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
1606 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
1616 static int string_size
;
1618 DEFUN(coff_fix_symbol_name
,(ignore_abfd
, symbol
, native
),
1619 bfd
*ignore_abfd AND
1621 combined_entry_type
*native
)
1623 unsigned int name_length
;
1624 union internal_auxent
*auxent
;
1625 char * name
= ( char *)(symbol
->name
);
1627 if (name
== (char *) NULL
) {
1628 /* coff symbols always have names, so we'll make one up */
1629 symbol
->name
= "strange";
1630 name
= (char *)symbol
->name
;
1632 name_length
= strlen(name
);
1634 if (native
->u
.syment
.n_sclass
== C_FILE
) {
1635 strncpy(native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
1636 auxent
= &(native
+1)->u
.auxent
;
1638 #ifdef COFF_LONG_FILENAMES
1639 if (name_length
<= FILNMLEN
) {
1640 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1643 auxent
->x_file
.x_n
.x_offset
= string_size
+ 4;
1644 auxent
->x_file
.x_n
.x_zeroes
= 0;
1645 string_size
+= name_length
+ 1;
1648 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1649 if (name_length
> FILNMLEN
) {
1650 name
[FILNMLEN
] = '\0';
1655 { /* NOT A C_FILE SYMBOL */
1656 if (name_length
<= SYMNMLEN
) {
1657 /* This name will fit into the symbol neatly */
1658 strncpy(native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
1661 native
->u
.syment
._n
._n_n
._n_offset
= string_size
+ 4;
1662 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1663 string_size
+= name_length
+ 1;
1671 DEFUN(coff_write_symbol
,(abfd
, symbol
, native
, written
),
1674 combined_entry_type
*native AND
1675 unsigned int written
)
1677 unsigned int numaux
= native
->u
.syment
.n_numaux
;
1678 int type
= native
->u
.syment
.n_type
;
1679 int class = native
->u
.syment
.n_sclass
;
1683 /* @@ bfd_debug_section isn't accessible outside this file, but we know
1684 that C_FILE symbols belong there. So move them. */
1685 if (native
->u
.syment
.n_sclass
== C_FILE
)
1686 symbol
->section
= &bfd_debug_section
;
1688 if (symbol
->section
== &bfd_abs_section
)
1690 native
->u
.syment
.n_scnum
= N_ABS
;
1692 else if (symbol
->section
== &bfd_debug_section
)
1694 native
->u
.syment
.n_scnum
= N_DEBUG
;
1696 else if (symbol
->section
== &bfd_und_section
)
1698 native
->u
.syment
.n_scnum
= N_UNDEF
;
1702 native
->u
.syment
.n_scnum
=
1703 symbol
->section
->output_section
->target_index
;
1707 coff_fix_symbol_name(abfd
, symbol
, native
);
1709 coff_swap_sym_out(abfd
, &native
->u
.syment
, &buf
);
1710 bfd_write((PTR
)& buf
, 1, SYMESZ
, abfd
);
1711 for (j
= 0; j
< native
->u
.syment
.n_numaux
; j
++)
1714 coff_swap_aux_out(abfd
,
1715 &( (native
+ j
+ 1)->u
.auxent
), type
, class, &buf1
);
1716 bfd_write((PTR
) (&buf1
), 1, AUXESZ
, abfd
);
1719 Reuse somewhere in the symbol to keep the index
1721 set_index(symbol
, written
);
1722 return written
+ 1 + numaux
;
1727 DEFUN(coff_write_alien_symbol
,(abfd
, symbol
, written
),
1730 unsigned int written
)
1733 This symbol has been created by the loader, or come from a non
1734 coff format. It has no native element to inherit, make our
1737 combined_entry_type
*native
;
1738 combined_entry_type dummy
;
1740 native
->u
.syment
.n_type
= T_NULL
;
1742 native
->u
.syment
.n_flags
= 0;
1744 if (symbol
->section
== &bfd_und_section
)
1746 native
->u
.syment
.n_scnum
= N_UNDEF
;
1747 native
->u
.syment
.n_value
= symbol
->value
;
1749 else if (symbol
->section
== &bfd_com_section
)
1751 native
->u
.syment
.n_scnum
= N_UNDEF
;
1752 native
->u
.syment
.n_value
= symbol
->value
;
1756 else if (symbol
->flags
& BSF_DEBUGGING
) {
1758 remove name so it doesn't take up any space
1763 native
->u
.syment
.n_scnum
= symbol
->section
->output_section
->target_index
;
1764 native
->u
.syment
.n_value
= symbol
->value
+
1765 symbol
->section
->output_section
->vma
+
1766 symbol
->section
->output_offset
;
1768 /* Copy the any flags from the the file hdr into the symbol */
1770 coff_symbol_type
*c
= coff_symbol_from(abfd
, symbol
);
1771 if (c
!= (coff_symbol_type
*)NULL
) {
1772 native
->u
.syment
.n_flags
= bfd_asymbol_bfd(&c
->symbol
)->flags
;
1779 native
->u
.syment
.pad1
[0] = 0;
1780 native
->u
.syment
.pad1
[0] = 0;
1783 native
->u
.syment
.n_type
= 0;
1784 if (symbol
->flags
& BSF_LOCAL
)
1785 native
->u
.syment
.n_sclass
= C_STAT
;
1787 native
->u
.syment
.n_sclass
= C_EXT
;
1788 native
->u
.syment
.n_numaux
= 0;
1790 return coff_write_symbol(abfd
, symbol
, native
, written
);
1794 DEFUN(coff_write_native_symbol
,(abfd
, symbol
, written
),
1796 coff_symbol_type
*symbol AND
1797 unsigned int written
)
1800 Does this symbol have an ascociated line number - if so then
1801 make it remember this symbol index. Also tag the auxent of
1802 this symbol to point to the right place in the lineno table
1804 combined_entry_type
*native
= symbol
->native
;
1806 alent
*lineno
= symbol
->lineno
;
1808 if (lineno
&& !symbol
->done_lineno
) {
1809 unsigned int count
= 0;
1810 lineno
[count
].u
.offset
= written
;
1811 if (native
->u
.syment
.n_numaux
) {
1812 union internal_auxent
*a
= &((native
+1)->u
.auxent
);
1814 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1815 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1818 And count and relocate all other linenumbers
1822 while (lineno
[count
].line_number
) {
1825 I've been told this, but still need proof:
1826 > The second bug is also in `bfd/coffcode.h'. This bug causes the linker to screw
1827 > up the pc-relocations for all the line numbers in COFF code. This bug isn't
1828 > only specific to A29K implementations, but affects all systems using COFF
1829 > format binaries. Note that in COFF object files, the line number core offsets
1830 > output by the assembler are relative to the start of each procedure, not
1831 > to the start of the .text section. This patch relocates the line numbers
1832 > relative to the `native->u.syment.n_value' instead of the section virtual
1833 > address. modular!olson@cs.arizona.edu (Jon Olson)
1835 lineno
[count
].u
.offset
+= native
->u
.syment
.n_value
;
1838 lineno
[count
].u
.offset
+=
1839 symbol
->symbol
.section
->output_section
->vma
+
1840 symbol
->symbol
.section
->output_offset
;
1844 symbol
->done_lineno
= true;
1846 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1849 return coff_write_symbol(abfd
, &( symbol
->symbol
), native
,written
);
1853 DEFUN(coff_write_symbols
,(abfd
),
1857 unsigned int limit
= bfd_get_symcount(abfd
);
1858 unsigned int written
= 0;
1865 /* Seek to the right place */
1866 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
1868 /* Output all the symbols we have */
1871 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1873 asymbol
*symbol
= *p
;
1874 coff_symbol_type
*c_symbol
= coff_symbol_from(abfd
, symbol
);
1876 if (c_symbol
== (coff_symbol_type
*) NULL
||
1877 c_symbol
->native
== (combined_entry_type
*)NULL
)
1879 written
= coff_write_alien_symbol(abfd
, symbol
, written
);
1883 written
= coff_write_native_symbol(abfd
, c_symbol
, written
);
1888 bfd_get_symcount(abfd
) = written
;
1890 /* Now write out strings */
1892 if (string_size
!= 0)
1894 unsigned int size
= string_size
+ 4;
1897 bfd_h_put_32(abfd
, size
, buffer
);
1898 bfd_write((PTR
) buffer
, 1, sizeof(buffer
), abfd
);
1899 for (p
= abfd
->outsymbols
, i
= 0;
1904 size_t name_length
= strlen(q
->name
);
1906 coff_symbol_type
* c_symbol
= coff_symbol_from(abfd
, q
);
1907 maxlen
= ((c_symbol
!= NULL
&& c_symbol
->native
!= NULL
) &&
1908 (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
)) ?
1909 FILNMLEN
: SYMNMLEN
;
1911 if (name_length
> maxlen
) {
1912 bfd_write((PTR
) (q
->name
), 1, name_length
+ 1, abfd
);
1917 /* We would normally not write anything here, but we'll write
1918 out 4 so that any stupid coff reader which tries to read
1919 the string table even when there isn't one won't croak.
1922 uint32e_type size
= 4;
1924 bfd_write((PTR
)&size
, 1, sizeof(size
), abfd
);
1933 To write relocations, all the back end does is step though the
1934 canonical relocation table, and create an
1935 @code{internal_reloc}. The symbol index to use is removed from
1936 the @code{offset} field in the symbol table supplied, the
1937 address comes directly from the sum of the section base
1938 address and the relocation offset and the type is dug directly
1939 from the howto field. Then the @code{internal_reloc} is
1940 swapped into the shape of an @code{external_reloc} and written
1946 DEFUN(coff_write_relocs
,(abfd
),
1950 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1952 struct external_reloc dst
;
1954 arelent
**p
= s
->orelocation
;
1955 bfd_seek(abfd
, s
->rel_filepos
, SEEK_SET
);
1956 for (i
= 0; i
< s
->reloc_count
; i
++) {
1957 struct internal_reloc n
;
1959 memset((PTR
)&n
, 0, sizeof(n
));
1961 n
.r_vaddr
= q
->address
+ s
->vma
;
1962 /* The 29k const/consth reloc pair is a real kludge - the consth
1963 part doesn't have a symbol - it has an offset. So rebuilt
1966 if (q
->howto
->type
== R_IHCONST
)
1967 n
.r_symndx
= q
->addend
;
1974 if (q
->sym_ptr_ptr
== bfd_abs_section
.symbol_ptr_ptr
)
1976 /* This is a relocation relative to the absolute symbol */
1981 n
.r_symndx
= get_index((*(q
->sym_ptr_ptr
)));
1982 /* Take notice if the symbol reloc points to a symbol we don't have
1983 in our symbol table. What should we do for this?? */
1984 if (n
.r_symndx
> obj_conv_table_size (abfd
))
1992 /* Work out reloc type from what is required */
1993 SELECT_RELOC(n
.r_type
, q
->howto
);
1995 n
.r_type
= q
->howto
->type
;
1997 coff_swap_reloc_out(abfd
, &n
, &dst
);
1998 bfd_write((PTR
) &dst
, 1, RELSZ
, abfd
);
2002 #endif /* NO_COFF_SYMBOLS */
2004 #ifndef NO_COFF_LINENOS
2007 DEFUN(coff_write_linenumbers
,(abfd
),
2011 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
2012 if (s
->lineno_count
) {
2013 asymbol
**q
= abfd
->outsymbols
;
2014 bfd_seek(abfd
, s
->line_filepos
, SEEK_SET
);
2015 /* Find all the linenumbers in this section */
2019 BFD_SEND(bfd_asymbol_bfd(p
), _get_lineno
, (bfd_asymbol_bfd(p
), p
));
2021 /* Found a linenumber entry, output */
2022 struct internal_lineno out
;
2024 memset( (PTR
)&out
, 0, sizeof(out
));
2026 out
.l_addr
.l_symndx
= l
->u
.offset
;
2027 coff_swap_lineno_out(abfd
, &out
, &buff
);
2028 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
2030 while (l
->line_number
) {
2031 out
.l_lnno
= l
->line_number
;
2032 out
.l_addr
.l_symndx
= l
->u
.offset
;
2033 coff_swap_lineno_out(abfd
, &out
, &buff
);
2034 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
2045 DEFUN(coff_get_lineno
,(ignore_abfd
, symbol
),
2046 bfd
*ignore_abfd AND
2049 return coffsymbol(symbol
)->lineno
;
2052 #endif /* NO_COFF_LINENOS */
2055 coff_make_empty_symbol(abfd
)
2058 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc(abfd
, sizeof(coff_symbol_type
));
2060 bfd_error
= no_memory
;
2063 new->symbol
.section
= 0;
2065 new->lineno
= (alent
*) NULL
;
2066 new->done_lineno
= false;
2067 new->symbol
.the_bfd
= abfd
;
2068 return &new->symbol
;
2071 #ifndef NO_COFF_SYMBOLS
2074 DEFUN (coff_make_debug_symbol
, (abfd
, ptr
, sz
),
2079 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc(abfd
, sizeof(coff_symbol_type
));
2081 bfd_error
= no_memory
;
2084 /* @@ This shouldn't be using a constant multiplier. */
2085 new->native
= (combined_entry_type
*) bfd_zalloc (abfd
, sizeof (combined_entry_type
) * 10);
2086 new->symbol
.section
= &bfd_debug_section
;
2087 new->lineno
= (alent
*) NULL
;
2088 new->done_lineno
= false;
2089 new->symbol
.the_bfd
= abfd
;
2090 return &new->symbol
;
2094 DEFUN(coff_print_symbol
,(ignore_abfd
, filep
, symbol
, how
),
2095 bfd
*ignore_abfd AND
2098 bfd_print_symbol_type how
)
2100 FILE *file
= (FILE *)filep
;
2102 case bfd_print_symbol_name
:
2103 fprintf(file
, "%s", symbol
->name
);
2105 case bfd_print_symbol_more
:
2106 fprintf(file
, "coff %lx %lx", (unsigned long) coffsymbol(symbol
)->native
,
2107 (unsigned long) coffsymbol(symbol
)->lineno
);
2109 case bfd_print_symbol_nm
:
2112 CONST
char *section_name
= symbol
->section
->name
;
2113 bfd_print_symbol_vandf((PTR
) file
, symbol
);
2116 fprintf(file
, " %-5s %s %s %s",
2118 coffsymbol(symbol
)->native
? "n" : "g",
2119 coffsymbol(symbol
)->lineno
? "l" : " ",
2125 case bfd_print_symbol_all
:
2126 /* Print out the symbols in a reasonable way */
2128 CONST
char *section_name
= symbol
->section
->name
;
2131 if (coffsymbol(symbol
)->native
)
2134 combined_entry_type
*combined
= coffsymbol(symbol
)->native
;
2135 combined_entry_type
*root
= obj_raw_syments(ignore_abfd
);
2137 fprintf(file
,"[%3d]",
2141 fprintf(file
, "(sc %2d)(fl%4x)(ty%3x)(sc%3d) nx(%d) %08x %s",
2142 combined
->u
.syment
.n_scnum
,
2143 combined
->u
.syment
.n_flags
,
2144 combined
->u
.syment
.n_type
,
2145 combined
->u
.syment
.n_sclass
,
2146 combined
->u
.syment
.n_numaux
,
2147 combined
->u
.syment
.n_value
,
2150 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
2153 switch (combined
->u
.syment
.n_sclass
) {
2155 fprintf(file
, "File ");
2158 fprintf(file
, "AUX lnno %x size %x tagndx %x",
2159 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
2160 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
2161 combined
[aux
+1].u
.auxent
.x_sym
.x_tagndx
.l
);
2169 struct lineno_cache_entry
*l
= coffsymbol(symbol
)->lineno
;
2172 printf("\n%s :", l
->u
.sym
->name
);
2174 while (l
->line_number
)
2176 printf("\n%4d : %x",
2190 bfd_print_symbol_vandf((PTR
) file
, symbol
);
2191 fprintf(file
, " %-5s %s %s %s",
2193 coffsymbol(symbol
)->native
? "n" : "g",
2194 coffsymbol(symbol
)->lineno
? "l" : " ",
2203 #endif /* NO_COFF_SYMBOLS */
2205 /* Set flags and magic number of a coff file from architecture and machine
2206 type. Result is true if we can represent the arch&type, false if not. */
2209 DEFUN(coff_set_flags
,(abfd
, magicp
, flagsp
),
2211 unsigned *magicp AND
2212 unsigned short *flagsp
)
2214 switch (bfd_get_arch(abfd
)) {
2218 switch (bfd_get_mach(abfd
))
2220 case bfd_mach_z8001
:
2223 case bfd_mach_z8002
:
2237 *magicp
= I960ROMAGIC
;
2239 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2240 I960RWMAGIC); FIXME???
2242 switch (bfd_get_mach(abfd
)) {
2243 case bfd_mach_i960_core
:
2246 case bfd_mach_i960_kb_sb
:
2249 case bfd_mach_i960_mc
:
2252 case bfd_mach_i960_xa
:
2255 case bfd_mach_i960_ca
:
2258 case bfd_mach_i960_ka_sa
:
2271 *magicp
= MIPS_MAGIC_2
;
2277 *magicp
= I386MAGIC
;
2283 *magicp
= MC68MAGIC
;
2290 *magicp
= MC88OMAGIC
;
2295 case bfd_arch_h8300
:
2296 *magicp
= H8300MAGIC
;
2300 #ifdef A29K_MAGIC_BIG
2302 if (abfd
->xvec
->byteorder_big_p
)
2303 *magicp
= A29K_MAGIC_BIG
;
2305 *magicp
= A29K_MAGIC_LITTLE
;
2311 case bfd_arch_we32k
:
2312 *magicp
= WE32KMAGIC
;
2318 case bfd_arch_rs6000
:
2319 *magicp
= U802TOCMAGIC
;
2324 default: /* Unknown architecture */
2325 /* return false; -- fall through to "return false" below, to avoid
2326 "statement never reached" errors on the one below. */
2335 DEFUN(coff_set_arch_mach
,(abfd
, arch
, machine
),
2337 enum bfd_architecture arch AND
2338 unsigned long machine
)
2341 unsigned short dummy2
;
2342 bfd_default_set_arch_mach(abfd
, arch
, machine
);
2344 if (arch
!= bfd_arch_unknown
&&
2345 coff_set_flags(abfd
, &dummy1
, &dummy2
) != true)
2346 return false; /* We can't represent this type */
2347 return true; /* We're easy ... */
2351 /* Calculate the file position for each section. */
2354 DEFUN(coff_compute_section_file_positions
,(abfd
),
2358 asection
*previous
= (asection
*)NULL
;
2359 file_ptr sofar
= FILHSZ
;
2361 if (bfd_get_start_address(abfd
))
2363 /* A start address may have been added to the original file. In this
2364 case it will need an optional header to record it. */
2365 abfd
->flags
|= EXEC_P
;
2368 if (abfd
->flags
& EXEC_P
)
2371 sofar
+= abfd
->section_count
* SCNHSZ
;
2372 for (current
= abfd
->sections
;
2373 current
!= (asection
*)NULL
;
2374 current
= current
->next
) {
2376 /* Only deal with sections which have contents */
2377 if (!(current
->flags
& SEC_HAS_CONTENTS
))
2380 /* Align the sections in the file to the same boundary on
2381 which they are aligned in virtual memory. I960 doesn't
2382 do this (FIXME) so we can stay in sync with Intel. 960
2383 doesn't yet page from files... */
2386 /* make sure this section is aligned on the right boundary - by
2387 padding the previous section up if necessary */
2390 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2391 if (previous
!= (asection
*)NULL
) {
2392 previous
->_raw_size
+= sofar
- old_sofar
;
2397 /* FIXME, in demand paged files, the low order bits of the file
2398 offset must match the low order bits of the virtual address.
2399 "Low order" is apparently implementation defined. Add code
2400 here to round sofar up to match the virtual address. */
2402 current
->filepos
= sofar
;
2404 sofar
+= current
->_raw_size
;
2406 /* make sure that this section is of the right size too */
2408 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2409 current
->_raw_size
+= sofar
- old_sofar
;
2414 obj_relocbase(abfd
) = sofar
;
2417 #ifndef NO_COFF_SYMBOLS
2419 coff_section_symbol (abfd
, name
)
2423 asection
*sec
= bfd_make_section_old_way (abfd
, name
);
2425 combined_entry_type
*csym
;
2428 if (coff_symbol_from (abfd
, sym
))
2429 csym
= coff_symbol_from (abfd
, sym
)->native
;
2432 /* Make sure back-end COFF stuff is there. */
2436 coff_symbol_type sym
;
2437 /* @@FIXME This shouldn't use a fixed size!! */
2438 combined_entry_type e
[10];
2441 f
= (struct foo
*) bfd_alloc_by_size_t (abfd
, sizeof (*f
));
2442 memset ((char *) f
, 0, sizeof (*f
));
2443 coff_symbol_from (abfd
, sym
)->native
= csym
= f
->e
;
2445 csym
[0].u
.syment
.n_sclass
= C_STAT
;
2446 csym
[0].u
.syment
.n_numaux
= 1;
2447 /* SF_SET_STATICS (sym); @@ ??? */
2450 csym
[1].u
.auxent
.x_scn
.x_scnlen
= sec
->_raw_size
;
2451 csym
[1].u
.auxent
.x_scn
.x_nreloc
= sec
->reloc_count
;
2452 csym
[1].u
.auxent
.x_scn
.x_nlinno
= sec
->lineno_count
;
2456 csym
[1].u
.auxent
.x_scn
.x_scnlen
= 0;
2457 csym
[1].u
.auxent
.x_scn
.x_nreloc
= 0;
2458 csym
[1].u
.auxent
.x_scn
.x_nlinno
= 0;
2463 /* If .file, .text, .data, .bss symbols are missing, add them. */
2464 /* @@ Should we only be adding missing symbols, or overriding the aux
2465 values for existing section symbols? */
2467 coff_add_missing_symbols (abfd
)
2470 unsigned int nsyms
= bfd_get_symcount (abfd
);
2471 asymbol
**sympp
= abfd
->outsymbols
;
2474 int need_text
= 1, need_data
= 1, need_bss
= 1, need_file
= 1;
2476 for (i
= 0; i
< nsyms
; i
++)
2478 coff_symbol_type
*csym
= coff_symbol_from (abfd
, sympp
[i
]);
2482 /* only do this if there is a coff representation of the input
2484 if (csym
->native
&& csym
->native
->u
.syment
.n_sclass
== C_FILE
)
2489 name
= csym
->symbol
.name
;
2492 if (!strcmp (name
, _TEXT
))
2494 else if (!strcmp (name
, _DATA
))
2496 else if (!strcmp (name
, _BSS
))
2500 /* Now i == bfd_get_symcount (abfd). */
2501 /* @@ For now, don't deal with .file symbol. */
2504 if (!need_text
&& !need_data
&& !need_bss
&& !need_file
)
2506 nsyms
+= need_text
+ need_data
+ need_bss
+ need_file
;
2507 sympp2
= (asymbol
**) bfd_alloc_by_size_t (abfd
, nsyms
* sizeof (asymbol
*));
2508 memcpy (sympp2
, sympp
, i
* sizeof (asymbol
*));
2511 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
2515 sympp2
[i
++] = coff_section_symbol (abfd
, _TEXT
);
2517 sympp2
[i
++] = coff_section_symbol (abfd
, _DATA
);
2519 sympp2
[i
++] = coff_section_symbol (abfd
, _BSS
);
2520 BFD_ASSERT (i
== nsyms
);
2521 bfd_set_symtab (abfd
, sympp2
, nsyms
);
2523 #endif /* NO_COFF_SYMBOLS */
2528 DEFUN(coff_write_object_contents
,(abfd
),
2534 boolean hasrelocs
= false;
2535 boolean haslinno
= false;
2536 file_ptr reloc_base
;
2537 file_ptr lineno_base
;
2541 unsigned long reloc_size
= 0;
2542 unsigned long lnno_size
= 0;
2543 asection
*text_sec
= NULL
;
2544 asection
*data_sec
= NULL
;
2545 asection
*bss_sec
= NULL
;
2547 struct internal_filehdr internal_f
;
2548 struct internal_aouthdr internal_a
;
2551 bfd_error
= system_call_error
;
2552 /* Number the output sections, starting from one on the first section
2553 with a name which doesn't start with a *.
2554 @@ The code doesn't make this check. Is it supposed to be done,
2557 for (current
= abfd
->sections
; current
!= (asection
*)NULL
;
2558 current
= current
->next
)
2560 current
->target_index
= count
;
2564 if(abfd
->output_has_begun
== false) {
2565 coff_compute_section_file_positions(abfd
);
2568 if (abfd
->sections
!= (asection
*)NULL
) {
2569 scn_base
= abfd
->sections
->filepos
;
2574 if (bfd_seek(abfd
, scn_base
, SEEK_SET
) != 0)
2576 reloc_base
= obj_relocbase(abfd
);
2578 /* Make a pass through the symbol table to count line number entries and
2579 put them into the correct asections */
2581 #ifndef NO_COFF_LINENOS
2582 coff_count_linenumbers(abfd
);
2584 data_base
= scn_base
;
2586 /* Work out the size of the reloc and linno areas */
2588 for (current
= abfd
->sections
; current
!= NULL
; current
=
2591 /* We give section headers to +ve indexes */
2592 if (current
->target_index
> 0)
2595 reloc_size
+= current
->reloc_count
* RELSZ
;
2596 #ifndef NO_COFF_LINENOS
2597 lnno_size
+= current
->lineno_count
* LINESZ
;
2599 data_base
+= SCNHSZ
;
2604 lineno_base
= reloc_base
+ reloc_size
;
2605 sym_base
= lineno_base
+ lnno_size
;
2607 /* Indicate in each section->line_filepos its actual file address */
2608 for (current
= abfd
->sections
; current
!= NULL
; current
=
2611 if (current
->target_index
> 0)
2614 if (current
->lineno_count
) {
2615 current
->line_filepos
= lineno_base
;
2616 current
->moving_line_filepos
= lineno_base
;
2617 #ifndef NO_COFF_LINENOS
2618 lineno_base
+= current
->lineno_count
* LINESZ
;
2622 current
->line_filepos
= 0;
2624 if (current
->reloc_count
) {
2625 current
->rel_filepos
= reloc_base
;
2626 reloc_base
+= current
->reloc_count
* RELSZ
;
2629 current
->rel_filepos
= 0;
2636 /* Write section headers to the file. */
2637 internal_f
.f_nscns
= 0;
2639 (file_ptr
) ((abfd
->flags
& EXEC_P
) ?
2640 (FILHSZ
+ AOUTSZ
) : FILHSZ
),
2645 unsigned int pad
= abfd
->flags
& D_PAGED
? data_base
: 0;
2647 unsigned int pad
= 0;
2649 for (current
= abfd
->sections
;
2651 current
= current
->next
) {
2652 struct internal_scnhdr section
;
2653 if (current
->target_index
> 0)
2655 internal_f
.f_nscns
++;
2656 strncpy(&(section
.s_name
[0]), current
->name
, 8);
2658 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
2659 Ian Taylor <ian@cygnus.com>. */
2660 if (strcmp (current
->name
, _LIB
) == 0)
2661 section
.s_vaddr
= 0;
2664 section
.s_vaddr
= current
->vma
+ pad
;
2665 section
.s_paddr
= current
->vma
+ pad
;
2666 section
.s_size
= current
->_raw_size
- pad
;
2668 If this section has no size or is unloadable then the scnptr
2671 if (current
->_raw_size
- pad
== 0 ||
2672 (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0) {
2673 section
.s_scnptr
= 0;
2676 section
.s_scnptr
= current
->filepos
;
2678 section
.s_relptr
= current
->rel_filepos
;
2679 section
.s_lnnoptr
= current
->line_filepos
;
2680 section
.s_nreloc
= current
->reloc_count
;
2681 section
.s_nlnno
= current
->lineno_count
;
2682 if (current
->reloc_count
!= 0)
2684 if (current
->lineno_count
!= 0)
2687 section
.s_flags
= sec_to_styp_flags(current
->name
,current
->flags
);
2689 if (!strcmp(current
->name
, _TEXT
)) {
2691 } else if (!strcmp(current
->name
, _DATA
)) {
2693 #ifdef TWO_DATA_SECS
2694 } else if (!strcmp(current
->name
, ".data2")) {
2696 #endif /* TWO_DATA_SECS */
2697 } else if (!strcmp(current
->name
, _BSS
)) {
2702 section
.s_align
= (current
->alignment_power
2703 ? 1 << current
->alignment_power
2710 coff_swap_scnhdr_out(abfd
, §ion
, &buff
);
2711 bfd_write((PTR
) (&buff
), 1, SCNHSZ
, abfd
);
2721 /* OK, now set up the filehdr... */
2723 /* Don't include the internal abs section in the section count */
2726 We will NOT put a fucking timestamp in the header here. Every time you
2727 put it back, I will come in and take it out again. I'm sorry. This
2728 field does not belong here. We fill it with a 0 so it compares the
2729 same but is not a reasonable time. -- gnu@cygnus.com
2731 internal_f
.f_timdat
= 0;
2733 if (bfd_get_symcount(abfd
) != 0)
2734 internal_f
.f_symptr
= sym_base
;
2736 internal_f
.f_symptr
= 0;
2738 internal_f
.f_flags
= 0;
2740 if (abfd
->flags
& EXEC_P
)
2741 internal_f
.f_opthdr
= AOUTSZ
;
2743 internal_f
.f_opthdr
= 0;
2746 internal_f
.f_flags
|= F_RELFLG
;
2748 internal_f
.f_flags
|= F_LNNO
;
2749 if (0 == bfd_get_symcount(abfd
))
2750 internal_f
.f_flags
|= F_LSYMS
;
2751 if (abfd
->flags
& EXEC_P
)
2752 internal_f
.f_flags
|= F_EXEC
;
2754 if (!abfd
->xvec
->byteorder_big_p
)
2755 internal_f
.f_flags
|= F_AR32WR
;
2757 internal_f
.f_flags
|= F_AR32W
;
2760 FIXME, should do something about the other byte orders and
2764 /* Set up architecture-dependent stuff */
2766 { unsigned int magic
= 0;
2767 unsigned short flags
= 0;
2768 coff_set_flags(abfd
, &magic
, &flags
);
2769 internal_f
.f_magic
= magic
;
2770 internal_f
.f_flags
|= flags
;
2771 /* ...and the "opt"hdr... */
2774 # ifdef ULTRA3 /* NYU's machine */
2775 /* FIXME: This is a bogus check. I really want to see if there
2776 * is a .shbss or a .shdata section, if so then set the magic
2777 * number to indicate a shared data executable.
2779 if (internal_f
.f_nscns
>= 7)
2780 internal_a
.magic
= SHMAGIC
; /* Shared magic */
2782 # endif /* ULTRA3 */
2783 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
2784 #define __A_MAGIC_SET__
2787 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
2788 #define __A_MAGIC_SET__
2791 #define __A_MAGIC_SET__
2792 internal_a
.magic
= PAGEMAGICBCS
;
2795 #if M68 || MIPS || WE32K
2796 #define __A_MAGIC_SET__
2797 /* Never was anything here for the 68k */
2798 #endif /* M68 || MIPS || WE32K */
2801 # define __A_MAGIC_SET__
2802 internal_a
.magic
= ZMAGIC
;
2806 #define __A_MAGIC_SET__
2807 internal_a
.magic
= (abfd
->flags
& D_PAGED
)? RS6K_AOUTHDR_ZMAGIC
:
2808 (abfd
->flags
& WP_TEXT
)? RS6K_AOUTHDR_NMAGIC
:
2809 RS6K_AOUTHDR_OMAGIC
;
2812 #ifndef __A_MAGIC_SET__
2813 # include "Your aouthdr magic number is not being set!"
2815 # undef __A_MAGIC_SET__
2818 /* Now should write relocs, strings, syms */
2819 obj_sym_filepos(abfd
) = sym_base
;
2821 #ifndef NO_COFF_SYMBOLS
2822 if (bfd_get_symcount(abfd
) != 0) {
2823 coff_add_missing_symbols (abfd
);
2824 coff_renumber_symbols(abfd
);
2825 coff_mangle_symbols(abfd
);
2826 coff_write_symbols(abfd
);
2827 coff_write_linenumbers(abfd
);
2828 coff_write_relocs(abfd
);
2830 #endif /* NO_COFF_SYMBOLS */
2832 internal_a
.tsize
= bfd_get_section_size_before_reloc(text_sec
);
2833 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
2836 internal_a
.dsize
= bfd_get_section_size_before_reloc(data_sec
);
2837 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
2840 internal_a
.bsize
= bfd_get_section_size_before_reloc(bss_sec
);
2843 internal_a
.entry
= bfd_get_start_address(abfd
);
2844 internal_f
.f_nsyms
= bfd_get_symcount(abfd
);
2846 /* now write them */
2847 if (bfd_seek(abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
2851 coff_swap_filehdr_out(abfd
, (PTR
)&internal_f
, (PTR
)&buff
);
2852 bfd_write((PTR
) &buff
, 1, FILHSZ
, abfd
);
2854 if (abfd
->flags
& EXEC_P
) {
2856 coff_swap_aouthdr_out(abfd
, (PTR
)&internal_a
, (PTR
)&buff
);
2857 bfd_write((PTR
) &buff
, 1, AOUTSZ
, abfd
);
2862 #ifndef NO_COFF_SYMBOLS
2865 this function transforms the offsets into the symbol table into
2866 pointers to syments.
2871 DEFUN(coff_pointerize_aux
,(ignore_abfd
, table_base
, type
, class, auxent
),
2872 bfd
*ignore_abfd AND
2873 combined_entry_type
*table_base AND
2876 combined_entry_type
*auxent
)
2878 /* Don't bother if this is a file or a section */
2879 if (class == C_STAT
&& type
== T_NULL
) return;
2880 if (class == C_FILE
) return;
2882 /* Otherwise patch up */
2883 if (ISFCN(type
) || ISTAG(class) || class == C_BLOCK
) {
2884 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
= table_base
+
2885 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2886 auxent
->fix_end
= 1;
2888 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
!= 0) {
2889 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
=
2890 table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
2891 auxent
->fix_tag
= 1;
2895 #endif /* NO_COFF_SYMBOLS */
2898 DEFUN(coff_set_section_contents
,(abfd
, section
, location
, offset
, count
),
2903 bfd_size_type count
)
2905 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
2906 coff_compute_section_file_positions(abfd
);
2909 /* If this is a .lib section, bump the vma address so that it
2910 winds up being the number of .lib sections output. This is
2911 right for SVR3.2. Shared libraries should probably get more
2912 generic support. Ian Taylor <ian@cygnus.com>. */
2913 if (strcmp (section
->name
, _LIB
) == 0)
2917 bfd_seek(abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
);
2920 return (bfd_write(location
, 1, count
, abfd
) == count
) ? true : false;
2926 coff_close_and_cleanup(abfd
)
2929 if (!bfd_read_p(abfd
))
2930 switch (abfd
->format
) {
2932 if (!_bfd_write_archive_contents(abfd
))
2936 if (!coff_write_object_contents(abfd
))
2940 bfd_error
= invalid_operation
;
2944 /* We depend on bfd_close to free all the memory on the obstack. */
2945 /* FIXME if bfd_release is not using obstacks! */
2951 buy_and_read(abfd
, where
, seek_direction
, size
)
2957 PTR area
= (PTR
) bfd_alloc(abfd
, size
);
2959 bfd_error
= no_memory
;
2962 bfd_seek(abfd
, where
, seek_direction
);
2963 if (bfd_read(area
, 1, size
, abfd
) != size
) {
2964 bfd_error
= system_call_error
;
2968 } /* buy_and_read() */
2971 #ifndef NO_COFF_SYMBOLS
2974 DEFUN(build_string_table
,(abfd
),
2977 char string_table_size_buffer
[4];
2978 unsigned int string_table_size
;
2981 /* At this point we should be "seek"'d to the end of the
2982 symbols === the symbol table size. */
2983 if (bfd_read((char *) string_table_size_buffer
,
2984 sizeof(string_table_size_buffer
),
2985 1, abfd
) != sizeof(string_table_size
)) {
2986 bfd_error
= system_call_error
;
2990 string_table_size
= bfd_h_get_32(abfd
, (bfd_byte
*) string_table_size_buffer
);
2992 if ((string_table
= (PTR
) bfd_alloc(abfd
, string_table_size
-= 4)) == NULL
) {
2993 bfd_error
= no_memory
;
2995 } /* on mallocation error */
2996 if (bfd_read(string_table
, string_table_size
, 1, abfd
) != string_table_size
) {
2997 bfd_error
= system_call_error
;
3000 return string_table
;
3003 /* Allocate space for the ".debug" section, and read it.
3004 We did not read the debug section until now, because
3005 we didn't want to go to the trouble until someone needed it. */
3008 DEFUN(build_debug_section
,(abfd
),
3011 char *debug_section
;
3014 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
3017 bfd_error
= no_debug_section
;
3021 debug_section
= (PTR
) bfd_alloc (abfd
,
3022 bfd_get_section_size_before_reloc (sect
));
3023 if (debug_section
== NULL
) {
3024 bfd_error
= no_memory
;
3028 /* Seek to the beginning of the `.debug' section and read it.
3029 Save the current position first; it is needed by our caller.
3030 Then read debug section and reset the file pointer. */
3032 position
= bfd_tell (abfd
);
3033 bfd_seek (abfd
, sect
->filepos
, SEEK_SET
);
3034 if (bfd_read (debug_section
,
3035 bfd_get_section_size_before_reloc (sect
), 1, abfd
)
3036 != bfd_get_section_size_before_reloc(sect
)) {
3037 bfd_error
= system_call_error
;
3040 bfd_seek (abfd
, position
, SEEK_SET
);
3041 return debug_section
;
3045 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
3046 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
3047 be \0-terminated. */
3049 DEFUN(copy_name
,(abfd
, name
, maxlen
),
3057 for (len
= 0; len
< maxlen
; ++len
) {
3058 if (name
[len
] == '\0') {
3063 if ((newname
= (PTR
) bfd_alloc(abfd
, len
+1)) == NULL
) {
3064 bfd_error
= no_memory
;
3067 strncpy(newname
, name
, len
);
3068 newname
[len
] = '\0';
3073 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
3074 knit the symbol names into a normalized form. By normalized here I
3075 mean that all symbols have an n_offset pointer that points to a null-
3076 terminated string. */
3078 #ifndef SYMNAME_IN_DEBUG
3079 #define SYMNAME_IN_DEBUG(x) 0
3082 static combined_entry_type
*
3083 DEFUN(get_normalized_symtab
,(abfd
),
3086 combined_entry_type
*internal
;
3087 combined_entry_type
*internal_ptr
;
3088 combined_entry_type
*symbol_ptr
;
3089 combined_entry_type
*internal_end
;
3093 char *string_table
= NULL
;
3094 char *debug_section
= NULL
;
3097 unsigned int raw_size
;
3098 if (obj_raw_syments(abfd
) != (combined_entry_type
*)NULL
) {
3099 return obj_raw_syments(abfd
);
3101 if ((size
= bfd_get_symcount(abfd
) * sizeof(combined_entry_type
)) == 0) {
3102 bfd_error
= no_symbols
;
3106 internal
= (combined_entry_type
*)bfd_alloc(abfd
, size
);
3107 internal_end
= internal
+ bfd_get_symcount(abfd
);
3109 raw_size
= bfd_get_symcount(abfd
) * SYMESZ
;
3110 raw
= (SYMENT
*)bfd_alloc(abfd
,raw_size
);
3112 if (bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
) == -1
3113 || bfd_read((PTR
)raw
, raw_size
, 1, abfd
) != raw_size
) {
3114 bfd_error
= system_call_error
;
3117 /* mark the end of the symbols */
3118 raw_end
= raw
+ bfd_get_symcount(abfd
);
3120 FIXME SOMEDAY. A string table size of zero is very weird, but
3121 probably possible. If one shows up, it will probably kill us.
3124 /* Swap all the raw entries */
3125 for (raw_src
= raw
, internal_ptr
= internal
;
3127 raw_src
++, internal_ptr
++) {
3130 coff_swap_sym_in(abfd
, (PTR
)raw_src
, (PTR
)&internal_ptr
->u
.syment
);
3131 internal_ptr
->fix_tag
= 0;
3132 internal_ptr
->fix_end
= 0;
3133 symbol_ptr
= internal_ptr
;
3136 i
< symbol_ptr
->u
.syment
.n_numaux
;
3142 internal_ptr
->fix_tag
= 0;
3143 internal_ptr
->fix_end
= 0;
3144 coff_swap_aux_in(abfd
, (char *)(raw_src
),
3145 symbol_ptr
->u
.syment
.n_type
,
3146 symbol_ptr
->u
.syment
.n_sclass
,
3147 &(internal_ptr
->u
.auxent
));
3148 /* Remember that bal entries arn't pointerized */
3149 if (i
!= 1 || symbol_ptr
->u
.syment
.n_sclass
!= C_LEAFPROC
)
3152 coff_pointerize_aux(abfd
,
3154 symbol_ptr
->u
.syment
.n_type
,
3155 symbol_ptr
->u
.syment
.n_sclass
,
3162 /* Free all the raw stuff */
3163 bfd_release(abfd
, raw
);
3165 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
3168 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
) {
3169 /* make a file symbol point to the name in the auxent, since
3170 the text ".file" is redundant */
3171 if ((internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_zeroes
== 0) {
3172 /* the filename is a long one, point into the string table */
3173 if (string_table
== NULL
) {
3174 string_table
= build_string_table(abfd
);
3177 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
3178 (int) (string_table
- 4 +
3179 (internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_offset
);
3182 /* ordinary short filename, put into memory anyway */
3183 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
3184 copy_name(abfd
, (internal_ptr
+1)->u
.auxent
.x_file
.x_fname
,
3189 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0) {
3190 /* This is a "short" name. Make it long. */
3191 unsigned long i
= 0;
3192 char *newstring
= NULL
;
3194 /* find the length of this string without walking into memory
3196 for (i
= 0; i
< 8; ++i
) {
3197 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0') {
3199 } /* if end of string */
3200 } /* possible lengths of this string. */
3202 if ((newstring
= (PTR
) bfd_alloc(abfd
, ++i
)) == NULL
) {
3203 bfd_error
= no_memory
;
3206 memset(newstring
, 0, i
);
3207 strncpy(newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
-1);
3208 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int) newstring
;
3209 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
3211 else if (!SYMNAME_IN_DEBUG(&internal_ptr
->u
.syment
)) {
3212 /* Long name already. Point symbol at the string in the table. */
3213 if (string_table
== NULL
) {
3214 string_table
= build_string_table(abfd
);
3216 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
3217 (string_table
- 4 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
3220 /* Long name in debug section. Very similar. */
3221 if (debug_section
== NULL
) {
3222 debug_section
= build_debug_section(abfd
);
3224 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
3225 (debug_section
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
3228 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
3231 obj_raw_syments(abfd
) = internal
;
3234 } /* get_normalized_symtab() */
3236 #endif /* NO_COFF_SYMBOLS */
3240 DEFUN(section_from_bfd_index
,(abfd
, index
),
3244 struct sec
*answer
= abfd
->sections
;
3248 return &bfd_abs_section
;
3250 if (index
== N_UNDEF
)
3252 return &bfd_und_section
;
3254 if(index
== N_DEBUG
)
3256 return &bfd_debug_section
;
3261 if (answer
->target_index
== index
)
3263 answer
= answer
->next
;
3266 return &bfd_und_section
; /* For gcc -W and lint. Never executed. */
3269 #ifndef NO_COFF_LINENOS
3275 Creating the linenumber table is done by reading in the entire
3276 coff linenumber table, and creating another table for internal use.
3278 A coff line number table is structured so that each function
3279 is marked as having a line number of 0. Each line within the
3280 function is an offset from the first line in the function. The
3281 base of the line number information for the table is stored in
3282 the symbol associated with the function.
3284 The information is copied from the external to the internal
3285 table, and each symbol which marks a function is marked by
3288 How does this work ?
3293 coff_slurp_line_table(abfd
, asect
)
3297 LINENO
*native_lineno
;
3298 alent
*lineno_cache
;
3300 BFD_ASSERT(asect
->lineno
== (alent
*) NULL
);
3302 native_lineno
= (LINENO
*) buy_and_read(abfd
,
3303 asect
->line_filepos
,
3306 asect
->lineno_count
));
3308 (alent
*) bfd_alloc(abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof(alent
)));
3309 if (lineno_cache
== NULL
) {
3310 bfd_error
= no_memory
;
3313 unsigned int counter
= 0;
3314 alent
*cache_ptr
= lineno_cache
;
3315 LINENO
*src
= native_lineno
;
3317 while (counter
< asect
->lineno_count
) {
3318 struct internal_lineno dst
;
3319 coff_swap_lineno_in(abfd
, src
, &dst
);
3320 cache_ptr
->line_number
= dst
.l_lnno
;
3322 if (cache_ptr
->line_number
== 0) {
3323 coff_symbol_type
*sym
=
3324 (coff_symbol_type
*) (dst
.l_addr
.l_symndx
3325 + obj_raw_syments(abfd
))->u
.syment
._n
._n_n
._n_zeroes
;
3326 cache_ptr
->u
.sym
= (asymbol
*) sym
;
3327 sym
->lineno
= cache_ptr
;
3330 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
3331 - bfd_section_vma(abfd
, asect
);
3332 } /* If no linenumber expect a symbol index */
3338 cache_ptr
->line_number
= 0;
3341 asect
->lineno
= lineno_cache
;
3342 /* FIXME, free native_lineno here, or use alloca or something. */
3344 } /* coff_slurp_line_table() */
3346 #endif /* NO_COFF_LINENOS */
3348 #ifndef NO_COFF_LINENOS
3351 DEFUN(coff_slurp_symbol_table
,(abfd
),
3354 combined_entry_type
*native_symbols
;
3355 coff_symbol_type
*cached_area
;
3356 unsigned int *table_ptr
;
3358 unsigned int number_of_symbols
= 0;
3359 if (obj_symbols(abfd
))
3361 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
3363 /* Read in the symbol table */
3364 if ((native_symbols
= get_normalized_symtab(abfd
)) == NULL
) {
3368 /* Allocate enough room for all the symbols in cached form */
3370 (coff_symbol_type
*)
3371 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(coff_symbol_type
)));
3373 if (cached_area
== NULL
) {
3374 bfd_error
= no_memory
;
3379 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(unsigned int)));
3381 if (table_ptr
== NULL
) {
3382 bfd_error
= no_memory
;
3387 coff_symbol_type
*dst
= cached_area
;
3388 unsigned int last_native_index
= bfd_get_symcount(abfd
);
3389 unsigned int this_index
= 0;
3390 while (this_index
< last_native_index
) {
3391 combined_entry_type
*src
= native_symbols
+ this_index
;
3392 table_ptr
[this_index
] = number_of_symbols
;
3393 dst
->symbol
.the_bfd
= abfd
;
3395 dst
->symbol
.name
= (char *)(src
->u
.syment
._n
._n_n
._n_offset
);
3397 We use the native name field to point to the cached field
3399 src
->u
.syment
._n
._n_n
._n_zeroes
= (int) dst
;
3400 dst
->symbol
.section
= section_from_bfd_index(abfd
,
3401 src
->u
.syment
.n_scnum
);
3402 dst
->symbol
.flags
= 0;
3403 dst
->done_lineno
= false;
3405 switch (src
->u
.syment
.n_sclass
) {
3409 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
3410 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
3411 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
3413 /* Fall through to next case */
3421 if ((src
->u
.syment
.n_scnum
) == 0) {
3422 if ((src
->u
.syment
.n_value
) == 0) {
3423 dst
->symbol
.section
= &bfd_und_section
;
3424 dst
->symbol
.value
= 0;
3427 dst
->symbol
.section
= &bfd_com_section
;
3428 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3433 Base the value as an index from the base of the
3437 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
3438 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
3440 if (ISFCN((src
->u
.syment
.n_type
))) {
3442 A function ext does not go at the end of a file
3444 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
3451 case C_STAT
: /* static */
3453 case C_LEAFSTAT
: /* static leaf procedure */
3455 case C_LABEL
: /* label */
3456 if (src
->u
.syment
.n_scnum
== -2)
3457 dst
->symbol
.flags
= BSF_DEBUGGING
;
3459 dst
->symbol
.flags
= BSF_LOCAL
;
3461 Base the value as an index from the base of the section, if
3464 if (dst
->symbol
.section
)
3465 dst
->symbol
.value
= (src
->u
.syment
.n_value
) -
3466 dst
->symbol
.section
->vma
;
3468 dst
->symbol
.value
= (src
->u
.syment
.n_value
) ;
3471 case C_MOS
: /* member of structure */
3472 case C_EOS
: /* end of structure */
3473 #ifdef NOTDEF /* C_AUTOARG has the same value */
3475 case C_GLBLREG
: /* A29k-specific storage class */
3478 case C_REGPARM
: /* register parameter */
3479 case C_REG
: /* register variable */
3481 case C_AUTOARG
: /* 960-specific storage class */
3483 case C_TPDEF
: /* type definition */
3485 case C_AUTO
: /* automatic variable */
3486 case C_FIELD
: /* bit field */
3487 case C_ENTAG
: /* enumeration tag */
3488 case C_MOE
: /* member of enumeration */
3489 case C_MOU
: /* member of union */
3490 case C_UNTAG
: /* union tag */
3491 dst
->symbol
.flags
= BSF_DEBUGGING
;
3492 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3495 case C_FILE
: /* file name */
3496 case C_STRTAG
: /* structure tag */
3498 case C_BINCL
: /* beginning of include file */
3499 case C_EINCL
: /* ending of include file */
3512 dst
->symbol
.flags
= BSF_DEBUGGING
;
3513 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3516 case C_BLOCK
: /* ".bb" or ".eb" */
3517 case C_FCN
: /* ".bf" or ".ef" */
3518 case C_EFCN
: /* physical end of function */
3519 dst
->symbol
.flags
= BSF_LOCAL
;
3521 Base the value as an index from the base of the section
3523 dst
->symbol
.value
= (src
->u
.syment
.n_value
) - dst
->symbol
.section
->vma
;
3527 case C_EXTDEF
: /* external definition */
3528 case C_ULABEL
: /* undefined label */
3529 case C_USTATIC
: /* undefined static */
3530 case C_LINE
: /* line # reformatted as symbol table entry */
3531 case C_ALIAS
: /* duplicate tag */
3532 case C_HIDDEN
: /* ext symbol in dmert public lib */
3535 fprintf(stderr
,"Unrecognized storage class %d\n",
3536 src
->u
.syment
.n_sclass
);
3538 dst
->symbol
.flags
= BSF_DEBUGGING
;
3539 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3543 /* BFD_ASSERT(dst->symbol.flags != 0);*/
3547 dst
->symbol
.udata
= 0;
3548 dst
->lineno
= (alent
*) NULL
;
3549 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
3551 number_of_symbols
++;
3552 } /* walk the native symtab */
3553 } /* bfdize the native symtab */
3555 obj_symbols(abfd
) = cached_area
;
3556 obj_raw_syments(abfd
) = native_symbols
;
3558 obj_conv_table_size (abfd
) = bfd_get_symcount (abfd
);
3559 bfd_get_symcount(abfd
) = number_of_symbols
;
3560 obj_convert(abfd
) = table_ptr
;
3561 /* Slurp the line tables for each section too */
3566 coff_slurp_line_table(abfd
, p
);
3571 } /* coff_slurp_symbol_table() */
3574 coff_get_symtab_upper_bound(abfd
)
3577 if (!coff_slurp_symbol_table(abfd
))
3580 return (bfd_get_symcount(abfd
) + 1) * (sizeof(coff_symbol_type
*));
3585 DEFUN(coff_get_symtab
, (abfd
, alocation
),
3587 asymbol
**alocation
)
3589 unsigned int counter
= 0;
3590 coff_symbol_type
*symbase
;
3591 coff_symbol_type
**location
= (coff_symbol_type
**) (alocation
);
3592 if (!coff_slurp_symbol_table(abfd
))
3595 symbase
= obj_symbols(abfd
);
3596 while (counter
< bfd_get_symcount(abfd
))
3598 /* This nasty code looks at the symbol to decide whether or
3599 not it is descibes a constructor/destructor entry point. It
3600 is structured this way to (hopefully) speed non matches */
3602 if (0 && symbase
->symbol
.name
[9] == '$')
3604 bfd_constructor_entry(abfd
,
3605 (asymbol
**)location
,
3606 symbase
->symbol
.name
[10] == 'I' ?
3610 *(location
++) = symbase
++;
3614 return bfd_get_symcount(abfd
);
3617 #endif /* NO_COFF_SYMBOLS */
3620 coff_get_reloc_upper_bound(abfd
, asect
)
3624 if (bfd_get_format(abfd
) != bfd_object
) {
3625 bfd_error
= invalid_operation
;
3628 return (asect
->reloc_count
+ 1) * sizeof(arelent
*);
3635 Coff relocations are easily transformed into the internal BFD form
3638 Reading a coff relocation table is done in the following stages:
3640 o The entire coff relocation table is read into memory.
3642 o Each relocation is processed in turn, first it is swapped from the
3643 external to the internal form.
3645 o The symbol referenced in the relocation's symbol index is
3646 turned intoa pointer into the canonical symbol table. Note
3647 that this table is the same as the one returned by a call to
3648 @code{bfd_canonicalize_symtab}. The back end will call the
3649 routine and save the result if a canonicalization hasn't been done.
3651 o The reloc index is turned into a pointer to a howto
3652 structure, in a back end specific way. For instance, the 386
3653 and 960 use the @code{r_type} to directly produce an index
3654 into a howto table vector; the 88k subtracts a number from the
3655 @code{r_type} field and creates an addend field.
3661 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
3662 if (ptr && bfd_asymbol_bfd(ptr) == abfd \
3663 && ((ptr->flags & BSF_OLD_COMMON)== 0)) \
3665 cache_ptr->addend = -(ptr->section->vma + ptr->value); \
3668 cache_ptr->addend = 0; \
3673 DEFUN(coff_slurp_reloc_table
,(abfd
, asect
, symbols
),
3678 RELOC
*native_relocs
;
3679 arelent
*reloc_cache
;
3684 if (asect
->relocation
)
3686 if (asect
->reloc_count
== 0)
3688 if (asect
->flags
& SEC_CONSTRUCTOR
)
3690 #ifndef NO_COFF_SYMBOLS
3691 if (!coff_slurp_symbol_table(abfd
))
3695 (RELOC
*) buy_and_read(abfd
,
3699 asect
->reloc_count
));
3700 reloc_cache
= (arelent
*)
3701 bfd_alloc(abfd
, (size_t) (asect
->reloc_count
* sizeof(arelent
)));
3703 if (reloc_cache
== NULL
) {
3704 bfd_error
= no_memory
;
3709 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
3711 #ifdef RELOC_PROCESSING
3712 struct internal_reloc dst
;
3713 struct external_reloc
*src
;
3715 cache_ptr
= reloc_cache
+ idx
;
3716 src
= native_relocs
+ idx
;
3717 bfd_swap_reloc_in(abfd
, src
, &dst
);
3719 RELOC_PROCESSING(cache_ptr
, &dst
, symbols
, abfd
, asect
);
3721 struct internal_reloc dst
;
3723 struct external_reloc
*src
;
3725 cache_ptr
= reloc_cache
+ idx
;
3726 src
= native_relocs
+ idx
;
3728 bfd_swap_reloc_in(abfd
, src
, &dst
);
3731 cache_ptr
->address
= dst
.r_vaddr
;
3733 if (dst
.r_symndx
!= -1)
3735 /* @@ Should never be greater than count of symbols! */
3736 if (dst
.r_symndx
>= obj_conv_table_size (abfd
))
3738 cache_ptr
->sym_ptr_ptr
= symbols
+ obj_convert(abfd
)[dst
.r_symndx
];
3739 ptr
= *(cache_ptr
->sym_ptr_ptr
);
3743 cache_ptr
->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
3748 The symbols definitions that we have read in have been
3749 relocated as if their sections started at 0. But the offsets
3750 refering to the symbols in the raw data have not been
3751 modified, so we have to have a negative addend to compensate.
3753 Note that symbols which used to be common must be left alone */
3755 /* Calculate any reloc addend by looking at the symbol */
3756 CALC_ADDEND(abfd
, ptr
, dst
, cache_ptr
);
3758 cache_ptr
->address
-= asect
->vma
;
3759 /* !! cache_ptr->section = (asection *) NULL;*/
3761 /* Fill in the cache_ptr->howto field from dst.r_type */
3762 RTYPE2HOWTO(cache_ptr
, &dst
);
3767 asect
->relocation
= reloc_cache
;
3772 /* This is stupid. This function should be a boolean predicate */
3774 DEFUN(coff_canonicalize_reloc
, (abfd
, section
, relptr
, symbols
),
3777 arelent
**relptr AND
3780 arelent
*tblptr
= section
->relocation
;
3781 unsigned int count
= 0;
3784 if (section
->flags
& SEC_CONSTRUCTOR
)
3786 /* this section has relocs made up by us, they are not in the
3787 file, so take them out of their chain and place them into
3788 the data area provided */
3789 arelent_chain
*chain
= section
->constructor_chain
;
3790 for (count
= 0; count
< section
->reloc_count
; count
++)
3792 *relptr
++ = &chain
->relent
;
3793 chain
= chain
->next
;
3799 coff_slurp_reloc_table(abfd
, section
, symbols
);
3802 tblptr
= section
->relocation
;
3806 for (; count
++ < section
->reloc_count
;)
3807 *relptr
++ = tblptr
++;
3812 return section
->reloc_count
;
3815 #ifndef NO_COFF_SYMBOLS
3818 provided a BFD, a section and an offset into the section, calculate and
3819 return the name of the source file and the line nearest to the wanted
3824 DEFUN(coff_find_nearest_line
,(abfd
,
3832 asection
*section AND
3833 asymbol
**ignore_symbols AND
3835 CONST
char **filename_ptr AND
3836 CONST
char **functionname_ptr AND
3837 unsigned int *line_ptr
)
3839 static bfd
*cache_abfd
;
3840 static asection
*cache_section
;
3841 static bfd_vma cache_offset
;
3842 static unsigned int cache_i
;
3843 static alent
*cache_l
;
3846 coff_data_type
*cof
= coff_data(abfd
);
3847 /* Run through the raw syments if available */
3848 combined_entry_type
*p
;
3850 unsigned int line_base
= 0;
3854 *functionname_ptr
= 0;
3857 /* Don't try and find line numbers in a non coff file */
3858 if (abfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
3864 p
= cof
->raw_syments
;
3866 for (i
= 0; i
< cof
->raw_syment_count
; i
++) {
3867 if (p
->u
.syment
.n_sclass
== C_FILE
) {
3868 /* File name has been moved into symbol */
3869 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
3872 p
+= 1 + p
->u
.syment
.n_numaux
;
3874 /* Now wander though the raw linenumbers of the section */
3876 If this is the same BFD as we were previously called with and this is
3877 the same section, and the offset we want is further down then we can
3878 prime the lookup loop
3880 if (abfd
== cache_abfd
&&
3881 section
== cache_section
&&
3882 offset
>= cache_offset
) {
3888 l
= section
->lineno
;
3891 for (; i
< section
->lineno_count
; i
++) {
3892 if (l
->line_number
== 0) {
3893 /* Get the symbol this line number points at */
3894 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
3895 *functionname_ptr
= coff
->symbol
.name
;
3897 combined_entry_type
*s
= coff
->native
;
3898 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
3900 S should now point to the .bf of the function
3902 if (s
->u
.syment
.n_numaux
) {
3904 The linenumber is stored in the auxent
3906 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
3907 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
3912 if (l
->u
.offset
> offset
)
3914 *line_ptr
= l
->line_number
+ line_base
+ 1;
3920 cache_section
= section
;
3921 cache_offset
= offset
;
3930 coff_sym_filepos(abfd
)
3933 return obj_sym_filepos(abfd
);
3937 #endif /* NO_COFF_SYMBOLS */
3941 DEFUN(coff_sizeof_headers
,(abfd
, reloc
),
3947 if (reloc
== false) {
3948 size
= FILHSZ
+ AOUTSZ
;
3954 size
+= abfd
->section_count
* SCNHSZ
;
3959 DEFUN(get_value
,(reloc
, seclet
),
3961 bfd_seclet_type
*seclet
)
3964 asymbol
*symbol
= *(reloc
->sym_ptr_ptr
);
3965 /* A symbol holds a pointer to a section, and an offset from the
3966 base of the section. To relocate, we find where the section will
3967 live in the output and add that in */
3969 if (symbol
->section
== &bfd_und_section
)
3971 /* Ouch, this is an undefined symbol.. */
3972 bfd_error_vector
.undefined_symbol(reloc
, seclet
);
3973 value
= symbol
->value
;
3977 value
= symbol
->value
+
3978 symbol
->section
->output_offset
+
3979 symbol
->section
->output_section
->vma
;
3983 /* Add the value contained in the relocation */
3984 value
+= reloc
->addend
;
3990 DEFUN(perform_slip
,(s
, slip
, input_section
, value
),
3992 unsigned int slip AND
3993 asection
*input_section AND
3997 /* Find all symbols past this point, and make them know
4002 if (p
->section
== input_section
)
4004 /* This was pointing into this section, so mangle it */
4005 if (p
->value
> value
)
4015 DEFUN(movb1
,(input_section
, symbols
, r
, shrink
),
4016 asection
*input_section AND
4017 asymbol
**symbols AND
4019 unsigned int shrink
)
4021 bfd_vma value
= get_value(r
,0);
4023 if (value
>= 0xff00)
4026 /* Change the reloc type from 16bit, possible 8 to 8bit
4028 r
->howto
= r
->howto
+ 1;
4029 /* The place to relc moves back by one */
4032 /* This will be two bytes smaller in the long run */
4034 perform_slip(symbols
, 2, input_section
, r
->address
- shrink
+1);
4042 DEFUN(jmp1
,(input_section
, symbols
, r
, shrink
),
4043 asection
*input_section AND
4044 asymbol
**symbols AND
4046 unsigned int shrink
)
4050 bfd_vma value
= get_value(r
, 0);
4052 bfd_vma dot
= input_section
->output_section
->vma
+
4053 input_section
->output_offset
+ r
->address
;
4056 /* See if the address we're looking at within 127 bytes of where
4057 we are, if so then we can use a small branch rather than the
4058 jump we were going to */
4060 gap
= value
- (dot
- shrink
);
4063 if (-120 < (long)gap
&& (long)gap
< 120 )
4066 /* Change the reloc type from 16bit, possible 8 to 8bit
4068 r
->howto
= r
->howto
+ 1;
4069 /* The place to relc moves back by one */
4072 /* This will be two bytes smaller in the long run */
4074 perform_slip(symbols
, 2, input_section
, r
->address
-shrink
+1);
4082 DEFUN(bfd_coff_relax_section
,(abfd
, i
, symbols
),
4088 /* Get enough memory to hold the stuff */
4089 bfd
*input_bfd
= i
->owner
;
4090 asection
*input_section
= i
;
4092 boolean
new = false;
4094 bfd_size_type reloc_size
= bfd_get_reloc_upper_bound(input_bfd
,
4096 arelent
**reloc_vector
= (arelent
**)bfd_xmalloc(reloc_size
);
4098 /* Get the relocs and think about them */
4099 if (bfd_canonicalize_reloc(input_bfd
,
4105 for (parent
= reloc_vector
; *parent
; parent
++)
4107 arelent
*r
= *parent
;
4108 switch (r
->howto
->type
) {
4116 shrink
= movb1(input_section
, symbols
, r
, shrink
);
4121 shrink
= jmp1(input_section
, symbols
, r
, shrink
);
4129 input_section
->_cooked_size
-= shrink
;
4130 free((char *)reloc_vector
);
4135 DEFUN(bfd_coff_get_relocated_section_contents
,(in_abfd
, seclet
, data
),
4137 bfd_seclet_type
*seclet AND
4141 /* Get enough memory to hold the stuff */
4142 bfd
*input_bfd
= seclet
->u
.indirect
.section
->owner
;
4143 asection
*input_section
= seclet
->u
.indirect
.section
;
4144 bfd_size_type reloc_size
= bfd_get_reloc_upper_bound(input_bfd
,
4146 arelent
**reloc_vector
= (arelent
**)bfd_xmalloc(reloc_size
);
4148 /* read in the section */
4149 bfd_get_section_contents(input_bfd
,
4153 input_section
->_raw_size
);
4156 if (bfd_canonicalize_reloc(input_bfd
,
4159 seclet
->u
.indirect
.symbols
) )
4161 arelent
**parent
= reloc_vector
;
4166 unsigned int dst_address
= 0;
4167 unsigned int src_address
= 0;
4171 /* Find how long a run we can do */
4172 while (dst_address
< seclet
->size
)
4178 /* Note that the relaxing didn't tie up the addresses in the
4179 relocation, so we use the original address to work out the
4180 run of non-relocated data */
4181 run
= reloc
->address
- src_address
;
4187 run
= seclet
->size
- dst_address
;
4189 /* Copy the bytes */
4190 for (idx
= 0; idx
< run
; idx
++)
4192 data
[dst_address
++] = data
[src_address
++];
4195 /* Now do the relocation */
4199 switch (reloc
->howto
->type
)
4202 /* Speciial relaxed type */
4204 bfd_vma dot
= seclet
->offset
+ dst_address
+ seclet
->u
.indirect
.section
->output_section
->vma
;
4205 int gap
= get_value(reloc
,seclet
)-dot
-1;
4206 if ((gap
& ~0xff ) != 0 &&((gap
& 0xff00)!= 0xff00)) abort();
4208 bfd_put_8(in_abfd
,gap
, data
+dst_address
);
4210 switch (data
[dst_address
-1])
4215 bfd_put_8(in_abfd
, 0x55, data
+dst_address
-1);
4219 bfd_put_8(in_abfd
, 0x40, data
+dst_address
-1);
4238 /* Special relaxed type, there will be a gap between where we
4239 get stuff from and where we put stuff to now
4241 for a mov.b @aa:16 -> mov.b @aa:8
4242 opcode 0x6a 0x0y offset
4245 if (data
[dst_address
-1] != 0x6a)
4247 switch (data
[src_address
] & 0xf0)
4251 data
[dst_address
-1] = (data
[src_address
] & 0xf) | 0x20;
4255 data
[dst_address
-1] = (data
[src_address
] & 0xf) | 0x30;
4261 /* the offset must fit ! after all, what was all the relaxing
4264 bfd_put_8(in_abfd
, get_value(reloc
, seclet
), data
+ dst_address
);
4266 /* Note the magic - src goes up by two bytes, but dst by only
4275 bfd_vma dot
= seclet
->offset
+ dst_address
+ seclet
->u
.indirect
.section
->output_section
->vma
;
4276 int gap
= get_value(reloc
,seclet
)-dot
;
4277 if (gap
> 127 || gap
< -128)
4279 bfd_error_vector
.reloc_value_truncated(reloc
, seclet
);
4282 bfd_put_8(in_abfd
,gap
, data
+dst_address
);
4291 unsigned int gap
=get_value(reloc
,seclet
);
4292 if (gap
> 0xff && gap
< ~0xff)
4294 bfd_error_vector
.reloc_value_truncated(reloc
, seclet
);
4297 bfd_put_8(in_abfd
, gap
, data
+dst_address
);
4305 /* A relword which would have like to have been a pcrel */
4307 /* A relword which would like to have been modified but
4310 bfd_put_16(in_abfd
, get_value(reloc
,seclet
), data
+dst_address
);
4325 free((char *)reloc_vector
);
4330 #if !defined (NO_COFF_SYMBOLS) && !defined (NO_COFF_LINENOS)
4331 static CONST bfd_coff_backend_data bfd_coff_std_swap_table
= {
4332 coff_swap_aux_in
, coff_swap_sym_in
, coff_swap_lineno_in
,
4333 coff_swap_aux_out
, coff_swap_sym_out
,
4334 coff_swap_lineno_out
, coff_swap_reloc_out
,
4335 coff_swap_filehdr_out
, coff_swap_aouthdr_out
,
4336 coff_swap_scnhdr_out
,
4340 #define coff_core_file_failing_command _bfd_dummy_core_file_failing_command
4341 #define coff_core_file_failing_signal _bfd_dummy_core_file_failing_signal
4342 #define coff_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
4343 #define coff_slurp_armap bfd_slurp_coff_armap
4344 #define coff_slurp_extended_name_table _bfd_slurp_extended_name_table
4345 #define coff_truncate_arname bfd_dont_truncate_arname
4346 #define coff_openr_next_archived_file bfd_generic_openr_next_archived_file
4347 #define coff_generic_stat_arch_elt bfd_generic_stat_arch_elt
4348 #define coff_get_section_contents bfd_generic_get_section_contents
4349 #define coff_close_and_cleanup bfd_generic_close_and_cleanup
4351 #define coff_bfd_debug_info_start bfd_void
4352 #define coff_bfd_debug_info_end bfd_void
4353 #define coff_bfd_debug_info_accumulate \
4354 (void (*) PARAMS ((bfd *, struct sec *))) bfd_void
4355 #define coff_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
4356 #define coff_bfd_relax_section bfd_generic_relax_section