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
462 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 .extern bfd_coff_backend_data bfd_coff_std_swap_table;
525 .#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
527 .#define bfd_coff_swap_aux_in(a,e,t,c,i) \
528 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,i))
530 .#define bfd_coff_swap_sym_in(a,e,i) \
531 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
533 .#define bfd_coff_swap_lineno_in(a,e,i) \
534 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
536 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
537 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
539 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
540 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
542 .#define bfd_coff_swap_aux_out(abfd, i, t,c,o) \
543 . ((coff_backend_info (abfd)->_bfd_coff_swap_aux_out) (abfd, i,t,c, o))
545 .#define bfd_coff_swap_sym_out(abfd, i,o) \
546 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
548 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
549 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
551 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
552 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
554 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
555 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
560 DEFUN(bfd_swap_reloc_in
,(abfd
, reloc_src
, reloc_dst
),
563 struct internal_reloc
*reloc_dst
)
565 reloc_dst
->r_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*)reloc_src
->r_vaddr
);
566 reloc_dst
->r_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) reloc_src
->r_symndx
);
569 reloc_dst
->r_type
= bfd_h_get_8(abfd
, reloc_src
->r_type
);
570 reloc_dst
->r_size
= bfd_h_get_8(abfd
, reloc_src
->r_size
);
572 reloc_dst
->r_type
= bfd_h_get_16(abfd
, (bfd_byte
*) reloc_src
->r_type
);
575 #ifdef SWAP_IN_RELOC_OFFSET
576 reloc_dst
->r_offset
= SWAP_IN_RELOC_OFFSET(abfd
,
577 (bfd_byte
*) reloc_src
->r_offset
);
583 DEFUN(coff_swap_reloc_out
,(abfd
, src
, dst
),
588 struct internal_reloc
*reloc_src
= (struct internal_reloc
*)src
;
589 struct external_reloc
*reloc_dst
= (struct external_reloc
*)dst
;
590 bfd_h_put_32(abfd
, reloc_src
->r_vaddr
, (bfd_byte
*) reloc_dst
->r_vaddr
);
591 bfd_h_put_32(abfd
, reloc_src
->r_symndx
, (bfd_byte
*) reloc_dst
->r_symndx
);
592 bfd_h_put_16(abfd
, reloc_src
->r_type
, (bfd_byte
*)
595 #ifdef SWAP_OUT_RELOC_OFFSET
596 SWAP_OUT_RELOC_OFFSET(abfd
,
598 (bfd_byte
*) reloc_dst
->r_offset
);
600 #ifdef SWAP_OUT_RELOC_EXTRA
601 SWAP_OUT_RELOC_EXTRA(abfd
,reloc_src
, reloc_dst
);
604 return sizeof(struct external_reloc
);
608 DEFUN(bfd_swap_filehdr_in
,(abfd
, filehdr_src
, filehdr_dst
),
610 FILHDR
*filehdr_src AND
611 struct internal_filehdr
*filehdr_dst
)
613 filehdr_dst
->f_magic
= bfd_h_get_16(abfd
, (bfd_byte
*) filehdr_src
->f_magic
);
614 filehdr_dst
->f_nscns
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_nscns
);
615 filehdr_dst
->f_timdat
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_timdat
);
616 filehdr_dst
->f_symptr
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_symptr
);
617 filehdr_dst
->f_nsyms
= bfd_h_get_32(abfd
, (bfd_byte
*)filehdr_src
-> f_nsyms
);
618 filehdr_dst
->f_opthdr
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_opthdr
);
619 filehdr_dst
->f_flags
= bfd_h_get_16(abfd
, (bfd_byte
*)filehdr_src
-> f_flags
);
623 DEFUN(coff_swap_filehdr_out
,(abfd
, in
, out
),
628 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*)in
;
629 FILHDR
*filehdr_out
= (FILHDR
*)out
;
630 bfd_h_put_16(abfd
, filehdr_in
->f_magic
, (bfd_byte
*) filehdr_out
->f_magic
);
631 bfd_h_put_16(abfd
, filehdr_in
->f_nscns
, (bfd_byte
*) filehdr_out
->f_nscns
);
632 bfd_h_put_32(abfd
, filehdr_in
->f_timdat
, (bfd_byte
*) filehdr_out
->f_timdat
);
633 bfd_h_put_32(abfd
, filehdr_in
->f_symptr
, (bfd_byte
*) filehdr_out
->f_symptr
);
634 bfd_h_put_32(abfd
, filehdr_in
->f_nsyms
, (bfd_byte
*) filehdr_out
->f_nsyms
);
635 bfd_h_put_16(abfd
, filehdr_in
->f_opthdr
, (bfd_byte
*) filehdr_out
->f_opthdr
);
636 bfd_h_put_16(abfd
, filehdr_in
->f_flags
, (bfd_byte
*) filehdr_out
->f_flags
);
637 return sizeof(FILHDR
);
641 #ifndef NO_COFF_SYMBOLS
644 DEFUN(coff_swap_sym_in
,(abfd
, ext1
, in1
),
649 SYMENT
*ext
= (SYMENT
*)ext1
;
650 struct internal_syment
*in
= (struct internal_syment
*)in1
;
652 if( ext
->e
.e_name
[0] == 0) {
653 in
->_n
._n_n
._n_zeroes
= 0;
654 in
->_n
._n_n
._n_offset
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e
.e
.e_offset
);
657 #if SYMNMLEN != E_SYMNMLEN
658 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
660 memcpy(in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
663 in
->n_value
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_value
);
664 in
->n_scnum
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_scnum
);
665 if (sizeof(ext
->e_type
) == 2){
666 in
->n_type
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->e_type
);
669 in
->n_type
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->e_type
);
671 in
->n_sclass
= bfd_h_get_8(abfd
, ext
->e_sclass
);
672 in
->n_numaux
= bfd_h_get_8(abfd
, ext
->e_numaux
);
676 DEFUN(coff_swap_sym_out
,(abfd
, inp
, extp
),
681 struct internal_syment
*in
= (struct internal_syment
*)inp
;
682 SYMENT
*ext
=(SYMENT
*)extp
;
683 if(in
->_n
._n_name
[0] == 0) {
684 bfd_h_put_32(abfd
, 0, (bfd_byte
*) ext
->e
.e
.e_zeroes
);
685 bfd_h_put_32(abfd
, in
->_n
._n_n
._n_offset
, (bfd_byte
*) ext
->e
.e
.e_offset
);
688 #if SYMNMLEN != E_SYMNMLEN
689 -> Error
, we need to cope with truncating
or extending SYMNMLEN
!;
691 memcpy(ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
694 bfd_h_put_32(abfd
, in
->n_value
, (bfd_byte
*) ext
->e_value
);
695 bfd_h_put_16(abfd
, in
->n_scnum
, (bfd_byte
*) ext
->e_scnum
);
696 if (sizeof(ext
->e_type
) == 2)
698 bfd_h_put_16(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
702 bfd_h_put_32(abfd
, in
->n_type
, (bfd_byte
*) ext
->e_type
);
704 bfd_h_put_8(abfd
, in
->n_sclass
, ext
->e_sclass
);
705 bfd_h_put_8(abfd
, in
->n_numaux
, ext
->e_numaux
);
706 return sizeof(SYMENT
);
710 DEFUN(coff_swap_aux_in
,(abfd
, ext1
, type
, class, in1
),
717 AUXENT
*ext
= (AUXENT
*)ext1
;
718 union internal_auxent
*in
= (union internal_auxent
*)in1
;
722 if (ext
->x_file
.x_fname
[0] == 0) {
723 in
->x_file
.x_n
.x_zeroes
= 0;
724 in
->x_file
.x_n
.x_offset
=
725 bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
727 #if FILNMLEN != E_FILNMLEN
728 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
730 memcpy (in
->x_file
.x_fname
, ext
->x_file
.x_fname
, FILNMLEN
);
735 /* RS/6000 "csect" auxents */
739 in
->x_csect
.x_scnlen
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_scnlen
);
740 in
->x_csect
.x_parmhash
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_parmhash
);
741 in
->x_csect
.x_snhash
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snhash
);
742 /* We don't have to hack bitfields in x_smtyp because it's defined by
743 shifts-and-ands, which are equivalent on all byte orders. */
744 in
->x_csect
.x_smtyp
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smtyp
);
745 in
->x_csect
.x_smclas
= bfd_h_get_8 (abfd
, (bfd_byte
*) ext
->x_csect
.x_smclas
);
746 in
->x_csect
.x_stab
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->x_csect
.x_stab
);
747 in
->x_csect
.x_snstab
= bfd_h_get_16 (abfd
, (bfd_byte
*) ext
->x_csect
.x_snstab
);
756 if (type
== T_NULL
) {
757 in
->x_scn
.x_scnlen
= GET_SCN_SCNLEN(abfd
, ext
);
758 in
->x_scn
.x_nreloc
= GET_SCN_NRELOC(abfd
, ext
);
759 in
->x_scn
.x_nlinno
= GET_SCN_NLINNO(abfd
, ext
);
763 in
->x_sym
.x_tagndx
.l
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
765 in
->x_sym
.x_tvndx
= bfd_h_get_16(abfd
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
769 #if DIMNUM != E_DIMNUM
770 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
772 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]);
773 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]);
774 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]);
775 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]);
778 if (class == C_BLOCK
|| ISFCN(type
) || ISTAG(class)) {
779 in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= GET_FCN_LNNOPTR(abfd
, ext
);
780 in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= GET_FCN_ENDNDX(abfd
, ext
);
784 in
->x_sym
.x_misc
.x_fsize
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
787 in
->x_sym
.x_misc
.x_lnsz
.x_lnno
= GET_LNSZ_LNNO(abfd
, ext
);
788 in
->x_sym
.x_misc
.x_lnsz
.x_size
= GET_LNSZ_SIZE(abfd
, ext
);
794 DEFUN(coff_swap_aux_out
,(abfd
, inp
, type
, class, extp
),
801 union internal_auxent
*in
= (union internal_auxent
*)inp
;
802 AUXENT
*ext
= (AUXENT
*)extp
;
804 memset((PTR
)ext
, 0, AUXESZ
);
807 if (in
->x_file
.x_fname
[0] == 0) {
808 PUTWORD(abfd
, 0, (bfd_byte
*) ext
->x_file
.x_n
.x_zeroes
);
810 in
->x_file
.x_n
.x_offset
,
811 (bfd_byte
*) ext
->x_file
.x_n
.x_offset
);
814 #if FILNMLEN != E_FILNMLEN
815 -> Error
, we need to cope with truncating
or extending FILNMLEN
!;
817 memcpy (ext
->x_file
.x_fname
, in
->x_file
.x_fname
, FILNMLEN
);
823 /* RS/6000 "csect" auxents */
826 PUTWORD (abfd
, in
->x_csect
.x_scnlen
, ext
->x_csect
.x_scnlen
);
827 PUTWORD (abfd
, in
->x_csect
.x_parmhash
, ext
->x_csect
.x_parmhash
);
828 PUTHALF (abfd
, in
->x_csect
.x_snhash
, ext
->x_csect
.x_snhash
);
829 /* We don't have to hack bitfields in x_smtyp because it's defined by
830 shifts-and-ands, which are equivalent on all byte orders. */
831 PUTBYTE (abfd
, in
->x_csect
.x_smtyp
, ext
->x_csect
.x_smtyp
);
832 PUTBYTE (abfd
, in
->x_csect
.x_smclas
, ext
->x_csect
.x_smclas
);
833 PUTWORD (abfd
, in
->x_csect
.x_stab
, ext
->x_csect
.x_stab
);
834 PUTHALF (abfd
, in
->x_csect
.x_snstab
, ext
->x_csect
.x_snstab
);
843 if (type
== T_NULL
) {
844 PUT_SCN_SCNLEN(abfd
, in
->x_scn
.x_scnlen
, ext
);
845 PUT_SCN_NRELOC(abfd
, in
->x_scn
.x_nreloc
, ext
);
846 PUT_SCN_NLINNO(abfd
, in
->x_scn
.x_nlinno
, ext
);
850 PUTWORD(abfd
, in
->x_sym
.x_tagndx
.l
, (bfd_byte
*) ext
->x_sym
.x_tagndx
);
852 bfd_h_put_16(abfd
, in
->x_sym
.x_tvndx
, (bfd_byte
*) ext
->x_sym
.x_tvndx
);
855 if (class == C_BLOCK
|| ISFCN(type
) || ISTAG(class)) {
856 PUT_FCN_LNNOPTR(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
857 PUT_FCN_ENDNDX(abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
861 PUTWORD(abfd
, in
->x_sym
.x_misc
.x_fsize
, (bfd_byte
*) ext
->x_sym
.x_misc
.x_fsize
);
865 #if DIMNUM != E_DIMNUM
866 -> Error
, we need to cope with truncating
or extending DIMNUM
!;
868 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]);
869 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]);
870 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]);
871 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]);
874 PUT_LNSZ_LNNO(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
875 PUT_LNSZ_SIZE(abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
878 return sizeof(AUXENT
);
881 #endif /* NO_COFF_SYMBOLS */
883 #ifndef NO_COFF_LINENOS
886 DEFUN(coff_swap_lineno_in
,(abfd
, ext1
, in1
),
891 LINENO
*ext
= (LINENO
*)ext1
;
892 struct internal_lineno
*in
= (struct internal_lineno
*)in1
;
894 in
->l_addr
.l_symndx
= bfd_h_get_32(abfd
, (bfd_byte
*) ext
->l_addr
.l_symndx
);
895 in
->l_lnno
= GET_LINENO_LNNO(abfd
, ext
);
899 DEFUN(coff_swap_lineno_out
,(abfd
, inp
, outp
),
904 struct internal_lineno
*in
= (struct internal_lineno
*)inp
;
905 struct external_lineno
*ext
= (struct external_lineno
*)outp
;
906 PUTWORD(abfd
, in
->l_addr
.l_symndx
, (bfd_byte
*)
907 ext
->l_addr
.l_symndx
);
909 PUT_LINENO_LNNO (abfd
, in
->l_lnno
, ext
);
910 return sizeof(struct external_lineno
);
913 #endif /* NO_COFF_LINENOS */
917 DEFUN(bfd_swap_aouthdr_in
,(abfd
, aouthdr_ext1
, aouthdr_int1
),
922 AOUTHDR
*aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
923 struct internal_aouthdr
*aouthdr_int
= (struct internal_aouthdr
*)aouthdr_int1
;
925 aouthdr_int
->magic
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->magic
);
926 aouthdr_int
->vstamp
= bfd_h_get_16(abfd
, (bfd_byte
*) aouthdr_ext
->vstamp
);
927 aouthdr_int
->tsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tsize
);
928 aouthdr_int
->dsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->dsize
);
929 aouthdr_int
->bsize
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->bsize
);
930 aouthdr_int
->entry
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->entry
);
931 aouthdr_int
->text_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->text_start
);
932 aouthdr_int
->data_start
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->data_start
);
934 aouthdr_int
->tagentries
= bfd_h_get_32(abfd
, (bfd_byte
*) aouthdr_ext
->tagentries
);
938 aouthdr_int
->o_toc
= bfd_h_get_32(abfd
, aouthdr_ext
->o_toc
);
939 aouthdr_int
->o_snentry
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snentry
);
940 aouthdr_int
->o_sntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntext
);
941 aouthdr_int
->o_sndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sndata
);
942 aouthdr_int
->o_sntoc
= bfd_h_get_16(abfd
, aouthdr_ext
->o_sntoc
);
943 aouthdr_int
->o_snloader
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snloader
);
944 aouthdr_int
->o_snbss
= bfd_h_get_16(abfd
, aouthdr_ext
->o_snbss
);
945 aouthdr_int
->o_algntext
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algntext
);
946 aouthdr_int
->o_algndata
= bfd_h_get_16(abfd
, aouthdr_ext
->o_algndata
);
947 aouthdr_int
->o_modtype
= bfd_h_get_16(abfd
, aouthdr_ext
->o_modtype
);
948 aouthdr_int
->o_maxstack
= bfd_h_get_32(abfd
, aouthdr_ext
->o_maxstack
);
953 DEFUN(coff_swap_aouthdr_out
,(abfd
, in
, out
),
958 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*)in
;
959 AOUTHDR
*aouthdr_out
= (AOUTHDR
*)out
;
960 bfd_h_put_16(abfd
, aouthdr_in
->magic
, (bfd_byte
*) aouthdr_out
->magic
);
961 bfd_h_put_16(abfd
, aouthdr_in
->vstamp
, (bfd_byte
*) aouthdr_out
->vstamp
);
962 bfd_h_put_32(abfd
, aouthdr_in
->tsize
, (bfd_byte
*) aouthdr_out
->tsize
);
963 bfd_h_put_32(abfd
, aouthdr_in
->dsize
, (bfd_byte
*) aouthdr_out
->dsize
);
964 bfd_h_put_32(abfd
, aouthdr_in
->bsize
, (bfd_byte
*) aouthdr_out
->bsize
);
965 bfd_h_put_32(abfd
, aouthdr_in
->entry
, (bfd_byte
*) aouthdr_out
->entry
);
966 bfd_h_put_32(abfd
, aouthdr_in
->text_start
,
967 (bfd_byte
*) aouthdr_out
->text_start
);
968 bfd_h_put_32(abfd
, aouthdr_in
->data_start
, (bfd_byte
*) aouthdr_out
->data_start
);
970 bfd_h_put_32(abfd
, aouthdr_in
->tagentries
, (bfd_byte
*) aouthdr_out
->tagentries
);
972 return sizeof(AOUTHDR
);
976 DEFUN(coff_swap_scnhdr_in
,(abfd
, scnhdr_ext
, scnhdr_int
),
978 SCNHDR
*scnhdr_ext AND
979 struct internal_scnhdr
*scnhdr_int
)
981 memcpy(scnhdr_int
->s_name
, scnhdr_ext
->s_name
, sizeof(scnhdr_int
->s_name
));
982 scnhdr_int
->s_vaddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
983 scnhdr_int
->s_paddr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
984 scnhdr_int
->s_size
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_size
);
986 scnhdr_int
->s_scnptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
987 scnhdr_int
->s_relptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
988 scnhdr_int
->s_lnnoptr
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
989 scnhdr_int
->s_flags
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_flags
);
991 scnhdr_int
->s_nreloc
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
992 scnhdr_int
->s_nlnno
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
994 scnhdr_int
->s_nreloc
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
995 scnhdr_int
->s_nlnno
= bfd_h_get_16(abfd
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
998 scnhdr_int
->s_align
= bfd_h_get_32(abfd
, (bfd_byte
*) scnhdr_ext
->s_align
);
1003 DEFUN(coff_swap_scnhdr_out
,(abfd
, in
, out
),
1008 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*)in
;
1009 SCNHDR
*scnhdr_ext
= (SCNHDR
*)out
;
1010 memcpy(scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof(scnhdr_int
->s_name
));
1011 PUTWORD(abfd
, scnhdr_int
->s_vaddr
, (bfd_byte
*) scnhdr_ext
->s_vaddr
);
1012 PUTWORD(abfd
, scnhdr_int
->s_paddr
, (bfd_byte
*) scnhdr_ext
->s_paddr
);
1013 PUTWORD(abfd
, scnhdr_int
->s_size
, (bfd_byte
*) scnhdr_ext
->s_size
);
1014 PUTWORD(abfd
, scnhdr_int
->s_scnptr
, (bfd_byte
*) scnhdr_ext
->s_scnptr
);
1015 PUTWORD(abfd
, scnhdr_int
->s_relptr
, (bfd_byte
*) scnhdr_ext
->s_relptr
);
1016 PUTWORD(abfd
, scnhdr_int
->s_lnnoptr
, (bfd_byte
*) scnhdr_ext
->s_lnnoptr
);
1017 PUTWORD(abfd
, scnhdr_int
->s_flags
, (bfd_byte
*) scnhdr_ext
->s_flags
);
1019 PUTWORD(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
1020 PUTWORD(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
1022 PUTHALF(abfd
, scnhdr_int
->s_nlnno
, (bfd_byte
*) scnhdr_ext
->s_nlnno
);
1023 PUTHALF(abfd
, scnhdr_int
->s_nreloc
, (bfd_byte
*) scnhdr_ext
->s_nreloc
);
1027 PUTWORD(abfd
, scnhdr_int
->s_align
, (bfd_byte
*) scnhdr_ext
->s_align
);
1029 return sizeof(SCNHDR
);
1034 initialize a section structure with information peculiar to this
1035 particular implementation of coff
1039 DEFUN(coff_new_section_hook
,(abfd
, section
),
1043 section
->alignment_power
= abfd
->xvec
->align_power_min
;
1044 /* Allocate aux records for section symbols, to store size and
1047 @@ Shouldn't use constant multiplier here! */
1048 coffsymbol (section
->symbol
)->native
=
1049 (combined_entry_type
*) bfd_zalloc (abfd
,
1050 sizeof (combined_entry_type
) * 10);
1054 static asection bfd_debug_section
= { "*DEBUG*" };
1056 /* Take a section header read from a coff file (in HOST byte order),
1057 and make a BFD "section" out of it. */
1059 DEFUN(make_a_section_from_file
,(abfd
, hdr
, target_index
),
1061 struct internal_scnhdr
*hdr AND
1062 unsigned int target_index
)
1064 asection
*return_section
;
1067 /* Assorted wastage to null-terminate the name, thanks AT&T! */
1068 name
= bfd_alloc(abfd
, sizeof (hdr
->s_name
)+1);
1070 bfd_error
= no_memory
;
1073 strncpy(name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
1074 name
[sizeof (hdr
->s_name
)] = 0;
1076 return_section
= bfd_make_section(abfd
, name
);
1077 #ifdef TWO_DATA_SECS
1078 /* On SCO a file created by the Microsoft assembler can have two
1079 .data sections. We use .data2 for the second one. */
1080 if (return_section
== NULL
&& strcmp(name
, _DATA
) == 0)
1081 return_section
= bfd_make_section(abfd
, ".data2");
1082 #endif /* TWO_DATA_SECS */
1083 if (return_section
== NULL
)
1086 /* s_paddr is presumed to be = to s_vaddr */
1088 return_section
->vma
= hdr
->s_vaddr
;
1089 return_section
->_raw_size
= hdr
->s_size
;
1090 return_section
->filepos
= hdr
->s_scnptr
;
1091 return_section
->rel_filepos
= hdr
->s_relptr
;
1092 return_section
->reloc_count
= hdr
->s_nreloc
;
1095 /* FIXME, use a temp var rather than alignment_power */
1096 return_section
->alignment_power
= hdr
->s_align
;
1099 for (i
= 0; i
< 32; i
++) {
1100 if ((1 << i
) >= (int) (return_section
->alignment_power
)) {
1101 return_section
->alignment_power
= i
;
1108 return_section
->line_filepos
= hdr
->s_lnnoptr
;
1110 return_section->linesize = hdr->s_nlnno * sizeof (struct lineno);
1113 return_section
->lineno_count
= hdr
->s_nlnno
;
1114 return_section
->userdata
= NULL
;
1115 return_section
->next
= (asection
*) NULL
;
1116 return_section
->flags
= styp_to_sec_flags(hdr
->s_flags
);
1118 return_section
->target_index
= target_index
;
1120 if (hdr
->s_nreloc
!= 0)
1121 return_section
->flags
|= SEC_RELOC
;
1122 /* FIXME: should this check 'hdr->s_size > 0' */
1123 if (hdr
->s_scnptr
!= 0)
1124 return_section
->flags
|= SEC_HAS_CONTENTS
;
1128 DEFUN(coff_mkobject
,(abfd
),
1131 abfd
->tdata
.coff_obj_data
= (struct coff_tdata
*)bfd_zalloc (abfd
,sizeof(coff_data_type
));
1132 if (abfd
->tdata
.coff_obj_data
== 0){
1133 bfd_error
= no_memory
;
1136 coff_data(abfd
)->relocbase
= 0;
1137 /* make_abs_section(abfd);*/
1143 DEFUN(coff_real_object_p
,(abfd
, nscns
, internal_f
, internal_a
),
1146 struct internal_filehdr
*internal_f AND
1147 struct internal_aouthdr
*internal_a
)
1149 coff_data_type
*coff
;
1150 enum bfd_architecture arch
;
1152 size_t readsize
; /* length of file_info */
1153 SCNHDR
*external_sections
;
1155 /* Build a play area */
1156 if (coff_mkobject(abfd
) != true)
1159 coff
= coff_data(abfd
);
1162 external_sections
= (SCNHDR
*)bfd_alloc(abfd
, readsize
= (nscns
* SCNHSZ
));
1164 if (bfd_read((PTR
)external_sections
, 1, readsize
, abfd
) != readsize
) {
1169 /* Now copy data as required; construct all asections etc */
1170 coff
->symbol_index_slew
= 0;
1172 coff
->raw_syment_count
= 0;
1173 coff
->raw_linenos
= 0;
1174 coff
->raw_syments
= 0;
1175 coff
->sym_filepos
=0;
1176 coff
->flags
= internal_f
->f_flags
;
1179 for (i
= 0; i
< nscns
; i
++) {
1180 struct internal_scnhdr tmp
;
1181 coff_swap_scnhdr_in(abfd
, external_sections
+ i
, &tmp
);
1182 make_a_section_from_file(abfd
,&tmp
, i
+1);
1186 /* make_abs_section(abfd);*/
1188 /* Determine the machine architecture and type. */
1190 switch (internal_f
->f_magic
) {
1193 arch
= bfd_arch_i386
;
1198 #ifdef A29K_MAGIC_BIG
1199 case A29K_MAGIC_BIG
:
1200 case A29K_MAGIC_LITTLE
:
1201 arch
= bfd_arch_a29k
;
1210 arch
= bfd_arch_mips
;
1218 arch
= bfd_arch_m68k
;
1226 arch
= bfd_arch_m88k
;
1232 arch
= bfd_arch_z8k
;
1233 switch (internal_f
->f_flags
& F_MACHMASK
)
1236 machine
= bfd_mach_z8001
;
1239 machine
= bfd_mach_z8002
;
1250 arch
= bfd_arch_i960
;
1251 switch (F_I960TYPE
& internal_f
->f_flags
)
1255 machine
= bfd_mach_i960_core
;
1258 machine
= bfd_mach_i960_kb_sb
;
1261 machine
= bfd_mach_i960_mc
;
1264 machine
= bfd_mach_i960_xa
;
1267 machine
= bfd_mach_i960_ca
;
1270 machine
= bfd_mach_i960_ka_sa
;
1281 arch
= bfd_arch_rs6000
;
1288 arch
= bfd_arch_we32k
;
1295 arch
= bfd_arch_h8300
;
1300 default: /* Unreadable input file type */
1301 arch
= bfd_arch_obscure
;
1305 bfd_default_set_arch_mach(abfd
, arch
, machine
);
1306 if (!(internal_f
->f_flags
& F_RELFLG
))
1307 abfd
->flags
|= HAS_RELOC
;
1308 if ((internal_f
->f_flags
& F_EXEC
))
1309 abfd
->flags
|= EXEC_P
;
1310 if (!(internal_f
->f_flags
& F_LNNO
))
1311 abfd
->flags
|= HAS_LINENO
;
1312 if (!(internal_f
->f_flags
& F_LSYMS
))
1313 abfd
->flags
|= HAS_LOCALS
;
1316 bfd_get_symcount(abfd
) = internal_f
->f_nsyms
;
1317 if (internal_f
->f_nsyms
)
1318 abfd
->flags
|= HAS_SYMS
;
1320 coff
->sym_filepos
= internal_f
->f_symptr
;
1322 /* These members communicate important constants about the symbol table
1323 to GDB's symbol-reading code. These `constants' unfortunately vary
1324 from coff implementation to implementation... */
1325 #ifndef NO_COFF_SYMBOLS
1326 coff
->local_n_btmask
= N_BTMASK
;
1327 coff
->local_n_btshft
= N_BTSHFT
;
1328 coff
->local_n_tmask
= N_TMASK
;
1329 coff
->local_n_tshift
= N_TSHIFT
;
1330 coff
->local_symesz
= SYMESZ
;
1331 coff
->local_auxesz
= AUXESZ
;
1332 coff
->local_linesz
= LINESZ
;
1335 coff
->symbols
= (coff_symbol_type
*) NULL
;
1336 bfd_get_start_address(abfd
) = internal_f
->f_opthdr
? internal_a
->entry
: 0;
1340 bfd_release(abfd
, coff
);
1341 return (bfd_target
*)NULL
;
1345 DEFUN(coff_object_p
,(abfd
),
1351 struct internal_filehdr internal_f
;
1352 struct internal_aouthdr internal_a
;
1354 bfd_error
= system_call_error
;
1356 /* figure out how much to read */
1357 if (bfd_read((PTR
) &filehdr
, 1, FILHSZ
, abfd
) != FILHSZ
)
1360 bfd_swap_filehdr_in(abfd
, &filehdr
, &internal_f
);
1362 if (BADMAG(internal_f
)) {
1363 bfd_error
= wrong_format
;
1366 nscns
=internal_f
.f_nscns
;
1368 if (internal_f
.f_opthdr
) {
1369 if (bfd_read((PTR
) &opthdr
, 1,AOUTSZ
, abfd
) != AOUTSZ
) {
1372 bfd_swap_aouthdr_in(abfd
, (char *)&opthdr
, (char *)&internal_a
);
1375 /* Seek past the opt hdr stuff */
1376 bfd_seek(abfd
, (file_ptr
) (internal_f
.f_opthdr
+ FILHSZ
), SEEK_SET
);
1378 /* if the optional header is NULL or not the correct size then
1379 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1380 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1381 optional header is of a different size.
1383 But the mips keeps extra stuff in it's opthdr, so dont check
1387 #if defined(M88) || defined(I960)
1388 if (internal_f
.f_opthdr
!= 0 && AOUTSZ
!= internal_f
.f_opthdr
)
1389 return (bfd_target
*)NULL
;
1392 return coff_real_object_p(abfd
, nscns
, &internal_f
, &internal_a
);
1397 #ifndef NO_COFF_LINENOS
1400 DEFUN(coff_count_linenumbers
,(abfd
),
1403 unsigned int limit
= bfd_get_symcount(abfd
);
1407 asection
*s
= abfd
->sections
->output_section
;
1409 BFD_ASSERT(s
->lineno_count
== 0);
1415 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++) {
1416 asymbol
*q_maybe
= *p
;
1417 if (q_maybe
->the_bfd
->xvec
->flavour
== bfd_target_coff_flavour
) {
1418 coff_symbol_type
*q
= coffsymbol(q_maybe
);
1421 This symbol has a linenumber, increment the owning
1422 section's linenumber count
1424 alent
*l
= q
->lineno
;
1425 q
->symbol
.section
->output_section
->lineno_count
++;
1427 while (l
->line_number
) {
1428 q
->symbol
.section
->output_section
->lineno_count
++;
1436 #endif /* NO_COFF_LINENOS */
1438 #ifndef NO_COFF_SYMBOLS
1441 Takes a bfd and a symbol, returns a pointer to the coff specific area
1442 of the symbol if there is one.
1444 static coff_symbol_type
*
1445 DEFUN(coff_symbol_from
,(ignore_abfd
, symbol
),
1446 bfd
*ignore_abfd AND
1449 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
1450 return (coff_symbol_type
*)NULL
;
1452 if (symbol
->the_bfd
->tdata
.coff_obj_data
== (coff_data_type
*)NULL
)
1453 return (coff_symbol_type
*)NULL
;
1455 return (coff_symbol_type
*) symbol
;
1461 DEFUN(fixup_symbol_value
,(coff_symbol_ptr
, syment
),
1462 coff_symbol_type
*coff_symbol_ptr AND
1463 struct internal_syment
*syment
)
1466 /* Normalize the symbol flags */
1467 if (coff_symbol_ptr
->symbol
.section
== &bfd_com_section
) {
1468 /* a common symbol is undefined with a value */
1469 syment
->n_scnum
= N_UNDEF
;
1470 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1472 else if (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) {
1473 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1475 else if (coff_symbol_ptr
->symbol
.section
== & bfd_und_section
) {
1476 syment
->n_scnum
= N_UNDEF
;
1477 syment
->n_value
= 0;
1480 if (coff_symbol_ptr
->symbol
.section
) {
1482 coff_symbol_ptr
->symbol
.section
->output_section
->target_index
;
1485 coff_symbol_ptr
->symbol
.value
+
1486 coff_symbol_ptr
->symbol
.section
->output_offset
+
1487 coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
1491 /* This can happen, but I don't know why yet (steve@cygnus.com) */
1492 syment
->n_scnum
= N_ABS
;
1493 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
1498 /* run through all the symbols in the symbol table and work out what
1499 their indexes into the symbol table will be when output
1501 Coff requires that each C_FILE symbol points to the next one in the
1502 chain, and that the last one points to the first external symbol. We
1507 DEFUN(coff_renumber_symbols
,(bfd_ptr
),
1510 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1511 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1512 unsigned int native_index
= 0;
1513 struct internal_syment
*last_file
= (struct internal_syment
*)NULL
;
1514 unsigned int symbol_index
;
1516 /* COFF demands that undefined symbols come after all other symbols.
1517 Since we don't need to impose this extra knowledge on all our client
1518 programs, deal with that here. Sort the symbol table; just move the
1519 undefined symbols to the end, leaving the rest alone. */
1520 /* @@ Do we have some condition we could test for, so we don't always
1521 have to do this? I don't think relocatability is quite right, but
1522 I'm not certain. [raeburn:19920508.1711EST] */
1527 newsyms
= (asymbol
**) bfd_alloc_by_size_t (bfd_ptr
,
1529 * (symbol_count
+ 1));
1530 bfd_ptr
->outsymbols
= newsyms
;
1531 for (i
= 0; i
< symbol_count
; i
++)
1532 if (symbol_ptr_ptr
[i
]->section
!= &bfd_und_section
)
1533 *newsyms
++ = symbol_ptr_ptr
[i
];
1534 for (i
= 0; i
< symbol_count
; i
++)
1535 if (symbol_ptr_ptr
[i
]->section
== &bfd_und_section
)
1536 *newsyms
++ = symbol_ptr_ptr
[i
];
1537 *newsyms
= (asymbol
*) NULL
;
1538 symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1541 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1543 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1544 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1545 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1548 if (s
->u
.syment
.n_sclass
== C_FILE
)
1550 if (last_file
!= (struct internal_syment
*)NULL
) {
1551 last_file
->n_value
= native_index
;
1553 last_file
= &(s
->u
.syment
);
1557 /* Modify the symbol values according to their section and
1560 fixup_symbol_value(coff_symbol_ptr
, &(s
->u
.syment
));
1562 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++) {
1563 s
[i
].offset
= native_index
++;
1570 obj_conv_table_size (bfd_ptr
) = native_index
;
1575 Run thorough the symbol table again, and fix it so that all pointers to
1576 entries are changed to the entries' index in the output symbol table.
1580 DEFUN(coff_mangle_symbols
,(bfd_ptr
),
1583 unsigned int symbol_count
= bfd_get_symcount(bfd_ptr
);
1584 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
1585 unsigned int symbol_index
;
1587 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
1589 coff_symbol_type
*coff_symbol_ptr
=
1590 coff_symbol_from(bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
1592 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
) {
1594 combined_entry_type
*s
= coff_symbol_ptr
->native
;
1596 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++) {
1597 combined_entry_type
*a
= s
+ i
+ 1;
1599 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
1600 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
1604 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
1605 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
1615 static int string_size
;
1617 DEFUN(coff_fix_symbol_name
,(ignore_abfd
, symbol
, native
),
1618 bfd
*ignore_abfd AND
1620 combined_entry_type
*native
)
1622 unsigned int name_length
;
1623 union internal_auxent
*auxent
;
1624 char * name
= ( char *)(symbol
->name
);
1626 if (name
== (char *) NULL
) {
1627 /* coff symbols always have names, so we'll make one up */
1628 symbol
->name
= "strange";
1629 name
= (char *)symbol
->name
;
1631 name_length
= strlen(name
);
1633 if (native
->u
.syment
.n_sclass
== C_FILE
) {
1634 strncpy(native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
1635 auxent
= &(native
+1)->u
.auxent
;
1637 #ifdef COFF_LONG_FILENAMES
1638 if (name_length
<= FILNMLEN
) {
1639 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1642 auxent
->x_file
.x_n
.x_offset
= string_size
+ 4;
1643 auxent
->x_file
.x_n
.x_zeroes
= 0;
1644 string_size
+= name_length
+ 1;
1647 strncpy(auxent
->x_file
.x_fname
, name
, FILNMLEN
);
1648 if (name_length
> FILNMLEN
) {
1649 name
[FILNMLEN
] = '\0';
1654 { /* NOT A C_FILE SYMBOL */
1655 if (name_length
<= SYMNMLEN
) {
1656 /* This name will fit into the symbol neatly */
1657 strncpy(native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
1660 native
->u
.syment
._n
._n_n
._n_offset
= string_size
+ 4;
1661 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1662 string_size
+= name_length
+ 1;
1670 DEFUN(coff_write_symbol
,(abfd
, symbol
, native
, written
),
1673 combined_entry_type
*native AND
1674 unsigned int written
)
1676 unsigned int numaux
= native
->u
.syment
.n_numaux
;
1677 int type
= native
->u
.syment
.n_type
;
1678 int class = native
->u
.syment
.n_sclass
;
1682 /* @@ bfd_debug_section isn't accessible outside this file, but we know
1683 that C_FILE symbols belong there. So move them. */
1684 if (native
->u
.syment
.n_sclass
== C_FILE
)
1685 symbol
->section
= &bfd_debug_section
;
1687 if (symbol
->section
== &bfd_abs_section
)
1689 native
->u
.syment
.n_scnum
= N_ABS
;
1691 else if (symbol
->section
== &bfd_debug_section
)
1693 native
->u
.syment
.n_scnum
= N_DEBUG
;
1695 else if (symbol
->section
== &bfd_und_section
)
1697 native
->u
.syment
.n_scnum
= N_UNDEF
;
1701 native
->u
.syment
.n_scnum
=
1702 symbol
->section
->output_section
->target_index
;
1706 coff_fix_symbol_name(abfd
, symbol
, native
);
1708 coff_swap_sym_out(abfd
, &native
->u
.syment
, &buf
);
1709 bfd_write((PTR
)& buf
, 1, SYMESZ
, abfd
);
1710 for (j
= 0; j
< native
->u
.syment
.n_numaux
; j
++)
1713 coff_swap_aux_out(abfd
,
1714 &( (native
+ j
+ 1)->u
.auxent
), type
, class, &buf1
);
1715 bfd_write((PTR
) (&buf1
), 1, AUXESZ
, abfd
);
1718 Reuse somewhere in the symbol to keep the index
1720 set_index(symbol
, written
);
1721 return written
+ 1 + numaux
;
1726 DEFUN(coff_write_alien_symbol
,(abfd
, symbol
, written
),
1729 unsigned int written
)
1732 This symbol has been created by the loader, or come from a non
1733 coff format. It has no native element to inherit, make our
1736 combined_entry_type
*native
;
1737 combined_entry_type dummy
;
1739 native
->u
.syment
.n_type
= T_NULL
;
1741 native
->u
.syment
.n_flags
= 0;
1743 if (symbol
->section
== &bfd_und_section
)
1745 native
->u
.syment
.n_scnum
= N_UNDEF
;
1746 native
->u
.syment
.n_value
= symbol
->value
;
1748 else if (symbol
->section
== &bfd_com_section
)
1750 native
->u
.syment
.n_scnum
= N_UNDEF
;
1751 native
->u
.syment
.n_value
= symbol
->value
;
1755 else if (symbol
->flags
& BSF_DEBUGGING
) {
1757 remove name so it doesn't take up any space
1762 native
->u
.syment
.n_scnum
= symbol
->section
->output_section
->target_index
;
1763 native
->u
.syment
.n_value
= symbol
->value
+
1764 symbol
->section
->output_section
->vma
+
1765 symbol
->section
->output_offset
;
1767 /* Copy the any flags from the the file hdr into the symbol */
1769 coff_symbol_type
*c
= coff_symbol_from(abfd
, symbol
);
1770 if (c
!= (coff_symbol_type
*)NULL
) {
1771 native
->u
.syment
.n_flags
= c
->symbol
.the_bfd
->flags
;
1778 native
->u
.syment
.pad1
[0] = 0;
1779 native
->u
.syment
.pad1
[0] = 0;
1782 native
->u
.syment
.n_type
= 0;
1783 if (symbol
->flags
& BSF_LOCAL
)
1784 native
->u
.syment
.n_sclass
= C_STAT
;
1786 native
->u
.syment
.n_sclass
= C_EXT
;
1787 native
->u
.syment
.n_numaux
= 0;
1789 return coff_write_symbol(abfd
, symbol
, native
, written
);
1793 DEFUN(coff_write_native_symbol
,(abfd
, symbol
, written
),
1795 coff_symbol_type
*symbol AND
1796 unsigned int written
)
1799 Does this symbol have an ascociated line number - if so then
1800 make it remember this symbol index. Also tag the auxent of
1801 this symbol to point to the right place in the lineno table
1803 combined_entry_type
*native
= symbol
->native
;
1805 alent
*lineno
= symbol
->lineno
;
1807 if (lineno
&& !symbol
->done_lineno
) {
1808 unsigned int count
= 0;
1809 lineno
[count
].u
.offset
= written
;
1810 if (native
->u
.syment
.n_numaux
) {
1811 union internal_auxent
*a
= &((native
+1)->u
.auxent
);
1813 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1814 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1817 And count and relocate all other linenumbers
1821 while (lineno
[count
].line_number
) {
1824 I've been told this, but still need proof:
1825 > The second bug is also in `bfd/coffcode.h'. This bug causes the linker to screw
1826 > up the pc-relocations for all the line numbers in COFF code. This bug isn't
1827 > only specific to A29K implementations, but affects all systems using COFF
1828 > format binaries. Note that in COFF object files, the line number core offsets
1829 > output by the assembler are relative to the start of each procedure, not
1830 > to the start of the .text section. This patch relocates the line numbers
1831 > relative to the `native->u.syment.n_value' instead of the section virtual
1832 > address. modular!olson@cs.arizona.edu (Jon Olson)
1834 lineno
[count
].u
.offset
+= native
->u
.syment
.n_value
;
1837 lineno
[count
].u
.offset
+=
1838 symbol
->symbol
.section
->output_section
->vma
+
1839 symbol
->symbol
.section
->output_offset
;
1843 symbol
->done_lineno
= true;
1845 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1848 return coff_write_symbol(abfd
, &( symbol
->symbol
), native
,written
);
1852 DEFUN(coff_write_symbols
,(abfd
),
1856 unsigned int limit
= bfd_get_symcount(abfd
);
1857 unsigned int written
= 0;
1864 /* Seek to the right place */
1865 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
1867 /* Output all the symbols we have */
1870 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1872 asymbol
*symbol
= *p
;
1873 coff_symbol_type
*c_symbol
= coff_symbol_from(abfd
, symbol
);
1875 if (c_symbol
== (coff_symbol_type
*) NULL
||
1876 c_symbol
->native
== (combined_entry_type
*)NULL
)
1878 written
= coff_write_alien_symbol(abfd
, symbol
, written
);
1882 written
= coff_write_native_symbol(abfd
, c_symbol
, written
);
1887 bfd_get_symcount(abfd
) = written
;
1889 /* Now write out strings */
1891 if (string_size
!= 0)
1893 unsigned int size
= string_size
+ 4;
1896 bfd_h_put_32(abfd
, size
, buffer
);
1897 bfd_write((PTR
) buffer
, 1, sizeof(buffer
), abfd
);
1898 for (p
= abfd
->outsymbols
, i
= 0;
1903 size_t name_length
= strlen(q
->name
);
1905 coff_symbol_type
* c_symbol
= coff_symbol_from(abfd
, q
);
1906 maxlen
= ((c_symbol
!= NULL
&& c_symbol
->native
!= NULL
) &&
1907 (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
)) ?
1908 FILNMLEN
: SYMNMLEN
;
1910 if (name_length
> maxlen
) {
1911 bfd_write((PTR
) (q
->name
), 1, name_length
+ 1, abfd
);
1916 /* We would normally not write anything here, but we'll write
1917 out 4 so that any stupid coff reader which tries to read
1918 the string table even when there isn't one won't croak.
1921 uint32e_type size
= 4;
1923 bfd_write((PTR
)&size
, 1, sizeof(size
), abfd
);
1932 To write relocations, all the back end does is step though the
1933 canonical relocation table, and create an
1934 @code{internal_reloc}. The symbol index to use is removed from
1935 the @code{offset} field in the symbol table supplied, the
1936 address comes directly from the sum of the section base
1937 address and the relocation offset and the type is dug directly
1938 from the howto field. Then the @code{internal_reloc} is
1939 swapped into the shape of an @code{external_reloc} and written
1945 DEFUN(coff_write_relocs
,(abfd
),
1949 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
1951 struct external_reloc dst
;
1953 arelent
**p
= s
->orelocation
;
1954 bfd_seek(abfd
, s
->rel_filepos
, SEEK_SET
);
1955 for (i
= 0; i
< s
->reloc_count
; i
++) {
1956 struct internal_reloc n
;
1958 memset((PTR
)&n
, 0, sizeof(n
));
1960 n
.r_vaddr
= q
->address
+ s
->vma
;
1961 /* The 29k const/consth reloc pair is a real kludge - the consth
1962 part doesn't have a symbol - it has an offset. So rebuilt
1965 if (q
->howto
->type
== R_IHCONST
)
1966 n
.r_symndx
= q
->addend
;
1973 if (q
->sym_ptr_ptr
== bfd_abs_section
.symbol_ptr_ptr
)
1975 /* This is a relocation relative to the absolute symbol */
1980 n
.r_symndx
= get_index((*(q
->sym_ptr_ptr
)));
1981 /* Take notice if the symbol reloc points to a symbol we don't have
1982 in our symbol table. What should we do for this?? */
1983 if (n
.r_symndx
> obj_conv_table_size (abfd
))
1991 /* Work out reloc type from what is required */
1992 SELECT_RELOC(n
.r_type
, q
->howto
);
1994 n
.r_type
= q
->howto
->type
;
1996 coff_swap_reloc_out(abfd
, &n
, &dst
);
1997 bfd_write((PTR
) &dst
, 1, RELSZ
, abfd
);
2001 #endif /* NO_COFF_SYMBOLS */
2003 #ifndef NO_COFF_LINENOS
2006 DEFUN(coff_write_linenumbers
,(abfd
),
2010 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
) {
2011 if (s
->lineno_count
) {
2012 asymbol
**q
= abfd
->outsymbols
;
2013 bfd_seek(abfd
, s
->line_filepos
, SEEK_SET
);
2014 /* Find all the linenumbers in this section */
2017 alent
*l
= BFD_SEND(p
->the_bfd
, _get_lineno
, (p
->the_bfd
, p
));
2019 /* Found a linenumber entry, output */
2020 struct internal_lineno out
;
2022 memset( (PTR
)&out
, 0, sizeof(out
));
2024 out
.l_addr
.l_symndx
= l
->u
.offset
;
2025 coff_swap_lineno_out(abfd
, &out
, &buff
);
2026 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
2028 while (l
->line_number
) {
2029 out
.l_lnno
= l
->line_number
;
2030 out
.l_addr
.l_symndx
= l
->u
.offset
;
2031 coff_swap_lineno_out(abfd
, &out
, &buff
);
2032 bfd_write((PTR
) &buff
, 1, LINESZ
, abfd
);
2043 DEFUN(coff_get_lineno
,(ignore_abfd
, symbol
),
2044 bfd
*ignore_abfd AND
2047 return coffsymbol(symbol
)->lineno
;
2050 #endif /* NO_COFF_LINENOS */
2053 coff_make_empty_symbol(abfd
)
2056 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc(abfd
, sizeof(coff_symbol_type
));
2058 bfd_error
= no_memory
;
2061 new->symbol
.section
= 0;
2063 new->lineno
= (alent
*) NULL
;
2064 new->done_lineno
= false;
2065 new->symbol
.the_bfd
= abfd
;
2066 return &new->symbol
;
2069 #ifndef NO_COFF_SYMBOLS
2072 DEFUN (coff_make_debug_symbol
, (abfd
, ptr
, sz
),
2077 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc(abfd
, sizeof(coff_symbol_type
));
2079 bfd_error
= no_memory
;
2082 /* @@ This shouldn't be using a constant multiplier. */
2083 new->native
= (combined_entry_type
*) bfd_zalloc (abfd
, sizeof (combined_entry_type
) * 10);
2084 new->symbol
.section
= &bfd_debug_section
;
2085 new->lineno
= (alent
*) NULL
;
2086 new->done_lineno
= false;
2087 new->symbol
.the_bfd
= abfd
;
2088 return &new->symbol
;
2092 DEFUN(coff_print_symbol
,(ignore_abfd
, filep
, symbol
, how
),
2093 bfd
*ignore_abfd AND
2096 bfd_print_symbol_type how
)
2098 FILE *file
= (FILE *)filep
;
2100 case bfd_print_symbol_name
:
2101 fprintf(file
, "%s", symbol
->name
);
2103 case bfd_print_symbol_more
:
2104 fprintf(file
, "coff %lx %lx", (unsigned long) coffsymbol(symbol
)->native
,
2105 (unsigned long) coffsymbol(symbol
)->lineno
);
2107 case bfd_print_symbol_nm
:
2110 CONST
char *section_name
= symbol
->section
->name
;
2111 bfd_print_symbol_vandf((PTR
) file
, symbol
);
2114 fprintf(file
, " %-5s %s %s %s",
2116 coffsymbol(symbol
)->native
? "n" : "g",
2117 coffsymbol(symbol
)->lineno
? "l" : " ",
2123 case bfd_print_symbol_all
:
2124 /* Print out the symbols in a reasonable way */
2126 CONST
char *section_name
= symbol
->section
->name
;
2129 if (coffsymbol(symbol
)->native
)
2132 combined_entry_type
*combined
= coffsymbol(symbol
)->native
;
2133 combined_entry_type
*root
= obj_raw_syments(ignore_abfd
);
2135 fprintf(file
,"[%3d]",
2139 fprintf(file
, "(sc %2d)(fl%4x)(ty%3x)(sc%3d) nx(%d) %08x %s",
2140 combined
->u
.syment
.n_scnum
,
2141 combined
->u
.syment
.n_flags
,
2142 combined
->u
.syment
.n_type
,
2143 combined
->u
.syment
.n_sclass
,
2144 combined
->u
.syment
.n_numaux
,
2145 combined
->u
.syment
.n_value
,
2148 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
2151 switch (combined
->u
.syment
.n_sclass
) {
2153 fprintf(file
, "File ");
2156 fprintf(file
, "AUX lnno %x size %x tagndx %x",
2157 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
2158 combined
[aux
+1].u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
2159 combined
[aux
+1].u
.auxent
.x_sym
.x_tagndx
.l
);
2167 struct lineno_cache_entry
*l
= coffsymbol(symbol
)->lineno
;
2170 printf("\n%s :", l
->u
.sym
->name
);
2172 while (l
->line_number
)
2174 printf("\n%4d : %x",
2188 bfd_print_symbol_vandf((PTR
) file
, symbol
);
2189 fprintf(file
, " %-5s %s %s %s",
2191 coffsymbol(symbol
)->native
? "n" : "g",
2192 coffsymbol(symbol
)->lineno
? "l" : " ",
2201 #endif /* NO_COFF_SYMBOLS */
2203 /* Set flags and magic number of a coff file from architecture and machine
2204 type. Result is true if we can represent the arch&type, false if not. */
2207 DEFUN(coff_set_flags
,(abfd
, magicp
, flagsp
),
2209 unsigned *magicp AND
2210 unsigned short *flagsp
)
2212 switch (bfd_get_arch(abfd
)) {
2216 switch (bfd_get_mach(abfd
))
2218 case bfd_mach_z8001
:
2221 case bfd_mach_z8002
:
2235 *magicp
= I960ROMAGIC
;
2237 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2238 I960RWMAGIC); FIXME???
2240 switch (bfd_get_mach(abfd
)) {
2241 case bfd_mach_i960_core
:
2244 case bfd_mach_i960_kb_sb
:
2247 case bfd_mach_i960_mc
:
2250 case bfd_mach_i960_xa
:
2253 case bfd_mach_i960_ca
:
2256 case bfd_mach_i960_ka_sa
:
2269 *magicp
= MIPS_MAGIC_2
;
2275 *magicp
= I386MAGIC
;
2281 *magicp
= MC68MAGIC
;
2288 *magicp
= MC88OMAGIC
;
2293 case bfd_arch_h8300
:
2294 *magicp
= H8300MAGIC
;
2298 #ifdef A29K_MAGIC_BIG
2300 if (abfd
->xvec
->byteorder_big_p
)
2301 *magicp
= A29K_MAGIC_BIG
;
2303 *magicp
= A29K_MAGIC_LITTLE
;
2309 case bfd_arch_we32k
:
2310 *magicp
= WE32KMAGIC
;
2316 case bfd_arch_rs6000
:
2317 *magicp
= U802TOCMAGIC
;
2322 default: /* Unknown architecture */
2323 /* return false; -- fall through to "return false" below, to avoid
2324 "statement never reached" errors on the one below. */
2333 DEFUN(coff_set_arch_mach
,(abfd
, arch
, machine
),
2335 enum bfd_architecture arch AND
2336 unsigned long machine
)
2339 unsigned short dummy2
;
2340 bfd_default_set_arch_mach(abfd
, arch
, machine
);
2342 if (arch
!= bfd_arch_unknown
&&
2343 coff_set_flags(abfd
, &dummy1
, &dummy2
) != true)
2344 return false; /* We can't represent this type */
2345 return true; /* We're easy ... */
2349 /* Calculate the file position for each section. */
2352 DEFUN(coff_compute_section_file_positions
,(abfd
),
2356 asection
*previous
= (asection
*)NULL
;
2357 file_ptr sofar
= FILHSZ
;
2359 if (bfd_get_start_address(abfd
))
2361 /* A start address may have been added to the original file. In this
2362 case it will need an optional header to record it. */
2363 abfd
->flags
|= EXEC_P
;
2366 if (abfd
->flags
& EXEC_P
)
2369 sofar
+= abfd
->section_count
* SCNHSZ
;
2370 for (current
= abfd
->sections
;
2371 current
!= (asection
*)NULL
;
2372 current
= current
->next
) {
2374 /* Only deal with sections which have contents */
2375 if (!(current
->flags
& SEC_HAS_CONTENTS
))
2378 /* Align the sections in the file to the same boundary on
2379 which they are aligned in virtual memory. I960 doesn't
2380 do this (FIXME) so we can stay in sync with Intel. 960
2381 doesn't yet page from files... */
2384 /* make sure this section is aligned on the right boundary - by
2385 padding the previous section up if necessary */
2388 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2389 if (previous
!= (asection
*)NULL
) {
2390 previous
->_raw_size
+= sofar
- old_sofar
;
2395 /* FIXME, in demand paged files, the low order bits of the file
2396 offset must match the low order bits of the virtual address.
2397 "Low order" is apparently implementation defined. Add code
2398 here to round sofar up to match the virtual address. */
2400 current
->filepos
= sofar
;
2402 sofar
+= current
->_raw_size
;
2404 /* make sure that this section is of the right size too */
2406 sofar
= BFD_ALIGN(sofar
, 1 << current
->alignment_power
);
2407 current
->_raw_size
+= sofar
- old_sofar
;
2412 obj_relocbase(abfd
) = sofar
;
2415 #ifndef NO_COFF_SYMBOLS
2417 coff_section_symbol (abfd
, name
)
2421 asection
*sec
= bfd_make_section_old_way (abfd
, name
);
2423 combined_entry_type
*csym
;
2426 if (coff_symbol_from (abfd
, sym
))
2427 csym
= coff_symbol_from (abfd
, sym
)->native
;
2430 /* Make sure back-end COFF stuff is there. */
2434 coff_symbol_type sym
;
2435 /* @@FIXME This shouldn't use a fixed size!! */
2436 combined_entry_type e
[10];
2439 f
= (struct foo
*) bfd_alloc_by_size_t (abfd
, sizeof (*f
));
2440 memset ((char *) f
, 0, sizeof (*f
));
2441 coff_symbol_from (abfd
, sym
)->native
= csym
= f
->e
;
2443 csym
[0].u
.syment
.n_sclass
= C_STAT
;
2444 csym
[0].u
.syment
.n_numaux
= 1;
2445 /* SF_SET_STATICS (sym); @@ ??? */
2448 csym
[1].u
.auxent
.x_scn
.x_scnlen
= sec
->_raw_size
;
2449 csym
[1].u
.auxent
.x_scn
.x_nreloc
= sec
->reloc_count
;
2450 csym
[1].u
.auxent
.x_scn
.x_nlinno
= sec
->lineno_count
;
2454 csym
[1].u
.auxent
.x_scn
.x_scnlen
= 0;
2455 csym
[1].u
.auxent
.x_scn
.x_nreloc
= 0;
2456 csym
[1].u
.auxent
.x_scn
.x_nlinno
= 0;
2461 /* If .file, .text, .data, .bss symbols are missing, add them. */
2462 /* @@ Should we only be adding missing symbols, or overriding the aux
2463 values for existing section symbols? */
2465 coff_add_missing_symbols (abfd
)
2468 unsigned int nsyms
= bfd_get_symcount (abfd
);
2469 asymbol
**sympp
= abfd
->outsymbols
;
2472 int need_text
= 1, need_data
= 1, need_bss
= 1, need_file
= 1;
2474 for (i
= 0; i
< nsyms
; i
++)
2476 coff_symbol_type
*csym
= coff_symbol_from (abfd
, sympp
[i
]);
2480 /* only do this if there is a coff representation of the input
2482 if (csym
->native
&& csym
->native
->u
.syment
.n_sclass
== C_FILE
)
2487 name
= csym
->symbol
.name
;
2490 if (!strcmp (name
, _TEXT
))
2492 else if (!strcmp (name
, _DATA
))
2494 else if (!strcmp (name
, _BSS
))
2498 /* Now i == bfd_get_symcount (abfd). */
2499 /* @@ For now, don't deal with .file symbol. */
2502 if (!need_text
&& !need_data
&& !need_bss
&& !need_file
)
2504 nsyms
+= need_text
+ need_data
+ need_bss
+ need_file
;
2505 sympp2
= (asymbol
**) bfd_alloc_by_size_t (abfd
, nsyms
* sizeof (asymbol
*));
2506 memcpy (sympp2
, sympp
, i
* sizeof (asymbol
*));
2509 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
2513 sympp2
[i
++] = coff_section_symbol (abfd
, _TEXT
);
2515 sympp2
[i
++] = coff_section_symbol (abfd
, _DATA
);
2517 sympp2
[i
++] = coff_section_symbol (abfd
, _BSS
);
2518 BFD_ASSERT (i
== nsyms
);
2519 bfd_set_symtab (abfd
, sympp2
, nsyms
);
2521 #endif /* NO_COFF_SYMBOLS */
2526 DEFUN(coff_write_object_contents
,(abfd
),
2532 boolean hasrelocs
= false;
2533 boolean haslinno
= false;
2534 file_ptr reloc_base
;
2535 file_ptr lineno_base
;
2539 unsigned long reloc_size
= 0;
2540 unsigned long lnno_size
= 0;
2541 asection
*text_sec
= NULL
;
2542 asection
*data_sec
= NULL
;
2543 asection
*bss_sec
= NULL
;
2545 struct internal_filehdr internal_f
;
2546 struct internal_aouthdr internal_a
;
2549 bfd_error
= system_call_error
;
2550 /* Number the output sections, starting from one on the first section
2551 with a name which doesn't start with a *.
2552 @@ The code doesn't make this check. Is it supposed to be done,
2555 for (current
= abfd
->sections
; current
!= (asection
*)NULL
;
2556 current
= current
->next
)
2558 current
->target_index
= count
;
2562 if(abfd
->output_has_begun
== false) {
2563 coff_compute_section_file_positions(abfd
);
2566 if (abfd
->sections
!= (asection
*)NULL
) {
2567 scn_base
= abfd
->sections
->filepos
;
2572 if (bfd_seek(abfd
, scn_base
, SEEK_SET
) != 0)
2574 reloc_base
= obj_relocbase(abfd
);
2576 /* Make a pass through the symbol table to count line number entries and
2577 put them into the correct asections */
2579 #ifndef NO_COFF_LINENOS
2580 coff_count_linenumbers(abfd
);
2582 data_base
= scn_base
;
2584 /* Work out the size of the reloc and linno areas */
2586 for (current
= abfd
->sections
; current
!= NULL
; current
=
2589 /* We give section headers to +ve indexes */
2590 if (current
->target_index
> 0)
2593 reloc_size
+= current
->reloc_count
* RELSZ
;
2594 #ifndef NO_COFF_LINENOS
2595 lnno_size
+= current
->lineno_count
* LINESZ
;
2597 data_base
+= SCNHSZ
;
2602 lineno_base
= reloc_base
+ reloc_size
;
2603 sym_base
= lineno_base
+ lnno_size
;
2605 /* Indicate in each section->line_filepos its actual file address */
2606 for (current
= abfd
->sections
; current
!= NULL
; current
=
2609 if (current
->target_index
> 0)
2612 if (current
->lineno_count
) {
2613 current
->line_filepos
= lineno_base
;
2614 current
->moving_line_filepos
= lineno_base
;
2615 #ifndef NO_COFF_LINENOS
2616 lineno_base
+= current
->lineno_count
* LINESZ
;
2620 current
->line_filepos
= 0;
2622 if (current
->reloc_count
) {
2623 current
->rel_filepos
= reloc_base
;
2624 reloc_base
+= current
->reloc_count
* RELSZ
;
2627 current
->rel_filepos
= 0;
2634 /* Write section headers to the file. */
2635 internal_f
.f_nscns
= 0;
2637 (file_ptr
) ((abfd
->flags
& EXEC_P
) ?
2638 (FILHSZ
+ AOUTSZ
) : FILHSZ
),
2643 unsigned int pad
= abfd
->flags
& D_PAGED
? data_base
: 0;
2645 unsigned int pad
= 0;
2647 for (current
= abfd
->sections
;
2649 current
= current
->next
) {
2650 struct internal_scnhdr section
;
2651 if (current
->target_index
> 0)
2653 internal_f
.f_nscns
++;
2654 strncpy(&(section
.s_name
[0]), current
->name
, 8);
2656 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
2657 Ian Taylor <ian@cygnus.com>. */
2658 if (strcmp (current
->name
, _LIB
) == 0)
2659 section
.s_vaddr
= 0;
2662 section
.s_vaddr
= current
->vma
+ pad
;
2663 section
.s_paddr
= current
->vma
+ pad
;
2664 section
.s_size
= current
->_raw_size
- pad
;
2666 If this section has no size or is unloadable then the scnptr
2669 if (current
->_raw_size
- pad
== 0 ||
2670 (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0) {
2671 section
.s_scnptr
= 0;
2674 section
.s_scnptr
= current
->filepos
;
2676 section
.s_relptr
= current
->rel_filepos
;
2677 section
.s_lnnoptr
= current
->line_filepos
;
2678 section
.s_nreloc
= current
->reloc_count
;
2679 section
.s_nlnno
= current
->lineno_count
;
2680 if (current
->reloc_count
!= 0)
2682 if (current
->lineno_count
!= 0)
2685 section
.s_flags
= sec_to_styp_flags(current
->name
,current
->flags
);
2687 if (!strcmp(current
->name
, _TEXT
)) {
2689 } else if (!strcmp(current
->name
, _DATA
)) {
2691 #ifdef TWO_DATA_SECS
2692 } else if (!strcmp(current
->name
, ".data2")) {
2694 #endif /* TWO_DATA_SECS */
2695 } else if (!strcmp(current
->name
, _BSS
)) {
2700 section
.s_align
= (current
->alignment_power
2701 ? 1 << current
->alignment_power
2708 coff_swap_scnhdr_out(abfd
, §ion
, &buff
);
2709 bfd_write((PTR
) (&buff
), 1, SCNHSZ
, abfd
);
2719 /* OK, now set up the filehdr... */
2721 /* Don't include the internal abs section in the section count */
2724 We will NOT put a fucking timestamp in the header here. Every time you
2725 put it back, I will come in and take it out again. I'm sorry. This
2726 field does not belong here. We fill it with a 0 so it compares the
2727 same but is not a reasonable time. -- gnu@cygnus.com
2729 internal_f
.f_timdat
= 0;
2731 if (bfd_get_symcount(abfd
) != 0)
2732 internal_f
.f_symptr
= sym_base
;
2734 internal_f
.f_symptr
= 0;
2736 internal_f
.f_flags
= 0;
2738 if (abfd
->flags
& EXEC_P
)
2739 internal_f
.f_opthdr
= AOUTSZ
;
2741 internal_f
.f_opthdr
= 0;
2744 internal_f
.f_flags
|= F_RELFLG
;
2746 internal_f
.f_flags
|= F_LNNO
;
2747 if (0 == bfd_get_symcount(abfd
))
2748 internal_f
.f_flags
|= F_LSYMS
;
2749 if (abfd
->flags
& EXEC_P
)
2750 internal_f
.f_flags
|= F_EXEC
;
2752 if (!abfd
->xvec
->byteorder_big_p
)
2753 internal_f
.f_flags
|= F_AR32WR
;
2755 internal_f
.f_flags
|= F_AR32W
;
2758 FIXME, should do something about the other byte orders and
2762 /* Set up architecture-dependent stuff */
2764 { unsigned int magic
= 0;
2765 unsigned short flags
= 0;
2766 coff_set_flags(abfd
, &magic
, &flags
);
2767 internal_f
.f_magic
= magic
;
2768 internal_f
.f_flags
|= flags
;
2769 /* ...and the "opt"hdr... */
2772 # ifdef ULTRA3 /* NYU's machine */
2773 /* FIXME: This is a bogus check. I really want to see if there
2774 * is a .shbss or a .shdata section, if so then set the magic
2775 * number to indicate a shared data executable.
2777 if (internal_f
.f_nscns
>= 7)
2778 internal_a
.magic
= SHMAGIC
; /* Shared magic */
2780 # endif /* ULTRA3 */
2781 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
2782 #define __A_MAGIC_SET__
2785 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
2786 #define __A_MAGIC_SET__
2789 #define __A_MAGIC_SET__
2790 internal_a
.magic
= PAGEMAGICBCS
;
2793 #if M68 || MIPS || WE32K
2794 #define __A_MAGIC_SET__
2795 /* Never was anything here for the 68k */
2796 #endif /* M68 || MIPS || WE32K */
2799 # define __A_MAGIC_SET__
2800 internal_a
.magic
= ZMAGIC
;
2804 #define __A_MAGIC_SET__
2805 internal_a
.magic
= (abfd
->flags
& D_PAGED
)? RS6K_AOUTHDR_ZMAGIC
:
2806 (abfd
->flags
& WP_TEXT
)? RS6K_AOUTHDR_NMAGIC
:
2807 RS6K_AOUTHDR_OMAGIC
;
2810 #ifndef __A_MAGIC_SET__
2811 # include "Your aouthdr magic number is not being set!"
2813 # undef __A_MAGIC_SET__
2816 /* Now should write relocs, strings, syms */
2817 obj_sym_filepos(abfd
) = sym_base
;
2819 #ifndef NO_COFF_SYMBOLS
2820 if (bfd_get_symcount(abfd
) != 0) {
2821 coff_add_missing_symbols (abfd
);
2822 coff_renumber_symbols(abfd
);
2823 coff_mangle_symbols(abfd
);
2824 coff_write_symbols(abfd
);
2825 coff_write_linenumbers(abfd
);
2826 coff_write_relocs(abfd
);
2828 #endif /* NO_COFF_SYMBOLS */
2830 internal_a
.tsize
= bfd_get_section_size_before_reloc(text_sec
);
2831 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
2834 internal_a
.dsize
= bfd_get_section_size_before_reloc(data_sec
);
2835 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
2838 internal_a
.bsize
= bfd_get_section_size_before_reloc(bss_sec
);
2841 internal_a
.entry
= bfd_get_start_address(abfd
);
2842 internal_f
.f_nsyms
= bfd_get_symcount(abfd
);
2844 /* now write them */
2845 if (bfd_seek(abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
2849 coff_swap_filehdr_out(abfd
, (PTR
)&internal_f
, (PTR
)&buff
);
2850 bfd_write((PTR
) &buff
, 1, FILHSZ
, abfd
);
2852 if (abfd
->flags
& EXEC_P
) {
2854 coff_swap_aouthdr_out(abfd
, (PTR
)&internal_a
, (PTR
)&buff
);
2855 bfd_write((PTR
) &buff
, 1, AOUTSZ
, abfd
);
2860 #ifndef NO_COFF_SYMBOLS
2863 this function transforms the offsets into the symbol table into
2864 pointers to syments.
2869 DEFUN(coff_pointerize_aux
,(ignore_abfd
, table_base
, type
, class, auxent
),
2870 bfd
*ignore_abfd AND
2871 combined_entry_type
*table_base AND
2874 combined_entry_type
*auxent
)
2876 /* Don't bother if this is a file or a section */
2877 if (class == C_STAT
&& type
== T_NULL
) return;
2878 if (class == C_FILE
) return;
2880 /* Otherwise patch up */
2881 if (ISFCN(type
) || ISTAG(class) || class == C_BLOCK
) {
2882 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
= table_base
+
2883 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2884 auxent
->fix_end
= 1;
2886 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
!= 0) {
2887 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
=
2888 table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
2889 auxent
->fix_tag
= 1;
2893 #endif /* NO_COFF_SYMBOLS */
2896 DEFUN(coff_set_section_contents
,(abfd
, section
, location
, offset
, count
),
2901 bfd_size_type count
)
2903 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
2904 coff_compute_section_file_positions(abfd
);
2907 /* If this is a .lib section, bump the vma address so that it
2908 winds up being the number of .lib sections output. This is
2909 right for SVR3.2. Shared libraries should probably get more
2910 generic support. Ian Taylor <ian@cygnus.com>. */
2911 if (strcmp (section
->name
, _LIB
) == 0)
2915 bfd_seek(abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
);
2918 return (bfd_write(location
, 1, count
, abfd
) == count
) ? true : false;
2924 coff_close_and_cleanup(abfd
)
2927 if (!bfd_read_p(abfd
))
2928 switch (abfd
->format
) {
2930 if (!_bfd_write_archive_contents(abfd
))
2934 if (!coff_write_object_contents(abfd
))
2938 bfd_error
= invalid_operation
;
2942 /* We depend on bfd_close to free all the memory on the obstack. */
2943 /* FIXME if bfd_release is not using obstacks! */
2949 buy_and_read(abfd
, where
, seek_direction
, size
)
2955 PTR area
= (PTR
) bfd_alloc(abfd
, size
);
2957 bfd_error
= no_memory
;
2960 bfd_seek(abfd
, where
, seek_direction
);
2961 if (bfd_read(area
, 1, size
, abfd
) != size
) {
2962 bfd_error
= system_call_error
;
2966 } /* buy_and_read() */
2969 #ifndef NO_COFF_SYMBOLS
2972 DEFUN(build_string_table
,(abfd
),
2975 char string_table_size_buffer
[4];
2976 unsigned int string_table_size
;
2979 /* At this point we should be "seek"'d to the end of the
2980 symbols === the symbol table size. */
2981 if (bfd_read((char *) string_table_size_buffer
,
2982 sizeof(string_table_size_buffer
),
2983 1, abfd
) != sizeof(string_table_size
)) {
2984 bfd_error
= system_call_error
;
2988 string_table_size
= bfd_h_get_32(abfd
, (bfd_byte
*) string_table_size_buffer
);
2990 if ((string_table
= (PTR
) bfd_alloc(abfd
, string_table_size
-= 4)) == NULL
) {
2991 bfd_error
= no_memory
;
2993 } /* on mallocation error */
2994 if (bfd_read(string_table
, string_table_size
, 1, abfd
) != string_table_size
) {
2995 bfd_error
= system_call_error
;
2998 return string_table
;
3001 /* Allocate space for the ".debug" section, and read it.
3002 We did not read the debug section until now, because
3003 we didn't want to go to the trouble until someone needed it. */
3006 DEFUN(build_debug_section
,(abfd
),
3009 char *debug_section
;
3012 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
3015 bfd_error
= no_debug_section
;
3019 debug_section
= (PTR
) bfd_alloc (abfd
,
3020 bfd_get_section_size_before_reloc (sect
));
3021 if (debug_section
== NULL
) {
3022 bfd_error
= no_memory
;
3026 /* Seek to the beginning of the `.debug' section and read it.
3027 Save the current position first; it is needed by our caller.
3028 Then read debug section and reset the file pointer. */
3030 position
= bfd_tell (abfd
);
3031 bfd_seek (abfd
, sect
->filepos
, SEEK_SET
);
3032 if (bfd_read (debug_section
,
3033 bfd_get_section_size_before_reloc (sect
), 1, abfd
)
3034 != bfd_get_section_size_before_reloc(sect
)) {
3035 bfd_error
= system_call_error
;
3038 bfd_seek (abfd
, position
, SEEK_SET
);
3039 return debug_section
;
3043 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
3044 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
3045 be \0-terminated. */
3047 DEFUN(copy_name
,(abfd
, name
, maxlen
),
3055 for (len
= 0; len
< maxlen
; ++len
) {
3056 if (name
[len
] == '\0') {
3061 if ((newname
= (PTR
) bfd_alloc(abfd
, len
+1)) == NULL
) {
3062 bfd_error
= no_memory
;
3065 strncpy(newname
, name
, len
);
3066 newname
[len
] = '\0';
3071 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
3072 knit the symbol names into a normalized form. By normalized here I
3073 mean that all symbols have an n_offset pointer that points to a null-
3074 terminated string. */
3076 #ifndef SYMNAME_IN_DEBUG
3077 #define SYMNAME_IN_DEBUG(x) 0
3080 static combined_entry_type
*
3081 DEFUN(get_normalized_symtab
,(abfd
),
3084 combined_entry_type
*internal
;
3085 combined_entry_type
*internal_ptr
;
3086 combined_entry_type
*symbol_ptr
;
3087 combined_entry_type
*internal_end
;
3091 char *string_table
= NULL
;
3092 char *debug_section
= NULL
;
3095 unsigned int raw_size
;
3096 if (obj_raw_syments(abfd
) != (combined_entry_type
*)NULL
) {
3097 return obj_raw_syments(abfd
);
3099 if ((size
= bfd_get_symcount(abfd
) * sizeof(combined_entry_type
)) == 0) {
3100 bfd_error
= no_symbols
;
3104 internal
= (combined_entry_type
*)bfd_alloc(abfd
, size
);
3105 internal_end
= internal
+ bfd_get_symcount(abfd
);
3107 raw_size
= bfd_get_symcount(abfd
) * SYMESZ
;
3108 raw
= (SYMENT
*)bfd_alloc(abfd
,raw_size
);
3110 if (bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
) == -1
3111 || bfd_read((PTR
)raw
, raw_size
, 1, abfd
) != raw_size
) {
3112 bfd_error
= system_call_error
;
3115 /* mark the end of the symbols */
3116 raw_end
= raw
+ bfd_get_symcount(abfd
);
3118 FIXME SOMEDAY. A string table size of zero is very weird, but
3119 probably possible. If one shows up, it will probably kill us.
3122 /* Swap all the raw entries */
3123 for (raw_src
= raw
, internal_ptr
= internal
;
3125 raw_src
++, internal_ptr
++) {
3128 coff_swap_sym_in(abfd
, (PTR
)raw_src
, (PTR
)&internal_ptr
->u
.syment
);
3129 internal_ptr
->fix_tag
= 0;
3130 internal_ptr
->fix_end
= 0;
3131 symbol_ptr
= internal_ptr
;
3134 i
< symbol_ptr
->u
.syment
.n_numaux
;
3140 internal_ptr
->fix_tag
= 0;
3141 internal_ptr
->fix_end
= 0;
3142 coff_swap_aux_in(abfd
, (char *)(raw_src
),
3143 symbol_ptr
->u
.syment
.n_type
,
3144 symbol_ptr
->u
.syment
.n_sclass
,
3145 &(internal_ptr
->u
.auxent
));
3146 /* Remember that bal entries arn't pointerized */
3147 if (i
!= 1 || symbol_ptr
->u
.syment
.n_sclass
!= C_LEAFPROC
)
3150 coff_pointerize_aux(abfd
,
3152 symbol_ptr
->u
.syment
.n_type
,
3153 symbol_ptr
->u
.syment
.n_sclass
,
3160 /* Free all the raw stuff */
3161 bfd_release(abfd
, raw
);
3163 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
3166 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
) {
3167 /* make a file symbol point to the name in the auxent, since
3168 the text ".file" is redundant */
3169 if ((internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_zeroes
== 0) {
3170 /* the filename is a long one, point into the string table */
3171 if (string_table
== NULL
) {
3172 string_table
= build_string_table(abfd
);
3175 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
3176 (int) (string_table
- 4 +
3177 (internal_ptr
+1)->u
.auxent
.x_file
.x_n
.x_offset
);
3180 /* ordinary short filename, put into memory anyway */
3181 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
3182 copy_name(abfd
, (internal_ptr
+1)->u
.auxent
.x_file
.x_fname
,
3187 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0) {
3188 /* This is a "short" name. Make it long. */
3189 unsigned long i
= 0;
3190 char *newstring
= NULL
;
3192 /* find the length of this string without walking into memory
3194 for (i
= 0; i
< 8; ++i
) {
3195 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0') {
3197 } /* if end of string */
3198 } /* possible lengths of this string. */
3200 if ((newstring
= (PTR
) bfd_alloc(abfd
, ++i
)) == NULL
) {
3201 bfd_error
= no_memory
;
3204 memset(newstring
, 0, i
);
3205 strncpy(newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
-1);
3206 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int) newstring
;
3207 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
3209 else if (!SYMNAME_IN_DEBUG(&internal_ptr
->u
.syment
)) {
3210 /* Long name already. Point symbol at the string in the table. */
3211 if (string_table
== NULL
) {
3212 string_table
= build_string_table(abfd
);
3214 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
3215 (string_table
- 4 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
3218 /* Long name in debug section. Very similar. */
3219 if (debug_section
== NULL
) {
3220 debug_section
= build_debug_section(abfd
);
3222 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (int)
3223 (debug_section
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
3226 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
3229 obj_raw_syments(abfd
) = internal
;
3232 } /* get_normalized_symtab() */
3234 #endif /* NO_COFF_SYMBOLS */
3238 DEFUN(section_from_bfd_index
,(abfd
, index
),
3242 struct sec
*answer
= abfd
->sections
;
3246 return &bfd_abs_section
;
3248 if (index
== N_UNDEF
)
3250 return &bfd_und_section
;
3252 if(index
== N_DEBUG
)
3254 return &bfd_debug_section
;
3259 if (answer
->target_index
== index
)
3261 answer
= answer
->next
;
3264 return &bfd_und_section
; /* For gcc -W and lint. Never executed. */
3267 #ifndef NO_COFF_LINENOS
3273 Creating the linenumber table is done by reading in the entire
3274 coff linenumber table, and creating another table for internal use.
3276 A coff line number table is structured so that each function
3277 is marked as having a line number of 0. Each line within the
3278 function is an offset from the first line in the function. The
3279 base of the line number information for the table is stored in
3280 the symbol associated with the function.
3282 The information is copied from the external to the internal
3283 table, and each symbol which marks a function is marked by
3286 How does this work ?
3291 coff_slurp_line_table(abfd
, asect
)
3295 LINENO
*native_lineno
;
3296 alent
*lineno_cache
;
3298 BFD_ASSERT(asect
->lineno
== (alent
*) NULL
);
3300 native_lineno
= (LINENO
*) buy_and_read(abfd
,
3301 asect
->line_filepos
,
3304 asect
->lineno_count
));
3306 (alent
*) bfd_alloc(abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof(alent
)));
3307 if (lineno_cache
== NULL
) {
3308 bfd_error
= no_memory
;
3311 unsigned int counter
= 0;
3312 alent
*cache_ptr
= lineno_cache
;
3313 LINENO
*src
= native_lineno
;
3315 while (counter
< asect
->lineno_count
) {
3316 struct internal_lineno dst
;
3317 coff_swap_lineno_in(abfd
, src
, &dst
);
3318 cache_ptr
->line_number
= dst
.l_lnno
;
3320 if (cache_ptr
->line_number
== 0) {
3321 coff_symbol_type
*sym
=
3322 (coff_symbol_type
*) (dst
.l_addr
.l_symndx
3323 + obj_raw_syments(abfd
))->u
.syment
._n
._n_n
._n_zeroes
;
3324 cache_ptr
->u
.sym
= (asymbol
*) sym
;
3325 sym
->lineno
= cache_ptr
;
3328 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
3329 - bfd_section_vma(abfd
, asect
);
3330 } /* If no linenumber expect a symbol index */
3336 cache_ptr
->line_number
= 0;
3339 asect
->lineno
= lineno_cache
;
3340 /* FIXME, free native_lineno here, or use alloca or something. */
3342 } /* coff_slurp_line_table() */
3344 #endif /* NO_COFF_LINENOS */
3346 #ifndef NO_COFF_LINENOS
3349 DEFUN(coff_slurp_symbol_table
,(abfd
),
3352 combined_entry_type
*native_symbols
;
3353 coff_symbol_type
*cached_area
;
3354 unsigned int *table_ptr
;
3356 unsigned int number_of_symbols
= 0;
3357 if (obj_symbols(abfd
))
3359 bfd_seek(abfd
, obj_sym_filepos(abfd
), SEEK_SET
);
3361 /* Read in the symbol table */
3362 if ((native_symbols
= get_normalized_symtab(abfd
)) == NULL
) {
3366 /* Allocate enough room for all the symbols in cached form */
3368 (coff_symbol_type
*)
3369 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(coff_symbol_type
)));
3371 if (cached_area
== NULL
) {
3372 bfd_error
= no_memory
;
3377 bfd_alloc(abfd
, (size_t) (bfd_get_symcount(abfd
) * sizeof(unsigned int)));
3379 if (table_ptr
== NULL
) {
3380 bfd_error
= no_memory
;
3385 coff_symbol_type
*dst
= cached_area
;
3386 unsigned int last_native_index
= bfd_get_symcount(abfd
);
3387 unsigned int this_index
= 0;
3388 while (this_index
< last_native_index
) {
3389 combined_entry_type
*src
= native_symbols
+ this_index
;
3390 table_ptr
[this_index
] = number_of_symbols
;
3391 dst
->symbol
.the_bfd
= abfd
;
3393 dst
->symbol
.name
= (char *)(src
->u
.syment
._n
._n_n
._n_offset
);
3395 We use the native name field to point to the cached field
3397 src
->u
.syment
._n
._n_n
._n_zeroes
= (int) dst
;
3398 dst
->symbol
.section
= section_from_bfd_index(abfd
,
3399 src
->u
.syment
.n_scnum
);
3400 dst
->symbol
.flags
= 0;
3401 dst
->done_lineno
= false;
3403 switch (src
->u
.syment
.n_sclass
) {
3407 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
3408 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
3409 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
3411 /* Fall through to next case */
3419 if ((src
->u
.syment
.n_scnum
) == 0) {
3420 if ((src
->u
.syment
.n_value
) == 0) {
3421 dst
->symbol
.section
= &bfd_und_section
;
3422 dst
->symbol
.value
= 0;
3425 dst
->symbol
.section
= &bfd_com_section
;
3426 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3431 Base the value as an index from the base of the
3435 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
3436 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
3438 if (ISFCN((src
->u
.syment
.n_type
))) {
3440 A function ext does not go at the end of a file
3442 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
3449 case C_STAT
: /* static */
3451 case C_LEAFSTAT
: /* static leaf procedure */
3453 case C_LABEL
: /* label */
3454 if (src
->u
.syment
.n_scnum
== -2)
3455 dst
->symbol
.flags
= BSF_DEBUGGING
;
3457 dst
->symbol
.flags
= BSF_LOCAL
;
3459 Base the value as an index from the base of the section, if
3462 if (dst
->symbol
.section
)
3463 dst
->symbol
.value
= (src
->u
.syment
.n_value
) -
3464 dst
->symbol
.section
->vma
;
3466 dst
->symbol
.value
= (src
->u
.syment
.n_value
) ;
3469 case C_MOS
: /* member of structure */
3470 case C_EOS
: /* end of structure */
3471 #ifdef NOTDEF /* C_AUTOARG has the same value */
3473 case C_GLBLREG
: /* A29k-specific storage class */
3476 case C_REGPARM
: /* register parameter */
3477 case C_REG
: /* register variable */
3479 case C_AUTOARG
: /* 960-specific storage class */
3481 case C_TPDEF
: /* type definition */
3483 case C_AUTO
: /* automatic variable */
3484 case C_FIELD
: /* bit field */
3485 case C_ENTAG
: /* enumeration tag */
3486 case C_MOE
: /* member of enumeration */
3487 case C_MOU
: /* member of union */
3488 case C_UNTAG
: /* union tag */
3489 dst
->symbol
.flags
= BSF_DEBUGGING
;
3490 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3493 case C_FILE
: /* file name */
3494 case C_STRTAG
: /* structure tag */
3496 case C_BINCL
: /* beginning of include file */
3497 case C_EINCL
: /* ending of include file */
3510 dst
->symbol
.flags
= BSF_DEBUGGING
;
3511 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3514 case C_BLOCK
: /* ".bb" or ".eb" */
3515 case C_FCN
: /* ".bf" or ".ef" */
3516 case C_EFCN
: /* physical end of function */
3517 dst
->symbol
.flags
= BSF_LOCAL
;
3519 Base the value as an index from the base of the section
3521 dst
->symbol
.value
= (src
->u
.syment
.n_value
) - dst
->symbol
.section
->vma
;
3525 case C_EXTDEF
: /* external definition */
3526 case C_ULABEL
: /* undefined label */
3527 case C_USTATIC
: /* undefined static */
3528 case C_LINE
: /* line # reformatted as symbol table entry */
3529 case C_ALIAS
: /* duplicate tag */
3530 case C_HIDDEN
: /* ext symbol in dmert public lib */
3533 fprintf(stderr
,"Unrecognized storage class %d\n",
3534 src
->u
.syment
.n_sclass
);
3536 dst
->symbol
.flags
= BSF_DEBUGGING
;
3537 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
3541 /* BFD_ASSERT(dst->symbol.flags != 0);*/
3545 dst
->symbol
.udata
= 0;
3546 dst
->lineno
= (alent
*) NULL
;
3547 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
3549 number_of_symbols
++;
3550 } /* walk the native symtab */
3551 } /* bfdize the native symtab */
3553 obj_symbols(abfd
) = cached_area
;
3554 obj_raw_syments(abfd
) = native_symbols
;
3556 obj_conv_table_size (abfd
) = bfd_get_symcount (abfd
);
3557 bfd_get_symcount(abfd
) = number_of_symbols
;
3558 obj_convert(abfd
) = table_ptr
;
3559 /* Slurp the line tables for each section too */
3564 coff_slurp_line_table(abfd
, p
);
3569 } /* coff_slurp_symbol_table() */
3572 coff_get_symtab_upper_bound(abfd
)
3575 if (!coff_slurp_symbol_table(abfd
))
3578 return (bfd_get_symcount(abfd
) + 1) * (sizeof(coff_symbol_type
*));
3583 DEFUN(coff_get_symtab
, (abfd
, alocation
),
3585 asymbol
**alocation
)
3587 unsigned int counter
= 0;
3588 coff_symbol_type
*symbase
;
3589 coff_symbol_type
**location
= (coff_symbol_type
**) (alocation
);
3590 if (!coff_slurp_symbol_table(abfd
))
3593 symbase
= obj_symbols(abfd
);
3594 while (counter
< bfd_get_symcount(abfd
))
3596 /* This nasty code looks at the symbol to decide whether or
3597 not it is descibes a constructor/destructor entry point. It
3598 is structured this way to (hopefully) speed non matches */
3600 if (0 && symbase
->symbol
.name
[9] == '$')
3602 bfd_constructor_entry(abfd
,
3603 (asymbol
**)location
,
3604 symbase
->symbol
.name
[10] == 'I' ?
3608 *(location
++) = symbase
++;
3612 return bfd_get_symcount(abfd
);
3615 #endif /* NO_COFF_SYMBOLS */
3618 coff_get_reloc_upper_bound(abfd
, asect
)
3622 if (bfd_get_format(abfd
) != bfd_object
) {
3623 bfd_error
= invalid_operation
;
3626 return (asect
->reloc_count
+ 1) * sizeof(arelent
*);
3633 Coff relocations are easily transformed into the internal BFD form
3636 Reading a coff relocation table is done in the following stages:
3638 o The entire coff relocation table is read into memory.
3640 o Each relocation is processed in turn, first it is swapped from the
3641 external to the internal form.
3643 o The symbol referenced in the relocation's symbol index is
3644 turned intoa pointer into the canonical symbol table. Note
3645 that this table is the same as the one returned by a call to
3646 @code{bfd_canonicalize_symtab}. The back end will call the
3647 routine and save the result if a canonicalization hasn't been done.
3649 o The reloc index is turned into a pointer to a howto
3650 structure, in a back end specific way. For instance, the 386
3651 and 960 use the @code{r_type} to directly produce an index
3652 into a howto table vector; the 88k subtracts a number from the
3653 @code{r_type} field and creates an addend field.
3659 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
3660 if (ptr && ptr->the_bfd == abfd \
3661 && ((ptr->flags & BSF_OLD_COMMON)== 0)) \
3663 cache_ptr->addend = -(ptr->section->vma + ptr->value); \
3666 cache_ptr->addend = 0; \
3671 DEFUN(coff_slurp_reloc_table
,(abfd
, asect
, symbols
),
3676 RELOC
*native_relocs
;
3677 arelent
*reloc_cache
;
3682 if (asect
->relocation
)
3684 if (asect
->reloc_count
== 0)
3686 if (asect
->flags
& SEC_CONSTRUCTOR
)
3688 #ifndef NO_COFF_SYMBOLS
3689 if (!coff_slurp_symbol_table(abfd
))
3693 (RELOC
*) buy_and_read(abfd
,
3697 asect
->reloc_count
));
3698 reloc_cache
= (arelent
*)
3699 bfd_alloc(abfd
, (size_t) (asect
->reloc_count
* sizeof(arelent
)));
3701 if (reloc_cache
== NULL
) {
3702 bfd_error
= no_memory
;
3707 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
3709 #ifdef RELOC_PROCESSING
3710 struct internal_reloc dst
;
3711 struct external_reloc
*src
;
3713 cache_ptr
= reloc_cache
+ idx
;
3714 src
= native_relocs
+ idx
;
3715 bfd_swap_reloc_in(abfd
, src
, &dst
);
3717 RELOC_PROCESSING(cache_ptr
, &dst
, symbols
, abfd
, asect
);
3719 struct internal_reloc dst
;
3721 struct external_reloc
*src
;
3723 cache_ptr
= reloc_cache
+ idx
;
3724 src
= native_relocs
+ idx
;
3726 bfd_swap_reloc_in(abfd
, src
, &dst
);
3729 cache_ptr
->address
= dst
.r_vaddr
;
3731 if (dst
.r_symndx
!= -1)
3733 /* @@ Should never be greater than count of symbols! */
3734 if (dst
.r_symndx
>= obj_conv_table_size (abfd
))
3736 cache_ptr
->sym_ptr_ptr
= symbols
+ obj_convert(abfd
)[dst
.r_symndx
];
3737 ptr
= *(cache_ptr
->sym_ptr_ptr
);
3741 cache_ptr
->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
3746 The symbols definitions that we have read in have been
3747 relocated as if their sections started at 0. But the offsets
3748 refering to the symbols in the raw data have not been
3749 modified, so we have to have a negative addend to compensate.
3751 Note that symbols which used to be common must be left alone */
3753 /* Calculate any reloc addend by looking at the symbol */
3754 CALC_ADDEND(abfd
, ptr
, dst
, cache_ptr
);
3756 cache_ptr
->address
-= asect
->vma
;
3757 /* !! cache_ptr->section = (asection *) NULL;*/
3759 /* Fill in the cache_ptr->howto field from dst.r_type */
3760 RTYPE2HOWTO(cache_ptr
, &dst
);
3765 asect
->relocation
= reloc_cache
;
3770 /* This is stupid. This function should be a boolean predicate */
3772 DEFUN(coff_canonicalize_reloc
, (abfd
, section
, relptr
, symbols
),
3775 arelent
**relptr AND
3778 arelent
*tblptr
= section
->relocation
;
3779 unsigned int count
= 0;
3782 if (section
->flags
& SEC_CONSTRUCTOR
)
3784 /* this section has relocs made up by us, they are not in the
3785 file, so take them out of their chain and place them into
3786 the data area provided */
3787 arelent_chain
*chain
= section
->constructor_chain
;
3788 for (count
= 0; count
< section
->reloc_count
; count
++)
3790 *relptr
++ = &chain
->relent
;
3791 chain
= chain
->next
;
3797 coff_slurp_reloc_table(abfd
, section
, symbols
);
3800 tblptr
= section
->relocation
;
3804 for (; count
++ < section
->reloc_count
;)
3805 *relptr
++ = tblptr
++;
3810 return section
->reloc_count
;
3813 #ifndef NO_COFF_SYMBOLS
3816 provided a BFD, a section and an offset into the section, calculate and
3817 return the name of the source file and the line nearest to the wanted
3822 DEFUN(coff_find_nearest_line
,(abfd
,
3830 asection
*section AND
3831 asymbol
**ignore_symbols AND
3833 CONST
char **filename_ptr AND
3834 CONST
char **functionname_ptr AND
3835 unsigned int *line_ptr
)
3837 static bfd
*cache_abfd
;
3838 static asection
*cache_section
;
3839 static bfd_vma cache_offset
;
3840 static unsigned int cache_i
;
3841 static alent
*cache_l
;
3844 coff_data_type
*cof
= coff_data(abfd
);
3845 /* Run through the raw syments if available */
3846 combined_entry_type
*p
;
3848 unsigned int line_base
= 0;
3852 *functionname_ptr
= 0;
3855 /* Don't try and find line numbers in a non coff file */
3856 if (abfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
3862 p
= cof
->raw_syments
;
3864 for (i
= 0; i
< cof
->raw_syment_count
; i
++) {
3865 if (p
->u
.syment
.n_sclass
== C_FILE
) {
3866 /* File name has been moved into symbol */
3867 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
3870 p
+= 1 + p
->u
.syment
.n_numaux
;
3872 /* Now wander though the raw linenumbers of the section */
3874 If this is the same BFD as we were previously called with and this is
3875 the same section, and the offset we want is further down then we can
3876 prime the lookup loop
3878 if (abfd
== cache_abfd
&&
3879 section
== cache_section
&&
3880 offset
>= cache_offset
) {
3886 l
= section
->lineno
;
3889 for (; i
< section
->lineno_count
; i
++) {
3890 if (l
->line_number
== 0) {
3891 /* Get the symbol this line number points at */
3892 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
3893 *functionname_ptr
= coff
->symbol
.name
;
3895 combined_entry_type
*s
= coff
->native
;
3896 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
3898 S should now point to the .bf of the function
3900 if (s
->u
.syment
.n_numaux
) {
3902 The linenumber is stored in the auxent
3904 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
3905 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
3910 if (l
->u
.offset
> offset
)
3912 *line_ptr
= l
->line_number
+ line_base
+ 1;
3918 cache_section
= section
;
3919 cache_offset
= offset
;
3928 coff_sym_filepos(abfd
)
3931 return obj_sym_filepos(abfd
);
3935 #endif /* NO_COFF_SYMBOLS */
3939 DEFUN(coff_sizeof_headers
,(abfd
, reloc
),
3945 if (reloc
== false) {
3946 size
= FILHSZ
+ AOUTSZ
;
3952 size
+= abfd
->section_count
* SCNHSZ
;
3957 DEFUN(get_value
,(reloc
, seclet
),
3959 bfd_seclet_type
*seclet
)
3962 asymbol
*symbol
= *(reloc
->sym_ptr_ptr
);
3963 /* A symbol holds a pointer to a section, and an offset from the
3964 base of the section. To relocate, we find where the section will
3965 live in the output and add that in */
3967 if (symbol
->section
== &bfd_und_section
)
3969 /* Ouch, this is an undefined symbol.. */
3970 bfd_error_vector
.undefined_symbol(reloc
, seclet
);
3971 value
= symbol
->value
;
3975 value
= symbol
->value
+
3976 symbol
->section
->output_offset
+
3977 symbol
->section
->output_section
->vma
;
3981 /* Add the value contained in the relocation */
3982 value
+= reloc
->addend
;
3988 DEFUN(perform_slip
,(s
, slip
, input_section
, value
),
3990 unsigned int slip AND
3991 asection
*input_section AND
3995 /* Find all symbols past this point, and make them know
4000 if (p
->section
== input_section
)
4002 /* This was pointing into this section, so mangle it */
4003 if (p
->value
> value
)
4013 DEFUN(movb1
,(input_section
, symbols
, r
, shrink
),
4014 asection
*input_section AND
4015 asymbol
**symbols AND
4017 unsigned int shrink
)
4019 bfd_vma value
= get_value(r
,0);
4021 if (value
>= 0xff00)
4024 /* Change the reloc type from 16bit, possible 8 to 8bit
4026 r
->howto
= r
->howto
+ 1;
4027 /* The place to relc moves back by one */
4030 /* This will be two bytes smaller in the long run */
4032 perform_slip(symbols
, 2, input_section
, r
->address
- shrink
+1);
4040 DEFUN(jmp1
,(input_section
, symbols
, r
, shrink
),
4041 asection
*input_section AND
4042 asymbol
**symbols AND
4044 unsigned int shrink
)
4048 bfd_vma value
= get_value(r
, 0);
4050 bfd_vma dot
= input_section
->output_section
->vma
+
4051 input_section
->output_offset
+ r
->address
;
4054 /* See if the address we're looking at within 127 bytes of where
4055 we are, if so then we can use a small branch rather than the
4056 jump we were going to */
4058 gap
= value
- (dot
- shrink
);
4061 if (-120 < (long)gap
&& (long)gap
< 120 )
4064 /* Change the reloc type from 16bit, possible 8 to 8bit
4066 r
->howto
= r
->howto
+ 1;
4067 /* The place to relc moves back by one */
4070 /* This will be two bytes smaller in the long run */
4072 perform_slip(symbols
, 2, input_section
, r
->address
-shrink
+1);
4080 DEFUN(bfd_coff_relax_section
,(abfd
, i
, symbols
),
4086 /* Get enough memory to hold the stuff */
4087 bfd
*input_bfd
= i
->owner
;
4088 asection
*input_section
= i
;
4090 boolean
new = false;
4092 bfd_size_type reloc_size
= bfd_get_reloc_upper_bound(input_bfd
,
4094 arelent
**reloc_vector
= (arelent
**)bfd_xmalloc(reloc_size
);
4096 /* Get the relocs and think about them */
4097 if (bfd_canonicalize_reloc(input_bfd
,
4103 for (parent
= reloc_vector
; *parent
; parent
++)
4105 arelent
*r
= *parent
;
4106 switch (r
->howto
->type
) {
4114 shrink
= movb1(input_section
, symbols
, r
, shrink
);
4119 shrink
= jmp1(input_section
, symbols
, r
, shrink
);
4127 input_section
->_cooked_size
-= shrink
;
4128 free((char *)reloc_vector
);
4133 DEFUN(bfd_coff_get_relocated_section_contents
,(in_abfd
, seclet
, data
),
4135 bfd_seclet_type
*seclet AND
4139 /* Get enough memory to hold the stuff */
4140 bfd
*input_bfd
= seclet
->u
.indirect
.section
->owner
;
4141 asection
*input_section
= seclet
->u
.indirect
.section
;
4142 bfd_size_type reloc_size
= bfd_get_reloc_upper_bound(input_bfd
,
4144 arelent
**reloc_vector
= (arelent
**)bfd_xmalloc(reloc_size
);
4146 /* read in the section */
4147 bfd_get_section_contents(input_bfd
,
4151 input_section
->_raw_size
);
4154 if (bfd_canonicalize_reloc(input_bfd
,
4157 seclet
->u
.indirect
.symbols
) )
4159 arelent
**parent
= reloc_vector
;
4164 unsigned int dst_address
= 0;
4165 unsigned int src_address
= 0;
4169 /* Find how long a run we can do */
4170 while (dst_address
< seclet
->size
)
4176 /* Note that the relaxing didn't tie up the addresses in the
4177 relocation, so we use the original address to work out the
4178 run of non-relocated data */
4179 run
= reloc
->address
- src_address
;
4185 run
= seclet
->size
- dst_address
;
4187 /* Copy the bytes */
4188 for (idx
= 0; idx
< run
; idx
++)
4190 data
[dst_address
++] = data
[src_address
++];
4193 /* Now do the relocation */
4197 switch (reloc
->howto
->type
)
4200 /* Speciial relaxed type */
4202 bfd_vma dot
= seclet
->offset
+ dst_address
+ seclet
->u
.indirect
.section
->output_section
->vma
;
4203 int gap
= get_value(reloc
,seclet
)-dot
-1;
4204 if ((gap
& ~0xff ) != 0 &&((gap
& 0xff00)!= 0xff00)) abort();
4206 bfd_put_8(in_abfd
,gap
, data
+dst_address
);
4208 switch (data
[dst_address
-1])
4213 bfd_put_8(in_abfd
, 0x55, data
+dst_address
-1);
4217 bfd_put_8(in_abfd
, 0x40, data
+dst_address
-1);
4236 /* Special relaxed type, there will be a gap between where we
4237 get stuff from and where we put stuff to now
4239 for a mov.b @aa:16 -> mov.b @aa:8
4240 opcode 0x6a 0x0y offset
4243 if (data
[dst_address
-1] != 0x6a)
4245 switch (data
[src_address
] & 0xf0)
4249 data
[dst_address
-1] = (data
[src_address
] & 0xf) | 0x20;
4253 data
[dst_address
-1] = (data
[src_address
] & 0xf) | 0x30;
4259 /* the offset must fit ! after all, what was all the relaxing
4262 bfd_put_8(in_abfd
, get_value(reloc
, seclet
), data
+ dst_address
);
4264 /* Note the magic - src goes up by two bytes, but dst by only
4273 bfd_vma dot
= seclet
->offset
+ dst_address
+ seclet
->u
.indirect
.section
->output_section
->vma
;
4274 int gap
= get_value(reloc
,seclet
)-dot
;
4275 if (gap
> 127 || gap
< -128)
4277 bfd_error_vector
.reloc_value_truncated(reloc
, seclet
);
4280 bfd_put_8(in_abfd
,gap
, data
+dst_address
);
4289 unsigned int gap
=get_value(reloc
,seclet
);
4290 if (gap
> 0xff && gap
< ~0xff)
4292 bfd_error_vector
.reloc_value_truncated(reloc
, seclet
);
4295 bfd_put_8(in_abfd
, gap
, data
+dst_address
);
4303 /* A relword which would have like to have been a pcrel */
4305 /* A relword which would like to have been modified but
4308 bfd_put_16(in_abfd
, get_value(reloc
,seclet
), data
+dst_address
);
4323 free((char *)reloc_vector
);
4328 #if !defined (NO_COFF_SYMBOLS) && !defined (NO_COFF_LINENOS)
4329 bfd_coff_backend_data bfd_coff_std_swap_table
= {
4330 coff_swap_aux_in
, coff_swap_sym_in
, coff_swap_lineno_in
,
4331 coff_swap_aux_out
, coff_swap_sym_out
,
4332 coff_swap_lineno_out
, coff_swap_reloc_out
,
4333 coff_swap_filehdr_out
, coff_swap_aouthdr_out
,
4334 coff_swap_scnhdr_out
,
4338 #define coff_core_file_failing_command _bfd_dummy_core_file_failing_command
4339 #define coff_core_file_failing_signal _bfd_dummy_core_file_failing_signal
4340 #define coff_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
4341 #define coff_slurp_armap bfd_slurp_coff_armap
4342 #define coff_slurp_extended_name_table _bfd_slurp_extended_name_table
4343 #define coff_truncate_arname bfd_dont_truncate_arname
4344 #define coff_openr_next_archived_file bfd_generic_openr_next_archived_file
4345 #define coff_generic_stat_arch_elt bfd_generic_stat_arch_elt
4346 #define coff_get_section_contents bfd_generic_get_section_contents
4347 #define coff_close_and_cleanup bfd_generic_close_and_cleanup
4349 #define coff_bfd_debug_info_start bfd_void
4350 #define coff_bfd_debug_info_end bfd_void
4351 #define coff_bfd_debug_info_accumulate \
4352 (void (*) PARAMS ((bfd *, struct sec *))) bfd_void
4353 #define coff_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
4354 #define coff_bfd_relax_section bfd_generic_relax_section