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