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