projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
One more try...
[deliverable/binutils-gdb.git] / bfd / coffcode.h
CommitLineData
6d7c88c3 1/* Support for the generic parts of most COFF variants, for BFD.
7a8b18b6
SC		 2 Copyright (C) 1990-1991 Free Software Foundation, Inc.
3 Written by Cygnus Support.
0f268757 4
7a8b18b6 5This file is part of BFD, the Binary File Descriptor library.
0f268757 6
7a8b18b6
SC		 7This program is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2 of the License, or
10(at your option) any later version.
0f268757 11
7a8b18b6
SC		 12This program is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
0f268757 16
7a8b18b6
SC		 17You should have received a copy of the GNU General Public License
18along with this program; if not, write to the Free Software
19Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
6f715d66 20
6590a8c9
SC		 21/*
22Most of this hacked by Steve Chamberlain,
23 sac@cygnus.com
24*/
9fda1a39 25/*
6f715d66 26
9fda1a39
SC		 27SECTION
28 coff backends
29
9fda1a39
SC		 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
33 extra field.
34
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}.
47
48
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}.
53
54SUBSECTION
55 Porting To A New Version of Coff
56
9fda1a39
SC		 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.
69
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.
78
79SUBSECTION
80 How The Coff Backend Works
81
82SUBSUBSECTION
83 Bit Twiddling
84
9fda1a39
SC		 85 Each flavour of coff supported in BFD has its own header file
86 descibing the external layout of the structures. There is also
87 an internal description of the coff layout (in
88 @code{internalcoff.h}) file (@code{}). A major function of the
89 coff backend is swapping the bytes and twiddling the bits to
90 translate the external form of the structures into the normal
91 internal form. This is all performed in the
92 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
93 elements are different sizes between different versions of
94 coff, it is the duty of the coff version specific include file
95 to override the definitions of various packing routines in
96 @code{coffcode.h}. Eg the size of line number entry in coff is
97 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
98 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
99 correct one. No doubt, some day someone will find a version of
100 coff which has a varying field size not catered for at the
101 moment. To port BFD, that person will have to add more @code{#defines}.
102 Three of the bit twiddling routines are exported to
103 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
104 and @code{coff_swap_linno_in}. @code{GDB} reads the symbol
105 table on its own, but uses BFD to fix things up. More of the
106 bit twiddlers are exported for @code{gas};
107 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
108 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
109 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
110 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
111 of all the symbol table and reloc drudgery itself, thereby
112 saving the internal BFD overhead, but uses BFD to swap things
113 on the way out, making cross ports much safer. This also
114 allows BFD (and thus the linker) to use the same header files
115 as @code{gas}, which makes one avenue to disaster disappear.
116
117SUBSUBSECTION
118 Symbol Reading
119
9fda1a39
SC		 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".
124
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
616ebcfd 137 (<<C_FILE>> symbols) are modified so that the internal
9fda1a39
SC		 138 string points to the value in the auxent (the real filename)
139 rather than the normal text associated with the symbol
140 (@code{".file"}).
141
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.
147
148
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.
155
156 Any linenumbers are read from the coff file too, and attached
157 to the symbols which own the functions the linenumbers belong to.
158
159SUBSUBSECTION
160 Symbol Writing
161
9fda1a39
SC		 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.
167
168 When the symbols have come from a coff file then all the
169 debugging information is preserved.
170
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.
175
9fda1a39
SC		 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.
181
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}.
192
193 o coff_mangle_symbols
616ebcfd 194
9fda1a39
SC		 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
200 being referenced.
201
202 o coff_write_symbols
616ebcfd 203
9fda1a39
SC		 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.
6f715d66 207
9fda1a39 208*/
6f715d66 209
9fda1a39 210/*
616ebcfd
SC		 211INTERNAL_DEFINITION
212 coff_symbol_type
6f715d66 213
616ebcfd 214DESCRIPTION
9fda1a39
SC		 215 The hidden information for an asymbol is described in a
216 coff_ptr_struct, which is typedefed to a combined_entry_type
6f715d66 217
616ebcfd 218CODE_FRAGMENT
e98e6ec1 219.
616ebcfd
SC		 220.typedef struct coff_ptr_struct
221.{
222.
223. {* Remembers the offset from the first symbol in the file for
224. this symbol. Generated by coff_renumber_symbols. *}
225.unsigned int offset;
226.
227. {* Should the tag field of this symbol be renumbered.
228. Created by coff_pointerize_aux. *}
229.char fix_tag;
230.
231. {* Should the endidx field of this symbol be renumbered.
232. Created by coff_pointerize_aux. *}
233.char fix_end;
234.
235. {* The container for the symbol structure as read and translated
236. from the file. *}
237.
238.union {
239. union internal_auxent auxent;
240. struct internal_syment syment;
241. } u;
242.} combined_entry_type;
243.
244.
245.{* Each canonical asymbol really looks like this: *}
246.
247.typedef struct coff_symbol_struct
248.{
249. {* The actual symbol which the rest of BFD works with *}
250.asymbol symbol;
251.
252. {* A pointer to the hidden information for this symbol *}
253.combined_entry_type *native;
254.
255. {* A pointer to the linenumber information for this symbol *}
256.struct lineno_cache_entry *lineno;
257.
d58b7049
SC		 258. {* Have the line numbers been relocated yet ? *}
259.boolean done_lineno;
616ebcfd 260.} coff_symbol_type;
6f715d66 261
6f715d66 262
0f268757
SC		 263*/
264
6590a8c9
SC		 265#include "seclet.h"
266extern bfd_error_vector_type bfd_error_vector;
267
268
0f268757 269
0f268757
SC		 270
271#define PUTWORD bfd_h_put_32
272#define PUTHALF bfd_h_put_16
6d7c88c3 273#define PUTBYTE bfd_h_put_8
6f715d66
SC		 274
275#ifndef GET_FCN_LNNOPTR
41f50af0 276#define GET_FCN_LNNOPTR(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
6f715d66
SC		 277#endif
278
279#ifndef GET_FCN_ENDNDX
41f50af0 280#define GET_FCN_ENDNDX(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
6f715d66
SC		 281#endif
282
283#ifndef PUT_FCN_LNNOPTR
41f50af0 284#define PUT_FCN_LNNOPTR(abfd, in, ext) PUTWORD(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
6f715d66
SC		 285#endif
286#ifndef PUT_FCN_ENDNDX
41f50af0 287#define PUT_FCN_ENDNDX(abfd, in, ext) PUTWORD(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
6f715d66
SC		 288#endif
289#ifndef GET_LNSZ_LNNO
41f50af0 290#define GET_LNSZ_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_lnno)
6f715d66
SC		 291#endif
292#ifndef GET_LNSZ_SIZE
41f50af0 293#define GET_LNSZ_SIZE(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_size)
6f715d66
SC		 294#endif
295#ifndef PUT_LNSZ_LNNO
41f50af0 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)
6f715d66
SC		 297#endif
298#ifndef PUT_LNSZ_SIZE
41f50af0 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)
6f715d66 300#endif
cbdc7909 301#ifndef GET_SCN_SCNLEN
41f50af0 302#define GET_SCN_SCNLEN(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_scn.x_scnlen)
6f715d66
SC		 303#endif
304#ifndef GET_SCN_NRELOC
41f50af0 305#define GET_SCN_NRELOC(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nreloc)
6f715d66
SC		 306#endif
307#ifndef GET_SCN_NLINNO
41f50af0 308#define GET_SCN_NLINNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nlinno)
6f715d66 309#endif
cbdc7909 310#ifndef PUT_SCN_SCNLEN
41f50af0 311#define PUT_SCN_SCNLEN(abfd,in, ext) bfd_h_put_32(abfd, in, (bfd_byte *) ext->x_scn.x_scnlen)
6f715d66
SC		 312#endif
313#ifndef PUT_SCN_NRELOC
41f50af0 314#define PUT_SCN_NRELOC(abfd,in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_scn.x_nreloc)
6f715d66
SC		 315#endif
316#ifndef PUT_SCN_NLINNO
85e0c721
SC		 317#define PUT_SCN_NLINNO(abfd,in, ext) bfd_h_put_16(abfd,in, (bfd_byte *) ext->x_scn.x_nlinno)
318#endif
319#ifndef GET_LINENO_LNNO
320#define GET_LINENO_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) (ext->l_lnno));
321#endif
8c4a1ace 322#ifndef PUT_LINENO_LNNO
85e0c721 323#define PUT_LINENO_LNNO(abfd,val, ext) bfd_h_put_16(abfd,val, (bfd_byte *) (ext->l_lnno));
0f268757 324#endif
0f268757
SC		 325
326\f
327/* void warning(); */
6f715d66 328
cbdc7909
JG		 329/*
330 * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the
41f50af0
SC		 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().
334 */
cbdc7909 335static long
41f50af0
SC		 336DEFUN(sec_to_styp_flags, (sec_name, sec_flags),
337 CONST char * sec_name AND
338 flagword sec_flags)
339{
340 long styp_flags = 0;
341
342 if (!strcmp(sec_name, _TEXT)) {
343 return((long)STYP_TEXT);
344 } else if (!strcmp(sec_name, _DATA)) {
345 return((long)STYP_DATA);
346 } else if (!strcmp(sec_name, _BSS)) {
347 return((long)STYP_BSS);
8c4a1ace
JG		 348#ifdef _COMMENT
349 } else if (!strcmp(sec_name, _COMMENT)) {
350 return((long)STYP_INFO);
351#endif /* _COMMENT */
cbdc7909 352 }
41f50af0
SC		 353
354/* Try and figure out what it should be */
cbdc7909
JG		 355 if (sec_flags & SEC_CODE) styp_flags = STYP_TEXT;
356 if (sec_flags & SEC_DATA) styp_flags = STYP_DATA;
357 else if (sec_flags & SEC_READONLY)
41f50af0 358#ifdef STYP_LIT /* 29k readonly text/data section */
cbdc7909 359 styp_flags = STYP_LIT;
41f50af0 360#else
cbdc7909 361 styp_flags = STYP_TEXT;
41f50af0
SC		 362#endif /* STYP_LIT */
363 else if (sec_flags & SEC_LOAD) styp_flags = STYP_TEXT;
364
365 if (styp_flags == 0) styp_flags = STYP_BSS;
366
367 return(styp_flags);
368}
cbdc7909 369/*
41f50af0 370 * Return a word with SEC_* flags set to represent the incoming
cbdc7909
JG		 371 * STYP_* flags (from scnhdr.s_flags). The inverse of this
372 * function is sec_to_styp_flags().
41f50af0
SC		 373 * NOTE: If you add to/change this routine, you should mirror the changes
374 * in sec_to_styp_flags().
375 */
cbdc7909 376static flagword
41f50af0
SC		 377DEFUN(styp_to_sec_flags, (styp_flags),
378 long styp_flags)
379{
380 flagword sec_flags=0;
381
382 if ((styp_flags & STYP_TEXT) || (styp_flags & STYP_DATA))
383 sec_flags = (SEC_LOAD | SEC_ALLOC);
384 else if (styp_flags & STYP_BSS)
385 sec_flags = SEC_ALLOC;
386
387#ifdef STYP_LIT /* A29k readonly text/data section type */
388 if ((styp_flags & STYP_LIT) == STYP_LIT)
389 sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
390#endif /* STYP_LIT */
853f0a70
JG		 391#ifdef STYP_OTHER_LOAD /* Other loaded sections */
392 if (styp_flags & STYP_OTHER_LOAD)
393 sec_flags = (SEC_LOAD | SEC_ALLOC);
394#endif /* STYP_SDATA */
41f50af0
SC		 395
396 return(sec_flags);
397}
0f268757 398
fb3be09b
JG		 399#define get_index(symbol) ((int) (symbol)->value)
400#define set_index(symbol, idx) ((symbol)->value = (idx))
0f268757 401
6f715d66
SC		 402/* **********************************************************************
403Here are all the routines for swapping the structures seen in the
cbdc7909 404outside world into the internal forms.
0f268757
SC		 405*/
406
407
2700c3c7 408static void
0f268757
SC		 409DEFUN(bfd_swap_reloc_in,(abfd, reloc_src, reloc_dst),
410 bfd *abfd AND
411 RELOC *reloc_src AND
412 struct internal_reloc *reloc_dst)
413{
41f50af0
SC		 414 reloc_dst->r_vaddr = bfd_h_get_32(abfd, (bfd_byte *)reloc_src->r_vaddr);
415 reloc_dst->r_symndx = bfd_h_get_32(abfd, (bfd_byte *) reloc_src->r_symndx);
cbdc7909
JG		 416
417#ifdef RS6000COFF_C
418 reloc_dst->r_type = bfd_h_get_8(abfd, reloc_src->r_type);
419 reloc_dst->r_size = bfd_h_get_8(abfd, reloc_src->r_size);
420#else
41f50af0 421 reloc_dst->r_type = bfd_h_get_16(abfd, (bfd_byte *) reloc_src->r_type);
cbdc7909
JG		 422#endif
423
3b4f1a5d 424#ifdef SWAP_IN_RELOC_OFFSET
9898b929
JG		 425 reloc_dst->r_offset = SWAP_IN_RELOC_OFFSET(abfd,
426 (bfd_byte *) reloc_src->r_offset);
0f268757
SC		 427#endif
428}
429
2700c3c7 430
0d740984
SC		 431static unsigned int
432DEFUN(coff_swap_reloc_out,(abfd, src, dst),
433 bfd *abfd AND
434 PTR src AND
435 PTR dst)
0f268757 436{
0d740984
SC		 437 struct internal_reloc *reloc_src = (struct internal_reloc *)src;
438 struct external_reloc *reloc_dst = (struct external_reloc *)dst;
41f50af0
SC		 439 bfd_h_put_32(abfd, reloc_src->r_vaddr, (bfd_byte *) reloc_dst->r_vaddr);
440 bfd_h_put_32(abfd, reloc_src->r_symndx, (bfd_byte *) reloc_dst->r_symndx);
3b4f1a5d
SC		 441 bfd_h_put_16(abfd, reloc_src->r_type, (bfd_byte *)
442 reloc_dst->r_type);
443
444#ifdef SWAP_OUT_RELOC_OFFSET
445 SWAP_OUT_RELOC_OFFSET(abfd,
446 reloc_src->r_offset,
447 (bfd_byte *) reloc_dst->r_offset);
448#endif
449#ifdef SWAP_OUT_RELOC_EXTRA
450 SWAP_OUT_RELOC_EXTRA(abfd,reloc_src, reloc_dst);
0f268757 451#endif
3b4f1a5d 452
0d740984 453 return sizeof(struct external_reloc);
0f268757
SC		 454}
455
2700c3c7 456static void
0f268757
SC		 457DEFUN(bfd_swap_filehdr_in,(abfd, filehdr_src, filehdr_dst),
458 bfd *abfd AND
459 FILHDR *filehdr_src AND
460 struct internal_filehdr *filehdr_dst)
461{
41f50af0
SC		 462 filehdr_dst->f_magic = bfd_h_get_16(abfd, (bfd_byte *) filehdr_src->f_magic);
463 filehdr_dst->f_nscns = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_nscns);
464 filehdr_dst->f_timdat = bfd_h_get_32(abfd, (bfd_byte *)filehdr_src-> f_timdat);
465 filehdr_dst->f_symptr = bfd_h_get_32(abfd, (bfd_byte *)filehdr_src-> f_symptr);
466 filehdr_dst->f_nsyms = bfd_h_get_32(abfd, (bfd_byte *)filehdr_src-> f_nsyms);
467 filehdr_dst->f_opthdr = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_opthdr);
468 filehdr_dst->f_flags = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_flags);
0f268757
SC		 469}
470
0d740984
SC		 471static unsigned int
472DEFUN(coff_swap_filehdr_out,(abfd, in, out),
473 bfd *abfd AND
474 PTR in AND
475 PTR out)
0f268757 476{
0d740984
SC		 477 struct internal_filehdr *filehdr_in = (struct internal_filehdr *)in;
478 FILHDR *filehdr_out = (FILHDR *)out;
41f50af0
SC		 479 bfd_h_put_16(abfd, filehdr_in->f_magic, (bfd_byte *) filehdr_out->f_magic);
480 bfd_h_put_16(abfd, filehdr_in->f_nscns, (bfd_byte *) filehdr_out->f_nscns);
481 bfd_h_put_32(abfd, filehdr_in->f_timdat, (bfd_byte *) filehdr_out->f_timdat);
482 bfd_h_put_32(abfd, filehdr_in->f_symptr, (bfd_byte *) filehdr_out->f_symptr);
483 bfd_h_put_32(abfd, filehdr_in->f_nsyms, (bfd_byte *) filehdr_out->f_nsyms);
484 bfd_h_put_16(abfd, filehdr_in->f_opthdr, (bfd_byte *) filehdr_out->f_opthdr);
485 bfd_h_put_16(abfd, filehdr_in->f_flags, (bfd_byte *) filehdr_out->f_flags);
0d740984 486 return sizeof(FILHDR);
0f268757
SC		 487}
488
489
7a8b18b6 490#ifndef NO_COFF_SYMBOLS
2700c3c7 491
cbdc7909 492static void
6f715d66 493DEFUN(coff_swap_sym_in,(abfd, ext1, in1),
0f268757 494 bfd *abfd AND
6f715d66
SC		 495 PTR ext1 AND
496 PTR in1)
0f268757 497{
6f715d66
SC		 498 SYMENT *ext = (SYMENT *)ext1;
499 struct internal_syment *in = (struct internal_syment *)in1;
500
0f268757
SC		 501 if( ext->e.e_name[0] == 0) {
502 in->_n._n_n._n_zeroes = 0;
41f50af0 503 in->_n._n_n._n_offset = bfd_h_get_32(abfd, (bfd_byte *) ext->e.e.e_offset);
0f268757
SC		 504 }
505 else {
fb3be09b
JG		 506#if SYMNMLEN != E_SYMNMLEN
507 -> Error, we need to cope with truncating or extending SYMNMLEN!;
508#else
0f268757 509 memcpy(in->_n._n_name, ext->e.e_name, SYMNMLEN);
fb3be09b 510#endif
0f268757 511 }
41f50af0
SC		 512 in->n_value = bfd_h_get_32(abfd, (bfd_byte *) ext->e_value);
513 in->n_scnum = bfd_h_get_16(abfd, (bfd_byte *) ext->e_scnum);
0f268757 514 if (sizeof(ext->e_type) == 2){
41f50af0 515 in->n_type = bfd_h_get_16(abfd, (bfd_byte *) ext->e_type);
0f268757
SC		 516 }
517 else {
41f50af0 518 in->n_type = bfd_h_get_32(abfd, (bfd_byte *) ext->e_type);
0f268757
SC		 519 }
520 in->n_sclass = bfd_h_get_8(abfd, ext->e_sclass);
521 in->n_numaux = bfd_h_get_8(abfd, ext->e_numaux);
522}
523
0d740984
SC		 524static unsigned int
525DEFUN(coff_swap_sym_out,(abfd, inp, extp),
526 bfd *abfd AND
527 PTR inp AND
528 PTR extp)
0f268757 529{
0d740984
SC		 530 struct internal_syment *in = (struct internal_syment *)inp;
531 SYMENT *ext =(SYMENT *)extp;
0f268757 532 if(in->_n._n_name[0] == 0) {
41f50af0
SC		 533 bfd_h_put_32(abfd, 0, (bfd_byte *) ext->e.e.e_zeroes);
534 bfd_h_put_32(abfd, in->_n._n_n._n_offset, (bfd_byte *) ext->e.e.e_offset);
0f268757
SC		 535 }
536 else {
fb3be09b 537#if SYMNMLEN != E_SYMNMLEN
0d740984 538 -> Error, we need to cope with truncating or extending SYMNMLEN!;
fb3be09b 539#else
0f268757 540 memcpy(ext->e.e_name, in->_n._n_name, SYMNMLEN);
fb3be09b 541#endif
0f268757 542 }
41f50af0
SC		 543 bfd_h_put_32(abfd, in->n_value , (bfd_byte *) ext->e_value);
544 bfd_h_put_16(abfd, in->n_scnum , (bfd_byte *) ext->e_scnum);
cbdc7909 545 if (sizeof(ext->e_type) == 2)
0f268757 546 {
41f50af0 547 bfd_h_put_16(abfd, in->n_type , (bfd_byte *) ext->e_type);
0f268757
SC		 548 }
549 else
550 {
41f50af0 551 bfd_h_put_32(abfd, in->n_type , (bfd_byte *) ext->e_type);
0f268757
SC		 552 }
553 bfd_h_put_8(abfd, in->n_sclass , ext->e_sclass);
554 bfd_h_put_8(abfd, in->n_numaux , ext->e_numaux);
0d740984 555 return sizeof(SYMENT);
0f268757
SC		 556}
557
2700c3c7 558static void
d05511ca 559DEFUN(coff_swap_aux_in,(abfd, ext1, type, class, in),
0f268757 560 bfd *abfd AND
fb3be09b 561 PTR ext1 AND
0f268757
SC		 562 int type AND
563 int class AND
d05511ca 564 union internal_auxent *in)
0f268757 565{
6f715d66 566 AUXENT *ext = (AUXENT *)ext1;
d05511ca 567
0f268757 568 switch (class) {
d05511ca
SC		 569 case C_FILE:
570 if (ext->x_file.x_fname[0] == 0) {
571 in->x_file.x_n.x_zeroes = 0;
572 in->x_file.x_n.x_offset =
573 bfd_h_get_32(abfd, (bfd_byte *) ext->x_file.x_n.x_offset);
574 } else {
fb3be09b 575#if FILNMLEN != E_FILNMLEN
d05511ca 576 -> Error, we need to cope with truncating or extending FILNMLEN!;
fb3be09b 577#else
d05511ca 578 memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
fb3be09b 579#endif
d05511ca
SC		 580 }
581 break;
0f268757 582
d05511ca 583 /* RS/6000 "csect" auxents */
6d7c88c3 584#ifdef RS6000COFF_C
d05511ca
SC		 585 case C_EXT:
586 case C_HIDEXT:
587 in->x_csect.x_scnlen = bfd_h_get_32 (abfd, (bfd_byte *) ext->x_csect.x_scnlen);
588 in->x_csect.x_parmhash = bfd_h_get_32 (abfd, (bfd_byte *) ext->x_csect.x_parmhash);
589 in->x_csect.x_snhash = bfd_h_get_16 (abfd, (bfd_byte *) ext->x_csect.x_snhash);
590 /* We don't have to hack bitfields in x_smtyp because it's defined by
591 shifts-and-ands, which are equivalent on all byte orders. */
592 in->x_csect.x_smtyp = bfd_h_get_8 (abfd, (bfd_byte *) ext->x_csect.x_smtyp);
593 in->x_csect.x_smclas = bfd_h_get_8 (abfd, (bfd_byte *) ext->x_csect.x_smclas);
594 in->x_csect.x_stab = bfd_h_get_32 (abfd, (bfd_byte *) ext->x_csect.x_stab);
595 in->x_csect.x_snstab = bfd_h_get_16 (abfd, (bfd_byte *) ext->x_csect.x_snstab);
596 break;
6d7c88c3
JG		 597#endif
598
d05511ca 599 case C_STAT:
0f268757 600#ifdef C_LEAFSTAT
d05511ca 601 case C_LEAFSTAT:
0f268757 602#endif
d05511ca
SC		 603 case C_HIDDEN:
604 if (type == T_NULL) {
605 in->x_scn.x_scnlen = GET_SCN_SCNLEN(abfd, ext);
606 in->x_scn.x_nreloc = GET_SCN_NRELOC(abfd, ext);
607 in->x_scn.x_nlinno = GET_SCN_NLINNO(abfd, ext);
608 break;
609 }
610 default:
611 in->x_sym.x_tagndx.l = bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_tagndx);
6f715d66 612#ifndef NO_TVNDX
d05511ca 613 in->x_sym.x_tvndx = bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_tvndx);
6f715d66 614#endif
0f268757 615
d05511ca 616 if (ISARY(type) || class == C_BLOCK) {
fb3be09b 617#if DIMNUM != E_DIMNUM
d05511ca 618 -> Error, we need to cope with truncating or extending DIMNUM!;
fb3be09b 619#else
d05511ca
SC		 620 in->x_sym.x_fcnary.x_ary.x_dimen[0] = bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
621 in->x_sym.x_fcnary.x_ary.x_dimen[1] = bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
622 in->x_sym.x_fcnary.x_ary.x_dimen[2] = bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
623 in->x_sym.x_fcnary.x_ary.x_dimen[3] = bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
fb3be09b 624#endif
d05511ca 625 }
6f715d66
SC		 626 in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR(abfd, ext);
627 in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX(abfd, ext);
628
d05511ca
SC		 629 if (ISFCN(type)) {
630 in->x_sym.x_misc.x_fsize = bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_misc.x_fsize);
631 }
632 else {
633 in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO(abfd, ext);
634 in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE(abfd, ext);
635 }
0f268757 636 }
0f268757
SC		 637}
638
0d740984
SC		 639static unsigned int
640DEFUN(coff_swap_aux_out,(abfd, inp, type, class, extp),
0f268757 641 bfd *abfd AND
0d740984
SC		 642 PTR inp AND
643 int type AND
644 int class AND
645 PTR extp)
0f268757 646{
0d740984
SC		 647 union internal_auxent *in = (union internal_auxent *)inp;
648 AUXENT *ext = (AUXENT *)extp;
0f268757
SC		 649 switch (class) {
650 case C_FILE:
651 if (in->x_file.x_fname[0] == 0) {
cbdc7909 652 PUTWORD(abfd, 0, (bfd_byte *) ext->x_file.x_n.x_zeroes);
0d740984
SC		 653 PUTWORD(abfd,
654 in->x_file.x_n.x_offset,
655 (bfd_byte *) ext->x_file.x_n.x_offset);
0f268757 656 }
6f715d66 657 else {
fb3be09b 658#if FILNMLEN != E_FILNMLEN
0d740984 659 -> Error, we need to cope with truncating or extending FILNMLEN!;
fb3be09b
JG		 660#else
661 memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
662#endif
cbdc7909 663 }
0f268757 664 break;
6d7c88c3
JG		 665
666#ifdef RS6000COFF_C
667 /* RS/6000 "csect" auxents */
668 case C_EXT:
669 case C_HIDEXT:
670 PUTWORD (abfd, in->x_csect.x_scnlen, ext->x_csect.x_scnlen);
671 PUTWORD (abfd, in->x_csect.x_parmhash, ext->x_csect.x_parmhash);
672 PUTHALF (abfd, in->x_csect.x_snhash, ext->x_csect.x_snhash);
673 /* We don't have to hack bitfields in x_smtyp because it's defined by
674 shifts-and-ands, which are equivalent on all byte orders. */
675 PUTBYTE (abfd, in->x_csect.x_smtyp, ext->x_csect.x_smtyp);
676 PUTBYTE (abfd, in->x_csect.x_smclas, ext->x_csect.x_smclas);
677 PUTWORD (abfd, in->x_csect.x_stab, ext->x_csect.x_stab);
678 PUTHALF (abfd, in->x_csect.x_snstab, ext->x_csect.x_snstab);
679 break;
680#endif
681
0f268757
SC		 682 case C_STAT:
683#ifdef C_LEAFSTAT
684 case C_LEAFSTAT:
685#endif
686 case C_HIDDEN:
687 if (type == T_NULL) {
6f715d66
SC		 688 PUT_SCN_SCNLEN(abfd, in->x_scn.x_scnlen, ext);
689 PUT_SCN_NRELOC(abfd, in->x_scn.x_nreloc, ext);
690 PUT_SCN_NLINNO(abfd, in->x_scn.x_nlinno, ext);
0f268757
SC		 691 break;
692 }
693 default:
41f50af0 694 PUTWORD(abfd, in->x_sym.x_tagndx.l, (bfd_byte *) ext->x_sym.x_tagndx);
6f715d66 695#ifndef NO_TVNDX
41f50af0 696 PUTWORD(abfd, in->x_sym.x_tvndx , (bfd_byte *) ext->x_sym.x_tvndx);
6f715d66 697#endif
0f268757 698
0f268757 699 if (ISFCN(type)) {
41f50af0 700 PUTWORD(abfd, in->x_sym.x_misc.x_fsize, (bfd_byte *) ext->x_sym.x_misc.x_fsize);
6f715d66
SC		 701 PUT_FCN_LNNOPTR(abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
702 PUT_FCN_ENDNDX(abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
0f268757
SC		 703 }
704 else {
6f715d66
SC		 705
706 if (ISARY(type) || class == C_BLOCK) {
fb3be09b 707#if DIMNUM != E_DIMNUM
0d740984 708 -> Error, we need to cope with truncating or extending DIMNUM!;
fb3be09b 709#else
41f50af0
SC		 710 bfd_h_put_16(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0], (bfd_byte *)ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
711 bfd_h_put_16(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1], (bfd_byte *)ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
712 bfd_h_put_16(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2], (bfd_byte *)ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
713 bfd_h_put_16(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3], (bfd_byte *)ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
fb3be09b 714#endif
6f715d66 715 }
0d740984
SC		 716 PUT_LNSZ_LNNO(abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
717 PUT_LNSZ_SIZE(abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
6f715d66
SC		 718
719 PUT_FCN_LNNOPTR(abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
720 PUT_FCN_ENDNDX(abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
721
722
0f268757
SC		 723 }
724 }
0d740984 725return sizeof(AUXENT);
0f268757
SC		 726}
727
7a8b18b6
SC		 728#endif /* NO_COFF_SYMBOLS */
729
730#ifndef NO_COFF_LINENOS
731
6f715d66
SC		 732static void
733DEFUN(coff_swap_lineno_in,(abfd, ext1, in1),
0f268757 734 bfd *abfd AND
6f715d66
SC		 735 PTR ext1 AND
736 PTR in1)
0f268757 737{
6f715d66
SC		 738 LINENO *ext = (LINENO *)ext1;
739 struct internal_lineno *in = (struct internal_lineno *)in1;
740
41f50af0 741 in->l_addr.l_symndx = bfd_h_get_32(abfd, (bfd_byte *) ext->l_addr.l_symndx);
85e0c721 742 in->l_lnno = GET_LINENO_LNNO(abfd, ext);
0f268757
SC		 743}
744
0d740984
SC		 745static unsigned int
746DEFUN(coff_swap_lineno_out,(abfd, inp, outp),
747 bfd *abfd AND
748 PTR inp AND
749 PTR outp)
0f268757 750{
0d740984
SC		 751 struct internal_lineno *in = (struct internal_lineno *)inp;
752 struct external_lineno *ext = (struct external_lineno *)outp;
85e0c721
SC		 753 PUTWORD(abfd, in->l_addr.l_symndx, (bfd_byte *)
754 ext->l_addr.l_symndx);
755
756 PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
0d740984 757 return sizeof(struct external_lineno);
0f268757
SC		 758}
759
7a8b18b6 760#endif /* NO_COFF_LINENOS */
0f268757
SC		 761
762
cbdc7909 763static void
6f715d66 764DEFUN(bfd_swap_aouthdr_in,(abfd, aouthdr_ext1, aouthdr_int1),
0f268757 765 bfd *abfd AND
6f715d66
SC		 766 PTR aouthdr_ext1 AND
767 PTR aouthdr_int1)
0f268757 768{
6f715d66
SC		 769 AOUTHDR *aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
770 struct internal_aouthdr *aouthdr_int = (struct internal_aouthdr *)aouthdr_int1;
771
41f50af0
SC		 772 aouthdr_int->magic = bfd_h_get_16(abfd, (bfd_byte *) aouthdr_ext->magic);
773 aouthdr_int->vstamp = bfd_h_get_16(abfd, (bfd_byte *) aouthdr_ext->vstamp);
774 aouthdr_int->tsize = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->tsize);
775 aouthdr_int->dsize = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->dsize);
776 aouthdr_int->bsize = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->bsize);
777 aouthdr_int->entry = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->entry);
778 aouthdr_int->text_start = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->text_start);
779 aouthdr_int->data_start = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->data_start);
0f268757 780#ifdef I960
41f50af0 781 aouthdr_int->tagentries = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->tagentries);
0f268757 782#endif
cbdc7909
JG		 783
784#ifdef RS6000COFF_C
785 aouthdr_int->o_toc = bfd_h_get_32(abfd, aouthdr_ext->o_toc);
786 aouthdr_int->o_snentry = bfd_h_get_16(abfd, aouthdr_ext->o_snentry);
787 aouthdr_int->o_sntext = bfd_h_get_16(abfd, aouthdr_ext->o_sntext);
788 aouthdr_int->o_sndata = bfd_h_get_16(abfd, aouthdr_ext->o_sndata);
789 aouthdr_int->o_sntoc = bfd_h_get_16(abfd, aouthdr_ext->o_sntoc);
790 aouthdr_int->o_snloader = bfd_h_get_16(abfd, aouthdr_ext->o_snloader);
791 aouthdr_int->o_snbss = bfd_h_get_16(abfd, aouthdr_ext->o_snbss);
792 aouthdr_int->o_algntext = bfd_h_get_16(abfd, aouthdr_ext->o_algntext);
793 aouthdr_int->o_algndata = bfd_h_get_16(abfd, aouthdr_ext->o_algndata);
794 aouthdr_int->o_modtype = bfd_h_get_16(abfd, aouthdr_ext->o_modtype);
795 aouthdr_int->o_maxstack = bfd_h_get_32(abfd, aouthdr_ext->o_maxstack);
796#endif
0f268757
SC		 797}
798
0d740984
SC		 799static unsigned int
800DEFUN(coff_swap_aouthdr_out,(abfd, in, out),
801 bfd *abfd AND
802 PTR in AND
803 PTR out)
0f268757 804{
0d740984
SC		 805 struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *)in;
806 AOUTHDR *aouthdr_out = (AOUTHDR *)out;
41f50af0
SC		 807 bfd_h_put_16(abfd, aouthdr_in->magic, (bfd_byte *) aouthdr_out->magic);
808 bfd_h_put_16(abfd, aouthdr_in->vstamp, (bfd_byte *) aouthdr_out->vstamp);
809 bfd_h_put_32(abfd, aouthdr_in->tsize, (bfd_byte *) aouthdr_out->tsize);
810 bfd_h_put_32(abfd, aouthdr_in->dsize, (bfd_byte *) aouthdr_out->dsize);
811 bfd_h_put_32(abfd, aouthdr_in->bsize, (bfd_byte *) aouthdr_out->bsize);
812 bfd_h_put_32(abfd, aouthdr_in->entry, (bfd_byte *) aouthdr_out->entry);
0d740984
SC		 813 bfd_h_put_32(abfd, aouthdr_in->text_start,
814 (bfd_byte *) aouthdr_out->text_start);
41f50af0 815 bfd_h_put_32(abfd, aouthdr_in->data_start, (bfd_byte *) aouthdr_out->data_start);
0f268757 816#ifdef I960
41f50af0 817 bfd_h_put_32(abfd, aouthdr_in->tagentries, (bfd_byte *) aouthdr_out->tagentries);
0f268757 818#endif
0d740984 819 return sizeof(AOUTHDR);
0f268757
SC		 820}
821
cbdc7909 822static void
2700c3c7 823DEFUN(coff_swap_scnhdr_in,(abfd, scnhdr_ext, scnhdr_int),
0f268757
SC		 824 bfd *abfd AND
825 SCNHDR *scnhdr_ext AND
826 struct internal_scnhdr *scnhdr_int)
827{
828 memcpy(scnhdr_int->s_name, scnhdr_ext->s_name, sizeof(scnhdr_int->s_name));
41f50af0
SC		 829 scnhdr_int->s_vaddr = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_vaddr);
830 scnhdr_int->s_paddr = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_paddr);
e98e6ec1
SC		 831 scnhdr_int->s_size = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_size);
832
41f50af0
SC		 833 scnhdr_int->s_scnptr = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_scnptr);
834 scnhdr_int->s_relptr = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_relptr);
835 scnhdr_int->s_lnnoptr = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_lnnoptr);
836 scnhdr_int->s_flags = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_flags);
6f715d66 837#if defined(M88)
41f50af0
SC		 838 scnhdr_int->s_nreloc = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_nreloc);
839 scnhdr_int->s_nlnno = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_nlnno);
6f715d66 840#else
41f50af0
SC		 841 scnhdr_int->s_nreloc = bfd_h_get_16(abfd, (bfd_byte *) scnhdr_ext->s_nreloc);
842 scnhdr_int->s_nlnno = bfd_h_get_16(abfd, (bfd_byte *) scnhdr_ext->s_nlnno);
6f715d66 843#endif
0f268757 844#ifdef I960
41f50af0 845 scnhdr_int->s_align = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_align);
0f268757
SC		 846#endif
847}
848
cbdc7909 849static unsigned int
0d740984
SC		 850DEFUN(coff_swap_scnhdr_out,(abfd, in, out),
851 bfd *abfd AND
852 PTR in AND
853 PTR out)
0f268757 854{
0d740984
SC		 855 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *)in;
856 SCNHDR *scnhdr_ext = (SCNHDR *)out;
0f268757 857 memcpy(scnhdr_ext->s_name, scnhdr_int->s_name, sizeof(scnhdr_int->s_name));
41f50af0
SC		 858 PUTWORD(abfd, scnhdr_int->s_vaddr, (bfd_byte *) scnhdr_ext->s_vaddr);
859 PUTWORD(abfd, scnhdr_int->s_paddr, (bfd_byte *) scnhdr_ext->s_paddr);
860 PUTWORD(abfd, scnhdr_int->s_size, (bfd_byte *) scnhdr_ext->s_size);
861 PUTWORD(abfd, scnhdr_int->s_scnptr, (bfd_byte *) scnhdr_ext->s_scnptr);
862 PUTWORD(abfd, scnhdr_int->s_relptr, (bfd_byte *) scnhdr_ext->s_relptr);
863 PUTWORD(abfd, scnhdr_int->s_lnnoptr, (bfd_byte *) scnhdr_ext->s_lnnoptr);
2f8d9c1c 864 PUTWORD(abfd, scnhdr_int->s_flags, (bfd_byte *) scnhdr_ext->s_flags);
6f715d66 865#if defined(M88)
41f50af0 866 PUTWORD(abfd, scnhdr_int->s_nlnno, (bfd_byte *) scnhdr_ext->s_nlnno);
41f50af0 867 PUTWORD(abfd, scnhdr_int->s_nreloc, (bfd_byte *) scnhdr_ext->s_nreloc);
6f715d66 868#else
41f50af0 869 PUTHALF(abfd, scnhdr_int->s_nlnno, (bfd_byte *) scnhdr_ext->s_nlnno);
41f50af0 870 PUTHALF(abfd, scnhdr_int->s_nreloc, (bfd_byte *) scnhdr_ext->s_nreloc);
6f715d66
SC		 871#endif
872
cbdc7909 873#if defined(I960)
41f50af0 874 PUTWORD(abfd, scnhdr_int->s_align, (bfd_byte *) scnhdr_ext->s_align);
0f268757 875#endif
0d740984 876 return sizeof(SCNHDR);
0f268757
SC		 877}
878
6f715d66 879
0f268757
SC		 880/*
881 initialize a section structure with information peculiar to this
882 particular implementation of coff
883*/
884
885static boolean
e98e6ec1 886DEFUN(coff_new_section_hook,(abfd_ignore, section),
0f268757 887 bfd *abfd_ignore AND
e98e6ec1 888 asection *section)
0f268757 889{
e98e6ec1 890 section->alignment_power = abfd_ignore->xvec->align_power_min;
0f268757
SC		 891 return true;
892}
893
6590a8c9
SC		 894static asection bfd_debug_section =
895{ "*DEBUG*" };
896
897
898
e98e6ec1
SC		 899static void
900DEFUN(make_abs_section,(abfd),
901 bfd *abfd)
902{
6590a8c9
SC		 903
904
e98e6ec1
SC		 905
906}
907
0f268757
SC		 908/* Take a section header read from a coff file (in HOST byte order),
909 and make a BFD "section" out of it. */
910static boolean
e98e6ec1 911DEFUN(make_a_section_from_file,(abfd, hdr, target_index),
0f268757 912 bfd *abfd AND
e98e6ec1
SC		 913 struct internal_scnhdr *hdr AND
914 unsigned int target_index)
0f268757 915{
e98e6ec1
SC		 916 asection *return_section;
917 char *name;
918
919 /* Assorted wastage to null-terminate the name, thanks AT&T! */
920 name = bfd_alloc(abfd, sizeof (hdr->s_name)+1);
921 if (name == NULL) {
922 bfd_error = no_memory;
923 return false;
924 }
925 strncpy(name, (char *) &hdr->s_name[0], sizeof (hdr->s_name));
926 name[sizeof (hdr->s_name)] = 0;
0f268757 927
e98e6ec1
SC		 928 return_section = bfd_make_section(abfd, name);
929 if (return_section == NULL)
930 return false;
0f268757 931
e98e6ec1 932 /* s_paddr is presumed to be = to s_vaddr */
0f268757 933
e98e6ec1
SC		 934 return_section->vma = hdr->s_vaddr;
935 return_section->_raw_size = hdr->s_size;
936 return_section->filepos = hdr->s_scnptr;
937 return_section->rel_filepos = hdr->s_relptr;
938 return_section->reloc_count = hdr->s_nreloc;
0f268757 939#ifdef I960
e98e6ec1
SC		 940
941 /* FIXME, use a temp var rather than alignment_power */
942 return_section->alignment_power = hdr->s_align;
943{
944 unsigned int i;
945 for (i = 0; i < 32; i++) {
946 if ((1 << i) >= (int) (return_section->alignment_power)) {
947 return_section->alignment_power = i;
948 break;
0f268757
SC		 949 }
950 }
e98e6ec1
SC		 951}
952
0f268757 953#endif
e98e6ec1
SC		 954return_section->line_filepos = hdr->s_lnnoptr;
955 /*
956 return_section->linesize = hdr->s_nlnno * sizeof (struct lineno);
0f268757
SC		 957 */
958
e98e6ec1
SC		 959 return_section->lineno_count = hdr->s_nlnno;
960 return_section->userdata = NULL;
961 return_section->next = (asection *) NULL;
962 return_section->flags = styp_to_sec_flags(hdr->s_flags);
41f50af0 963
e98e6ec1 964 return_section->target_index = target_index;
0f268757 965
e98e6ec1
SC		 966 if (hdr->s_nreloc != 0)
967 return_section->flags |= SEC_RELOC;
968 /* FIXME: should this check 'hdr->s_size > 0' */
969 if (hdr->s_scnptr != 0)
970 return_section->flags |= SEC_HAS_CONTENTS;
971 return true;
0f268757
SC		 972}
973static boolean
974DEFUN(coff_mkobject,(abfd),
975 bfd *abfd)
976{
e98e6ec1
SC		 977 abfd->tdata.coff_obj_data = (struct coff_tdata *)bfd_zalloc (abfd,sizeof(coff_data_type));
978 if (abfd->tdata.coff_obj_data == 0){
0f268757
SC		 979 bfd_error = no_memory;
980 return false;
981 }
982 coff_data(abfd)->relocbase = 0;
6590a8c9 983/* make_abs_section(abfd);*/
0f268757
SC		 984 return true;
985}
986
987static
988bfd_target *
989DEFUN(coff_real_object_p,(abfd, nscns, internal_f, internal_a),
990 bfd *abfd AND
991 unsigned nscns AND
992 struct internal_filehdr *internal_f AND
993 struct internal_aouthdr *internal_a)
994{
995 coff_data_type *coff;
0d740984
SC		 996 enum bfd_architecture arch;
997 long machine;
0f268757
SC		 998 size_t readsize; /* length of file_info */
999 SCNHDR *external_sections;
cbdc7909 1000
0f268757
SC		 1001 /* Build a play area */
1002 if (coff_mkobject(abfd) != true)
1003 return 0;
e98e6ec1 1004
0f268757 1005 coff = coff_data(abfd);
cbdc7909
JG		 1006
1007
0f268757 1008 external_sections = (SCNHDR *)bfd_alloc(abfd, readsize = (nscns * SCNHSZ));
cbdc7909 1009
0f268757
SC		 1010 if (bfd_read((PTR)external_sections, 1, readsize, abfd) != readsize) {
1011 goto fail;
1012 }
cbdc7909
JG		 1013
1014
0f268757
SC		 1015 /* Now copy data as required; construct all asections etc */
1016 coff->symbol_index_slew = 0;
1017 coff->relocbase =0;
1018 coff->raw_syment_count = 0;
1019 coff->raw_linenos = 0;
1020 coff->raw_syments = 0;
1021 coff->sym_filepos =0;
1022 coff->flags = internal_f->f_flags;
1023 if (nscns != 0) {
1024 unsigned int i;
1025 for (i = 0; i < nscns; i++) {
1026 struct internal_scnhdr tmp;
2700c3c7 1027 coff_swap_scnhdr_in(abfd, external_sections + i, &tmp);
e98e6ec1 1028 make_a_section_from_file(abfd,&tmp, i+1);
0f268757
SC		 1029 }
1030 }
e98e6ec1
SC		 1031
1032/* make_abs_section(abfd);*/
1033
0f268757 1034 /* Determine the machine architecture and type. */
0d740984 1035machine = 0;
0f268757 1036 switch (internal_f->f_magic) {
20fdc627
SC		 1037#ifdef I386MAGIC
1038 case I386MAGIC:
0d740984
SC		 1039 arch = bfd_arch_i386;
1040 machine = 0;
20fdc627
SC		 1041 break;
1042#endif
cbdc7909
JG		 1043
1044#ifdef A29K_MAGIC_BIG
41f50af0
SC		 1045 case A29K_MAGIC_BIG:
1046 case A29K_MAGIC_LITTLE:
0d740984
SC		 1047 arch = bfd_arch_a29k;
1048 machine = 0;
41f50af0
SC		 1049 break;
1050#endif
cbdc7909 1051
0f268757 1052#ifdef MIPS
20fdc627
SC		 1053 case MIPS_MAGIC_1:
1054 case MIPS_MAGIC_2:
1055 case MIPS_MAGIC_3:
0d740984
SC		 1056 arch = bfd_arch_mips;
1057 machine = 0;
0f268757
SC		 1058 break;
1059#endif
cbdc7909 1060
0f268757
SC		 1061#ifdef MC68MAGIC
1062 case MC68MAGIC:
1063 case M68MAGIC:
0d740984
SC		 1064 arch = bfd_arch_m68k;
1065 machine = 68020;
0f268757
SC		 1066 break;
1067#endif
1068#ifdef MC88MAGIC
1069 case MC88MAGIC:
1070 case MC88DMAGIC:
1071 case MC88OMAGIC:
0d740984
SC		 1072 arch = bfd_arch_m88k;
1073 machine = 88100;
0f268757
SC		 1074 break;
1075#endif
1076#ifdef I960
1077#ifdef I960ROMAGIC
1078 case I960ROMAGIC:
1079 case I960RWMAGIC:
0d740984 1080 arch = bfd_arch_i960;
cbdc7909 1081 switch (F_I960TYPE & internal_f->f_flags)
0f268757
SC		 1082 {
1083 default:
1084 case F_I960CORE:
0d740984 1085 machine = bfd_mach_i960_core;
0f268757
SC		 1086 break;
1087 case F_I960KB:
0d740984 1088 machine = bfd_mach_i960_kb_sb;
0f268757 1089 break;
0d740984
SC		 1090 case F_I960MC:
1091 machine = bfd_mach_i960_mc;
0f268757
SC		 1092 break;
1093 case F_I960XA:
0d740984 1094 machine = bfd_mach_i960_xa;
0f268757
SC		 1095 break;
1096 case F_I960CA:
0d740984 1097 machine = bfd_mach_i960_ca;
0f268757
SC		 1098 break;
1099 case F_I960KA:
0d740984 1100 machine = bfd_mach_i960_ka_sa;
0f268757 1101 break;
0f268757
SC		 1102 }
1103 break;
1104#endif
1105#endif
cbdc7909
JG		 1106
1107#ifdef U802ROMAGIC
1108 case U802ROMAGIC:
1109 case U802WRMAGIC:
1110 case U802TOCMAGIC:
1111 arch = bfd_arch_rs6000;
1112 machine = 6000;
1113 break;
1114#endif
1115
3b4f1a5d
SC		 1116#ifdef H8300MAGIC
1117 case H8300MAGIC:
1118 arch = bfd_arch_h8300;
1119 machine = 0;
1120 break;
1121#endif
cbdc7909 1122
0f268757 1123 default: /* Unreadable input file type */
0d740984 1124 arch = bfd_arch_obscure;
0f268757
SC		 1125 break;
1126 }
cbdc7909 1127
0d740984 1128 bfd_default_set_arch_mach(abfd, arch, machine);
0f268757
SC		 1129 if (!(internal_f->f_flags & F_RELFLG))
1130 abfd->flags |= HAS_RELOC;
1131 if ((internal_f->f_flags & F_EXEC))
1132 abfd->flags |= EXEC_P;
1133 if (!(internal_f->f_flags & F_LNNO))
1134 abfd->flags |= HAS_LINENO;
1135 if (!(internal_f->f_flags & F_LSYMS))
1136 abfd->flags |= HAS_LOCALS;
cbdc7909
JG		 1137
1138
0f268757
SC		 1139 bfd_get_symcount(abfd) = internal_f->f_nsyms;
1140 if (internal_f->f_nsyms)
1141 abfd->flags |= HAS_SYMS;
cbdc7909 1142
0f268757 1143 coff->sym_filepos = internal_f->f_symptr;
cbdc7909 1144
fb3be09b 1145 /* These members communicate important constants about the symbol table
0d740984
SC		 1146 to GDB's symbol-reading code. These `constants' unfortunately vary
1147 from coff implementation to implementation... */
fb3be09b
JG		 1148#ifndef NO_COFF_SYMBOLS
1149 coff->local_n_btmask = N_BTMASK;
1150 coff->local_n_btshft = N_BTSHFT;
1151 coff->local_n_tmask = N_TMASK;
1152 coff->local_n_tshift = N_TSHIFT;
1153 coff->local_symesz = SYMESZ;
1154 coff->local_auxesz = AUXESZ;
1155 coff->local_linesz = LINESZ;
1156#endif
cbdc7909 1157
0f268757
SC		 1158 coff->symbols = (coff_symbol_type *) NULL;
1159 bfd_get_start_address(abfd) = internal_f->f_opthdr ? internal_a->entry : 0;
cbdc7909 1160
0f268757
SC		 1161 return abfd->xvec;
1162 fail:
1163 bfd_release(abfd, coff);
1164 return (bfd_target *)NULL;
1165}
1166
1167static bfd_target *
1168DEFUN(coff_object_p,(abfd),
1169 bfd *abfd)
6f715d66
SC		 1170{
1171 int nscns;
1172 FILHDR filehdr;
1173 AOUTHDR opthdr;
1174 struct internal_filehdr internal_f;
1175 struct internal_aouthdr internal_a;
cbdc7909 1176
6f715d66 1177 bfd_error = system_call_error;
cbdc7909 1178
6f715d66
SC		 1179 /* figure out how much to read */
1180 if (bfd_read((PTR) &filehdr, 1, FILHSZ, abfd) != FILHSZ)
1181 return 0;
cbdc7909 1182
6f715d66 1183 bfd_swap_filehdr_in(abfd, &filehdr, &internal_f);
cbdc7909 1184
6f715d66
SC		 1185 if (BADMAG(internal_f)) {
1186 bfd_error = wrong_format;
1187 return 0;
1188 }
1189 nscns =internal_f.f_nscns;
cbdc7909 1190
6f715d66
SC		 1191 if (internal_f.f_opthdr) {
1192 if (bfd_read((PTR) &opthdr, 1,AOUTSZ, abfd) != AOUTSZ) {
1193 return 0;
0f268757 1194 }
7d003262 1195 bfd_swap_aouthdr_in(abfd, (char *)&opthdr, (char *)&internal_a);
6f715d66 1196 }
cbdc7909 1197
6f715d66
SC		 1198 /* Seek past the opt hdr stuff */
1199 bfd_seek(abfd, internal_f.f_opthdr + FILHSZ, SEEK_SET);
cbdc7909 1200
6f715d66
SC		 1201 /* if the optional header is NULL or not the correct size then
1202 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1203 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1204 optional header is of a different size.
cbdc7909 1205
6f715d66
SC		 1206 But the mips keeps extra stuff in it's opthdr, so dont check
1207 when doing that
1208 */
cbdc7909 1209
0d740984 1210#if defined(M88) || defined(I960)
6f715d66
SC		 1211 if (internal_f.f_opthdr != 0 && AOUTSZ != internal_f.f_opthdr)
1212 return (bfd_target *)NULL;
0f268757 1213#endif
cbdc7909 1214
6f715d66
SC		 1215 return coff_real_object_p(abfd, nscns, &internal_f, &internal_a);
1216}
0f268757
SC		 1217
1218
1219
7a8b18b6 1220#ifndef NO_COFF_LINENOS
0f268757 1221
cbdc7909 1222static void
0f268757
SC		 1223DEFUN(coff_count_linenumbers,(abfd),
1224 bfd *abfd)
6f715d66
SC		 1225{
1226 unsigned int limit = bfd_get_symcount(abfd);
1227 unsigned int i;
1228 asymbol **p;
1229 {
1230 asection *s = abfd->sections->output_section;
1231 while (s) {
1232 BFD_ASSERT(s->lineno_count == 0);
1233 s = s->next;
20fdc627 1234 }
6f715d66 1235 }
cbdc7909
JG		 1236
1237
6f715d66
SC		 1238 for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) {
1239 asymbol *q_maybe = *p;
0d740984 1240 if (q_maybe->the_bfd->xvec->flavour == bfd_target_coff_flavour) {
6f715d66
SC		 1241 coff_symbol_type *q = coffsymbol(q_maybe);
1242 if (q->lineno) {
1243 /*
1244 This symbol has a linenumber, increment the owning
1245 section's linenumber count
1246 */
1247 alent *l = q->lineno;
1248 q->symbol.section->output_section->lineno_count++;
1249 l++;
1250 while (l->line_number) {
20fdc627
SC		 1251 q->symbol.section->output_section->lineno_count++;
1252 l++;
0f268757 1253 }
20fdc627 1254 }
0f268757 1255 }
20fdc627 1256 }
6f715d66 1257}
0f268757 1258
7a8b18b6
SC		 1259#endif /* NO_COFF_LINENOS */
1260
1261#ifndef NO_COFF_SYMBOLS
1262
cbdc7909 1263/*
0d740984
SC		 1264 Takes a bfd and a symbol, returns a pointer to the coff specific area
1265 of the symbol if there is one.
1266 */
7a8b18b6 1267static coff_symbol_type *
fb3be09b
JG		 1268DEFUN(coff_symbol_from,(ignore_abfd, symbol),
1269 bfd *ignore_abfd AND
7a8b18b6
SC		 1270 asymbol *symbol)
1271{
cbdc7909 1272 if (symbol->the_bfd->xvec->flavour != bfd_target_coff_flavour)
7a8b18b6 1273 return (coff_symbol_type *)NULL;
cbdc7909 1274
e98e6ec1 1275 if (symbol->the_bfd->tdata.coff_obj_data == (coff_data_type*)NULL)
7a8b18b6 1276 return (coff_symbol_type *)NULL;
cbdc7909 1277
7a8b18b6
SC		 1278 return (coff_symbol_type *) symbol;
1279}
1280
0f268757 1281
0f268757 1282
6f715d66
SC		 1283static void
1284DEFUN(fixup_symbol_value,(coff_symbol_ptr, syment),
1285coff_symbol_type *coff_symbol_ptr AND
1286struct internal_syment *syment)
1287{
0f268757 1288
6f715d66 1289 /* Normalize the symbol flags */
e98e6ec1 1290 if (coff_symbol_ptr->symbol.section == &bfd_com_section) {
6f715d66
SC		 1291 /* a common symbol is undefined with a value */
1292 syment->n_scnum = N_UNDEF;
1293 syment->n_value = coff_symbol_ptr->symbol.value;
1294 }
1295 else if (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING) {
1296 syment->n_value = coff_symbol_ptr->symbol.value;
1297 }
e98e6ec1 1298 else if (coff_symbol_ptr->symbol.section == & bfd_und_section) {
6f715d66
SC		 1299 syment->n_scnum = N_UNDEF;
1300 syment->n_value = 0;
cbdc7909 1301 }
6f715d66 1302 else {
f58809fd 1303 if (coff_symbol_ptr->symbol.section) {
cbdc7909 1304 syment->n_scnum =
e98e6ec1 1305 coff_symbol_ptr->symbol.section->output_section->target_index;
cbdc7909
JG		 1306
1307 syment->n_value =
f58809fd 1308 coff_symbol_ptr->symbol.value +
6f715d66 1309 coff_symbol_ptr->symbol.section->output_offset +
f58809fd
SC		 1310 coff_symbol_ptr->symbol.section->output_section->vma;
1311 }
1312 else {
e98e6ec1 1313 BFD_ASSERT(0);
f58809fd
SC		 1314 /* This can happen, but I don't know why yet (steve@cygnus.com) */
1315 syment->n_scnum = N_ABS;
cbdc7909 1316 syment->n_value = coff_symbol_ptr->symbol.value;
f58809fd 1317 }
6f715d66
SC		 1318 }
1319}
0f268757 1320
6f715d66 1321/* run through all the symbols in the symbol table and work out what
cbdc7909 1322 their indexes into the symbol table will be when output
0f268757 1323
6f715d66
SC		 1324 Coff requires that each C_FILE symbol points to the next one in the
1325 chain, and that the last one points to the first external symbol. We
1326 do that here too.
0f268757 1327
6f715d66
SC		 1328*/
1329static void
1330DEFUN(coff_renumber_symbols,(bfd_ptr),
1331 bfd *bfd_ptr)
1332{
1333 unsigned int symbol_count = bfd_get_symcount(bfd_ptr);
1334 asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
1335 unsigned int native_index = 0;
1336 struct internal_syment *last_file = (struct internal_syment *)NULL;
1337 unsigned int symbol_index;
cbdc7909 1338 for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
6f715d66
SC		 1339 {
1340 coff_symbol_type *coff_symbol_ptr = coff_symbol_from(bfd_ptr, symbol_ptr_ptr[symbol_index]);
1341 if (coff_symbol_ptr && coff_symbol_ptr->native) {
1342 combined_entry_type *s = coff_symbol_ptr->native;
1343 int i;
0f268757 1344
cbdc7909 1345 if (s->u.syment.n_sclass == C_FILE)
6f715d66
SC		 1346 {
1347 if (last_file != (struct internal_syment *)NULL) {
1348 last_file->n_value = native_index;
1349 }
1350 last_file = &(s->u.syment);
1351 }
1352 else {
0f268757 1353
6f715d66
SC		 1354 /* Modify the symbol values according to their section and
1355 type */
0f268757 1356
6f715d66
SC		 1357 fixup_symbol_value(coff_symbol_ptr, &(s->u.syment));
1358 }
1359 for (i = 0; i < s->u.syment.n_numaux + 1; i++) {
1360 s[i].offset = native_index ++;
1361 }
1362 }
1363 else {
1364 native_index++;
1365 }
1366 }
1367}
0f268757 1368
0f268757 1369
41f50af0 1370/*
6f715d66
SC		 1371 Run thorough the symbol table again, and fix it so that all pointers to
1372 entries are changed to the entries' index in the output symbol table.
0f268757 1373
6f715d66 1374*/
cbdc7909 1375static void
0f268757
SC		 1376DEFUN(coff_mangle_symbols,(bfd_ptr),
1377 bfd *bfd_ptr)
6f715d66
SC		 1378{
1379 unsigned int symbol_count = bfd_get_symcount(bfd_ptr);
1380 asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
6f715d66
SC		 1381 unsigned int symbol_index;
1382
cbdc7909 1383 for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
6f715d66 1384 {
cbdc7909
JG		 1385 coff_symbol_type *coff_symbol_ptr =
1386 coff_symbol_from(bfd_ptr, symbol_ptr_ptr[symbol_index]);
1387
1388 if (coff_symbol_ptr && coff_symbol_ptr->native) {
6f715d66
SC		 1389 int i;
1390 combined_entry_type *s = coff_symbol_ptr->native;
1391
6f715d66
SC		 1392 for (i = 0; i < s->u.syment.n_numaux ; i++) {
1393 combined_entry_type *a = s + i + 1;
1394 if (a->fix_tag) {
cbdc7909
JG		 1395 a->u.auxent.x_sym.x_tagndx.l =
1396 a->u.auxent.x_sym.x_tagndx.p->offset;
6590a8c9 1397 a->fix_tag = 0;
6f715d66
SC		 1398 }
1399 if (a->fix_end) {
1400 a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l =
1401 a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p->offset;
6590a8c9
SC		 1402 a->fix_end = 0;
1403
6f715d66
SC		 1404 }
1405
1406 }
1407 }
1408 }
1409}
1410
cbdc7909 1411static int string_size;
6f715d66 1412static void
fb3be09b
JG		 1413DEFUN(coff_fix_symbol_name,(ignore_abfd, symbol, native),
1414 bfd *ignore_abfd AND
6f715d66
SC		 1415 asymbol *symbol AND
1416 combined_entry_type *native)
1417{
1418 unsigned int name_length;
1419 union internal_auxent *auxent;
41f50af0 1420 char * name = ( char *)(symbol->name);
6f715d66
SC		 1421
1422 if (name == (char *) NULL) {
fb3be09b
JG		 1423 /* coff symbols always have names, so we'll make one up */
1424 symbol->name = "strange";
41f50af0 1425 name = (char *)symbol->name;
6f715d66
SC		 1426 }
1427 name_length = strlen(name);
cbdc7909 1428
6f715d66
SC		 1429 if (native->u.syment.n_sclass == C_FILE) {
1430 strncpy(native->u.syment._n._n_name, ".file", SYMNMLEN);
1431 auxent = &(native+1)->u.auxent;
cbdc7909 1432
6f715d66
SC		 1433#ifdef COFF_LONG_FILENAMES
1434 if (name_length <= FILNMLEN) {
1435 strncpy(auxent->x_file.x_fname, name, FILNMLEN);
1436 }
1437 else {
1438 auxent->x_file.x_n.x_offset = string_size + 4;
1439 auxent->x_file.x_n.x_zeroes = 0;
1440 string_size += name_length + 1;
1441 }
1442#else
1443 strncpy(auxent->x_file.x_fname, name, FILNMLEN);
1444 if (name_length > FILNMLEN) {
1445 name[FILNMLEN] = '\0';
1446 }
1447#endif
1448 }
1449 else
1450 { /* NOT A C_FILE SYMBOL */
1451 if (name_length <= SYMNMLEN) {
1452 /* This name will fit into the symbol neatly */
1453 strncpy(native->u.syment._n._n_name, symbol->name, SYMNMLEN);
1454 }
1455 else {
1456 native->u.syment._n._n_n._n_offset = string_size + 4;
1457 native->u.syment._n._n_n._n_zeroes = 0;
1458 string_size += name_length + 1;
1459 }
1460 }
1461}
1462
1463
1464
cbdc7909 1465static unsigned int
6f715d66
SC		 1466DEFUN(coff_write_symbol,(abfd, symbol, native, written),
1467bfd *abfd AND
1468asymbol *symbol AND
1469combined_entry_type *native AND
1470unsigned int written)
1471{
1472 unsigned int numaux = native->u.syment.n_numaux;
1473 int type = native->u.syment.n_type;
1474 int class = native->u.syment.n_sclass;
1475 SYMENT buf;
1476 unsigned int j;
6590a8c9
SC		 1477 if (symbol->section == &bfd_abs_section)
1478 {
1479 native->u.syment.n_scnum = N_ABS;
1480 }
1481 else if (symbol->section == &bfd_debug_section)
1482 {
1483 native->u.syment.n_scnum = N_DEBUG;
1484 }
1485 else if (symbol->section == &bfd_und_section)
1486 {
1487 native->u.syment.n_scnum = N_UNDEF;
1488 }
1489 else
1490 {
1491 native->u.syment.n_scnum =
1492 symbol->section->output_section->target_index;
1493 }
1494
e98e6ec1 1495
6f715d66 1496 coff_fix_symbol_name(abfd, symbol, native);
e98e6ec1 1497
6f715d66
SC		 1498 coff_swap_sym_out(abfd, &native->u.syment, &buf);
1499 bfd_write((PTR)& buf, 1, SYMESZ, abfd);
d05511ca 1500 for (j = 0; j <= native->u.syment.n_numaux; j++)
6590a8c9
SC		 1501 {
1502 AUXENT buf1;
1503 bzero((PTR)&buf, AUXESZ);
1504 coff_swap_aux_out(abfd,
1505 &( (native + j + 1)->u.auxent), type, class, &buf1);
1506 bfd_write((PTR) (&buf1), 1, AUXESZ, abfd);
1507 }
6f715d66
SC		 1508 /*
1509 Reuse somewhere in the symbol to keep the index
1510 */
1511 set_index(symbol, written);
1512 return written + 1 + numaux;
1513}
1514
1515
1516static unsigned int
1517DEFUN(coff_write_alien_symbol,(abfd, symbol, written),
1518 bfd *abfd AND
1519 asymbol *symbol AND
1520 unsigned int written)
1521{
1522 /*
1523 This symbol has been created by the loader, or come from a non
1524 coff format. It has no native element to inherit, make our
1525 own
1526 */
e98e6ec1
SC		 1527 combined_entry_type *native;
1528 combined_entry_type dummy;
6f715d66
SC		 1529 native = &dummy;
1530 native->u.syment.n_type = T_NULL;
1531#ifdef I960
1532 native->u.syment.n_flags = 0;
1533#endif
6590a8c9
SC		 1534 if (symbol->section == &bfd_und_section)
1535 {
e98e6ec1
SC		 1536 native->u.syment.n_scnum = N_UNDEF;
1537 native->u.syment.n_value = symbol->value;
1538 }
1539 else if (symbol->section == &bfd_com_section)
1540 {
1541 native->u.syment.n_scnum = N_UNDEF;
1542 native->u.syment.n_value = symbol->value;
1543
6f715d66 1544 }
e98e6ec1 1545
6f715d66 1546 else if (symbol->flags & BSF_DEBUGGING) {
e98e6ec1
SC		 1547 /*
1548 remove name so it doesn't take up any space
1549 */
1550 symbol->name = "";
1551 }
6f715d66 1552 else {
e98e6ec1
SC		 1553 native->u.syment.n_scnum = symbol->section->output_section->target_index;
1554 native->u.syment.n_value = symbol->value +
1555 symbol->section->output_section->vma +
6f715d66
SC		 1556 symbol->section->output_offset;
1557#ifdef I960
e98e6ec1
SC		 1558 /* Copy the any flags from the the file hdr into the symbol */
1559 {
1560 coff_symbol_type *c = coff_symbol_from(abfd, symbol);
1561 if (c != (coff_symbol_type *)NULL) {
6f715d66
SC		 1562 native->u.syment.n_flags = c->symbol.the_bfd->flags;
1563 }
e98e6ec1 1564 }
6f715d66 1565#endif
e98e6ec1 1566 }
cbdc7909 1567
6f715d66
SC		 1568#ifdef HASPAD1
1569 native->u.syment.pad1[0] = 0;
1570 native->u.syment.pad1[0] = 0;
1571#endif
cbdc7909 1572
6f715d66
SC		 1573 native->u.syment.n_type = 0;
1574 if (symbol->flags & BSF_LOCAL)
e98e6ec1 1575 native->u.syment.n_sclass = C_STAT;
cbdc7909 1576 else
e98e6ec1 1577 native->u.syment.n_sclass = C_EXT;
6f715d66
SC		 1578 native->u.syment.n_numaux = 0;
1579
1580 return coff_write_symbol(abfd, symbol, native, written);
1581}
1582
cbdc7909 1583static unsigned int
6f715d66
SC		 1584DEFUN(coff_write_native_symbol,(abfd, symbol, written),
1585bfd *abfd AND
1586coff_symbol_type *symbol AND
1587unsigned int written)
1588{
1589 /*
1590 Does this symbol have an ascociated line number - if so then
1591 make it remember this symbol index. Also tag the auxent of
1592 this symbol to point to the right place in the lineno table
1593 */
1594 combined_entry_type *native = symbol->native;
1595
1596 alent *lineno = symbol->lineno;
1597
2f8640fe 1598 if (lineno && !symbol->done_lineno) {
6f715d66
SC		 1599 unsigned int count = 0;
1600 lineno[count].u.offset = written;
1601 if (native->u.syment.n_numaux) {
1602 union internal_auxent *a = &((native+1)->u.auxent);
cbdc7909
JG		 1603
1604 a->x_sym.x_fcnary.x_fcn.x_lnnoptr =
6f715d66
SC		 1605 symbol->symbol.section->output_section->moving_line_filepos;
1606 }
1607 /*
1608 And count and relocate all other linenumbers
1609 */
e98e6ec1 1610
6f715d66
SC		 1611 count++;
1612 while (lineno[count].line_number) {
1613 lineno[count].u.offset +=
1614 symbol->symbol.section->output_section->vma +
1615 symbol->symbol.section->output_offset;
1616 count++;
1617 }
2f8640fe
SC		 1618 symbol->done_lineno = true;
1619
6f715d66
SC		 1620 symbol->symbol.section->output_section->moving_line_filepos +=
1621 count * LINESZ;
6f715d66
SC		 1622 }
1623 return coff_write_symbol(abfd, &( symbol->symbol), native,written);
1624}
1625
cbdc7909 1626static void
0f268757 1627DEFUN(coff_write_symbols,(abfd),
6f715d66 1628 bfd *abfd)
0f268757
SC		 1629{
1630 unsigned int i;
1631 unsigned int limit = bfd_get_symcount(abfd);
1632 unsigned int written = 0;
6f715d66 1633
0f268757 1634 asymbol **p;
6f715d66
SC		 1635
1636 string_size = 0;
cbdc7909
JG		 1637
1638
0f268757
SC		 1639 /* Seek to the right place */
1640 bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET);
cbdc7909 1641
0f268757 1642 /* Output all the symbols we have */
cbdc7909 1643
0f268757 1644 written = 0;
cbdc7909 1645 for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
0f268757 1646 {
6f715d66
SC		 1647 asymbol *symbol = *p;
1648 coff_symbol_type *c_symbol = coff_symbol_from(abfd, symbol);
6f715d66
SC		 1649
1650 if (c_symbol == (coff_symbol_type *) NULL ||
1651 c_symbol->native == (combined_entry_type *)NULL)
1652 {
1653 written = coff_write_alien_symbol(abfd, symbol, written);
0f268757 1654 }
6f715d66
SC		 1655 else
1656 {
1657 written = coff_write_native_symbol(abfd, c_symbol, written);
1658 }
1659
0f268757 1660 }
6f715d66 1661
0f268757 1662 bfd_get_symcount(abfd) = written;
6f715d66 1663
0f268757 1664 /* Now write out strings */
cbdc7909
JG		 1665
1666 if (string_size != 0)
6f715d66
SC		 1667 {
1668 unsigned int size = string_size + 4;
fb3be09b
JG		 1669 bfd_byte buffer[4];
1670
7a8b18b6
SC		 1671 bfd_h_put_32(abfd, size, buffer);
1672 bfd_write((PTR) buffer, 1, sizeof(buffer), abfd);
cbdc7909
JG		 1673 for (p = abfd->outsymbols, i = 0;
1674 i < limit;
1675 i++, p++)
6f715d66
SC		 1676 {
1677 asymbol *q = *p;
1678 size_t name_length = strlen(q->name);
1679 int maxlen;
1680 coff_symbol_type* c_symbol = coff_symbol_from(abfd, q);
7a8b18b6
SC		 1681 maxlen = ((c_symbol != NULL && c_symbol->native != NULL) &&
1682 (c_symbol->native->u.syment.n_sclass == C_FILE)) ?
6f715d66 1683 FILNMLEN : SYMNMLEN;
cbdc7909 1684
6f715d66
SC		 1685 if (name_length > maxlen) {
1686 bfd_write((PTR) (q->name), 1, name_length + 1, abfd);
1687 }
1688 }
1689 }
0f268757
SC		 1690 else {
1691 /* We would normally not write anything here, but we'll write
1692 out 4 so that any stupid coff reader which tries to read
1693 the string table even when there isn't one won't croak.
1694 */
cbdc7909 1695
0f268757
SC		 1696 uint32e_type size = 4;
1697 size = size;
1698 bfd_write((PTR)&size, 1, sizeof(size), abfd);
cbdc7909 1699
0f268757 1700 }
0f268757 1701}
7a8b18b6 1702
9fda1a39
SC		 1703/*
1704SUBSUBSECTION
1705 Writing Relocations
1706
9fda1a39
SC		 1707 To write relocations, all the back end does is step though the
1708 canonical relocation table, and create an
1709 @code{internal_reloc}. The symbol index to use is removed from
1710 the @code{offset} field in the symbol table supplied, the
1711 address comes directly from the sum of the section base
1712 address and the relocation offset and the type is dug directly
1713 from the howto field. Then the @code{internal_reloc} is
1714 swapped into the shape of an @code{external_reloc} and written
1715 out to disk.
1716
6f715d66 1717*/
0f268757 1718
cbdc7909 1719static void
6f715d66
SC		 1720DEFUN(coff_write_relocs,(abfd),
1721 bfd *abfd)
1722{
1723 asection *s;
1724 for (s = abfd->sections; s != (asection *) NULL; s = s->next) {
1725 unsigned int i;
1726 struct external_reloc dst;
cbdc7909 1727
6f715d66
SC		 1728 arelent **p = s->orelocation;
1729 bfd_seek(abfd, s->rel_filepos, SEEK_SET);
1730 for (i = 0; i < s->reloc_count; i++) {
1731 struct internal_reloc n;
1732 arelent *q = p[i];
1733 memset((PTR)&n, 0, sizeof(n));
1734 n.r_vaddr = q->address + s->vma;
1735 if (q->sym_ptr_ptr) {
1736 n.r_symndx = get_index((*(q->sym_ptr_ptr)));
1737 }
0f268757 1738#ifdef SELECT_RELOC
6f715d66
SC		 1739 /* Work out reloc type from what is required */
1740 SELECT_RELOC(n.r_type, q->howto);
0f268757 1741#else
6f715d66 1742 n.r_type = q->howto->type;
0f268757 1743#endif
0d740984 1744 coff_swap_reloc_out(abfd, &n, &dst);
6f715d66 1745 bfd_write((PTR) &n, 1, RELSZ, abfd);
0f268757
SC		 1746 }
1747 }
6f715d66 1748}
fb3be09b 1749#endif /* NO_COFF_SYMBOLS */
0f268757 1750
7a8b18b6
SC		 1751#ifndef NO_COFF_LINENOS
1752
cbdc7909 1753static void
0f268757
SC		 1754DEFUN(coff_write_linenumbers,(abfd),
1755 bfd *abfd)
6f715d66
SC		 1756{
1757 asection *s;
1758 for (s = abfd->sections; s != (asection *) NULL; s = s->next) {
1759 if (s->lineno_count) {
1760 asymbol **q = abfd->outsymbols;
1761 bfd_seek(abfd, s->line_filepos, SEEK_SET);
1762 /* Find all the linenumbers in this section */
1763 while (*q) {
1764 asymbol *p = *q;
1765 alent *l = BFD_SEND(p->the_bfd, _get_lineno, (p->the_bfd, p));
1766 if (l) {
1767 /* Found a linenumber entry, output */
1768 struct internal_lineno out;
1769 LINENO buff;
1770 memset( (PTR)&out, 0, sizeof(out));
1771 out.l_lnno = 0;
1772 out.l_addr.l_symndx = l->u.offset;
1773 coff_swap_lineno_out(abfd, &out, &buff);
1774 bfd_write((PTR) &buff, 1, LINESZ, abfd);
1775 l++;
1776 while (l->line_number) {
1777 out.l_lnno = l->line_number;
0f268757 1778 out.l_addr.l_symndx = l->u.offset;
2700c3c7 1779 coff_swap_lineno_out(abfd, &out, &buff);
0f268757
SC		 1780 bfd_write((PTR) &buff, 1, LINESZ, abfd);
1781 l++;
0f268757 1782 }
0f268757 1783 }
6f715d66 1784 q++;
0f268757
SC		 1785 }
1786 }
1787 }
6f715d66 1788}
0f268757 1789
7a8b18b6
SC		 1790static alent *
1791DEFUN(coff_get_lineno,(ignore_abfd, symbol),
1792 bfd *ignore_abfd AND
1793 asymbol *symbol)
1794{
1795 return coffsymbol(symbol)->lineno;
1796}
1797
1798#endif /* NO_COFF_LINENOS */
0f268757
SC		 1799
1800static asymbol *
1801coff_make_empty_symbol(abfd)
1802bfd *abfd;
6f715d66
SC		 1803{
1804 coff_symbol_type *new = (coff_symbol_type *) bfd_alloc(abfd, sizeof(coff_symbol_type));
1805 if (new == NULL) {
1806 bfd_error = no_memory;
1807 return (NULL);
1808 } /* on error */
1809 new->native = 0;
1810 new->lineno = (alent *) NULL;
2f8640fe 1811 new->done_lineno = false;
6f715d66
SC		 1812 new->symbol.the_bfd = abfd;
1813 return &new->symbol;
1814}
0f268757 1815
7a8b18b6
SC		 1816#ifndef NO_COFF_SYMBOLS
1817
cbdc7909 1818static void
ee32cba6 1819DEFUN(coff_print_symbol,(ignore_abfd, filep, symbol, how),
6f715d66 1820 bfd *ignore_abfd AND
41f50af0 1821 PTR filep AND
6f715d66 1822 asymbol *symbol AND
0d740984 1823 bfd_print_symbol_type how)
6f715d66 1824{
41f50af0 1825 FILE *file = (FILE *)filep;
6f715d66 1826 switch (how) {
3b4f1a5d
SC		 1827 case bfd_print_symbol_name:
1828 fprintf(file, "%s", symbol->name);
1829 break;
1830 case bfd_print_symbol_more:
1831 fprintf(file, "coff %lx %lx", (unsigned long) coffsymbol(symbol)->native,
1832 (unsigned long) coffsymbol(symbol)->lineno);
1833 break;
1834 case bfd_print_symbol_nm:
1835
1836 {
e98e6ec1 1837 CONST char *section_name = symbol->section->name;
3b4f1a5d
SC		 1838 bfd_print_symbol_vandf((PTR) file, symbol);
1839
1840
1841 fprintf(file, " %-5s %s %s %s",
1842 section_name,
1843 coffsymbol(symbol)->native ? "n" : "g",
1844 coffsymbol(symbol)->lineno ? "l" : " ",
1845 symbol->name);
1846 }
1847
1848
1849 break;
1850 case bfd_print_symbol_all:
1851 /* Print out the symbols in a reasonable way */
1852 {
e98e6ec1 1853 CONST char *section_name = symbol->section->name;
3b4f1a5d
SC		 1854
1855
1856 if (coffsymbol(symbol)->native)
6f715d66 1857 {
3b4f1a5d
SC		 1858 unsigned int aux;
1859 combined_entry_type *combined = coffsymbol(symbol)->native;
1860 combined_entry_type *root = obj_raw_syments(ignore_abfd);
1861
e98e6ec1
SC		 1862 fprintf(file,"[%3d]",
1863 combined - root);
3b4f1a5d 1864
cbdc7909 1865
3b4f1a5d
SC		 1866 fprintf(file, "(sc %2d)(fl%4x)(ty%3x)(sc%3d) nx(%d) %08x %s",
1867 combined->u.syment.n_scnum,
1868 combined->u.syment.n_flags,
1869 combined->u.syment.n_type,
1870 combined->u.syment.n_sclass,
1871 combined->u.syment.n_numaux,
1872 combined->u.syment.n_value,
1873 symbol->name
1874 );
1875 for (aux = 0; aux < combined->u.syment.n_numaux; aux++)
1876 {
1877 fprintf(file,"\n");
1878 switch (combined->u.syment.n_sclass) {
1879 case C_FILE:
1880 fprintf(file, "File ");
1881 break;
1882 default:
d05511ca 1883 fprintf(file, "AUX lnno %x size %x tagndx %x",
3b4f1a5d 1884 combined[aux+1].u.auxent.x_sym.x_misc.x_lnsz.x_lnno,
d05511ca
SC		 1885 combined[aux+1].u.auxent.x_sym.x_misc.x_lnsz.x_size,
1886 combined[aux+1].u.auxent.x_sym.x_tagndx.l);
3b4f1a5d
SC		 1887 break;
1888
1889 }
cbdc7909 1890
3b4f1a5d
SC		 1891 }
1892
2f8640fe
SC		 1893 {
1894 struct lineno_cache_entry *l = coffsymbol(symbol)->lineno;
1895 if (l)
1896 {
1897 printf("\n%s :", l->u.sym->name);
1898 l++;
1899 while (l->line_number)
1900 {
1901 printf("\n%4d : %x",
1902 l->line_number,
1903 l->u.offset);
1904 l++;
1905
1906 }
1907 }
1908 }
3b4f1a5d
SC		 1909
1910
1911
1912 }
1913
1914 else {
1915 bfd_print_symbol_vandf((PTR) file, symbol);
1916 fprintf(file, " %-5s %s %s %s",
1917 section_name,
1918 coffsymbol(symbol)->native ? "n" : "g",
1919 coffsymbol(symbol)->lineno ? "l" : " ",
1920 symbol->name);
1921 }
1922
1923 }
1924
1925 }
6f715d66 1926}
0f268757 1927
7a8b18b6
SC		 1928#endif /* NO_COFF_SYMBOLS */
1929
1930/* Set flags and magic number of a coff file from architecture and machine
1931 type. Result is true if we can represent the arch&type, false if not. */
0f268757 1932
0f268757 1933static boolean
6f715d66
SC		 1934DEFUN(coff_set_flags,(abfd, magicp, flagsp),
1935 bfd *abfd AND
1936 unsigned *magicp AND
1937 unsigned short *flagsp)
1938{
0d740984 1939 switch (bfd_get_arch(abfd)) {
cbdc7909 1940
0f268757 1941#ifdef I960ROMAGIC
cbdc7909 1942
3b4f1a5d 1943 case bfd_arch_i960:
cbdc7909 1944
6f715d66
SC		 1945 {
1946 unsigned flags;
1947 *magicp = I960ROMAGIC;
1948 /*
1949 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1950 I960RWMAGIC); FIXME???
1951 */
0d740984 1952 switch (bfd_get_mach(abfd)) {
6f715d66
SC		 1953 case bfd_mach_i960_core:
1954 flags = F_I960CORE;
1955 break;
1956 case bfd_mach_i960_kb_sb:
1957 flags = F_I960KB;
1958 break;
1959 case bfd_mach_i960_mc:
1960 flags = F_I960MC;
1961 break;
1962 case bfd_mach_i960_xa:
1963 flags = F_I960XA;
1964 break;
1965 case bfd_mach_i960_ca:
1966 flags = F_I960CA;
1967 break;
1968 case bfd_mach_i960_ka_sa:
1969 flags = F_I960KA;
1970 break;
1971 default:
1972 return false;
0f268757 1973 }
6f715d66
SC		 1974 *flagsp = flags;
1975 return true;
1976 }
1977 break;
0f268757
SC		 1978#endif
1979#ifdef MIPS
6f715d66
SC		 1980 case bfd_arch_mips:
1981 *magicp = MIPS_MAGIC_2;
1982 return true;
1983 break;
0f268757 1984#endif
20fdc627 1985#ifdef I386MAGIC
6f715d66
SC		 1986 case bfd_arch_i386:
1987 *magicp = I386MAGIC;
1988 return true;
20fdc627 1989#endif
0f268757 1990#ifdef MC68MAGIC
6f715d66
SC		 1991 case bfd_arch_m68k:
1992 *magicp = MC68MAGIC;
1993 return true;
0f268757 1994#endif
cbdc7909 1995
0f268757 1996#ifdef MC88MAGIC
3b4f1a5d
SC		 1997 case bfd_arch_m88k:
1998 *magicp = MC88OMAGIC;
1999 return true;
2000 break;
2001#endif
2002#ifdef H8300MAGIC
2003 case bfd_arch_h8300:
2004 *magicp = H8300MAGIC;
2005 return true;
2006 break;
0f268757 2007#endif
41f50af0 2008#ifdef A29K_MAGIC_BIG
3b4f1a5d
SC		 2009 case bfd_arch_a29k:
2010 if (abfd->xvec->byteorder_big_p)
2011 *magicp = A29K_MAGIC_BIG;
2012 else
2013 *magicp = A29K_MAGIC_LITTLE;
2014 return true;
2015 break;
41f50af0 2016#endif
cbdc7909
JG		 2017
2018#ifdef U802TOCMAGIC
2019 case bfd_arch_rs6000:
2020 *magicp = U802TOCMAGIC;
2021 break;
2022#endif
2023
6f715d66 2024 default: /* Unknown architecture */
8acc9e05 2025 /* return false; -- fall through to "return false" below, to avoid
cbdc7909 2026 "statement never reached" errors on the one below. */
8acc9e05 2027 break;
0f268757 2028 }
cbdc7909 2029
6f715d66
SC		 2030 return false;
2031}
0f268757
SC		 2032
2033
2034static boolean
6f715d66
SC		 2035DEFUN(coff_set_arch_mach,(abfd, arch, machine),
2036 bfd *abfd AND
2037 enum bfd_architecture arch AND
2038 unsigned long machine)
2039{
0d740984
SC		 2040 unsigned dummy1;
2041 unsigned short dummy2;
2042 bfd_default_set_arch_mach(abfd, arch, machine);
2043
2044 if (arch != bfd_arch_unknown &&
2045 coff_set_flags(abfd, &dummy1, &dummy2) != true)
2046 return false; /* We can't represent this type */
2047 return true; /* We're easy ... */
2048}
0f268757
SC		 2049
2050
2051/* Calculate the file position for each section. */
2052
cbdc7909 2053static void
6f715d66
SC		 2054DEFUN(coff_compute_section_file_positions,(abfd),
2055 bfd *abfd)
2056{
e98e6ec1
SC		 2057 asection *current;
2058 asection *previous = (asection *)NULL;
2059 file_ptr sofar = FILHSZ;
2060 file_ptr old_sofar;
2061 if (bfd_get_start_address(abfd))
2062 {
2063 /* A start address may have been added to the original file. In this
2064 case it will need an optional header to record it. */
2065 abfd->flags |= EXEC_P;
2066 }
85e0c721 2067
e98e6ec1
SC		 2068 if (abfd->flags & EXEC_P)
2069 sofar += AOUTSZ;
cbdc7909 2070
e98e6ec1
SC		 2071 sofar += abfd->section_count * SCNHSZ;
2072 for (current = abfd->sections;
2073 current != (asection *)NULL;
2074 current = current->next) {
cbdc7909 2075
e98e6ec1
SC		 2076 /* Only deal with sections which have contents */
2077 if (!(current->flags & SEC_HAS_CONTENTS))
2078 continue;
cbdc7909 2079
e98e6ec1
SC		 2080 /* Align the sections in the file to the same boundary on
2081 which they are aligned in virtual memory. I960 doesn't
2082 do this (FIXME) so we can stay in sync with Intel. 960
2083 doesn't yet page from files... */
0f268757 2084#ifndef I960
e98e6ec1
SC		 2085 {
2086 /* make sure this section is aligned on the right boundary - by
2087 padding the previous section up if necessary */
2088
2089 old_sofar= sofar;
2090 sofar = BFD_ALIGN(sofar, 1 << current->alignment_power);
2091 if (previous != (asection *)NULL) {
6590a8c9 2092 previous->_raw_size += sofar - old_sofar;
e98e6ec1
SC		 2093 }
2094 }
85e0c721 2095
0f268757 2096#endif
e98e6ec1
SC		 2097 /* FIXME, in demand paged files, the low order bits of the file
2098 offset must match the low order bits of the virtual address.
2099 "Low order" is apparently implementation defined. Add code
2100 here to round sofar up to match the virtual address. */
cbdc7909 2101
e98e6ec1 2102 current->filepos = sofar;
85e0c721 2103
e98e6ec1 2104 /* make sure that this section is of the right size too */
6590a8c9 2105 old_sofar = sofar += current->_raw_size;
e98e6ec1
SC		 2106 sofar = BFD_ALIGN(sofar, 1 << current->alignment_power);
2107 current->_raw_size += sofar - old_sofar ;
85e0c721 2108
e98e6ec1 2109 previous = current;
85e0c721 2110 }
e98e6ec1 2111 obj_relocbase(abfd) = sofar;
6f715d66 2112}
0f268757
SC		 2113
2114
2115
2116
2117/* SUPPRESS 558 */
2118/* SUPPRESS 529 */
2119static boolean
2120DEFUN(coff_write_object_contents,(abfd),
6f715d66 2121 bfd *abfd)
e98e6ec1
SC		 2122{
2123 asection *current;
2124 unsigned int count;
2125
2126 boolean hasrelocs = false;
2127 boolean haslinno = false;
2128 file_ptr reloc_base;
2129 file_ptr lineno_base;
2130 file_ptr sym_base;
2131 file_ptr scn_base;
2132 file_ptr data_base;
2133 unsigned long reloc_size = 0;
2134 unsigned long lnno_size = 0;
2135 asection *text_sec = NULL;
2136 asection *data_sec = NULL;
2137 asection *bss_sec = NULL;
cbdc7909 2138
e98e6ec1
SC		 2139 struct internal_filehdr internal_f;
2140 struct internal_aouthdr internal_a;
cbdc7909 2141
cbdc7909 2142
e98e6ec1
SC		 2143 bfd_error = system_call_error;
2144 /* Number the output sections, starting from one on the first section
2145 with a name which doesn't start with a * */
2146 count = 1;
2147 for (current = abfd->sections; current != (asection *)NULL;
2148 current = current->next)
2149 {
e98e6ec1 2150 current->target_index = count;
e98e6ec1
SC		 2151 }
2152
2153
cbdc7909 2154
6590a8c9
SC		 2155
2156
e98e6ec1 2157 if(abfd->output_has_begun == false) {
6f715d66
SC		 2158 coff_compute_section_file_positions(abfd);
2159 }
cbdc7909 2160
e98e6ec1 2161 if (abfd->sections != (asection *)NULL) {
6f715d66 2162 scn_base = abfd->sections->filepos;
e98e6ec1 2163 }
0f268757 2164 else {
e98e6ec1
SC		 2165 scn_base = 0;
2166 }
0f268757 2167 if (bfd_seek(abfd, scn_base, SEEK_SET) != 0)
e98e6ec1 2168 return false;
0f268757 2169 reloc_base = obj_relocbase(abfd);
cbdc7909 2170
0f268757
SC		 2171 /* Make a pass through the symbol table to count line number entries and
2172 put them into the correct asections */
cbdc7909 2173
7a8b18b6 2174#ifndef NO_COFF_LINENOS
0f268757 2175 coff_count_linenumbers(abfd);
7a8b18b6 2176#endif
0f268757 2177 data_base = scn_base;
cbdc7909 2178
0f268757 2179 /* Work out the size of the reloc and linno areas */
cbdc7909 2180
e98e6ec1
SC		 2181 for (current = abfd->sections; current != NULL; current =
2182 current->next)
2183 {
2184 /* We give section headers to +ve indexes */
2185 if (current->target_index > 0)
2186 {
2187
2188 reloc_size += current->reloc_count * RELSZ;
7a8b18b6 2189#ifndef NO_COFF_LINENOS
e98e6ec1 2190 lnno_size += current->lineno_count * LINESZ;
7a8b18b6 2191#endif
e98e6ec1
SC		 2192 data_base += SCNHSZ;
2193 }
2194
0f268757 2195 }
cbdc7909 2196
0f268757
SC		 2197 lineno_base = reloc_base + reloc_size;
2198 sym_base = lineno_base + lnno_size;
cbdc7909 2199
0f268757 2200 /* Indicate in each section->line_filepos its actual file address */
e98e6ec1
SC		 2201 for (current = abfd->sections; current != NULL; current =
2202 current->next)
2203 {
2204 if (current->target_index > 0)
2205 {
2206
2207 if (current->lineno_count) {
2208 current->line_filepos = lineno_base;
2209 current->moving_line_filepos = lineno_base;
7a8b18b6 2210#ifndef NO_COFF_LINENOS
e98e6ec1 2211 lineno_base += current->lineno_count * LINESZ;
7a8b18b6 2212#endif
e98e6ec1
SC		 2213 }
2214 else {
2215 current->line_filepos = 0;
2216 }
2217 if (current->reloc_count) {
2218 current->rel_filepos = reloc_base;
2219 reloc_base += current->reloc_count * sizeof(struct internal_reloc);
2220 }
2221 else {
2222 current->rel_filepos = 0;
2223 }
0f268757 2224 }
e98e6ec1
SC		 2225 }
2226
cbdc7909 2227
cbdc7909 2228
e98e6ec1
SC		 2229 /* Write section headers to the file. */
2230 internal_f.f_nscns = 0;
0f268757
SC		 2231 bfd_seek(abfd,
2232 (file_ptr) ((abfd->flags & EXEC_P) ?
2233 (FILHSZ + AOUTSZ) : FILHSZ),
2234 SEEK_SET);
cbdc7909 2235
e98e6ec1 2236{
0f268757 2237#if 0
e98e6ec1 2238 unsigned int pad = abfd->flags & D_PAGED ? data_base : 0;
0f268757 2239#endif
e98e6ec1 2240 unsigned int pad = 0;
cbdc7909 2241
e98e6ec1
SC		 2242 for (current = abfd->sections;
2243 current != NULL;
2244 current = current->next) {
2245 struct internal_scnhdr section;
2246 if (current->target_index > 0)
2247 {
2248 internal_f.f_nscns ++;
0f268757
SC		 2249 strncpy(&(section.s_name[0]), current->name, 8);
2250 section.s_vaddr = current->vma + pad;
2251 section.s_paddr = current->vma + pad;
6590a8c9 2252 section.s_size = current->_raw_size - pad;
0f268757
SC		 2253 /*
2254 If this section has no size or is unloadable then the scnptr
2255 will be 0 too
2256 */
6590a8c9 2257 if (current->_raw_size - pad == 0 ||
0f268757 2258 (current->flags & SEC_LOAD) == 0) {
e98e6ec1
SC		 2259 section.s_scnptr = 0;
2260 }
0f268757 2261 else {
e98e6ec1
SC		 2262 section.s_scnptr = current->filepos;
2263 }
0f268757
SC		 2264 section.s_relptr = current->rel_filepos;
2265 section.s_lnnoptr = current->line_filepos;
2266 section.s_nreloc = current->reloc_count;
2267 section.s_nlnno = current->lineno_count;
2268 if (current->reloc_count != 0)
e98e6ec1 2269 hasrelocs = true;
0f268757 2270 if (current->lineno_count != 0)
e98e6ec1 2271 haslinno = true;
cbdc7909 2272
41f50af0
SC		 2273 section.s_flags = sec_to_styp_flags(current->name,current->flags);
2274
0f268757 2275 if (!strcmp(current->name, _TEXT)) {
e98e6ec1
SC		 2276 text_sec = current;
2277 } else if (!strcmp(current->name, _DATA)) {
2278 data_sec = current;
2279 } else if (!strcmp(current->name, _BSS)) {
2280 bss_sec = current;
2281 }
cbdc7909 2282
0f268757
SC		 2283#ifdef I960
2284 section.s_align = (current->alignment_power
2285 ? 1 << current->alignment_power
2286 : 0);
2287
2288#endif
e98e6ec1
SC		 2289 {
2290 SCNHDR buff;
0f268757 2291
e98e6ec1
SC		 2292 coff_swap_scnhdr_out(abfd, &section, &buff);
2293 bfd_write((PTR) (&buff), 1, SCNHSZ, abfd);
2294
2295 }
0f268757 2296
0f268757
SC		 2297 pad = 0;
2298 }
e98e6ec1
SC		 2299 }
2300}
2301
0f268757
SC		 2302
2303 /* OK, now set up the filehdr... */
e98e6ec1
SC		 2304
2305 /* Don't include the internal abs section in the section count */
2306
0f268757
SC		 2307 /*
2308 We will NOT put a fucking timestamp in the header here. Every time you
2309 put it back, I will come in and take it out again. I'm sorry. This
2310 field does not belong here. We fill it with a 0 so it compares the
2311 same but is not a reasonable time. -- gnu@cygnus.com
2312 */
2313 /*
a0f3f080
SC		 2314 Well, I like it, and now we have *customers* who have requested it,
2315 so I'm conditionally compiling it in.
2316
2317 sac@cygnus.com
0f268757 2318 */
a0f3f080 2319#ifndef NOCOFF_TIMESTAMP
0f268757
SC		 2320 internal_f.f_timdat = time(0);
2321#else
2322 internal_f.f_timdat = 0;
2323#endif
2324
2325 if (bfd_get_symcount(abfd) != 0)
e98e6ec1 2326 internal_f.f_symptr = sym_base;
0f268757 2327 else
e98e6ec1 2328 internal_f.f_symptr = 0;
0f268757
SC		 2329
2330 internal_f.f_flags = 0;
2331
2332 if (abfd->flags & EXEC_P)
e98e6ec1 2333 internal_f.f_opthdr = AOUTSZ;
0f268757 2334 else
e98e6ec1 2335 internal_f.f_opthdr = 0;
0f268757
SC		 2336
2337 if (!hasrelocs)
e98e6ec1 2338 internal_f.f_flags |= F_RELFLG;
0f268757 2339 if (!haslinno)
e98e6ec1 2340 internal_f.f_flags |= F_LNNO;
0f268757 2341 if (0 == bfd_get_symcount(abfd))
e98e6ec1 2342 internal_f.f_flags |= F_LSYMS;
0f268757 2343 if (abfd->flags & EXEC_P)
e98e6ec1 2344 internal_f.f_flags |= F_EXEC;
a0f3f080 2345
0f268757 2346 if (!abfd->xvec->byteorder_big_p)
e98e6ec1 2347 internal_f.f_flags |= F_AR32WR;
a0f3f080
SC		 2348 else
2349 internal_f.f_flags |= F_AR32W;
2350
0f268757
SC		 2351 /*
2352 FIXME, should do something about the other byte orders and
2353 architectures.
2354 */
2355
2356 /* Set up architecture-dependent stuff */
2357
e98e6ec1
SC		 2358{ unsigned int magic = 0;
2359 unsigned short flags = 0;
2360 coff_set_flags(abfd, &magic, &flags);
2361 internal_f.f_magic = magic;
2362 internal_f.f_flags |= flags;
2363 /* ...and the "opt"hdr... */
0f268757 2364
cbdc7909 2365#ifdef A29K
e98e6ec1
SC		 2366# ifdef ULTRA3 /* NYU's machine */
2367 /* FIXME: This is a bogus check. I really want to see if there
2368 * is a .shbss or a .shdata section, if so then set the magic
2369 * number to indicate a shared data executable.
2370 */
2371 if (internal_f.f_nscns >= 7)
2372 internal_a.magic = SHMAGIC; /* Shared magic */
2373 else
2374# endif /* ULTRA3 */
2375 internal_a.magic = NMAGIC; /* Assume separate i/d */
41f50af0 2376#define __A_MAGIC_SET__
e98e6ec1 2377#endif /* A29K */
0f268757 2378#ifdef I960
e98e6ec1 2379 internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
41f50af0 2380#define __A_MAGIC_SET__
e98e6ec1 2381#endif /* I960 */
0f268757 2382#if M88
41f50af0 2383#define __A_MAGIC_SET__
e98e6ec1
SC		 2384 internal_a.magic = PAGEMAGICBCS;
2385#endif /* M88 */
41f50af0
SC		 2386
2387#if M68 || I386 || MIPS
2388#define __A_MAGIC_SET__
e98e6ec1
SC		 2389 /* Never was anything here for the 68k */
2390#endif /* M88 */
41f50af0 2391
cbdc7909
JG		 2392#if RS6000COFF_C
2393#define __A_MAGIC_SET__
e98e6ec1
SC		 2394 internal_a.magic = (abfd->flags & D_PAGED)? RS6K_AOUTHDR_ZMAGIC:
2395 (abfd->flags & WP_TEXT)? RS6K_AOUTHDR_NMAGIC:
2396 RS6K_AOUTHDR_OMAGIC;
cbdc7909
JG		 2397#endif
2398
41f50af0
SC		 2399#ifndef __A_MAGIC_SET__
2400# include "Your aouthdr magic number is not being set!"
2401#else
2402# undef __A_MAGIC_SET__
0f268757 2403#endif
e98e6ec1 2404}
0f268757
SC		 2405 /* Now should write relocs, strings, syms */
2406 obj_sym_filepos(abfd) = sym_base;
2407
7a8b18b6 2408#ifndef NO_COFF_SYMBOLS
0f268757 2409 if (bfd_get_symcount(abfd) != 0) {
e98e6ec1
SC		 2410 coff_renumber_symbols(abfd);
2411 coff_mangle_symbols(abfd);
2412 coff_write_symbols(abfd);
2413 coff_write_linenumbers(abfd);
2414 coff_write_relocs(abfd);
2415 }
2416#endif /* NO_COFF_SYMBOLS */
0f268757 2417 if (text_sec) {
6590a8c9 2418 internal_a.tsize = bfd_get_section_size_before_reloc(text_sec);
e98e6ec1
SC		 2419 internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
2420 }
0f268757 2421 if (data_sec) {
6590a8c9 2422 internal_a.dsize = bfd_get_section_size_before_reloc(data_sec);
e98e6ec1
SC		 2423 internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
2424 }
0f268757 2425 if (bss_sec) {
6590a8c9 2426 internal_a.bsize = bfd_get_section_size_before_reloc(bss_sec);
e98e6ec1 2427 }
0f268757
SC		 2428
2429 internal_a.entry = bfd_get_start_address(abfd);
2430 internal_f.f_nsyms = bfd_get_symcount(abfd);
2431
2432 /* now write them */
2433 if (bfd_seek(abfd, 0L, SEEK_SET) != 0)
e98e6ec1
SC		 2434 return false;
2435{
2436 FILHDR buff;
2437 coff_swap_filehdr_out(abfd, &internal_f, &buff);
2438 bfd_write((PTR) &buff, 1, FILHSZ, abfd);
2439}
0f268757 2440 if (abfd->flags & EXEC_P) {
e98e6ec1
SC		 2441 AOUTHDR buff;
2442 coff_swap_aouthdr_out(abfd, &internal_a, &buff);
2443 bfd_write((PTR) &buff, 1, AOUTSZ, abfd);
2444 }
0f268757 2445 return true;
6f715d66
SC		 2446}
2447
7a8b18b6
SC		 2448#ifndef NO_COFF_SYMBOLS
2449
6f715d66
SC		 2450/*
2451this function transforms the offsets into the symbol table into
2452pointers to syments.
2453*/
2454
2455
2456static void
fb3be09b
JG		 2457DEFUN(coff_pointerize_aux,(ignore_abfd, table_base, type, class, auxent),
2458bfd *ignore_abfd AND
6f715d66
SC		 2459combined_entry_type *table_base AND
2460int type AND
2461int class AND
2462combined_entry_type *auxent)
2463{
2464 /* Don't bother if this is a file or a section */
2465 if (class == C_STAT && type == T_NULL) return;
2466 if (class == C_FILE) return;
2467
2468 /* Otherwise patch up */
2469 if (ISFCN(type) || ISTAG(class) || class == C_BLOCK) {
6590a8c9
SC		 2470 auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p = table_base +
2471 auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l;
2472 auxent->fix_end = 1;
2473 }
7a8b18b6 2474 if (auxent->u.auxent.x_sym.x_tagndx.l != 0) {
6590a8c9
SC		 2475 auxent->u.auxent.x_sym.x_tagndx.p =
2476 table_base + auxent->u.auxent.x_sym.x_tagndx.l;
2477 auxent->fix_tag = 1;
2478 }
6f715d66
SC		 2479}
2480
7a8b18b6 2481#endif /* NO_COFF_SYMBOLS */
0f268757
SC		 2482
2483static boolean
6f715d66
SC		 2484DEFUN(coff_set_section_contents,(abfd, section, location, offset, count),
2485 bfd *abfd AND
2486 sec_ptr section AND
2487 PTR location AND
2488 file_ptr offset AND
41f50af0 2489 bfd_size_type count)
0f268757
SC		 2490{
2491 if (abfd->output_has_begun == false) /* set by bfd.c handler */
2492 coff_compute_section_file_positions(abfd);
2493
2494 bfd_seek(abfd, (file_ptr) (section->filepos + offset), SEEK_SET);
2495
2496 if (count != 0) {
2497 return (bfd_write(location, 1, count, abfd) == count) ? true : false;
2498 }
2499 return true;
2500}
2501#if 0
2502static boolean
2503coff_close_and_cleanup(abfd)
2504 bfd *abfd;
2505{
2506 if (!bfd_read_p(abfd))
2507 switch (abfd->format) {
2508 case bfd_archive:
2509 if (!_bfd_write_archive_contents(abfd))
2510 return false;
2511 break;
2512 case bfd_object:
2513 if (!coff_write_object_contents(abfd))
2514 return false;
2515 break;
2516 default:
2517 bfd_error = invalid_operation;
2518 return false;
2519 }
2520
2521 /* We depend on bfd_close to free all the memory on the obstack. */
2522 /* FIXME if bfd_release is not using obstacks! */
2523 return true;
2524}
2525
2526#endif
cbdc7909 2527static PTR
0f268757
SC		 2528buy_and_read(abfd, where, seek_direction, size)
2529 bfd *abfd;
2530 file_ptr where;
2531 int seek_direction;
2532 size_t size;
2533{
2534 PTR area = (PTR) bfd_alloc(abfd, size);
2535 if (!area) {
2536 bfd_error = no_memory;
2537 return (NULL);
2538 }
2539 bfd_seek(abfd, where, seek_direction);
2540 if (bfd_read(area, 1, size, abfd) != size) {
2541 bfd_error = system_call_error;
2542 return (NULL);
2543 } /* on error */
2544 return (area);
2545} /* buy_and_read() */
2546
6f715d66 2547
7a8b18b6 2548#ifndef NO_COFF_SYMBOLS
6f715d66
SC		 2549
2550static char *
2551DEFUN(build_string_table,(abfd),
2552bfd *abfd)
0f268757 2553{
6f715d66
SC		 2554 char string_table_size_buffer[4];
2555 unsigned int string_table_size;
2556 char *string_table;
cbdc7909
JG		 2557
2558 /* At this point we should be "seek"'d to the end of the
2559 symbols === the symbol table size. */
6f715d66
SC		 2560 if (bfd_read((char *) string_table_size_buffer,
2561 sizeof(string_table_size_buffer),
2562 1, abfd) != sizeof(string_table_size)) {
2563 bfd_error = system_call_error;
2564 return (NULL);
2565 } /* on error */
cbdc7909 2566
41f50af0 2567 string_table_size = bfd_h_get_32(abfd, (bfd_byte *) string_table_size_buffer);
cbdc7909 2568
6f715d66
SC		 2569 if ((string_table = (PTR) bfd_alloc(abfd, string_table_size -= 4)) == NULL) {
2570 bfd_error = no_memory;
2571 return (NULL);
2572 } /* on mallocation error */
2573 if (bfd_read(string_table, string_table_size, 1, abfd) != string_table_size) {
2574 bfd_error = system_call_error;
2575 return (NULL);
cbdc7909 2576 }
6f715d66
SC		 2577 return string_table;
2578}
0f268757 2579
cbdc7909
JG		 2580/* Allocate space for the ".debug" section, and read it.
2581 We did not read the debug section until now, because
2582 we didn't want to go to the trouble until someone needed it. */
2583
2584static char *
2585DEFUN(build_debug_section,(abfd),
2586 bfd *abfd)
2587{
2588 char *debug_section;
2589 long position;
2590
2591 asection *sect = bfd_get_section_by_name (abfd, ".debug");
2592
2593 if (!sect) {
2594 bfd_error = no_debug_section;
2595 return NULL;
2596 }
2597
e98e6ec1
SC		 2598 debug_section = (PTR) bfd_alloc (abfd,
2599 bfd_get_section_size_before_reloc (sect));
cbdc7909
JG		 2600 if (debug_section == NULL) {
2601 bfd_error = no_memory;
2602 return NULL;
2603 }
2604
2605 /* Seek to the beginning of the `.debug' section and read it.
2606 Save the current position first; it is needed by our caller.
2607 Then read debug section and reset the file pointer. */
2608
2609 position = bfd_tell (abfd);
2610 bfd_seek (abfd, sect->filepos, SEEK_SET);
e98e6ec1
SC		 2611 if (bfd_read (debug_section,
2612 bfd_get_section_size_before_reloc (sect), 1, abfd)
2613 != bfd_get_section_size_before_reloc(sect)) {
cbdc7909
JG		 2614 bfd_error = system_call_error;
2615 return NULL;
2616 }
2617 bfd_seek (abfd, position, SEEK_SET);
2618 return debug_section;
2619}
2620
2621
fb3be09b
JG		 2622/* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
2623 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
2624 be \0-terminated. */
2625static char *
2626DEFUN(copy_name,(abfd, name, maxlen),
2627 bfd *abfd AND
2628 char *name AND
2629 int maxlen)
2630{
2631 int len;
2632 char *newname;
cbdc7909 2633
fb3be09b
JG		 2634 for (len = 0; len < maxlen; ++len) {
2635 if (name[len] == '\0') {
2636 break;
2637 }
2638 }
cbdc7909 2639
fb3be09b
JG		 2640 if ((newname = (PTR) bfd_alloc(abfd, len+1)) == NULL) {
2641 bfd_error = no_memory;
2642 return (NULL);
2643 }
2644 strncpy(newname, name, len);
2645 newname[len] = '\0';
2646 return newname;
2647}
2648
2649
cbdc7909
JG		 2650/* Read a symbol table into freshly bfd_allocated memory, swap it, and
2651 knit the symbol names into a normalized form. By normalized here I
2652 mean that all symbols have an n_offset pointer that points to a null-
2653 terminated string. */
2654
2655#ifndef SYMNAME_IN_DEBUG
2656#define SYMNAME_IN_DEBUG(x) 0
2657#endif
0f268757 2658
6f715d66 2659static combined_entry_type *
0f268757
SC		 2660DEFUN(get_normalized_symtab,(abfd),
2661bfd *abfd)
2662{
6f715d66
SC		 2663 combined_entry_type *internal;
2664 combined_entry_type *internal_ptr;
a0f3f080 2665 combined_entry_type *symbol_ptr;
6f715d66 2666 combined_entry_type *internal_end;
0f268757
SC		 2667 SYMENT *raw;
2668 SYMENT *raw_src;
2669 SYMENT *raw_end;
2670 char *string_table = NULL;
cbdc7909 2671 char *debug_section = NULL;
0f268757 2672 unsigned long size;
6f715d66 2673
0f268757 2674 unsigned int raw_size;
6f715d66 2675 if (obj_raw_syments(abfd) != (combined_entry_type *)NULL) {
d05511ca
SC		 2676 return obj_raw_syments(abfd);
2677 }
6f715d66 2678 if ((size = bfd_get_symcount(abfd) * sizeof(combined_entry_type)) == 0) {
d05511ca
SC		 2679 bfd_error = no_symbols;
2680 return (NULL);
2681 }
0f268757 2682
6f715d66 2683 internal = (combined_entry_type *)bfd_alloc(abfd, size);
0f268757
SC		 2684 internal_end = internal + bfd_get_symcount(abfd);
2685
2686 raw_size = bfd_get_symcount(abfd) * SYMESZ;
2687 raw = (SYMENT *)bfd_alloc(abfd,raw_size);
2688
2689 if (bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET) == -1
2690 || bfd_read((PTR)raw, raw_size, 1, abfd) != raw_size) {
d05511ca
SC		 2691 bfd_error = system_call_error;
2692 return (NULL);
2693 }
0f268757
SC		 2694 /* mark the end of the symbols */
2695 raw_end = raw + bfd_get_symcount(abfd);
2696 /*
2697 FIXME SOMEDAY. A string table size of zero is very weird, but
2698 probably possible. If one shows up, it will probably kill us.
2699 */
2700
2701 /* Swap all the raw entries */
cbdc7909
JG		 2702 for (raw_src = raw, internal_ptr = internal;
2703 raw_src < raw_end;
2704 raw_src++, internal_ptr++) {
2705
d05511ca
SC		 2706 unsigned int i;
2707 coff_swap_sym_in(abfd, (char *)raw_src, (char *)&internal_ptr->u.syment);
a0f3f080
SC		 2708 internal_ptr->fix_tag = 0;
2709 internal_ptr->fix_end = 0;
d05511ca
SC		 2710 symbol_ptr = internal_ptr;
2711
2712 for (i = 0;
2713 i < symbol_ptr->u.syment.n_numaux;
2714 i++)
2715 {
2716 internal_ptr++;
2717 raw_src++;
2718
2719 internal_ptr->fix_tag = 0;
2720 internal_ptr->fix_end = 0;
2721 coff_swap_aux_in(abfd, (char *)(raw_src),
2722 symbol_ptr->u.syment.n_type,
2723 symbol_ptr->u.syment.n_sclass,
2724 &(internal_ptr->u.auxent));
2725
2726 coff_pointerize_aux(abfd,
2727 internal,
2728 symbol_ptr->u.syment.n_type,
2729 symbol_ptr->u.syment.n_sclass,
2730 internal_ptr);
2731 }
0f268757 2732 }
cbdc7909 2733
0f268757 2734 /* Free all the raw stuff */
0d740984 2735 bfd_release(abfd, raw);
0f268757 2736
6f715d66 2737 for (internal_ptr = internal; internal_ptr < internal_end;
cbdc7909 2738 internal_ptr ++)
d05511ca
SC		 2739 {
2740 if (internal_ptr->u.syment.n_sclass == C_FILE) {
2741 /* make a file symbol point to the name in the auxent, since
2742 the text ".file" is redundant */
2743 if ((internal_ptr+1)->u.auxent.x_file.x_n.x_zeroes == 0) {
cbdc7909 2744 /* the filename is a long one, point into the string table */
6f715d66 2745 if (string_table == NULL) {
d05511ca
SC		 2746 string_table = build_string_table(abfd);
2747 }
0f268757 2748
6f715d66 2749 internal_ptr->u.syment._n._n_n._n_offset =
d05511ca
SC		 2750 (int) (string_table - 4 +
2751 (internal_ptr+1)->u.auxent.x_file.x_n.x_offset);
6f715d66 2752 }
d05511ca 2753 else {
6f715d66
SC		 2754 /* ordinary short filename, put into memory anyway */
2755 internal_ptr->u.syment._n._n_n._n_offset = (int)
d05511ca
SC		 2756 copy_name(abfd, (internal_ptr+1)->u.auxent.x_file.x_fname,
2757 FILNMLEN);
6f715d66 2758 }
d05511ca
SC		 2759 }
2760 else {
2761 if (internal_ptr->u.syment._n._n_n._n_zeroes != 0) {
cbdc7909 2762 /* This is a "short" name. Make it long. */
6f715d66
SC		 2763 unsigned long i = 0;
2764 char *newstring = NULL;
cbdc7909
JG		 2765
2766 /* find the length of this string without walking into memory
2767 that isn't ours. */
6f715d66 2768 for (i = 0; i < 8; ++i) {
d05511ca
SC		 2769 if (internal_ptr->u.syment._n._n_name[i] == '\0') {
2770 break;
2771 } /* if end of string */
2772 } /* possible lengths of this string. */
cbdc7909 2773
6f715d66 2774 if ((newstring = (PTR) bfd_alloc(abfd, ++i)) == NULL) {
d05511ca
SC		 2775 bfd_error = no_memory;
2776 return (NULL);
2777 } /* on error */
6f715d66
SC		 2778 bzero(newstring, i);
2779 strncpy(newstring, internal_ptr->u.syment._n._n_name, i-1);
2780 internal_ptr->u.syment._n._n_n._n_offset = (int) newstring;
2781 internal_ptr->u.syment._n._n_n._n_zeroes = 0;
6f715d66 2782 }
d05511ca 2783 else if (!SYMNAME_IN_DEBUG(&internal_ptr->u.syment)) {
cbdc7909 2784 /* Long name already. Point symbol at the string in the table. */
6f715d66 2785 if (string_table == NULL) {
d05511ca
SC		 2786 string_table = build_string_table(abfd);
2787 }
cbdc7909 2788 internal_ptr->u.syment._n._n_n._n_offset = (int)
d05511ca 2789 (string_table - 4 + internal_ptr->u.syment._n._n_n._n_offset);
cbdc7909 2790 }
d05511ca 2791 else {
cbdc7909
JG		 2792 /* Long name in debug section. Very similar. */
2793 if (debug_section == NULL) {
d05511ca
SC		 2794 debug_section = build_debug_section(abfd);
2795 }
cbdc7909 2796 internal_ptr->u.syment._n._n_n._n_offset = (int)
d05511ca 2797 (debug_section + internal_ptr->u.syment._n._n_n._n_offset);
cbdc7909 2798 }
cbdc7909 2799 }
d05511ca
SC		 2800 internal_ptr += internal_ptr->u.syment.n_numaux;
2801 }
0f268757 2802
0f268757 2803 obj_raw_syments(abfd) = internal;
cbdc7909 2804
0f268757
SC		 2805 return (internal);
2806} /* get_normalized_symtab() */
2807
7a8b18b6
SC		 2808#endif /* NO_COFF_SYMBOLS */
2809
0f268757
SC		 2810static
2811struct sec *
2812DEFUN(section_from_bfd_index,(abfd, index),
2813 bfd *abfd AND
2814 int index)
2815{
e98e6ec1 2816 struct sec *answer = abfd->sections;
6590a8c9
SC		 2817
2818 if (index == N_ABS)
2819 {
2820 return &bfd_abs_section;
2821 }
2822 if (index == N_UNDEF)
2823 {
2824 return &bfd_und_section;
2825 }
2826 if(index == N_DEBUG)
2827 {
2828 return &bfd_debug_section;
2829
2830 }
e98e6ec1
SC		 2831
2832 while (answer) {
2833 if (answer->target_index == index)
2834 return answer;
0f268757
SC		 2835 answer = answer->next;
2836 }
e98e6ec1 2837 BFD_ASSERT(0);
0f268757
SC		 2838}
2839
7a8b18b6 2840#ifndef NO_COFF_LINENOS
0f268757 2841
9fda1a39
SC		 2842/*
2843SUBSUBSECTION
2844 Reading Linenumbers
2845
9fda1a39
SC		 2846 Creating the linenumber table is done by reading in the entire
2847 coff linenumber table, and creating another table for internal use.
6f715d66 2848
9fda1a39
SC		 2849 A coff line number table is structured so that each function
2850 is marked as having a line number of 0. Each line within the
2851 function is an offset from the first line in the function. The
2852 base of the line number information for the table is stored in
2853 the symbol associated with the function.
6f715d66 2854
9fda1a39
SC		 2855 The information is copied from the external to the internal
2856 table, and each symbol which marks a function is marked by
2857 pointing its...
6f715d66 2858
9fda1a39 2859 How does this work ?
6f715d66
SC		 2860
2861*/
0f268757
SC		 2862
2863static boolean
2864coff_slurp_line_table(abfd, asect)
2865bfd *abfd;
2866asection *asect;
2867 {
2868 LINENO *native_lineno;
2869 alent *lineno_cache;
cbdc7909 2870
0f268757 2871 BFD_ASSERT(asect->lineno == (alent *) NULL);
cbdc7909 2872
0f268757
SC		 2873 native_lineno = (LINENO *) buy_and_read(abfd,
2874 asect->line_filepos,
2875 SEEK_SET,
2876 (size_t) (LINESZ *
2877 asect->lineno_count));
2878 lineno_cache =
2879 (alent *) bfd_alloc(abfd, (size_t) ((asect->lineno_count + 1) * sizeof(alent)));
2880 if (lineno_cache == NULL) {
2881 bfd_error = no_memory;
2882 return false;
cbdc7909 2883 } else {
0f268757
SC		 2884 unsigned int counter = 0;
2885 alent *cache_ptr = lineno_cache;
2886 LINENO *src = native_lineno;
cbdc7909 2887
0f268757
SC		 2888 while (counter < asect->lineno_count) {
2889 struct internal_lineno dst;
2700c3c7 2890 coff_swap_lineno_in(abfd, src, &dst);
0f268757 2891 cache_ptr->line_number = dst.l_lnno;
cbdc7909 2892
0f268757
SC		 2893 if (cache_ptr->line_number == 0) {
2894 coff_symbol_type *sym =
2895 (coff_symbol_type *) (dst.l_addr.l_symndx
6f715d66 2896 + obj_raw_syments(abfd))->u.syment._n._n_n._n_zeroes;
0f268757
SC		 2897 cache_ptr->u.sym = (asymbol *) sym;
2898 sym->lineno = cache_ptr;
2899 }
2900 else {
2901 cache_ptr->u.offset = dst.l_addr.l_paddr
2902 - bfd_section_vma(abfd, asect);
2903 } /* If no linenumber expect a symbol index */
cbdc7909 2904
0f268757
SC		 2905 cache_ptr++;
2906 src++;
2907 counter++;
2908 }
2909 cache_ptr->line_number = 0;
cbdc7909 2910
0f268757
SC		 2911 }
2912 asect->lineno = lineno_cache;
2913 /* FIXME, free native_lineno here, or use alloca or something. */
2914 return true;
2915 } /* coff_slurp_line_table() */
2916
7a8b18b6
SC		 2917#endif /* NO_COFF_LINENOS */
2918
2919#ifndef NO_COFF_LINENOS
2920
0f268757
SC		 2921static boolean
2922DEFUN(coff_slurp_symbol_table,(abfd),
2923 bfd *abfd)
6f715d66
SC		 2924{
2925 combined_entry_type *native_symbols;
2926 coff_symbol_type *cached_area;
2927 unsigned int *table_ptr;
cbdc7909 2928
6f715d66
SC		 2929 unsigned int number_of_symbols = 0;
2930 if (obj_symbols(abfd))
2931 return true;
2932 bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET);
cbdc7909 2933
6f715d66
SC		 2934 /* Read in the symbol table */
2935 if ((native_symbols = get_normalized_symtab(abfd)) == NULL) {
2936 return (false);
2937 } /* on error */
cbdc7909 2938
6f715d66
SC		 2939 /* Allocate enough room for all the symbols in cached form */
2940 cached_area =
2941 (coff_symbol_type *)
2942 bfd_alloc(abfd, (size_t) (bfd_get_symcount(abfd) * sizeof(coff_symbol_type)));
cbdc7909 2943
6f715d66
SC		 2944 if (cached_area == NULL) {
2945 bfd_error = no_memory;
2946 return false;
2947 } /* on error */
2948 table_ptr =
2949 (unsigned int *)
2950 bfd_alloc(abfd, (size_t) (bfd_get_symcount(abfd) * sizeof(unsigned int)));
cbdc7909 2951
6f715d66
SC		 2952 if (table_ptr == NULL) {
2953 bfd_error = no_memory;
2954 return false;
85e0c721
SC		 2955 }
2956 else
2957 {
6f715d66
SC		 2958 coff_symbol_type *dst = cached_area;
2959 unsigned int last_native_index = bfd_get_symcount(abfd);
2960 unsigned int this_index = 0;
2961 while (this_index < last_native_index) {
2962 combined_entry_type *src = native_symbols + this_index;
2963 table_ptr[this_index] = number_of_symbols;
2964 dst->symbol.the_bfd = abfd;
cbdc7909 2965
6f715d66
SC		 2966 dst->symbol.name = (char *)(src->u.syment._n._n_n._n_offset);
2967 /*
2968 We use the native name field to point to the cached field
2969 */
2970 src->u.syment._n._n_n._n_zeroes = (int) dst;
2971 dst->symbol.section = section_from_bfd_index(abfd,
2972 src->u.syment.n_scnum);
2973 switch (src->u.syment.n_sclass) {
0f268757 2974#ifdef I960
6f715d66 2975 case C_LEAFEXT:
0f268757 2976#if 0
6f715d66
SC		 2977 dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
2978 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
2979 dst->symbol.flags |= BSF_NOT_AT_END;
0f268757 2980#endif
6f715d66 2981 /* Fall through to next case */
cbdc7909 2982
0f268757 2983#endif
cbdc7909 2984
6f715d66 2985 case C_EXT:
cbdc7909
JG		 2986#ifdef RS6000COFF_C
2987 case C_HIDEXT:
2988#endif
6f715d66
SC		 2989 if ((src->u.syment.n_scnum) == 0) {
2990 if ((src->u.syment.n_value) == 0) {
e98e6ec1 2991 dst->symbol.section = &bfd_und_section;
6f715d66
SC		 2992 dst->symbol.value= 0;
2993 }
2994 else {
e98e6ec1 2995 dst->symbol.section = &bfd_com_section;
6f715d66
SC		 2996 dst->symbol.value = (src->u.syment.n_value);
2997 }
2998 }
2999 else {
3000 /*
3001 Base the value as an index from the base of the
3002 section
3003 */
e98e6ec1 3004
6f715d66
SC		 3005 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
3006 dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
e98e6ec1 3007
6f715d66 3008 if (ISFCN((src->u.syment.n_type))) {
0f268757 3009 /*
6f715d66
SC		 3010 A function ext does not go at the end of a file
3011 */
3012 dst->symbol.flags |= BSF_NOT_AT_END;
0f268757 3013 }
6f715d66 3014 }
85e0c721
SC		 3015
3016
6f715d66 3017 break;
cbdc7909 3018
6f715d66 3019 case C_STAT: /* static */
0f268757 3020#ifdef I960
6f715d66 3021 case C_LEAFSTAT: /* static leaf procedure */
0f268757 3022#endif
6f715d66 3023 case C_LABEL: /* label */
0d740984
SC		 3024 if (src->u.syment.n_scnum == -2)
3025 dst->symbol.flags = BSF_DEBUGGING;
3026 else
3027 dst->symbol.flags = BSF_LOCAL;
6f715d66 3028 /*
0d740984
SC		 3029 Base the value as an index from the base of the section, if
3030 there is one
6f715d66 3031 */
0d740984
SC		 3032 if (dst->symbol.section)
3033 dst->symbol.value = (src->u.syment.n_value) -
3034 dst->symbol.section->vma;
3035 else
3036 dst->symbol.value = (src->u.syment.n_value) ;
6f715d66 3037 break;
cbdc7909 3038
6f715d66
SC		 3039 case C_MOS: /* member of structure */
3040 case C_EOS: /* end of structure */
41f50af0
SC		 3041#ifdef NOTDEF /* C_AUTOARG has the same value */
3042#ifdef C_GLBLREG
3043 case C_GLBLREG: /* A29k-specific storage class */
3044#endif
3045#endif
6f715d66
SC		 3046 case C_REGPARM: /* register parameter */
3047 case C_REG: /* register variable */
0f268757 3048#ifdef C_AUTOARG
6f715d66 3049 case C_AUTOARG: /* 960-specific storage class */
0f268757 3050#endif
6f715d66 3051 case C_TPDEF: /* type definition */
6f715d66
SC		 3052 case C_ARG:
3053 case C_AUTO: /* automatic variable */
3054 case C_FIELD: /* bit field */
3055 case C_ENTAG: /* enumeration tag */
3056 case C_MOE: /* member of enumeration */
3057 case C_MOU: /* member of union */
3058 case C_UNTAG: /* union tag */
6f715d66
SC		 3059 dst->symbol.flags = BSF_DEBUGGING;
3060 dst->symbol.value = (src->u.syment.n_value);
3061 break;
cbdc7909 3062
6f715d66
SC		 3063 case C_FILE: /* file name */
3064 case C_STRTAG: /* structure tag */
cbdc7909
JG		 3065#ifdef RS6000COFF_C
3066 case C_BINCL: /* beginning of include file */
3067 case C_EINCL: /* ending of include file */
3068 case C_GSYM:
3069 case C_LSYM:
3070 case C_PSYM:
3071 case C_RSYM:
3072 case C_RPSYM:
3073 case C_STSYM:
3074 case C_DECL:
3075 case C_ENTRY:
3076 case C_FUN:
3077 case C_BSTAT:
3078 case C_ESTAT:
3079#endif
6f715d66
SC		 3080 dst->symbol.flags = BSF_DEBUGGING;
3081 dst->symbol.value = (src->u.syment.n_value);
6f715d66 3082 break;
cbdc7909 3083
6f715d66
SC		 3084 case C_BLOCK: /* ".bb" or ".eb" */
3085 case C_FCN: /* ".bf" or ".ef" */
41f50af0 3086 case C_EFCN: /* physical end of function */
6f715d66
SC		 3087 dst->symbol.flags = BSF_LOCAL;
3088 /*
3089 Base the value as an index from the base of the section
3090 */
3091 dst->symbol.value = (src->u.syment.n_value) - dst->symbol.section->vma;
6f715d66 3092 break;
cbdc7909 3093
6f715d66
SC		 3094 case C_NULL:
3095 case C_EXTDEF: /* external definition */
3096 case C_ULABEL: /* undefined label */
3097 case C_USTATIC: /* undefined static */
3098 case C_LINE: /* line # reformatted as symbol table entry */
3099 case C_ALIAS: /* duplicate tag */
3100 case C_HIDDEN: /* ext symbol in dmert public lib */
6f715d66 3101 default:
cbdc7909
JG		 3102
3103 fprintf(stderr,"Unrecognized storage class %d\n",
41f50af0 3104 src->u.syment.n_sclass);
6f715d66
SC		 3105 abort();
3106 dst->symbol.flags = BSF_DEBUGGING;
3107 dst->symbol.value = (src->u.syment.n_value);
6f715d66
SC		 3108 break;
3109 }
cbdc7909 3110
6590a8c9 3111/* BFD_ASSERT(dst->symbol.flags != 0);*/
cbdc7909 3112
6f715d66 3113 dst->native = src;
cbdc7909 3114
6f715d66
SC		 3115 dst->symbol.udata = 0;
3116 dst->lineno = (alent *) NULL;
3117 this_index += (src->u.syment.n_numaux) + 1;
3118 dst++;
3119 number_of_symbols++;
3120 } /* walk the native symtab */
3121 } /* bfdize the native symtab */
cbdc7909 3122
6f715d66
SC		 3123 obj_symbols(abfd) = cached_area;
3124 obj_raw_syments(abfd) = native_symbols;
cbdc7909 3125
6f715d66
SC		 3126 bfd_get_symcount(abfd) = number_of_symbols;
3127 obj_convert(abfd) = table_ptr;
3128 /* Slurp the line tables for each section too */
3129 {
3130 asection *p;
3131 p = abfd->sections;
3132 while (p) {
3133 coff_slurp_line_table(abfd, p);
3134 p = p->next;
0f268757 3135 }
6f715d66
SC		 3136 }
3137 return true;
3138} /* coff_slurp_symbol_table() */
0f268757
SC		 3139
3140static unsigned int
3141coff_get_symtab_upper_bound(abfd)
3142bfd *abfd;
3143 {
3144 if (!coff_slurp_symbol_table(abfd))
3145 return 0;
cbdc7909 3146
0f268757
SC		 3147 return (bfd_get_symcount(abfd) + 1) * (sizeof(coff_symbol_type *));
3148 }
3149
3150
3151static unsigned int
85e0c721
SC		 3152DEFUN(coff_get_symtab, (abfd, alocation),
3153 bfd *abfd AND
3154 asymbol **alocation)
3155{
0f268757
SC		 3156 unsigned int counter = 0;
3157 coff_symbol_type *symbase;
3158 coff_symbol_type **location = (coff_symbol_type **) (alocation);
3159 if (!coff_slurp_symbol_table(abfd))
85e0c721
SC		 3160 return 0;
3161
3162 symbase = obj_symbols(abfd);
3163 while (counter < bfd_get_symcount(abfd))
3164 {
3165 /* This nasty code looks at the symbol to decide whether or
3166 not it is descibes a constructor/destructor entry point. It
3167 is structured this way to (hopefully) speed non matches */
3b4f1a5d
SC		 3168#if 0
3169 if (0 && symbase->symbol.name[9] == '$')
85e0c721
SC		 3170 {
3171 bfd_constructor_entry(abfd,
3172 (asymbol **)location,
3173 symbase->symbol.name[10] == 'I' ?
3174 "CTOR" : "DTOR");
3175 }
3b4f1a5d 3176#endif
85e0c721
SC		 3177 *(location++) = symbase++;
3178 counter++;
3179 }
0f268757
SC		 3180 *location++ = 0;
3181 return bfd_get_symcount(abfd);
85e0c721 3182}
0f268757 3183
7a8b18b6
SC		 3184#endif /* NO_COFF_SYMBOLS */
3185
0f268757
SC		 3186static unsigned int
3187coff_get_reloc_upper_bound(abfd, asect)
3188bfd *abfd;
3189sec_ptr asect;
3190 {
3191 if (bfd_get_format(abfd) != bfd_object) {
3192 bfd_error = invalid_operation;
3193 return 0;
3194 }
3195 return (asect->reloc_count + 1) * sizeof(arelent *);
3196 }
3197
9fda1a39
SC		 3198/*
3199SUBSUBSECTION
3200 Reading Relocations
3201
9fda1a39
SC		 3202 Coff relocations are easily transformed into the internal BFD form
3203 (@code{arelent}).
3204
3205 Reading a coff relocation table is done in the following stages:
3206
3207 o The entire coff relocation table is read into memory.
3208
3209 o Each relocation is processed in turn, first it is swapped from the
3210 external to the internal form.
3211
3212 o The symbol referenced in the relocation's symbol index is
3213 turned intoa pointer into the canonical symbol table. Note
3214 that this table is the same as the one returned by a call to
3215 @code{bfd_canonicalize_symtab}. The back end will call the
3216 routine and save the result if a canonicalization hasn't been done.
3217
3218 o The reloc index is turned into a pointer to a howto
3219 structure, in a back end specific way. For instance, the 386
3220 and 960 use the @code{r_type} to directly produce an index
3221 into a howto table vector; the 88k subtracts a number from the
3222 @code{r_type} field and creates an addend field.
3223
3224
6f715d66
SC		 3225*/
3226
3b4f1a5d
SC		 3227#ifndef CALC_ADDEND
3228#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
3229 if (ptr && ptr->the_bfd == abfd \
3230 && ptr->section != (asection *) NULL \
3231 && ((ptr->flags & BSF_OLD_COMMON)== 0)) \
3232 { \
3233 cache_ptr->addend = -(ptr->section->vma + ptr->value); \
3234 } \
3235 else { \
3236 cache_ptr->addend = 0; \
3237 }
3238#endif
3239
0f268757
SC		 3240static boolean
3241DEFUN(coff_slurp_reloc_table,(abfd, asect, symbols),
3242 bfd *abfd AND
3243 sec_ptr asect AND
3244 asymbol **symbols)
85e0c721 3245{
3b4f1a5d
SC		 3246 RELOC *native_relocs;
3247 arelent *reloc_cache;
3248 arelent *cache_ptr;
3249
3250 unsigned int idx;
3251
3252 if (asect->relocation)
3253 return true;
3254 if (asect->reloc_count == 0)
3255 return true;
3256 if (asect->flags & SEC_CONSTRUCTOR)
3257 return true;
7a8b18b6 3258#ifndef NO_COFF_SYMBOLS
3b4f1a5d
SC		 3259 if (!coff_slurp_symbol_table(abfd))
3260 return false;
3261#endif
3262 native_relocs =
3263 (RELOC *) buy_and_read(abfd,
3264 asect->rel_filepos,
3265 SEEK_SET,
3266 (size_t) (RELSZ *
3267 asect->reloc_count));
3268 reloc_cache = (arelent *)
3269 bfd_alloc(abfd, (size_t) (asect->reloc_count * sizeof(arelent)));
3270
3271 if (reloc_cache == NULL) {
3272 bfd_error = no_memory;
3273 return false;
3274 }
3275
3276
3277 for (idx = 0; idx < asect->reloc_count; idx ++)
3278 {
616ebcfd 3279#ifdef RELOC_PROCESSING
3b4f1a5d 3280 struct internal_reloc dst;
3b4f1a5d
SC		 3281 struct external_reloc *src;
3282
3283 cache_ptr = reloc_cache + idx;
3284 src = native_relocs + idx;
3b4f1a5d
SC		 3285 bfd_swap_reloc_in(abfd, src, &dst);
3286
9898b929
JG		 3287 RELOC_PROCESSING(cache_ptr, &dst, symbols, abfd, asect);
3288#else
616ebcfd
SC		 3289 struct internal_reloc dst;
3290 asymbol *ptr;
3291 struct external_reloc *src;
3292
3293 cache_ptr = reloc_cache + idx;
3294 src = native_relocs + idx;
3295
3296 bfd_swap_reloc_in(abfd, src, &dst);
3297
9898b929
JG		 3298
3299 cache_ptr->address = dst.r_vaddr;
3300
3b4f1a5d
SC		 3301 if (dst.r_symndx != -1)
3302 {
9898b929
JG		 3303 cache_ptr->sym_ptr_ptr = symbols + obj_convert(abfd)[dst.r_symndx];
3304 ptr = *(cache_ptr->sym_ptr_ptr);
3b4f1a5d
SC		 3305 }
3306 else
3307 {
9898b929
JG		 3308 cache_ptr->sym_ptr_ptr = 0;
3309 ptr = 0;
3b4f1a5d
SC		 3310
3311 }
85e0c721 3312
3b4f1a5d
SC		 3313 /*
3314 The symbols definitions that we have read in have been
3315 relocated as if their sections started at 0. But the offsets
3316 refering to the symbols in the raw data have not been
3317 modified, so we have to have a negative addend to compensate.
3318
3319 Note that symbols which used to be common must be left alone */
cbdc7909 3320
3b4f1a5d
SC		 3321 /* Calculate any reloc addend by looking at the symbol */
3322 CALC_ADDEND(abfd, ptr, dst, cache_ptr);
cbdc7909 3323
3b4f1a5d 3324 cache_ptr->address -= asect->vma;
e98e6ec1 3325/* !! cache_ptr->section = (asection *) NULL;*/
20fdc627 3326
3b4f1a5d 3327 /* Fill in the cache_ptr->howto field from dst.r_type */
e98e6ec1 3328 RTYPE2HOWTO(cache_ptr, &dst);
9898b929
JG		 3329#endif
3330
3331 }
cbdc7909 3332
3b4f1a5d
SC		 3333 asect->relocation = reloc_cache;
3334 return true;
85e0c721 3335}
0f268757
SC		 3336
3337
3338/* This is stupid. This function should be a boolean predicate */
3339static unsigned int
85e0c721
SC		 3340DEFUN(coff_canonicalize_reloc, (abfd, section, relptr, symbols),
3341bfd *abfd AND
3342sec_ptr section AND
3343arelent **relptr AND
3344asymbol **symbols)
3345{
e98e6ec1
SC		 3346 arelent *tblptr = section->relocation;
3347 unsigned int count = 0;
cbdc7909 3348
cbdc7909 3349
e98e6ec1
SC		 3350 if (section->flags & SEC_CONSTRUCTOR)
3351 {
3352 /* this section has relocs made up by us, they are not in the
3353 file, so take them out of their chain and place them into
3354 the data area provided */
3355 arelent_chain *chain = section->constructor_chain;
3356 for (count = 0; count < section->reloc_count; count ++)
85e0c721 3357 {
e98e6ec1
SC		 3358 *relptr ++ = &chain->relent;
3359 chain = chain->next;
85e0c721 3360 }
e98e6ec1
SC		 3361
3362 }
3363 else
3364 {
3365 coff_slurp_reloc_table(abfd, section, symbols);
85e0c721
SC		 3366
3367
e98e6ec1
SC		 3368 tblptr = section->relocation;
3369 if (!tblptr)
3370 return 0;
85e0c721 3371
e98e6ec1
SC		 3372 for (; count++ < section->reloc_count;)
3373 *relptr++ = tblptr++;
cbdc7909 3374
85e0c721 3375
e98e6ec1
SC		 3376 }
3377 *relptr = 0;
3378 return section->reloc_count;
85e0c721 3379}
0f268757 3380
7a8b18b6 3381#ifndef NO_COFF_SYMBOLS
0f268757
SC		 3382
3383/*
6724ff46 3384provided a BFD, a section and an offset into the section, calculate and
0f268757
SC		 3385return the name of the source file and the line nearest to the wanted
3386location.
3387*/
3388
3389static boolean
3390DEFUN(coff_find_nearest_line,(abfd,
3391 section,
fb3be09b 3392 ignore_symbols,
0f268757
SC		 3393 offset,
3394 filename_ptr,
3395 functionname_ptr,
3396 line_ptr),
3397 bfd *abfd AND
3398 asection *section AND
fb3be09b 3399 asymbol **ignore_symbols AND
0f268757
SC		 3400 bfd_vma offset AND
3401 CONST char **filename_ptr AND
3402 CONST char **functionname_ptr AND
3403 unsigned int *line_ptr)
3404{
3405 static bfd *cache_abfd;
3406 static asection *cache_section;
3407 static bfd_vma cache_offset;
3408 static unsigned int cache_i;
3409 static alent *cache_l;
cbdc7909 3410
0f268757 3411 unsigned int i = 0;
fb3be09b 3412 coff_data_type *cof = coff_data(abfd);
0f268757 3413 /* Run through the raw syments if available */
6f715d66 3414 combined_entry_type *p;
0f268757
SC		 3415 alent *l;
3416 unsigned int line_base = 0;
cbdc7909
JG		 3417
3418
0f268757
SC		 3419 *filename_ptr = 0;
3420 *functionname_ptr = 0;
3421 *line_ptr = 0;
cbdc7909 3422
0f268757 3423 /* Don't try and find line numbers in a non coff file */
0d740984 3424 if (abfd->xvec->flavour != bfd_target_coff_flavour)
0f268757 3425 return false;
cbdc7909 3426
fb3be09b 3427 if (cof == NULL)
0f268757 3428 return false;
6f715d66 3429
0f268757 3430 p = cof->raw_syments;
cbdc7909 3431
0f268757 3432 for (i = 0; i < cof->raw_syment_count; i++) {
6f715d66
SC		 3433 if (p->u.syment.n_sclass == C_FILE) {
3434 /* File name has been moved into symbol */
3435 *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
0f268757
SC		 3436 break;
3437 }
6f715d66 3438 p += 1 + p->u.syment.n_numaux;
0f268757
SC		 3439 }
3440 /* Now wander though the raw linenumbers of the section */
3441 /*
6724ff46 3442 If this is the same BFD as we were previously called with and this is
0f268757
SC		 3443 the same section, and the offset we want is further down then we can
3444 prime the lookup loop
3445 */
3446 if (abfd == cache_abfd &&
3447 section == cache_section &&
3448 offset >= cache_offset) {
3449 i = cache_i;
3450 l = cache_l;
3451 }
3452 else {
3453 i = 0;
3454 l = section->lineno;
3455 }
cbdc7909 3456
0f268757
SC		 3457 for (; i < section->lineno_count; i++) {
3458 if (l->line_number == 0) {
3459 /* Get the symbol this line number points at */
3460 coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym);
3461 *functionname_ptr = coff->symbol.name;
3462 if (coff->native) {
6f715d66
SC		 3463 combined_entry_type *s = coff->native;
3464 s = s + 1 + s->u.syment.n_numaux;
0f268757
SC		 3465 /*
3466 S should now point to the .bf of the function
3467 */
6f715d66 3468 if (s->u.syment.n_numaux) {
0f268757
SC		 3469 /*
3470 The linenumber is stored in the auxent
3471 */
6f715d66 3472 union internal_auxent *a = &((s + 1)->u.auxent);
0f268757
SC		 3473 line_base = a->x_sym.x_misc.x_lnsz.x_lnno;
3474 }
3475 }
3476 }
3477 else {
3478 if (l->u.offset > offset)
3479 break;
3480 *line_ptr = l->line_number + line_base + 1;
3481 }
3482 l++;
3483 }
cbdc7909 3484
0f268757
SC		 3485 cache_abfd = abfd;
3486 cache_section = section;
3487 cache_offset = offset;
3488 cache_i = i;
3489 cache_l = l;
6f715d66 3490
0f268757
SC		 3491 return true;
3492}
3493
3494#ifdef GNU960
3495file_ptr
3496coff_sym_filepos(abfd)
3497bfd *abfd;
3498 {
3499 return obj_sym_filepos(abfd);
3500 }
3501#endif
3502
7a8b18b6
SC		 3503#endif /* NO_COFF_SYMBOLS */
3504
0f268757 3505
cbdc7909 3506static int
0f268757
SC		 3507DEFUN(coff_sizeof_headers,(abfd, reloc),
3508 bfd *abfd AND
3509 boolean reloc)
85e0c721 3510{
0f268757 3511 size_t size;
cbdc7909 3512
0f268757 3513 if (reloc == false) {
85e0c721 3514 size = FILHSZ + AOUTSZ;
0f268757
SC		 3515 }
3516 else {
85e0c721 3517 size = FILHSZ;
0f268757 3518 }
cbdc7909 3519
0f268757
SC		 3520 size += abfd->section_count * SCNHSZ;
3521 return size;
85e0c721 3522}
0f268757 3523
6590a8c9
SC		 3524static bfd_vma
3525DEFUN(get_value,(reloc, seclet),
3526 arelent *reloc AND
3527 bfd_seclet_type *seclet)
3528{
3529 bfd_vma value;
3530 asymbol *symbol = *(reloc->sym_ptr_ptr);
3531 /* A symbol holds a pointer to a section, and an offset from the
3532 base of the section. To relocate, we find where the section will
3533 live in the output and add that in */
3534
3535 if (symbol->section == &bfd_und_section)
3536 {
3537 /* Ouch, this is an undefined symbol.. */
3538 bfd_error_vector.undefined_symbol(reloc, seclet);
3539 value = symbol->value;
3540 }
3541 else
3542 {
3543 value = symbol->value +
3544 symbol->section->output_offset +
3545 symbol->section->output_section->vma;
3546 }
3547
3548
3549 /* Add the value contained in the relocation */
3550 value += (short)((reloc->addend) & 0xffff);
3551
3552 return value;
3553}
3554
3555static void
3556DEFUN(perform_slip,(s, slip, input_section, value),
3557 asymbol **s AND
3558 unsigned int slip AND
3559 asection *input_section AND
3560 bfd_vma value)
3561{
3562
3563 /* Find all symbols past this point, and make them know
3564 what's happened */
3565 while (*s)
3566 {
3567 asymbol *p = *s;
3568 if (p->section == input_section)
3569 {
3570 /* This was pointing into this section, so mangle it */
3571 if (p->value > value)
3572 {
3573 p->value -=2;
3574 }
3575 }
3576 s++;
3577
3578 }
3579}
3580static int
3581DEFUN(movb1,(input_section, symbols, r, shrink),
3582 asection *input_section AND
3583 asymbol **symbols AND
3584 arelent *r AND
3585 unsigned int shrink)
3586{
3587 bfd_vma value = get_value(r,0);
3588
3589 if (value >= 0xff00)
3590 {
3591
3592 /* Change the reloc type from 16bit, possible 8 to 8bit
3593 possible 16 */
3594 r->howto = r->howto + 1;
3595 /* The place to relc moves back by one */
3596 r->address -=1;
3597
3598 /* This will be two bytes smaller in the long run */
3599 shrink +=2 ;
3600 perform_slip(symbols, 2, input_section, r->address - shrink +1);
3601
3602
3603 }
3604 return shrink;
3605}
3606
3607static int
3608DEFUN(jmp1,(input_section, symbols, r, shrink),
3609 asection *input_section AND
3610 asymbol **symbols AND
3611 arelent *r AND
3612 unsigned int shrink)
3613{
3614
3615
3616 bfd_vma value = get_value(r, 0);
3617
3618 bfd_vma dot = input_section->output_section->vma +
3619 input_section->output_offset + r->address;
3620 bfd_vma gap;
3621
3622 /* See if the address we're looking at within 127 bytes of where
3623 we are, if so then we can use a small branch rather than the
3624 jump we were going to */
3625
3626 gap = value - (dot - shrink);
3627
3628
3629 if (-120 < (long)gap && (long)gap < 120 )
3630 {
3631
3632 /* Change the reloc type from 16bit, possible 8 to 8bit
3633 possible 16 */
3634 r->howto = r->howto + 1;
3635 /* The place to relc moves back by one */
3636 r->address -=1;
3637
3638 /* This will be two bytes smaller in the long run */
3639 shrink +=2 ;
3640 perform_slip(symbols, 2, input_section, r->address-shrink +1);
3641
3642
3643 }
3644 return shrink;
3645}
3646
2f8640fe 3647static boolean
a0f3f080 3648DEFUN(bfd_coff_relax_section,(abfd, i, symbols),
6590a8c9
SC		 3649 bfd *abfd AND
3650 asection *i AND
a0f3f080 3651 asymbol **symbols)
6590a8c9
SC		 3652{
3653
3654 /* Get enough memory to hold the stuff */
3655 bfd *input_bfd = i->owner;
3656 asection *input_section = i;
3657 int shrink = 0 ;
2f8640fe 3658 boolean new = false;
6590a8c9
SC		 3659
3660 bfd_size_type reloc_size = bfd_get_reloc_upper_bound(input_bfd,
3661 input_section);
3662 arelent **reloc_vector = (arelent **)bfd_xmalloc(reloc_size);
3663
3664 /* Get the relocs and think about them */
3665 if (bfd_canonicalize_reloc(input_bfd,
3666 input_section,
3667 reloc_vector,
3668 symbols))
3669 {
3670 arelent **parent;
3671 for (parent = reloc_vector; *parent; parent++)
3672 {
3673 arelent *r = *parent;
3674 switch (r->howto->type) {
3675 case R_MOVB2:
3676 case R_JMP2:
3677
3678 shrink+=2;
3679 break;
3680
3681 case R_MOVB1:
3682 shrink = movb1(input_section, symbols, r, shrink);
2f8640fe 3683 new = true;
6590a8c9
SC		 3684
3685 break;
3686 case R_JMP1:
3687 shrink = jmp1(input_section, symbols, r, shrink);
2f8640fe 3688 new = true;
6590a8c9
SC		 3689
3690 break;
3691 }
3692 }
3693
3694 }
3695 input_section->_cooked_size -= shrink;
3696 free((char *)reloc_vector);
3697 return new;
3698}
3699
3700static bfd_byte *
3701DEFUN(bfd_coff_get_relocated_section_contents,(in_abfd, seclet),
3702 bfd *in_abfd AND
3703 bfd_seclet_type *seclet)
3704
3705{
3706 asymbol **symbols = 0;
3707 extern bfd *output_bfd;
3708
3709 /* Get enough memory to hold the stuff */
3710 bfd *input_bfd = seclet->u.indirect.section->owner;
3711 asection *input_section = seclet->u.indirect.section;
3712
2f8640fe
SC		 3713 bfd_byte *data = (bfd_byte *)malloc(input_section->_raw_size);
3714 bfd_byte *dst = data;
3715 bfd_byte *prev_dst = data;
6590a8c9
SC		 3716
3717 unsigned int gap = 0;
3718
3719 bfd_size_type reloc_size = bfd_get_reloc_upper_bound(input_bfd,
3720 input_section);
3721 arelent **reloc_vector = (arelent **)bfd_xmalloc(reloc_size);
3722
3723 /* read in the section */
3724 bfd_get_section_contents(input_bfd,
3725 input_section,
3726 data,
3727 0,
3728 input_section->_raw_size);
3729
3730
3731 if (bfd_canonicalize_reloc(input_bfd,
3732 input_section,
3733 reloc_vector,
3734 seclet->u.indirect.symbols) )
3735 {
3736 arelent **parent = reloc_vector;
3737 arelent *reloc ;
3738
3739
3740
3741 unsigned int dst_address = 0;
3742 unsigned int src_address = 0;
3743 unsigned int run;
3744 unsigned int idx;
3745
3746 /* Find how long a run we can do */
3747 while (dst_address < seclet->size)
3748 {
3749
3750 reloc = *parent;
3751 if (reloc)
3752 {
3753 /* Note that the relaxing didn't tie up the addresses in the
3754 relocation, so we use the original address to work out the
3755 run of non-relocated data */
3756 run = reloc->address - src_address;
3757 parent++;
3758
3759 }
3760 else
3761 {
3762 run = seclet->size - dst_address;
3763 }
3764 /* Copy the bytes */
3765 for (idx = 0; idx < run; idx++)
3766 {
3767 data[dst_address++] = data[src_address++];
3768 }
3769
3770 /* Now do the relocation */
3771
3772 if (reloc)
3773 {
3774 switch (reloc->howto->type)
3775 {
3776 case R_JMP2:
3777 /* Speciial relaxed type */
3778 {
3779 bfd_vma dot = seclet->offset + dst_address + seclet->u.indirect.section->output_section->vma;
3780 int gap = get_value(reloc,seclet)-dot-1;
3781 if ((gap & ~0xff ) != 0 &&((gap & 0xff00)!= 0xff00)) abort();
3782
3783 bfd_put_8(in_abfd,gap, data+dst_address);
3784
3785 switch (data[dst_address-1])
3786 {
3787
3788 case 0x5e:
3789 /* jsr -> bsr */
3790 bfd_put_8(in_abfd, 0x55, data+dst_address-1);
3791 break;
3792 case 0x5a:
3793 /* jmp ->bra */
3794 bfd_put_8(in_abfd, 0x40, data+dst_address-1);
3795 break;
3796
3797 default:
3798 abort();
3799
3800 }
3801
3802
3803
3804
3805 dst_address++;
3806 src_address+=3;
3807
3808 break;
3809 }
3810
3811
3812 case R_MOVB2:
3813 /* Special relaxed type, there will be a gap between where we
3814 get stuff from and where we put stuff to now
3815
3816 for a mov.b @aa:16 -> mov.b @aa:8
3817 opcode 0x6a 0x0y offset
3818 -> 0x2y off
3819 */
3820 if (data[dst_address-1] != 0x6a)
3821 abort();
3822 switch (data[dst_address] & 0xf0)
3823 {
3824 case 0x00:
3825 /* Src is memory */
3826 data[dst_address-1] = (data[src_address] & 0xf) | 0x20;
3827 break;
3828 case 0x80:
3829 /* Src is reg */
3830 data[dst_address-1] = (data[src_address] & 0xf) | 0x30;
3831 break;
3832 default:
3833 abort();
3834 }
3835
3836 /* the offset must fit ! after all, what was all the relaxing
3837 about ? */
3838
3839 bfd_put_8(in_abfd, get_value(reloc, seclet), data + dst_address);
3840
3841 /* Note the magic - src goes up by two bytes, but dst by only
3842 one */
3843 dst_address+=1;
3844 src_address+=3;
3845
3846 break;
3847 /* PCrel 8 bits */
3848 case R_PCRBYTE:
3849 {
3850 bfd_vma dot = seclet->offset + dst_address + seclet->u.indirect.section->output_section->vma;
3851 int gap = get_value(reloc,seclet)-dot;
3852 if (gap > 127 || gap < -128)
3853 {
3854 bfd_error_vector.reloc_value_truncated(reloc, seclet);
3855 }
3856
3857 bfd_put_8(in_abfd,gap, data+dst_address);
3858 dst_address++;
3859 src_address++;
3860
3861 break;
3862 }
3863
3864 case R_RELBYTE:
3865 {
3866 unsigned int gap =get_value(reloc,seclet);
3867 if (gap > 256)
3868 {
3869 bfd_error_vector.reloc_value_truncated(reloc, seclet);
3870 }
3871
3872 bfd_put_8(in_abfd, gap, data+dst_address);
3873 dst_address+=1;
3874 src_address+=1;
3875
3876
3877 }
3878 break;
3879 case R_JMP1:
3880 /* A relword which would have like to have been a pcrel */
3881 case R_MOVB1:
3882 /* A relword which would like to have been modified but
3883 didn't make it */
3884 case R_RELWORD:
3885 bfd_put_16(in_abfd, get_value(reloc,seclet), data+dst_address);
3886 dst_address+=2;
3887 src_address+=2;
3888 break;
3889
3890 default:
3891 abort();
3892 }
3893 }
3894 }
3895 }
3896 free((char *)reloc_vector);
3897 return data;
3898
3899}
3900
0f268757
SC		 3901
3902#define coff_core_file_failing_command _bfd_dummy_core_file_failing_command
3903#define coff_core_file_failing_signal _bfd_dummy_core_file_failing_signal
3904#define coff_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
3905#define coff_slurp_armap bfd_slurp_coff_armap
3906#define coff_slurp_extended_name_table _bfd_slurp_extended_name_table
3907#define coff_truncate_arname bfd_dont_truncate_arname
3908#define coff_openr_next_archived_file bfd_generic_openr_next_archived_file
3909#define coff_generic_stat_arch_elt bfd_generic_stat_arch_elt
3910#define coff_get_section_contents bfd_generic_get_section_contents
3911#define coff_close_and_cleanup bfd_generic_close_and_cleanup
6f715d66
SC		 3912
3913#define coff_bfd_debug_info_start bfd_void
3914#define coff_bfd_debug_info_end bfd_void
41f50af0 3915#define coff_bfd_debug_info_accumulate (PROTO(void,(*),(bfd*, struct sec *))) bfd_void
6590a8c9
SC		 3916#define coff_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
3917#define coff_bfd_relax_section bfd_generic_relax_section
3918
GDB Binutils - Deliverables
This page took 0.231213 seconds and 4 git commands to generate.