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