projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add 29k-UDI stuff back in...
[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
061a65a5 653 if (ISARY(type)) {
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 }
061a65a5
SEF		 663 if (class == C_BLOCK || ISFCN(type) || ISTAG(type)) {
664 in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR(abfd, ext);
665 in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX(abfd, ext);
666 }
6f715d66 667
d05511ca
SC		 668 if (ISFCN(type)) {
669 in->x_sym.x_misc.x_fsize = bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_misc.x_fsize);
670 }
671 else {
672 in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO(abfd, ext);
673 in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE(abfd, ext);
674 }
0f268757 675 }
0f268757
SC		 676}
677
0d740984
SC		 678static unsigned int
679DEFUN(coff_swap_aux_out,(abfd, inp, type, class, extp),
0f268757 680 bfd *abfd AND
0d740984
SC		 681 PTR inp AND
682 int type AND
683 int class AND
684 PTR extp)
0f268757 685{
0d740984
SC		 686 union internal_auxent *in = (union internal_auxent *)inp;
687 AUXENT *ext = (AUXENT *)extp;
98fd98bc
ILT		 688
689 memset((PTR)ext, 0, AUXESZ);
0f268757
SC		 690 switch (class) {
691 case C_FILE:
692 if (in->x_file.x_fname[0] == 0) {
cbdc7909 693 PUTWORD(abfd, 0, (bfd_byte *) ext->x_file.x_n.x_zeroes);
0d740984
SC		 694 PUTWORD(abfd,
695 in->x_file.x_n.x_offset,
696 (bfd_byte *) ext->x_file.x_n.x_offset);
0f268757 697 }
6f715d66 698 else {
fb3be09b 699#if FILNMLEN != E_FILNMLEN
0d740984 700 -> Error, we need to cope with truncating or extending FILNMLEN!;
fb3be09b
JG		 701#else
702 memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
703#endif
cbdc7909 704 }
0f268757 705 break;
6d7c88c3
JG		 706
707#ifdef RS6000COFF_C
708 /* RS/6000 "csect" auxents */
709 case C_EXT:
710 case C_HIDEXT:
711 PUTWORD (abfd, in->x_csect.x_scnlen, ext->x_csect.x_scnlen);
712 PUTWORD (abfd, in->x_csect.x_parmhash, ext->x_csect.x_parmhash);
713 PUTHALF (abfd, in->x_csect.x_snhash, ext->x_csect.x_snhash);
714 /* We don't have to hack bitfields in x_smtyp because it's defined by
715 shifts-and-ands, which are equivalent on all byte orders. */
716 PUTBYTE (abfd, in->x_csect.x_smtyp, ext->x_csect.x_smtyp);
717 PUTBYTE (abfd, in->x_csect.x_smclas, ext->x_csect.x_smclas);
718 PUTWORD (abfd, in->x_csect.x_stab, ext->x_csect.x_stab);
719 PUTHALF (abfd, in->x_csect.x_snstab, ext->x_csect.x_snstab);
720 break;
721#endif
722
0f268757
SC		 723 case C_STAT:
724#ifdef C_LEAFSTAT
725 case C_LEAFSTAT:
726#endif
727 case C_HIDDEN:
728 if (type == T_NULL) {
6f715d66
SC		 729 PUT_SCN_SCNLEN(abfd, in->x_scn.x_scnlen, ext);
730 PUT_SCN_NRELOC(abfd, in->x_scn.x_nreloc, ext);
731 PUT_SCN_NLINNO(abfd, in->x_scn.x_nlinno, ext);
0f268757
SC		 732 break;
733 }
734 default:
41f50af0 735 PUTWORD(abfd, in->x_sym.x_tagndx.l, (bfd_byte *) ext->x_sym.x_tagndx);
6f715d66 736#ifndef NO_TVNDX
859f11ff 737 bfd_h_put_16(abfd, in->x_sym.x_tvndx , (bfd_byte *) ext->x_sym.x_tvndx);
6f715d66 738#endif
0f268757 739
061a65a5
SEF		 740 if (class == C_BLOCK || ISFCN(type) || ISTAG(type)) {
741 PUT_FCN_LNNOPTR(abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
742 PUT_FCN_ENDNDX(abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
743 }
98fd98bc 744
0f268757 745 if (ISFCN(type)) {
41f50af0 746 PUTWORD(abfd, in->x_sym.x_misc.x_fsize, (bfd_byte *) ext->x_sym.x_misc.x_fsize);
0f268757
SC		 747 }
748 else {
061a65a5 749 if (ISARY(type)) {
fb3be09b 750#if DIMNUM != E_DIMNUM
0d740984 751 -> Error, we need to cope with truncating or extending DIMNUM!;
fb3be09b 752#else
41f50af0
SC		 753 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]);
754 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]);
755 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]);
756 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 757#endif
6f715d66 758 }
0d740984
SC		 759 PUT_LNSZ_LNNO(abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
760 PUT_LNSZ_SIZE(abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
0f268757
SC		 761 }
762 }
0d740984 763return sizeof(AUXENT);
0f268757
SC		 764}
765
7a8b18b6
SC		 766#endif /* NO_COFF_SYMBOLS */
767
768#ifndef NO_COFF_LINENOS
769
6f715d66
SC		 770static void
771DEFUN(coff_swap_lineno_in,(abfd, ext1, in1),
0f268757 772 bfd *abfd AND
6f715d66
SC		 773 PTR ext1 AND
774 PTR in1)
0f268757 775{
6f715d66
SC		 776 LINENO *ext = (LINENO *)ext1;
777 struct internal_lineno *in = (struct internal_lineno *)in1;
778
41f50af0 779 in->l_addr.l_symndx = bfd_h_get_32(abfd, (bfd_byte *) ext->l_addr.l_symndx);
85e0c721 780 in->l_lnno = GET_LINENO_LNNO(abfd, ext);
0f268757
SC		 781}
782
0d740984
SC		 783static unsigned int
784DEFUN(coff_swap_lineno_out,(abfd, inp, outp),
785 bfd *abfd AND
786 PTR inp AND
787 PTR outp)
0f268757 788{
0d740984
SC		 789 struct internal_lineno *in = (struct internal_lineno *)inp;
790 struct external_lineno *ext = (struct external_lineno *)outp;
85e0c721
SC		 791 PUTWORD(abfd, in->l_addr.l_symndx, (bfd_byte *)
792 ext->l_addr.l_symndx);
793
794 PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
0d740984 795 return sizeof(struct external_lineno);
0f268757
SC		 796}
797
7a8b18b6 798#endif /* NO_COFF_LINENOS */
0f268757
SC		 799
800
cbdc7909 801static void
6f715d66 802DEFUN(bfd_swap_aouthdr_in,(abfd, aouthdr_ext1, aouthdr_int1),
0f268757 803 bfd *abfd AND
6f715d66
SC		 804 PTR aouthdr_ext1 AND
805 PTR aouthdr_int1)
0f268757 806{
6f715d66
SC		 807 AOUTHDR *aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
808 struct internal_aouthdr *aouthdr_int = (struct internal_aouthdr *)aouthdr_int1;
809
41f50af0
SC		 810 aouthdr_int->magic = bfd_h_get_16(abfd, (bfd_byte *) aouthdr_ext->magic);
811 aouthdr_int->vstamp = bfd_h_get_16(abfd, (bfd_byte *) aouthdr_ext->vstamp);
812 aouthdr_int->tsize = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->tsize);
813 aouthdr_int->dsize = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->dsize);
814 aouthdr_int->bsize = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->bsize);
815 aouthdr_int->entry = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->entry);
816 aouthdr_int->text_start = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->text_start);
817 aouthdr_int->data_start = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->data_start);
0f268757 818#ifdef I960
41f50af0 819 aouthdr_int->tagentries = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->tagentries);
0f268757 820#endif
cbdc7909
JG		 821
822#ifdef RS6000COFF_C
823 aouthdr_int->o_toc = bfd_h_get_32(abfd, aouthdr_ext->o_toc);
824 aouthdr_int->o_snentry = bfd_h_get_16(abfd, aouthdr_ext->o_snentry);
825 aouthdr_int->o_sntext = bfd_h_get_16(abfd, aouthdr_ext->o_sntext);
826 aouthdr_int->o_sndata = bfd_h_get_16(abfd, aouthdr_ext->o_sndata);
827 aouthdr_int->o_sntoc = bfd_h_get_16(abfd, aouthdr_ext->o_sntoc);
828 aouthdr_int->o_snloader = bfd_h_get_16(abfd, aouthdr_ext->o_snloader);
829 aouthdr_int->o_snbss = bfd_h_get_16(abfd, aouthdr_ext->o_snbss);
830 aouthdr_int->o_algntext = bfd_h_get_16(abfd, aouthdr_ext->o_algntext);
831 aouthdr_int->o_algndata = bfd_h_get_16(abfd, aouthdr_ext->o_algndata);
832 aouthdr_int->o_modtype = bfd_h_get_16(abfd, aouthdr_ext->o_modtype);
833 aouthdr_int->o_maxstack = bfd_h_get_32(abfd, aouthdr_ext->o_maxstack);
834#endif
0f268757
SC		 835}
836
0d740984
SC		 837static unsigned int
838DEFUN(coff_swap_aouthdr_out,(abfd, in, out),
839 bfd *abfd AND
840 PTR in AND
841 PTR out)
0f268757 842{
0d740984
SC		 843 struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *)in;
844 AOUTHDR *aouthdr_out = (AOUTHDR *)out;
41f50af0
SC		 845 bfd_h_put_16(abfd, aouthdr_in->magic, (bfd_byte *) aouthdr_out->magic);
846 bfd_h_put_16(abfd, aouthdr_in->vstamp, (bfd_byte *) aouthdr_out->vstamp);
847 bfd_h_put_32(abfd, aouthdr_in->tsize, (bfd_byte *) aouthdr_out->tsize);
848 bfd_h_put_32(abfd, aouthdr_in->dsize, (bfd_byte *) aouthdr_out->dsize);
849 bfd_h_put_32(abfd, aouthdr_in->bsize, (bfd_byte *) aouthdr_out->bsize);
850 bfd_h_put_32(abfd, aouthdr_in->entry, (bfd_byte *) aouthdr_out->entry);
0d740984
SC		 851 bfd_h_put_32(abfd, aouthdr_in->text_start,
852 (bfd_byte *) aouthdr_out->text_start);
41f50af0 853 bfd_h_put_32(abfd, aouthdr_in->data_start, (bfd_byte *) aouthdr_out->data_start);
0f268757 854#ifdef I960
41f50af0 855 bfd_h_put_32(abfd, aouthdr_in->tagentries, (bfd_byte *) aouthdr_out->tagentries);
0f268757 856#endif
0d740984 857 return sizeof(AOUTHDR);
0f268757
SC		 858}
859
cbdc7909 860static void
2700c3c7 861DEFUN(coff_swap_scnhdr_in,(abfd, scnhdr_ext, scnhdr_int),
0f268757
SC		 862 bfd *abfd AND
863 SCNHDR *scnhdr_ext AND
864 struct internal_scnhdr *scnhdr_int)
865{
866 memcpy(scnhdr_int->s_name, scnhdr_ext->s_name, sizeof(scnhdr_int->s_name));
41f50af0
SC		 867 scnhdr_int->s_vaddr = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_vaddr);
868 scnhdr_int->s_paddr = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_paddr);
e98e6ec1
SC		 869 scnhdr_int->s_size = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_size);
870
41f50af0
SC		 871 scnhdr_int->s_scnptr = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_scnptr);
872 scnhdr_int->s_relptr = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_relptr);
873 scnhdr_int->s_lnnoptr = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_lnnoptr);
874 scnhdr_int->s_flags = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_flags);
6f715d66 875#if defined(M88)
41f50af0
SC		 876 scnhdr_int->s_nreloc = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_nreloc);
877 scnhdr_int->s_nlnno = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_nlnno);
6f715d66 878#else
41f50af0
SC		 879 scnhdr_int->s_nreloc = bfd_h_get_16(abfd, (bfd_byte *) scnhdr_ext->s_nreloc);
880 scnhdr_int->s_nlnno = bfd_h_get_16(abfd, (bfd_byte *) scnhdr_ext->s_nlnno);
6f715d66 881#endif
0f268757 882#ifdef I960
41f50af0 883 scnhdr_int->s_align = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_align);
0f268757
SC		 884#endif
885}
886
cbdc7909 887static unsigned int
0d740984
SC		 888DEFUN(coff_swap_scnhdr_out,(abfd, in, out),
889 bfd *abfd AND
890 PTR in AND
891 PTR out)
0f268757 892{
0d740984
SC		 893 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *)in;
894 SCNHDR *scnhdr_ext = (SCNHDR *)out;
0f268757 895 memcpy(scnhdr_ext->s_name, scnhdr_int->s_name, sizeof(scnhdr_int->s_name));
41f50af0
SC		 896 PUTWORD(abfd, scnhdr_int->s_vaddr, (bfd_byte *) scnhdr_ext->s_vaddr);
897 PUTWORD(abfd, scnhdr_int->s_paddr, (bfd_byte *) scnhdr_ext->s_paddr);
898 PUTWORD(abfd, scnhdr_int->s_size, (bfd_byte *) scnhdr_ext->s_size);
899 PUTWORD(abfd, scnhdr_int->s_scnptr, (bfd_byte *) scnhdr_ext->s_scnptr);
900 PUTWORD(abfd, scnhdr_int->s_relptr, (bfd_byte *) scnhdr_ext->s_relptr);
901 PUTWORD(abfd, scnhdr_int->s_lnnoptr, (bfd_byte *) scnhdr_ext->s_lnnoptr);
2f8d9c1c 902 PUTWORD(abfd, scnhdr_int->s_flags, (bfd_byte *) scnhdr_ext->s_flags);
6f715d66 903#if defined(M88)
41f50af0 904 PUTWORD(abfd, scnhdr_int->s_nlnno, (bfd_byte *) scnhdr_ext->s_nlnno);
41f50af0 905 PUTWORD(abfd, scnhdr_int->s_nreloc, (bfd_byte *) scnhdr_ext->s_nreloc);
6f715d66 906#else
41f50af0 907 PUTHALF(abfd, scnhdr_int->s_nlnno, (bfd_byte *) scnhdr_ext->s_nlnno);
41f50af0 908 PUTHALF(abfd, scnhdr_int->s_nreloc, (bfd_byte *) scnhdr_ext->s_nreloc);
6f715d66
SC		 909#endif
910
cbdc7909 911#if defined(I960)
41f50af0 912 PUTWORD(abfd, scnhdr_int->s_align, (bfd_byte *) scnhdr_ext->s_align);
0f268757 913#endif
0d740984 914 return sizeof(SCNHDR);
0f268757
SC		 915}
916
6f715d66 917
0f268757
SC		 918/*
919 initialize a section structure with information peculiar to this
920 particular implementation of coff
921*/
922
923static boolean
800aef7c
SC		 924DEFUN(coff_new_section_hook,(abfd, section),
925 bfd *abfd AND
e98e6ec1 926 asection *section)
0f268757 927{
8070f29d
KR		 928 section->alignment_power = abfd->xvec->align_power_min;
929 /* Allocate aux records for section symbols, to store size and
930 related info.
931
932 @@ Shouldn't use constant multiplier here! */
933 coffsymbol (section->symbol)->native =
934 (combined_entry_type *) bfd_zalloc (abfd,
935 sizeof (combined_entry_type) * 10);
0f268757
SC		 936 return true;
937}
938
8070f29d 939static asection bfd_debug_section = { "*DEBUG*" };
e98e6ec1 940
0f268757
SC		 941/* Take a section header read from a coff file (in HOST byte order),
942 and make a BFD "section" out of it. */
943static boolean
e98e6ec1 944DEFUN(make_a_section_from_file,(abfd, hdr, target_index),
0f268757 945 bfd *abfd AND
e98e6ec1
SC		 946 struct internal_scnhdr *hdr AND
947 unsigned int target_index)
0f268757 948{
e98e6ec1
SC		 949 asection *return_section;
950 char *name;
951
952 /* Assorted wastage to null-terminate the name, thanks AT&T! */
953 name = bfd_alloc(abfd, sizeof (hdr->s_name)+1);
954 if (name == NULL) {
955 bfd_error = no_memory;
956 return false;
957 }
958 strncpy(name, (char *) &hdr->s_name[0], sizeof (hdr->s_name));
959 name[sizeof (hdr->s_name)] = 0;
0f268757 960
e98e6ec1 961 return_section = bfd_make_section(abfd, name);
b26059aa
ILT		 962#ifdef TWO_DATA_SECS
963 /* On SCO a file created by the Microsoft assembler can have two
964 .data sections. We use .data2 for the second one. */
965 if (return_section == NULL && strcmp(name, _DATA) == 0)
966 return_section = bfd_make_section(abfd, ".data2");
967#endif /* TWO_DATA_SECS */
e98e6ec1
SC		 968 if (return_section == NULL)
969 return false;
0f268757 970
e98e6ec1 971 /* s_paddr is presumed to be = to s_vaddr */
0f268757 972
e98e6ec1
SC		 973 return_section->vma = hdr->s_vaddr;
974 return_section->_raw_size = hdr->s_size;
975 return_section->filepos = hdr->s_scnptr;
976 return_section->rel_filepos = hdr->s_relptr;
977 return_section->reloc_count = hdr->s_nreloc;
0f268757 978#ifdef I960
e98e6ec1
SC		 979
980 /* FIXME, use a temp var rather than alignment_power */
981 return_section->alignment_power = hdr->s_align;
982{
983 unsigned int i;
984 for (i = 0; i < 32; i++) {
985 if ((1 << i) >= (int) (return_section->alignment_power)) {
986 return_section->alignment_power = i;
987 break;
0f268757
SC		 988 }
989 }
e98e6ec1
SC		 990}
991
0f268757 992#endif
e98e6ec1
SC		 993return_section->line_filepos = hdr->s_lnnoptr;
994 /*
995 return_section->linesize = hdr->s_nlnno * sizeof (struct lineno);
0f268757
SC		 996 */
997
e98e6ec1
SC		 998 return_section->lineno_count = hdr->s_nlnno;
999 return_section->userdata = NULL;
1000 return_section->next = (asection *) NULL;
1001 return_section->flags = styp_to_sec_flags(hdr->s_flags);
41f50af0 1002
e98e6ec1 1003 return_section->target_index = target_index;
0f268757 1004
e98e6ec1
SC		 1005 if (hdr->s_nreloc != 0)
1006 return_section->flags |= SEC_RELOC;
1007 /* FIXME: should this check 'hdr->s_size > 0' */
1008 if (hdr->s_scnptr != 0)
1009 return_section->flags |= SEC_HAS_CONTENTS;
1010 return true;
0f268757
SC		 1011}
1012static boolean
1013DEFUN(coff_mkobject,(abfd),
1014 bfd *abfd)
1015{
e98e6ec1
SC		 1016 abfd->tdata.coff_obj_data = (struct coff_tdata *)bfd_zalloc (abfd,sizeof(coff_data_type));
1017 if (abfd->tdata.coff_obj_data == 0){
0f268757
SC		 1018 bfd_error = no_memory;
1019 return false;
1020 }
1021 coff_data(abfd)->relocbase = 0;
6590a8c9 1022/* make_abs_section(abfd);*/
0f268757
SC		 1023 return true;
1024}
1025
1026static
1027bfd_target *
1028DEFUN(coff_real_object_p,(abfd, nscns, internal_f, internal_a),
1029 bfd *abfd AND
1030 unsigned nscns AND
1031 struct internal_filehdr *internal_f AND
1032 struct internal_aouthdr *internal_a)
1033{
1034 coff_data_type *coff;
0d740984
SC		 1035 enum bfd_architecture arch;
1036 long machine;
0f268757
SC		 1037 size_t readsize; /* length of file_info */
1038 SCNHDR *external_sections;
cbdc7909 1039
0f268757
SC		 1040 /* Build a play area */
1041 if (coff_mkobject(abfd) != true)
1042 return 0;
e98e6ec1 1043
0f268757 1044 coff = coff_data(abfd);
cbdc7909
JG		 1045
1046
0f268757 1047 external_sections = (SCNHDR *)bfd_alloc(abfd, readsize = (nscns * SCNHSZ));
cbdc7909 1048
0f268757
SC		 1049 if (bfd_read((PTR)external_sections, 1, readsize, abfd) != readsize) {
1050 goto fail;
1051 }
cbdc7909
JG		 1052
1053
0f268757
SC		 1054 /* Now copy data as required; construct all asections etc */
1055 coff->symbol_index_slew = 0;
1056 coff->relocbase =0;
1057 coff->raw_syment_count = 0;
1058 coff->raw_linenos = 0;
1059 coff->raw_syments = 0;
1060 coff->sym_filepos =0;
1061 coff->flags = internal_f->f_flags;
1062 if (nscns != 0) {
1063 unsigned int i;
1064 for (i = 0; i < nscns; i++) {
1065 struct internal_scnhdr tmp;
2700c3c7 1066 coff_swap_scnhdr_in(abfd, external_sections + i, &tmp);
e98e6ec1 1067 make_a_section_from_file(abfd,&tmp, i+1);
0f268757
SC		 1068 }
1069 }
e98e6ec1
SC		 1070
1071/* make_abs_section(abfd);*/
1072
0f268757 1073 /* Determine the machine architecture and type. */
0d740984 1074machine = 0;
0f268757 1075 switch (internal_f->f_magic) {
20fdc627
SC		 1076#ifdef I386MAGIC
1077 case I386MAGIC:
0d740984
SC		 1078 arch = bfd_arch_i386;
1079 machine = 0;
20fdc627
SC		 1080 break;
1081#endif
cbdc7909
JG		 1082
1083#ifdef A29K_MAGIC_BIG
41f50af0
SC		 1084 case A29K_MAGIC_BIG:
1085 case A29K_MAGIC_LITTLE:
0d740984
SC		 1086 arch = bfd_arch_a29k;
1087 machine = 0;
41f50af0
SC		 1088 break;
1089#endif
cbdc7909 1090
0f268757 1091#ifdef MIPS
20fdc627
SC		 1092 case MIPS_MAGIC_1:
1093 case MIPS_MAGIC_2:
1094 case MIPS_MAGIC_3:
0d740984
SC		 1095 arch = bfd_arch_mips;
1096 machine = 0;
0f268757
SC		 1097 break;
1098#endif
cbdc7909 1099
0f268757
SC		 1100#ifdef MC68MAGIC
1101 case MC68MAGIC:
1102 case M68MAGIC:
0d740984
SC		 1103 arch = bfd_arch_m68k;
1104 machine = 68020;
0f268757
SC		 1105 break;
1106#endif
1107#ifdef MC88MAGIC
1108 case MC88MAGIC:
1109 case MC88DMAGIC:
1110 case MC88OMAGIC:
0d740984
SC		 1111 arch = bfd_arch_m88k;
1112 machine = 88100;
0f268757
SC		 1113 break;
1114#endif
dc999ad9
ILT		 1115#ifdef Z8KMAGIC
1116 case Z8KMAGIC:
1117 arch = bfd_arch_z8k;
1118 switch (internal_f->f_flags & F_MACHMASK)
1119{
1120 case F_Z8001:
1121 machine = bfd_mach_z8001;
1122 break;
1123 case F_Z8002:
1124 machine = bfd_mach_z8002;
1125 break;
1126 default:
1127 goto fail;
1128 }
1129 break;
1130#endif
0f268757
SC		 1131#ifdef I960
1132#ifdef I960ROMAGIC
1133 case I960ROMAGIC:
1134 case I960RWMAGIC:
0d740984 1135 arch = bfd_arch_i960;
cbdc7909 1136 switch (F_I960TYPE & internal_f->f_flags)
0f268757
SC		 1137 {
1138 default:
1139 case F_I960CORE:
0d740984 1140 machine = bfd_mach_i960_core;
0f268757
SC		 1141 break;
1142 case F_I960KB:
0d740984 1143 machine = bfd_mach_i960_kb_sb;
0f268757 1144 break;
0d740984
SC		 1145 case F_I960MC:
1146 machine = bfd_mach_i960_mc;
0f268757
SC		 1147 break;
1148 case F_I960XA:
0d740984 1149 machine = bfd_mach_i960_xa;
0f268757
SC		 1150 break;
1151 case F_I960CA:
0d740984 1152 machine = bfd_mach_i960_ca;
0f268757
SC		 1153 break;
1154 case F_I960KA:
0d740984 1155 machine = bfd_mach_i960_ka_sa;
0f268757 1156 break;
0f268757
SC		 1157 }
1158 break;
1159#endif
1160#endif
cbdc7909
JG		 1161
1162#ifdef U802ROMAGIC
1163 case U802ROMAGIC:
1164 case U802WRMAGIC:
1165 case U802TOCMAGIC:
1166 arch = bfd_arch_rs6000;
1167 machine = 6000;
1168 break;
1169#endif
1170
dc999ad9
ILT		 1171#ifdef WE32KMAGIC
1172 case WE32KMAGIC:
1173 arch = bfd_arch_we32k;
1174 machine = 0;
1175 break;
1176#endif
1177
3b4f1a5d
SC		 1178#ifdef H8300MAGIC
1179 case H8300MAGIC:
1180 arch = bfd_arch_h8300;
1181 machine = 0;
1182 break;
1183#endif
cbdc7909 1184
0f268757 1185 default: /* Unreadable input file type */
0d740984 1186 arch = bfd_arch_obscure;
0f268757
SC		 1187 break;
1188 }
cbdc7909 1189
0d740984 1190 bfd_default_set_arch_mach(abfd, arch, machine);
0f268757
SC		 1191 if (!(internal_f->f_flags & F_RELFLG))
1192 abfd->flags |= HAS_RELOC;
1193 if ((internal_f->f_flags & F_EXEC))
1194 abfd->flags |= EXEC_P;
1195 if (!(internal_f->f_flags & F_LNNO))
1196 abfd->flags |= HAS_LINENO;
1197 if (!(internal_f->f_flags & F_LSYMS))
1198 abfd->flags |= HAS_LOCALS;
cbdc7909
JG		 1199
1200
0f268757
SC		 1201 bfd_get_symcount(abfd) = internal_f->f_nsyms;
1202 if (internal_f->f_nsyms)
1203 abfd->flags |= HAS_SYMS;
cbdc7909 1204
0f268757 1205 coff->sym_filepos = internal_f->f_symptr;
cbdc7909 1206
fb3be09b 1207 /* These members communicate important constants about the symbol table
0d740984
SC		 1208 to GDB's symbol-reading code. These `constants' unfortunately vary
1209 from coff implementation to implementation... */
fb3be09b
JG		 1210#ifndef NO_COFF_SYMBOLS
1211 coff->local_n_btmask = N_BTMASK;
1212 coff->local_n_btshft = N_BTSHFT;
1213 coff->local_n_tmask = N_TMASK;
1214 coff->local_n_tshift = N_TSHIFT;
1215 coff->local_symesz = SYMESZ;
1216 coff->local_auxesz = AUXESZ;
1217 coff->local_linesz = LINESZ;
1218#endif
cbdc7909 1219
0f268757
SC		 1220 coff->symbols = (coff_symbol_type *) NULL;
1221 bfd_get_start_address(abfd) = internal_f->f_opthdr ? internal_a->entry : 0;
cbdc7909 1222
0f268757
SC		 1223 return abfd->xvec;
1224 fail:
1225 bfd_release(abfd, coff);
1226 return (bfd_target *)NULL;
1227}
1228
1229static bfd_target *
1230DEFUN(coff_object_p,(abfd),
1231 bfd *abfd)
6f715d66
SC		 1232{
1233 int nscns;
1234 FILHDR filehdr;
1235 AOUTHDR opthdr;
1236 struct internal_filehdr internal_f;
1237 struct internal_aouthdr internal_a;
cbdc7909 1238
6f715d66 1239 bfd_error = system_call_error;
cbdc7909 1240
6f715d66
SC		 1241 /* figure out how much to read */
1242 if (bfd_read((PTR) &filehdr, 1, FILHSZ, abfd) != FILHSZ)
1243 return 0;
cbdc7909 1244
6f715d66 1245 bfd_swap_filehdr_in(abfd, &filehdr, &internal_f);
cbdc7909 1246
6f715d66
SC		 1247 if (BADMAG(internal_f)) {
1248 bfd_error = wrong_format;
1249 return 0;
1250 }
1251 nscns =internal_f.f_nscns;
cbdc7909 1252
6f715d66
SC		 1253 if (internal_f.f_opthdr) {
1254 if (bfd_read((PTR) &opthdr, 1,AOUTSZ, abfd) != AOUTSZ) {
1255 return 0;
0f268757 1256 }
7d003262 1257 bfd_swap_aouthdr_in(abfd, (char *)&opthdr, (char *)&internal_a);
6f715d66 1258 }
cbdc7909 1259
6f715d66 1260 /* Seek past the opt hdr stuff */
f8e01940 1261 bfd_seek(abfd, (file_ptr) (internal_f.f_opthdr + FILHSZ), SEEK_SET);
cbdc7909 1262
6f715d66
SC		 1263 /* if the optional header is NULL or not the correct size then
1264 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1265 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1266 optional header is of a different size.
cbdc7909 1267
6f715d66
SC		 1268 But the mips keeps extra stuff in it's opthdr, so dont check
1269 when doing that
1270 */
cbdc7909 1271
0d740984 1272#if defined(M88) || defined(I960)
6f715d66
SC		 1273 if (internal_f.f_opthdr != 0 && AOUTSZ != internal_f.f_opthdr)
1274 return (bfd_target *)NULL;
0f268757 1275#endif
cbdc7909 1276
6f715d66
SC		 1277 return coff_real_object_p(abfd, nscns, &internal_f, &internal_a);
1278}
0f268757
SC		 1279
1280
1281
7a8b18b6 1282#ifndef NO_COFF_LINENOS
0f268757 1283
cbdc7909 1284static void
0f268757
SC		 1285DEFUN(coff_count_linenumbers,(abfd),
1286 bfd *abfd)
6f715d66
SC		 1287{
1288 unsigned int limit = bfd_get_symcount(abfd);
1289 unsigned int i;
1290 asymbol **p;
1291 {
1292 asection *s = abfd->sections->output_section;
1293 while (s) {
1294 BFD_ASSERT(s->lineno_count == 0);
1295 s = s->next;
20fdc627 1296 }
6f715d66 1297 }
cbdc7909
JG		 1298
1299
6f715d66
SC		 1300 for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) {
1301 asymbol *q_maybe = *p;
0d740984 1302 if (q_maybe->the_bfd->xvec->flavour == bfd_target_coff_flavour) {
6f715d66
SC		 1303 coff_symbol_type *q = coffsymbol(q_maybe);
1304 if (q->lineno) {
1305 /*
1306 This symbol has a linenumber, increment the owning
1307 section's linenumber count
1308 */
1309 alent *l = q->lineno;
1310 q->symbol.section->output_section->lineno_count++;
1311 l++;
1312 while (l->line_number) {
20fdc627
SC		 1313 q->symbol.section->output_section->lineno_count++;
1314 l++;
0f268757 1315 }
20fdc627 1316 }
0f268757 1317 }
20fdc627 1318 }
6f715d66 1319}
0f268757 1320
7a8b18b6
SC		 1321#endif /* NO_COFF_LINENOS */
1322
1323#ifndef NO_COFF_SYMBOLS
1324
cbdc7909 1325/*
0d740984
SC		 1326 Takes a bfd and a symbol, returns a pointer to the coff specific area
1327 of the symbol if there is one.
1328 */
7a8b18b6 1329static coff_symbol_type *
fb3be09b
JG		 1330DEFUN(coff_symbol_from,(ignore_abfd, symbol),
1331 bfd *ignore_abfd AND
7a8b18b6
SC		 1332 asymbol *symbol)
1333{
cbdc7909 1334 if (symbol->the_bfd->xvec->flavour != bfd_target_coff_flavour)
7a8b18b6 1335 return (coff_symbol_type *)NULL;
cbdc7909 1336
e98e6ec1 1337 if (symbol->the_bfd->tdata.coff_obj_data == (coff_data_type*)NULL)
7a8b18b6 1338 return (coff_symbol_type *)NULL;
cbdc7909 1339
7a8b18b6
SC		 1340 return (coff_symbol_type *) symbol;
1341}
1342
0f268757 1343
0f268757 1344
6f715d66
SC		 1345static void
1346DEFUN(fixup_symbol_value,(coff_symbol_ptr, syment),
1347coff_symbol_type *coff_symbol_ptr AND
1348struct internal_syment *syment)
1349{
0f268757 1350
6f715d66 1351 /* Normalize the symbol flags */
e98e6ec1 1352 if (coff_symbol_ptr->symbol.section == &bfd_com_section) {
6f715d66
SC		 1353 /* a common symbol is undefined with a value */
1354 syment->n_scnum = N_UNDEF;
1355 syment->n_value = coff_symbol_ptr->symbol.value;
1356 }
1357 else if (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING) {
1358 syment->n_value = coff_symbol_ptr->symbol.value;
1359 }
e98e6ec1 1360 else if (coff_symbol_ptr->symbol.section == & bfd_und_section) {
6f715d66
SC		 1361 syment->n_scnum = N_UNDEF;
1362 syment->n_value = 0;
cbdc7909 1363 }
6f715d66 1364 else {
f58809fd 1365 if (coff_symbol_ptr->symbol.section) {
cbdc7909 1366 syment->n_scnum =
e98e6ec1 1367 coff_symbol_ptr->symbol.section->output_section->target_index;
cbdc7909
JG		 1368
1369 syment->n_value =
f58809fd 1370 coff_symbol_ptr->symbol.value +
6f715d66 1371 coff_symbol_ptr->symbol.section->output_offset +
f58809fd
SC		 1372 coff_symbol_ptr->symbol.section->output_section->vma;
1373 }
1374 else {
e98e6ec1 1375 BFD_ASSERT(0);
f58809fd
SC		 1376 /* This can happen, but I don't know why yet (steve@cygnus.com) */
1377 syment->n_scnum = N_ABS;
cbdc7909 1378 syment->n_value = coff_symbol_ptr->symbol.value;
f58809fd 1379 }
6f715d66
SC		 1380 }
1381}
0f268757 1382
6f715d66 1383/* run through all the symbols in the symbol table and work out what
cbdc7909 1384 their indexes into the symbol table will be when output
0f268757 1385
6f715d66
SC		 1386 Coff requires that each C_FILE symbol points to the next one in the
1387 chain, and that the last one points to the first external symbol. We
1388 do that here too.
0f268757 1389
6f715d66
SC		 1390*/
1391static void
1392DEFUN(coff_renumber_symbols,(bfd_ptr),
1393 bfd *bfd_ptr)
1394{
1395 unsigned int symbol_count = bfd_get_symcount(bfd_ptr);
1396 asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
1397 unsigned int native_index = 0;
1398 struct internal_syment *last_file = (struct internal_syment *)NULL;
1399 unsigned int symbol_index;
8070f29d
KR		 1400
1401 /* COFF demands that undefined symbols come after all other symbols.
1402 Since we don't need to impose this extra knowledge on all our client
1403 programs, deal with that here. Sort the symbol table; just move the
1404 undefined symbols to the end, leaving the rest alone. */
1405 /* @@ Do we have some condition we could test for, so we don't always
1406 have to do this? I don't think relocatability is quite right, but
1407 I'm not certain. [raeburn:19920508.1711EST] */
1408 {
1409 asymbol **newsyms;
1410 int i;
1411
1412 newsyms = (asymbol **) bfd_alloc_by_size_t (bfd_ptr,
dc999ad9
ILT		 1413 sizeof (asymbol *)
1414 * (symbol_count + 1));
8070f29d
KR		 1415 bfd_ptr->outsymbols = newsyms;
1416 for (i = 0; i < symbol_count; i++)
1417 if (symbol_ptr_ptr[i]->section != &bfd_und_section)
1418 *newsyms++ = symbol_ptr_ptr[i];
1419 for (i = 0; i < symbol_count; i++)
1420 if (symbol_ptr_ptr[i]->section == &bfd_und_section)
1421 *newsyms++ = symbol_ptr_ptr[i];
dc999ad9 1422 *newsyms = (asymbol *) NULL;
8070f29d
KR		 1423 symbol_ptr_ptr = bfd_ptr->outsymbols;
1424 }
1425
cbdc7909 1426 for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
6f715d66
SC		 1427 {
1428 coff_symbol_type *coff_symbol_ptr = coff_symbol_from(bfd_ptr, symbol_ptr_ptr[symbol_index]);
1429 if (coff_symbol_ptr && coff_symbol_ptr->native) {
1430 combined_entry_type *s = coff_symbol_ptr->native;
1431 int i;
0f268757 1432
cbdc7909 1433 if (s->u.syment.n_sclass == C_FILE)
6f715d66
SC		 1434 {
1435 if (last_file != (struct internal_syment *)NULL) {
1436 last_file->n_value = native_index;
1437 }
1438 last_file = &(s->u.syment);
1439 }
1440 else {
0f268757 1441
6f715d66
SC		 1442 /* Modify the symbol values according to their section and
1443 type */
0f268757 1444
6f715d66
SC		 1445 fixup_symbol_value(coff_symbol_ptr, &(s->u.syment));
1446 }
1447 for (i = 0; i < s->u.syment.n_numaux + 1; i++) {
1448 s[i].offset = native_index ++;
1449 }
1450 }
1451 else {
1452 native_index++;
1453 }
1454 }
8070f29d 1455 obj_conv_table_size (bfd_ptr) = native_index;
6f715d66 1456}
0f268757 1457
0f268757 1458
41f50af0 1459/*
6f715d66
SC		 1460 Run thorough the symbol table again, and fix it so that all pointers to
1461 entries are changed to the entries' index in the output symbol table.
0f268757 1462
6f715d66 1463*/
cbdc7909 1464static void
0f268757
SC		 1465DEFUN(coff_mangle_symbols,(bfd_ptr),
1466 bfd *bfd_ptr)
6f715d66
SC		 1467{
1468 unsigned int symbol_count = bfd_get_symcount(bfd_ptr);
1469 asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
6f715d66
SC		 1470 unsigned int symbol_index;
1471
cbdc7909 1472 for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
6f715d66 1473 {
cbdc7909
JG		 1474 coff_symbol_type *coff_symbol_ptr =
1475 coff_symbol_from(bfd_ptr, symbol_ptr_ptr[symbol_index]);
1476
1477 if (coff_symbol_ptr && coff_symbol_ptr->native) {
6f715d66
SC		 1478 int i;
1479 combined_entry_type *s = coff_symbol_ptr->native;
1480
6f715d66
SC		 1481 for (i = 0; i < s->u.syment.n_numaux ; i++) {
1482 combined_entry_type *a = s + i + 1;
1483 if (a->fix_tag) {
cbdc7909
JG		 1484 a->u.auxent.x_sym.x_tagndx.l =
1485 a->u.auxent.x_sym.x_tagndx.p->offset;
6590a8c9 1486 a->fix_tag = 0;
6f715d66
SC		 1487 }
1488 if (a->fix_end) {
1489 a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l =
1490 a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p->offset;
6590a8c9
SC		 1491 a->fix_end = 0;
1492
6f715d66
SC		 1493 }
1494
1495 }
1496 }
1497 }
1498}
1499
cbdc7909 1500static int string_size;
6f715d66 1501static void
fb3be09b
JG		 1502DEFUN(coff_fix_symbol_name,(ignore_abfd, symbol, native),
1503 bfd *ignore_abfd AND
6f715d66
SC		 1504 asymbol *symbol AND
1505 combined_entry_type *native)
1506{
1507 unsigned int name_length;
1508 union internal_auxent *auxent;
41f50af0 1509 char * name = ( char *)(symbol->name);
6f715d66
SC		 1510
1511 if (name == (char *) NULL) {
fb3be09b
JG		 1512 /* coff symbols always have names, so we'll make one up */
1513 symbol->name = "strange";
41f50af0 1514 name = (char *)symbol->name;
6f715d66
SC		 1515 }
1516 name_length = strlen(name);
cbdc7909 1517
6f715d66
SC		 1518 if (native->u.syment.n_sclass == C_FILE) {
1519 strncpy(native->u.syment._n._n_name, ".file", SYMNMLEN);
1520 auxent = &(native+1)->u.auxent;
cbdc7909 1521
6f715d66
SC		 1522#ifdef COFF_LONG_FILENAMES
1523 if (name_length <= FILNMLEN) {
1524 strncpy(auxent->x_file.x_fname, name, FILNMLEN);
1525 }
1526 else {
1527 auxent->x_file.x_n.x_offset = string_size + 4;
1528 auxent->x_file.x_n.x_zeroes = 0;
1529 string_size += name_length + 1;
1530 }
1531#else
1532 strncpy(auxent->x_file.x_fname, name, FILNMLEN);
1533 if (name_length > FILNMLEN) {
1534 name[FILNMLEN] = '\0';
1535 }
1536#endif
1537 }
1538 else
1539 { /* NOT A C_FILE SYMBOL */
1540 if (name_length <= SYMNMLEN) {
1541 /* This name will fit into the symbol neatly */
1542 strncpy(native->u.syment._n._n_name, symbol->name, SYMNMLEN);
1543 }
1544 else {
1545 native->u.syment._n._n_n._n_offset = string_size + 4;
1546 native->u.syment._n._n_n._n_zeroes = 0;
1547 string_size += name_length + 1;
1548 }
1549 }
1550}
1551
1552
1553
cbdc7909 1554static unsigned int
6f715d66
SC		 1555DEFUN(coff_write_symbol,(abfd, symbol, native, written),
1556bfd *abfd AND
1557asymbol *symbol AND
1558combined_entry_type *native AND
1559unsigned int written)
1560{
1561 unsigned int numaux = native->u.syment.n_numaux;
1562 int type = native->u.syment.n_type;
1563 int class = native->u.syment.n_sclass;
1564 SYMENT buf;
1565 unsigned int j;
8070f29d
KR		 1566
1567 /* @@ bfd_debug_section isn't accessible outside this file, but we know
1568 that C_FILE symbols belong there. So move them. */
1569 if (native->u.syment.n_sclass == C_FILE)
1570 symbol->section = &bfd_debug_section;
1571
6590a8c9
SC		 1572 if (symbol->section == &bfd_abs_section)
1573 {
1574 native->u.syment.n_scnum = N_ABS;
1575 }
1576 else if (symbol->section == &bfd_debug_section)
1577 {
1578 native->u.syment.n_scnum = N_DEBUG;
1579 }
1580 else if (symbol->section == &bfd_und_section)
1581 {
1582 native->u.syment.n_scnum = N_UNDEF;
1583 }
1584 else
1585 {
1586 native->u.syment.n_scnum =
1587 symbol->section->output_section->target_index;
1588 }
1589
e98e6ec1 1590
6f715d66 1591 coff_fix_symbol_name(abfd, symbol, native);
e98e6ec1 1592
6f715d66
SC		 1593 coff_swap_sym_out(abfd, &native->u.syment, &buf);
1594 bfd_write((PTR)& buf, 1, SYMESZ, abfd);
859f11ff 1595 for (j = 0; j < native->u.syment.n_numaux; j++)
6590a8c9
SC		 1596 {
1597 AUXENT buf1;
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
17f9c817 2610 put it back, I will come in and take it out again. I'm sorry. This
0f268757
SC		 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 */
0f268757 2614 internal_f.f_timdat = 0;
0f268757
SC		 2615
2616 if (bfd_get_symcount(abfd) != 0)
e98e6ec1 2617 internal_f.f_symptr = sym_base;
0f268757 2618 else
e98e6ec1 2619 internal_f.f_symptr = 0;
0f268757
SC		 2620
2621 internal_f.f_flags = 0;
2622
2623 if (abfd->flags & EXEC_P)
e98e6ec1 2624 internal_f.f_opthdr = AOUTSZ;
0f268757 2625 else
e98e6ec1 2626 internal_f.f_opthdr = 0;
0f268757
SC		 2627
2628 if (!hasrelocs)
e98e6ec1 2629 internal_f.f_flags |= F_RELFLG;
0f268757 2630 if (!haslinno)
e98e6ec1 2631 internal_f.f_flags |= F_LNNO;
0f268757 2632 if (0 == bfd_get_symcount(abfd))
e98e6ec1 2633 internal_f.f_flags |= F_LSYMS;
0f268757 2634 if (abfd->flags & EXEC_P)
e98e6ec1 2635 internal_f.f_flags |= F_EXEC;
a0f3f080 2636
0f268757 2637 if (!abfd->xvec->byteorder_big_p)
e98e6ec1 2638 internal_f.f_flags |= F_AR32WR;
a0f3f080
SC		 2639 else
2640 internal_f.f_flags |= F_AR32W;
2641
0f268757
SC		 2642 /*
2643 FIXME, should do something about the other byte orders and
2644 architectures.
2645 */
2646
2647 /* Set up architecture-dependent stuff */
2648
e98e6ec1
SC		 2649{ unsigned int magic = 0;
2650 unsigned short flags = 0;
2651 coff_set_flags(abfd, &magic, &flags);
2652 internal_f.f_magic = magic;
2653 internal_f.f_flags |= flags;
2654 /* ...and the "opt"hdr... */
0f268757 2655
cbdc7909 2656#ifdef A29K
e98e6ec1
SC		 2657# ifdef ULTRA3 /* NYU's machine */
2658 /* FIXME: This is a bogus check. I really want to see if there
2659 * is a .shbss or a .shdata section, if so then set the magic
2660 * number to indicate a shared data executable.
2661 */
2662 if (internal_f.f_nscns >= 7)
2663 internal_a.magic = SHMAGIC; /* Shared magic */
2664 else
2665# endif /* ULTRA3 */
2666 internal_a.magic = NMAGIC; /* Assume separate i/d */
41f50af0 2667#define __A_MAGIC_SET__
e98e6ec1 2668#endif /* A29K */
0f268757 2669#ifdef I960
e98e6ec1 2670 internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
41f50af0 2671#define __A_MAGIC_SET__
e98e6ec1 2672#endif /* I960 */
0f268757 2673#if M88
41f50af0 2674#define __A_MAGIC_SET__
e98e6ec1
SC		 2675 internal_a.magic = PAGEMAGICBCS;
2676#endif /* M88 */
41f50af0 2677
8ad2a31d 2678#if M68 || MIPS || WE32K
41f50af0 2679#define __A_MAGIC_SET__
e98e6ec1 2680 /* Never was anything here for the 68k */
8ad2a31d
SC		 2681#endif /* M68 || MIPS || WE32K */
2682
2683#if I386
2684# define __A_MAGIC_SET__
2685 internal_a.magic = ZMAGIC;
2686#endif /* I386 */
41f50af0 2687
cbdc7909
JG		 2688#if RS6000COFF_C
2689#define __A_MAGIC_SET__
e98e6ec1
SC		 2690 internal_a.magic = (abfd->flags & D_PAGED)? RS6K_AOUTHDR_ZMAGIC:
2691 (abfd->flags & WP_TEXT)? RS6K_AOUTHDR_NMAGIC:
2692 RS6K_AOUTHDR_OMAGIC;
cbdc7909
JG		 2693#endif
2694
41f50af0
SC		 2695#ifndef __A_MAGIC_SET__
2696# include "Your aouthdr magic number is not being set!"
2697#else
2698# undef __A_MAGIC_SET__
0f268757 2699#endif
e98e6ec1 2700}
0f268757
SC		 2701 /* Now should write relocs, strings, syms */
2702 obj_sym_filepos(abfd) = sym_base;
2703
7a8b18b6 2704#ifndef NO_COFF_SYMBOLS
0f268757 2705 if (bfd_get_symcount(abfd) != 0) {
8070f29d 2706 coff_add_missing_symbols (abfd);
e98e6ec1
SC		 2707 coff_renumber_symbols(abfd);
2708 coff_mangle_symbols(abfd);
2709 coff_write_symbols(abfd);
2710 coff_write_linenumbers(abfd);
2711 coff_write_relocs(abfd);
2712 }
2713#endif /* NO_COFF_SYMBOLS */
0f268757 2714 if (text_sec) {
6590a8c9 2715 internal_a.tsize = bfd_get_section_size_before_reloc(text_sec);
e98e6ec1
SC		 2716 internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
2717 }
0f268757 2718 if (data_sec) {
6590a8c9 2719 internal_a.dsize = bfd_get_section_size_before_reloc(data_sec);
e98e6ec1
SC		 2720 internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
2721 }
0f268757 2722 if (bss_sec) {
6590a8c9 2723 internal_a.bsize = bfd_get_section_size_before_reloc(bss_sec);
e98e6ec1 2724 }
0f268757
SC		 2725
2726 internal_a.entry = bfd_get_start_address(abfd);
2727 internal_f.f_nsyms = bfd_get_symcount(abfd);
2728
2729 /* now write them */
f8e01940 2730 if (bfd_seek(abfd, (file_ptr) 0, SEEK_SET) != 0)
e98e6ec1
SC		 2731 return false;
2732{
2733 FILHDR buff;
859f11ff 2734 coff_swap_filehdr_out(abfd, (PTR)&internal_f, (PTR)&buff);
e98e6ec1
SC		 2735 bfd_write((PTR) &buff, 1, FILHSZ, abfd);
2736}
0f268757 2737 if (abfd->flags & EXEC_P) {
e98e6ec1 2738 AOUTHDR buff;
859f11ff 2739 coff_swap_aouthdr_out(abfd, (PTR)&internal_a, (PTR)&buff);
e98e6ec1
SC		 2740 bfd_write((PTR) &buff, 1, AOUTSZ, abfd);
2741 }
0f268757 2742 return true;
6f715d66
SC		 2743}
2744
7a8b18b6
SC		 2745#ifndef NO_COFF_SYMBOLS
2746
6f715d66
SC		 2747/*
2748this function transforms the offsets into the symbol table into
2749pointers to syments.
2750*/
2751
2752
2753static void
fb3be09b
JG		 2754DEFUN(coff_pointerize_aux,(ignore_abfd, table_base, type, class, auxent),
2755bfd *ignore_abfd AND
6f715d66
SC		 2756combined_entry_type *table_base AND
2757int type AND
2758int class AND
2759combined_entry_type *auxent)
2760{
2761 /* Don't bother if this is a file or a section */
2762 if (class == C_STAT && type == T_NULL) return;
2763 if (class == C_FILE) return;
2764
2765 /* Otherwise patch up */
2766 if (ISFCN(type) || ISTAG(class) || class == C_BLOCK) {
6590a8c9
SC		 2767 auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p = table_base +
2768 auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l;
2769 auxent->fix_end = 1;
2770 }
7a8b18b6 2771 if (auxent->u.auxent.x_sym.x_tagndx.l != 0) {
6590a8c9
SC		 2772 auxent->u.auxent.x_sym.x_tagndx.p =
2773 table_base + auxent->u.auxent.x_sym.x_tagndx.l;
2774 auxent->fix_tag = 1;
2775 }
6f715d66
SC		 2776}
2777
7a8b18b6 2778#endif /* NO_COFF_SYMBOLS */
0f268757
SC		 2779
2780static boolean
6f715d66
SC		 2781DEFUN(coff_set_section_contents,(abfd, section, location, offset, count),
2782 bfd *abfd AND
2783 sec_ptr section AND
2784 PTR location AND
2785 file_ptr offset AND
41f50af0 2786 bfd_size_type count)
0f268757
SC		 2787{
2788 if (abfd->output_has_begun == false) /* set by bfd.c handler */
2789 coff_compute_section_file_positions(abfd);
2790
b26059aa
ILT		 2791#ifdef _LIB
2792 /* If this is a .lib section, bump the vma address so that it
2793 winds up being the number of .lib sections output. This is
2794 right for SVR3.2. Shared libraries should probably get more
2795 generic support. Ian Taylor <ian@cygnus.com>. */
2796 if (strcmp (section->name, _LIB) == 0)
2797 ++section->vma;
2798#endif
2799
0f268757
SC		 2800 bfd_seek(abfd, (file_ptr) (section->filepos + offset), SEEK_SET);
2801
2802 if (count != 0) {
2803 return (bfd_write(location, 1, count, abfd) == count) ? true : false;
2804 }
2805 return true;
2806}
2807#if 0
2808static boolean
2809coff_close_and_cleanup(abfd)
2810 bfd *abfd;
2811{
2812 if (!bfd_read_p(abfd))
2813 switch (abfd->format) {
2814 case bfd_archive:
2815 if (!_bfd_write_archive_contents(abfd))
2816 return false;
2817 break;
2818 case bfd_object:
2819 if (!coff_write_object_contents(abfd))
2820 return false;
2821 break;
2822 default:
2823 bfd_error = invalid_operation;
2824 return false;
2825 }
2826
2827 /* We depend on bfd_close to free all the memory on the obstack. */
2828 /* FIXME if bfd_release is not using obstacks! */
2829 return true;
2830}
2831
2832#endif
cbdc7909 2833static PTR
0f268757
SC		 2834buy_and_read(abfd, where, seek_direction, size)
2835 bfd *abfd;
2836 file_ptr where;
2837 int seek_direction;
2838 size_t size;
2839{
2840 PTR area = (PTR) bfd_alloc(abfd, size);
2841 if (!area) {
2842 bfd_error = no_memory;
2843 return (NULL);
2844 }
2845 bfd_seek(abfd, where, seek_direction);
2846 if (bfd_read(area, 1, size, abfd) != size) {
2847 bfd_error = system_call_error;
2848 return (NULL);
2849 } /* on error */
2850 return (area);
2851} /* buy_and_read() */
2852
6f715d66 2853
7a8b18b6 2854#ifndef NO_COFF_SYMBOLS
6f715d66
SC		 2855
2856static char *
2857DEFUN(build_string_table,(abfd),
2858bfd *abfd)
0f268757 2859{
6f715d66
SC		 2860 char string_table_size_buffer[4];
2861 unsigned int string_table_size;
2862 char *string_table;
cbdc7909
JG		 2863
2864 /* At this point we should be "seek"'d to the end of the
2865 symbols === the symbol table size. */
6f715d66
SC		 2866 if (bfd_read((char *) string_table_size_buffer,
2867 sizeof(string_table_size_buffer),
2868 1, abfd) != sizeof(string_table_size)) {
2869 bfd_error = system_call_error;
2870 return (NULL);
2871 } /* on error */
cbdc7909 2872
41f50af0 2873 string_table_size = bfd_h_get_32(abfd, (bfd_byte *) string_table_size_buffer);
cbdc7909 2874
6f715d66
SC		 2875 if ((string_table = (PTR) bfd_alloc(abfd, string_table_size -= 4)) == NULL) {
2876 bfd_error = no_memory;
2877 return (NULL);
2878 } /* on mallocation error */
2879 if (bfd_read(string_table, string_table_size, 1, abfd) != string_table_size) {
2880 bfd_error = system_call_error;
2881 return (NULL);
cbdc7909 2882 }
6f715d66
SC		 2883 return string_table;
2884}
0f268757 2885
cbdc7909
JG		 2886/* Allocate space for the ".debug" section, and read it.
2887 We did not read the debug section until now, because
2888 we didn't want to go to the trouble until someone needed it. */
2889
2890static char *
2891DEFUN(build_debug_section,(abfd),
2892 bfd *abfd)
2893{
2894 char *debug_section;
2895 long position;
2896
2897 asection *sect = bfd_get_section_by_name (abfd, ".debug");
2898
2899 if (!sect) {
2900 bfd_error = no_debug_section;
2901 return NULL;
2902 }
2903
e98e6ec1
SC		 2904 debug_section = (PTR) bfd_alloc (abfd,
2905 bfd_get_section_size_before_reloc (sect));
cbdc7909
JG		 2906 if (debug_section == NULL) {
2907 bfd_error = no_memory;
2908 return NULL;
2909 }
2910
2911 /* Seek to the beginning of the `.debug' section and read it.
2912 Save the current position first; it is needed by our caller.
2913 Then read debug section and reset the file pointer. */
2914
2915 position = bfd_tell (abfd);
2916 bfd_seek (abfd, sect->filepos, SEEK_SET);
e98e6ec1
SC		 2917 if (bfd_read (debug_section,
2918 bfd_get_section_size_before_reloc (sect), 1, abfd)
2919 != bfd_get_section_size_before_reloc(sect)) {
cbdc7909
JG		 2920 bfd_error = system_call_error;
2921 return NULL;
2922 }
2923 bfd_seek (abfd, position, SEEK_SET);
2924 return debug_section;
2925}
2926
2927
fb3be09b
JG		 2928/* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
2929 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
2930 be \0-terminated. */
2931static char *
2932DEFUN(copy_name,(abfd, name, maxlen),
2933 bfd *abfd AND
2934 char *name AND
2935 int maxlen)
2936{
2937 int len;
2938 char *newname;
cbdc7909 2939
fb3be09b
JG		 2940 for (len = 0; len < maxlen; ++len) {
2941 if (name[len] == '\0') {
2942 break;
2943 }
2944 }
cbdc7909 2945
fb3be09b
JG		 2946 if ((newname = (PTR) bfd_alloc(abfd, len+1)) == NULL) {
2947 bfd_error = no_memory;
2948 return (NULL);
2949 }
2950 strncpy(newname, name, len);
2951 newname[len] = '\0';
2952 return newname;
2953}
2954
2955
cbdc7909
JG		 2956/* Read a symbol table into freshly bfd_allocated memory, swap it, and
2957 knit the symbol names into a normalized form. By normalized here I
2958 mean that all symbols have an n_offset pointer that points to a null-
2959 terminated string. */
2960
2961#ifndef SYMNAME_IN_DEBUG
2962#define SYMNAME_IN_DEBUG(x) 0
2963#endif
0f268757 2964
6f715d66 2965static combined_entry_type *
0f268757
SC		 2966DEFUN(get_normalized_symtab,(abfd),
2967bfd *abfd)
2968{
6f715d66
SC		 2969 combined_entry_type *internal;
2970 combined_entry_type *internal_ptr;
a0f3f080 2971 combined_entry_type *symbol_ptr;
6f715d66 2972 combined_entry_type *internal_end;
0f268757
SC		 2973 SYMENT *raw;
2974 SYMENT *raw_src;
2975 SYMENT *raw_end;
2976 char *string_table = NULL;
cbdc7909 2977 char *debug_section = NULL;
0f268757 2978 unsigned long size;
6f715d66 2979
0f268757 2980 unsigned int raw_size;
6f715d66 2981 if (obj_raw_syments(abfd) != (combined_entry_type *)NULL) {
d05511ca
SC		 2982 return obj_raw_syments(abfd);
2983 }
6f715d66 2984 if ((size = bfd_get_symcount(abfd) * sizeof(combined_entry_type)) == 0) {
d05511ca
SC		 2985 bfd_error = no_symbols;
2986 return (NULL);
2987 }
0f268757 2988
6f715d66 2989 internal = (combined_entry_type *)bfd_alloc(abfd, size);
0f268757
SC		 2990 internal_end = internal + bfd_get_symcount(abfd);
2991
2992 raw_size = bfd_get_symcount(abfd) * SYMESZ;
2993 raw = (SYMENT *)bfd_alloc(abfd,raw_size);
2994
2995 if (bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET) == -1
2996 || bfd_read((PTR)raw, raw_size, 1, abfd) != raw_size) {
d05511ca
SC		 2997 bfd_error = system_call_error;
2998 return (NULL);
2999 }
0f268757
SC		 3000 /* mark the end of the symbols */
3001 raw_end = raw + bfd_get_symcount(abfd);
3002 /*
3003 FIXME SOMEDAY. A string table size of zero is very weird, but
3004 probably possible. If one shows up, it will probably kill us.
3005 */
3006
3007 /* Swap all the raw entries */
cbdc7909
JG		 3008 for (raw_src = raw, internal_ptr = internal;
3009 raw_src < raw_end;
3010 raw_src++, internal_ptr++) {
3011
d05511ca 3012 unsigned int i;
859f11ff 3013 coff_swap_sym_in(abfd, (PTR)raw_src, (PTR)&internal_ptr->u.syment);
a0f3f080
SC		 3014 internal_ptr->fix_tag = 0;
3015 internal_ptr->fix_end = 0;
d05511ca
SC		 3016 symbol_ptr = internal_ptr;
3017
3018 for (i = 0;
3019 i < symbol_ptr->u.syment.n_numaux;
3020 i++)
3021 {
3022 internal_ptr++;
3023 raw_src++;
3024
3025 internal_ptr->fix_tag = 0;
3026 internal_ptr->fix_end = 0;
3027 coff_swap_aux_in(abfd, (char *)(raw_src),
3028 symbol_ptr->u.syment.n_type,
3029 symbol_ptr->u.syment.n_sclass,
3030 &(internal_ptr->u.auxent));
859f11ff
SC		 3031 /* Remember that bal entries arn't pointerized */
3032 if (i != 1 || symbol_ptr->u.syment.n_sclass != C_LEAFPROC)
3033 {
3034
d05511ca
SC		 3035 coff_pointerize_aux(abfd,
3036 internal,
3037 symbol_ptr->u.syment.n_type,
3038 symbol_ptr->u.syment.n_sclass,
3039 internal_ptr);
3040 }
859f11ff
SC		 3041
3042 }
0f268757 3043 }
cbdc7909 3044
0f268757 3045 /* Free all the raw stuff */
0d740984 3046 bfd_release(abfd, raw);
0f268757 3047
6f715d66 3048 for (internal_ptr = internal; internal_ptr < internal_end;
cbdc7909 3049 internal_ptr ++)
d05511ca
SC		 3050 {
3051 if (internal_ptr->u.syment.n_sclass == C_FILE) {
3052 /* make a file symbol point to the name in the auxent, since
3053 the text ".file" is redundant */
3054 if ((internal_ptr+1)->u.auxent.x_file.x_n.x_zeroes == 0) {
cbdc7909 3055 /* the filename is a long one, point into the string table */
6f715d66 3056 if (string_table == NULL) {
d05511ca
SC		 3057 string_table = build_string_table(abfd);
3058 }
0f268757 3059
6f715d66 3060 internal_ptr->u.syment._n._n_n._n_offset =
d05511ca
SC		 3061 (int) (string_table - 4 +
3062 (internal_ptr+1)->u.auxent.x_file.x_n.x_offset);
6f715d66 3063 }
d05511ca 3064 else {
6f715d66
SC		 3065 /* ordinary short filename, put into memory anyway */
3066 internal_ptr->u.syment._n._n_n._n_offset = (int)
d05511ca
SC		 3067 copy_name(abfd, (internal_ptr+1)->u.auxent.x_file.x_fname,
3068 FILNMLEN);
6f715d66 3069 }
d05511ca
SC		 3070 }
3071 else {
3072 if (internal_ptr->u.syment._n._n_n._n_zeroes != 0) {
cbdc7909 3073 /* This is a "short" name. Make it long. */
6f715d66
SC		 3074 unsigned long i = 0;
3075 char *newstring = NULL;
cbdc7909
JG		 3076
3077 /* find the length of this string without walking into memory
3078 that isn't ours. */
6f715d66 3079 for (i = 0; i < 8; ++i) {
d05511ca
SC		 3080 if (internal_ptr->u.syment._n._n_name[i] == '\0') {
3081 break;
3082 } /* if end of string */
3083 } /* possible lengths of this string. */
cbdc7909 3084
6f715d66 3085 if ((newstring = (PTR) bfd_alloc(abfd, ++i)) == NULL) {
d05511ca
SC		 3086 bfd_error = no_memory;
3087 return (NULL);
3088 } /* on error */
df4d92f6 3089 memset(newstring, 0, i);
6f715d66
SC		 3090 strncpy(newstring, internal_ptr->u.syment._n._n_name, i-1);
3091 internal_ptr->u.syment._n._n_n._n_offset = (int) newstring;
3092 internal_ptr->u.syment._n._n_n._n_zeroes = 0;
6f715d66 3093 }
d05511ca 3094 else if (!SYMNAME_IN_DEBUG(&internal_ptr->u.syment)) {
cbdc7909 3095 /* Long name already. Point symbol at the string in the table. */
6f715d66 3096 if (string_table == NULL) {
d05511ca
SC		 3097 string_table = build_string_table(abfd);
3098 }
cbdc7909 3099 internal_ptr->u.syment._n._n_n._n_offset = (int)
d05511ca 3100 (string_table - 4 + internal_ptr->u.syment._n._n_n._n_offset);
cbdc7909 3101 }
d05511ca 3102 else {
cbdc7909
JG		 3103 /* Long name in debug section. Very similar. */
3104 if (debug_section == NULL) {
d05511ca
SC		 3105 debug_section = build_debug_section(abfd);
3106 }
cbdc7909 3107 internal_ptr->u.syment._n._n_n._n_offset = (int)
d05511ca 3108 (debug_section + internal_ptr->u.syment._n._n_n._n_offset);
cbdc7909 3109 }
cbdc7909 3110 }
d05511ca
SC		 3111 internal_ptr += internal_ptr->u.syment.n_numaux;
3112 }
0f268757 3113
0f268757 3114 obj_raw_syments(abfd) = internal;
cbdc7909 3115
0f268757
SC		 3116 return (internal);
3117} /* get_normalized_symtab() */
3118
7a8b18b6
SC		 3119#endif /* NO_COFF_SYMBOLS */
3120
0f268757
SC		 3121static
3122struct sec *
3123DEFUN(section_from_bfd_index,(abfd, index),
3124 bfd *abfd AND
3125 int index)
3126{
e98e6ec1 3127 struct sec *answer = abfd->sections;
6590a8c9
SC		 3128
3129 if (index == N_ABS)
3130 {
3131 return &bfd_abs_section;
3132 }
3133 if (index == N_UNDEF)
3134 {
3135 return &bfd_und_section;
3136 }
3137 if(index == N_DEBUG)
3138 {
3139 return &bfd_debug_section;
3140
3141 }
e98e6ec1
SC		 3142
3143 while (answer) {
3144 if (answer->target_index == index)
3145 return answer;
0f268757
SC		 3146 answer = answer->next;
3147 }
e98e6ec1 3148 BFD_ASSERT(0);
859f11ff 3149 return &bfd_und_section; /* For gcc -W and lint. Never executed. */
0f268757
SC		 3150}
3151
7a8b18b6 3152#ifndef NO_COFF_LINENOS
0f268757 3153
9fda1a39
SC		 3154/*
3155SUBSUBSECTION
3156 Reading Linenumbers
3157
9fda1a39
SC		 3158 Creating the linenumber table is done by reading in the entire
3159 coff linenumber table, and creating another table for internal use.
6f715d66 3160
9fda1a39
SC		 3161 A coff line number table is structured so that each function
3162 is marked as having a line number of 0. Each line within the
3163 function is an offset from the first line in the function. The
3164 base of the line number information for the table is stored in
3165 the symbol associated with the function.
6f715d66 3166
9fda1a39
SC		 3167 The information is copied from the external to the internal
3168 table, and each symbol which marks a function is marked by
3169 pointing its...
6f715d66 3170
9fda1a39 3171 How does this work ?
6f715d66
SC		 3172
3173*/
0f268757
SC		 3174
3175static boolean
3176coff_slurp_line_table(abfd, asect)
3177bfd *abfd;
3178asection *asect;
3179 {
3180 LINENO *native_lineno;
3181 alent *lineno_cache;
cbdc7909 3182
0f268757 3183 BFD_ASSERT(asect->lineno == (alent *) NULL);
cbdc7909 3184
0f268757
SC		 3185 native_lineno = (LINENO *) buy_and_read(abfd,
3186 asect->line_filepos,
3187 SEEK_SET,
3188 (size_t) (LINESZ *
3189 asect->lineno_count));
3190 lineno_cache =
3191 (alent *) bfd_alloc(abfd, (size_t) ((asect->lineno_count + 1) * sizeof(alent)));
3192 if (lineno_cache == NULL) {
3193 bfd_error = no_memory;
3194 return false;
cbdc7909 3195 } else {
0f268757
SC		 3196 unsigned int counter = 0;
3197 alent *cache_ptr = lineno_cache;
3198 LINENO *src = native_lineno;
cbdc7909 3199
0f268757
SC		 3200 while (counter < asect->lineno_count) {
3201 struct internal_lineno dst;
2700c3c7 3202 coff_swap_lineno_in(abfd, src, &dst);
0f268757 3203 cache_ptr->line_number = dst.l_lnno;
cbdc7909 3204
0f268757
SC		 3205 if (cache_ptr->line_number == 0) {
3206 coff_symbol_type *sym =
3207 (coff_symbol_type *) (dst.l_addr.l_symndx
6f715d66 3208 + obj_raw_syments(abfd))->u.syment._n._n_n._n_zeroes;
0f268757
SC		 3209 cache_ptr->u.sym = (asymbol *) sym;
3210 sym->lineno = cache_ptr;
3211 }
3212 else {
3213 cache_ptr->u.offset = dst.l_addr.l_paddr
3214 - bfd_section_vma(abfd, asect);
3215 } /* If no linenumber expect a symbol index */
cbdc7909 3216
0f268757
SC		 3217 cache_ptr++;
3218 src++;
3219 counter++;
3220 }
3221 cache_ptr->line_number = 0;
cbdc7909 3222
0f268757
SC		 3223 }
3224 asect->lineno = lineno_cache;
3225 /* FIXME, free native_lineno here, or use alloca or something. */
3226 return true;
3227 } /* coff_slurp_line_table() */
3228
7a8b18b6
SC		 3229#endif /* NO_COFF_LINENOS */
3230
3231#ifndef NO_COFF_LINENOS
3232
0f268757
SC		 3233static boolean
3234DEFUN(coff_slurp_symbol_table,(abfd),
3235 bfd *abfd)
6f715d66
SC		 3236{
3237 combined_entry_type *native_symbols;
3238 coff_symbol_type *cached_area;
3239 unsigned int *table_ptr;
cbdc7909 3240
6f715d66
SC		 3241 unsigned int number_of_symbols = 0;
3242 if (obj_symbols(abfd))
3243 return true;
3244 bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET);
cbdc7909 3245
6f715d66
SC		 3246 /* Read in the symbol table */
3247 if ((native_symbols = get_normalized_symtab(abfd)) == NULL) {
3248 return (false);
3249 } /* on error */
cbdc7909 3250
6f715d66
SC		 3251 /* Allocate enough room for all the symbols in cached form */
3252 cached_area =
3253 (coff_symbol_type *)
3254 bfd_alloc(abfd, (size_t) (bfd_get_symcount(abfd) * sizeof(coff_symbol_type)));
cbdc7909 3255
6f715d66
SC		 3256 if (cached_area == NULL) {
3257 bfd_error = no_memory;
3258 return false;
3259 } /* on error */
3260 table_ptr =
3261 (unsigned int *)
3262 bfd_alloc(abfd, (size_t) (bfd_get_symcount(abfd) * sizeof(unsigned int)));
cbdc7909 3263
6f715d66
SC		 3264 if (table_ptr == NULL) {
3265 bfd_error = no_memory;
3266 return false;
85e0c721
SC		 3267 }
3268 else
3269 {
6f715d66
SC		 3270 coff_symbol_type *dst = cached_area;
3271 unsigned int last_native_index = bfd_get_symcount(abfd);
3272 unsigned int this_index = 0;
3273 while (this_index < last_native_index) {
3274 combined_entry_type *src = native_symbols + this_index;
3275 table_ptr[this_index] = number_of_symbols;
3276 dst->symbol.the_bfd = abfd;
cbdc7909 3277
6f715d66
SC		 3278 dst->symbol.name = (char *)(src->u.syment._n._n_n._n_offset);
3279 /*
3280 We use the native name field to point to the cached field
3281 */
3282 src->u.syment._n._n_n._n_zeroes = (int) dst;
3283 dst->symbol.section = section_from_bfd_index(abfd,
3284 src->u.syment.n_scnum);
859f11ff
SC		 3285 dst->symbol.flags = 0;
3286 dst->done_lineno = false;
3287
6f715d66 3288 switch (src->u.syment.n_sclass) {
0f268757 3289#ifdef I960
6f715d66 3290 case C_LEAFEXT:
0f268757 3291#if 0
6f715d66
SC		 3292 dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
3293 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
3294 dst->symbol.flags |= BSF_NOT_AT_END;
0f268757 3295#endif
6f715d66 3296 /* Fall through to next case */
cbdc7909 3297
0f268757 3298#endif
cbdc7909 3299
6f715d66 3300 case C_EXT:
cbdc7909
JG		 3301#ifdef RS6000COFF_C
3302 case C_HIDEXT:
3303#endif
6f715d66
SC		 3304 if ((src->u.syment.n_scnum) == 0) {
3305 if ((src->u.syment.n_value) == 0) {
e98e6ec1 3306 dst->symbol.section = &bfd_und_section;
6f715d66
SC		 3307 dst->symbol.value= 0;
3308 }
3309 else {
e98e6ec1 3310 dst->symbol.section = &bfd_com_section;
6f715d66
SC		 3311 dst->symbol.value = (src->u.syment.n_value);
3312 }
3313 }
3314 else {
3315 /*
3316 Base the value as an index from the base of the
3317 section
3318 */
e98e6ec1 3319
6f715d66
SC		 3320 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
3321 dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
e98e6ec1 3322
6f715d66 3323 if (ISFCN((src->u.syment.n_type))) {
0f268757 3324 /*
6f715d66
SC		 3325 A function ext does not go at the end of a file
3326 */
3327 dst->symbol.flags |= BSF_NOT_AT_END;
0f268757 3328 }
6f715d66 3329 }
85e0c721
SC		 3330
3331
6f715d66 3332 break;
cbdc7909 3333
6f715d66 3334 case C_STAT: /* static */
0f268757 3335#ifdef I960
6f715d66 3336 case C_LEAFSTAT: /* static leaf procedure */
0f268757 3337#endif
6f715d66 3338 case C_LABEL: /* label */
0d740984
SC		 3339 if (src->u.syment.n_scnum == -2)
3340 dst->symbol.flags = BSF_DEBUGGING;
3341 else
3342 dst->symbol.flags = BSF_LOCAL;
6f715d66 3343 /*
0d740984
SC		 3344 Base the value as an index from the base of the section, if
3345 there is one
6f715d66 3346 */
0d740984
SC		 3347 if (dst->symbol.section)
3348 dst->symbol.value = (src->u.syment.n_value) -
3349 dst->symbol.section->vma;
3350 else
3351 dst->symbol.value = (src->u.syment.n_value) ;
6f715d66 3352 break;
cbdc7909 3353
6f715d66
SC		 3354 case C_MOS: /* member of structure */
3355 case C_EOS: /* end of structure */
41f50af0
SC		 3356#ifdef NOTDEF /* C_AUTOARG has the same value */
3357#ifdef C_GLBLREG
3358 case C_GLBLREG: /* A29k-specific storage class */
3359#endif
3360#endif
6f715d66
SC		 3361 case C_REGPARM: /* register parameter */
3362 case C_REG: /* register variable */
0f268757 3363#ifdef C_AUTOARG
6f715d66 3364 case C_AUTOARG: /* 960-specific storage class */
0f268757 3365#endif
6f715d66 3366 case C_TPDEF: /* type definition */
6f715d66
SC		 3367 case C_ARG:
3368 case C_AUTO: /* automatic variable */
3369 case C_FIELD: /* bit field */
3370 case C_ENTAG: /* enumeration tag */
3371 case C_MOE: /* member of enumeration */
3372 case C_MOU: /* member of union */
3373 case C_UNTAG: /* union tag */
6f715d66
SC		 3374 dst->symbol.flags = BSF_DEBUGGING;
3375 dst->symbol.value = (src->u.syment.n_value);
3376 break;
cbdc7909 3377
6f715d66
SC		 3378 case C_FILE: /* file name */
3379 case C_STRTAG: /* structure tag */
cbdc7909
JG		 3380#ifdef RS6000COFF_C
3381 case C_BINCL: /* beginning of include file */
3382 case C_EINCL: /* ending of include file */
3383 case C_GSYM:
3384 case C_LSYM:
3385 case C_PSYM:
3386 case C_RSYM:
3387 case C_RPSYM:
3388 case C_STSYM:
3389 case C_DECL:
3390 case C_ENTRY:
3391 case C_FUN:
3392 case C_BSTAT:
3393 case C_ESTAT:
3394#endif
6f715d66
SC		 3395 dst->symbol.flags = BSF_DEBUGGING;
3396 dst->symbol.value = (src->u.syment.n_value);
6f715d66 3397 break;
cbdc7909 3398
6f715d66
SC		 3399 case C_BLOCK: /* ".bb" or ".eb" */
3400 case C_FCN: /* ".bf" or ".ef" */
41f50af0 3401 case C_EFCN: /* physical end of function */
6f715d66
SC		 3402 dst->symbol.flags = BSF_LOCAL;
3403 /*
3404 Base the value as an index from the base of the section
3405 */
3406 dst->symbol.value = (src->u.syment.n_value) - dst->symbol.section->vma;
6f715d66 3407 break;
cbdc7909 3408
6f715d66
SC		 3409 case C_NULL:
3410 case C_EXTDEF: /* external definition */
3411 case C_ULABEL: /* undefined label */
3412 case C_USTATIC: /* undefined static */
3413 case C_LINE: /* line # reformatted as symbol table entry */
3414 case C_ALIAS: /* duplicate tag */
3415 case C_HIDDEN: /* ext symbol in dmert public lib */
6f715d66 3416 default:
cbdc7909
JG		 3417
3418 fprintf(stderr,"Unrecognized storage class %d\n",
41f50af0 3419 src->u.syment.n_sclass);
954d412a 3420/* abort();*/
6f715d66
SC		 3421 dst->symbol.flags = BSF_DEBUGGING;
3422 dst->symbol.value = (src->u.syment.n_value);
6f715d66
SC		 3423 break;
3424 }
cbdc7909 3425
6590a8c9 3426/* BFD_ASSERT(dst->symbol.flags != 0);*/
cbdc7909 3427
6f715d66 3428 dst->native = src;
cbdc7909 3429
6f715d66
SC		 3430 dst->symbol.udata = 0;
3431 dst->lineno = (alent *) NULL;
3432 this_index += (src->u.syment.n_numaux) + 1;
3433 dst++;
3434 number_of_symbols++;
3435 } /* walk the native symtab */
3436 } /* bfdize the native symtab */
cbdc7909 3437
6f715d66
SC		 3438 obj_symbols(abfd) = cached_area;
3439 obj_raw_syments(abfd) = native_symbols;
cbdc7909 3440
8070f29d 3441 obj_conv_table_size (abfd) = bfd_get_symcount (abfd);
6f715d66
SC		 3442 bfd_get_symcount(abfd) = number_of_symbols;
3443 obj_convert(abfd) = table_ptr;
3444 /* Slurp the line tables for each section too */
3445 {
3446 asection *p;
3447 p = abfd->sections;
3448 while (p) {
3449 coff_slurp_line_table(abfd, p);
3450 p = p->next;
0f268757 3451 }
6f715d66
SC		 3452 }
3453 return true;
3454} /* coff_slurp_symbol_table() */
0f268757
SC		 3455
3456static unsigned int
3457coff_get_symtab_upper_bound(abfd)
3458bfd *abfd;
3459 {
3460 if (!coff_slurp_symbol_table(abfd))
3461 return 0;
cbdc7909 3462
0f268757
SC		 3463 return (bfd_get_symcount(abfd) + 1) * (sizeof(coff_symbol_type *));
3464 }
3465
3466
3467static unsigned int
85e0c721
SC		 3468DEFUN(coff_get_symtab, (abfd, alocation),
3469 bfd *abfd AND
3470 asymbol **alocation)
3471{
0f268757
SC		 3472 unsigned int counter = 0;
3473 coff_symbol_type *symbase;
3474 coff_symbol_type **location = (coff_symbol_type **) (alocation);
3475 if (!coff_slurp_symbol_table(abfd))
85e0c721
SC		 3476 return 0;
3477
3478 symbase = obj_symbols(abfd);
3479 while (counter < bfd_get_symcount(abfd))
3480 {
3481 /* This nasty code looks at the symbol to decide whether or
3482 not it is descibes a constructor/destructor entry point. It
3483 is structured this way to (hopefully) speed non matches */
3b4f1a5d
SC		 3484#if 0
3485 if (0 && symbase->symbol.name[9] == '$')
85e0c721
SC		 3486 {
3487 bfd_constructor_entry(abfd,
3488 (asymbol **)location,
3489 symbase->symbol.name[10] == 'I' ?
3490 "CTOR" : "DTOR");
3491 }
3b4f1a5d 3492#endif
85e0c721
SC		 3493 *(location++) = symbase++;
3494 counter++;
3495 }
0f268757
SC		 3496 *location++ = 0;
3497 return bfd_get_symcount(abfd);
85e0c721 3498}
0f268757 3499
7a8b18b6
SC		 3500#endif /* NO_COFF_SYMBOLS */
3501
0f268757
SC		 3502static unsigned int
3503coff_get_reloc_upper_bound(abfd, asect)
3504bfd *abfd;
3505sec_ptr asect;
3506 {
3507 if (bfd_get_format(abfd) != bfd_object) {
3508 bfd_error = invalid_operation;
3509 return 0;
3510 }
3511 return (asect->reloc_count + 1) * sizeof(arelent *);
3512 }
3513
9fda1a39
SC		 3514/*
3515SUBSUBSECTION
3516 Reading Relocations
3517
9fda1a39
SC		 3518 Coff relocations are easily transformed into the internal BFD form
3519 (@code{arelent}).
3520
3521 Reading a coff relocation table is done in the following stages:
3522
3523 o The entire coff relocation table is read into memory.
3524
3525 o Each relocation is processed in turn, first it is swapped from the
3526 external to the internal form.
3527
3528 o The symbol referenced in the relocation's symbol index is
3529 turned intoa pointer into the canonical symbol table. Note
3530 that this table is the same as the one returned by a call to
3531 @code{bfd_canonicalize_symtab}. The back end will call the
3532 routine and save the result if a canonicalization hasn't been done.
3533
3534 o The reloc index is turned into a pointer to a howto
3535 structure, in a back end specific way. For instance, the 386
3536 and 960 use the @code{r_type} to directly produce an index
3537 into a howto table vector; the 88k subtracts a number from the
3538 @code{r_type} field and creates an addend field.
3539
3540
6f715d66
SC		 3541*/
3542
3b4f1a5d
SC		 3543#ifndef CALC_ADDEND
3544#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
3545 if (ptr && ptr->the_bfd == abfd \
3b4f1a5d
SC		 3546 && ((ptr->flags & BSF_OLD_COMMON)== 0)) \
3547 { \
3548 cache_ptr->addend = -(ptr->section->vma + ptr->value); \
3549 } \
3550 else { \
3551 cache_ptr->addend = 0; \
3552 }
3553#endif
3554
0f268757
SC		 3555static boolean
3556DEFUN(coff_slurp_reloc_table,(abfd, asect, symbols),
3557 bfd *abfd AND
3558 sec_ptr asect AND
3559 asymbol **symbols)
85e0c721 3560{
3b4f1a5d
SC		 3561 RELOC *native_relocs;
3562 arelent *reloc_cache;
3563 arelent *cache_ptr;
3564
3565 unsigned int idx;
3566
3567 if (asect->relocation)
3568 return true;
3569 if (asect->reloc_count == 0)
3570 return true;
3571 if (asect->flags & SEC_CONSTRUCTOR)
3572 return true;
7a8b18b6 3573#ifndef NO_COFF_SYMBOLS
3b4f1a5d
SC		 3574 if (!coff_slurp_symbol_table(abfd))
3575 return false;
3576#endif
3577 native_relocs =
3578 (RELOC *) buy_and_read(abfd,
3579 asect->rel_filepos,
3580 SEEK_SET,
3581 (size_t) (RELSZ *
3582 asect->reloc_count));
3583 reloc_cache = (arelent *)
3584 bfd_alloc(abfd, (size_t) (asect->reloc_count * sizeof(arelent)));
3585
3586 if (reloc_cache == NULL) {
3587 bfd_error = no_memory;
3588 return false;
3589 }
3590
3591
3592 for (idx = 0; idx < asect->reloc_count; idx ++)
3593 {
616ebcfd 3594#ifdef RELOC_PROCESSING
3b4f1a5d 3595 struct internal_reloc dst;
3b4f1a5d
SC		 3596 struct external_reloc *src;
3597
3598 cache_ptr = reloc_cache + idx;
3599 src = native_relocs + idx;
3b4f1a5d
SC		 3600 bfd_swap_reloc_in(abfd, src, &dst);
3601
9898b929
JG		 3602 RELOC_PROCESSING(cache_ptr, &dst, symbols, abfd, asect);
3603#else
616ebcfd
SC		 3604 struct internal_reloc dst;
3605 asymbol *ptr;
3606 struct external_reloc *src;
3607
3608 cache_ptr = reloc_cache + idx;
3609 src = native_relocs + idx;
3610
3611 bfd_swap_reloc_in(abfd, src, &dst);
3612
9898b929
JG		 3613
3614 cache_ptr->address = dst.r_vaddr;
3615
3b4f1a5d 3616 if (dst.r_symndx != -1)
8070f29d
KR		 3617 {
3618 /* @@ Should never be greater than count of symbols! */
3619 if (dst.r_symndx >= obj_conv_table_size (abfd))
3620 abort ();
9898b929
JG		 3621 cache_ptr->sym_ptr_ptr = symbols + obj_convert(abfd)[dst.r_symndx];
3622 ptr = *(cache_ptr->sym_ptr_ptr);
8070f29d 3623 }
3b4f1a5d 3624 else
8070f29d
KR		 3625 {
3626 cache_ptr->sym_ptr_ptr= bfd_abs_section.symbol_ptr_ptr;
3627 ptr = 0;
3628 }
85e0c721 3629
3b4f1a5d
SC		 3630 /*
3631 The symbols definitions that we have read in have been
3632 relocated as if their sections started at 0. But the offsets
3633 refering to the symbols in the raw data have not been
3634 modified, so we have to have a negative addend to compensate.
3635
3636 Note that symbols which used to be common must be left alone */
cbdc7909 3637
3b4f1a5d
SC		 3638 /* Calculate any reloc addend by looking at the symbol */
3639 CALC_ADDEND(abfd, ptr, dst, cache_ptr);
cbdc7909 3640
3b4f1a5d 3641 cache_ptr->address -= asect->vma;
e98e6ec1 3642/* !! cache_ptr->section = (asection *) NULL;*/
20fdc627 3643
3b4f1a5d 3644 /* Fill in the cache_ptr->howto field from dst.r_type */
e98e6ec1 3645 RTYPE2HOWTO(cache_ptr, &dst);
9898b929
JG		 3646#endif
3647
3648 }
cbdc7909 3649
3b4f1a5d
SC		 3650 asect->relocation = reloc_cache;
3651 return true;
85e0c721 3652}
0f268757
SC		 3653
3654
3655/* This is stupid. This function should be a boolean predicate */
3656static unsigned int
85e0c721
SC		 3657DEFUN(coff_canonicalize_reloc, (abfd, section, relptr, symbols),
3658bfd *abfd AND
3659sec_ptr section AND
3660arelent **relptr AND
3661asymbol **symbols)
3662{
e98e6ec1
SC		 3663 arelent *tblptr = section->relocation;
3664 unsigned int count = 0;
cbdc7909 3665
cbdc7909 3666
e98e6ec1
SC		 3667 if (section->flags & SEC_CONSTRUCTOR)
3668 {
3669 /* this section has relocs made up by us, they are not in the
3670 file, so take them out of their chain and place them into
3671 the data area provided */
3672 arelent_chain *chain = section->constructor_chain;
3673 for (count = 0; count < section->reloc_count; count ++)
85e0c721 3674 {
e98e6ec1
SC		 3675 *relptr ++ = &chain->relent;
3676 chain = chain->next;
85e0c721 3677 }
e98e6ec1
SC		 3678
3679 }
3680 else
3681 {
3682 coff_slurp_reloc_table(abfd, section, symbols);
85e0c721
SC		 3683
3684
e98e6ec1
SC		 3685 tblptr = section->relocation;
3686 if (!tblptr)
3687 return 0;
85e0c721 3688
e98e6ec1
SC		 3689 for (; count++ < section->reloc_count;)
3690 *relptr++ = tblptr++;
cbdc7909 3691
85e0c721 3692
e98e6ec1
SC		 3693 }
3694 *relptr = 0;
3695 return section->reloc_count;
85e0c721 3696}
0f268757 3697
7a8b18b6 3698#ifndef NO_COFF_SYMBOLS
0f268757
SC		 3699
3700/*
6724ff46 3701provided a BFD, a section and an offset into the section, calculate and
0f268757
SC		 3702return the name of the source file and the line nearest to the wanted
3703location.
3704*/
3705
3706static boolean
3707DEFUN(coff_find_nearest_line,(abfd,
3708 section,
fb3be09b 3709 ignore_symbols,
0f268757
SC		 3710 offset,
3711 filename_ptr,
3712 functionname_ptr,
3713 line_ptr),
3714 bfd *abfd AND
3715 asection *section AND
fb3be09b 3716 asymbol **ignore_symbols AND
0f268757
SC		 3717 bfd_vma offset AND
3718 CONST char **filename_ptr AND
3719 CONST char **functionname_ptr AND
3720 unsigned int *line_ptr)
3721{
3722 static bfd *cache_abfd;
3723 static asection *cache_section;
3724 static bfd_vma cache_offset;
3725 static unsigned int cache_i;
3726 static alent *cache_l;
cbdc7909 3727
0f268757 3728 unsigned int i = 0;
fb3be09b 3729 coff_data_type *cof = coff_data(abfd);
0f268757 3730 /* Run through the raw syments if available */
6f715d66 3731 combined_entry_type *p;
0f268757
SC		 3732 alent *l;
3733 unsigned int line_base = 0;
cbdc7909
JG		 3734
3735
0f268757
SC		 3736 *filename_ptr = 0;
3737 *functionname_ptr = 0;
3738 *line_ptr = 0;
cbdc7909 3739
0f268757 3740 /* Don't try and find line numbers in a non coff file */
0d740984 3741 if (abfd->xvec->flavour != bfd_target_coff_flavour)
0f268757 3742 return false;
cbdc7909 3743
fb3be09b 3744 if (cof == NULL)
0f268757 3745 return false;
6f715d66 3746
0f268757 3747 p = cof->raw_syments;
cbdc7909 3748
0f268757 3749 for (i = 0; i < cof->raw_syment_count; i++) {
6f715d66
SC		 3750 if (p->u.syment.n_sclass == C_FILE) {
3751 /* File name has been moved into symbol */
3752 *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
0f268757
SC		 3753 break;
3754 }
6f715d66 3755 p += 1 + p->u.syment.n_numaux;
0f268757
SC		 3756 }
3757 /* Now wander though the raw linenumbers of the section */
3758 /*
6724ff46 3759 If this is the same BFD as we were previously called with and this is
0f268757
SC		 3760 the same section, and the offset we want is further down then we can
3761 prime the lookup loop
3762 */
3763 if (abfd == cache_abfd &&
3764 section == cache_section &&
3765 offset >= cache_offset) {
3766 i = cache_i;
3767 l = cache_l;
3768 }
3769 else {
3770 i = 0;
3771 l = section->lineno;
3772 }
cbdc7909 3773
0f268757
SC		 3774 for (; i < section->lineno_count; i++) {
3775 if (l->line_number == 0) {
3776 /* Get the symbol this line number points at */
3777 coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym);
3778 *functionname_ptr = coff->symbol.name;
3779 if (coff->native) {
6f715d66
SC		 3780 combined_entry_type *s = coff->native;
3781 s = s + 1 + s->u.syment.n_numaux;
0f268757
SC		 3782 /*
3783 S should now point to the .bf of the function
3784 */
6f715d66 3785 if (s->u.syment.n_numaux) {
0f268757
SC		 3786 /*
3787 The linenumber is stored in the auxent
3788 */
6f715d66 3789 union internal_auxent *a = &((s + 1)->u.auxent);
0f268757
SC		 3790 line_base = a->x_sym.x_misc.x_lnsz.x_lnno;
3791 }
3792 }
3793 }
3794 else {
3795 if (l->u.offset > offset)
3796 break;
3797 *line_ptr = l->line_number + line_base + 1;
3798 }
3799 l++;
3800 }
cbdc7909 3801
0f268757
SC		 3802 cache_abfd = abfd;
3803 cache_section = section;
3804 cache_offset = offset;
3805 cache_i = i;
3806 cache_l = l;
6f715d66 3807
0f268757
SC		 3808 return true;
3809}
3810
3811#ifdef GNU960
3812file_ptr
3813coff_sym_filepos(abfd)
3814bfd *abfd;
3815 {
3816 return obj_sym_filepos(abfd);
3817 }
3818#endif
3819
7a8b18b6
SC		 3820#endif /* NO_COFF_SYMBOLS */
3821
0f268757 3822
cbdc7909 3823static int
0f268757
SC		 3824DEFUN(coff_sizeof_headers,(abfd, reloc),
3825 bfd *abfd AND
3826 boolean reloc)
85e0c721 3827{
0f268757 3828 size_t size;
cbdc7909 3829
0f268757 3830 if (reloc == false) {
85e0c721 3831 size = FILHSZ + AOUTSZ;
0f268757
SC		 3832 }
3833 else {
85e0c721 3834 size = FILHSZ;
0f268757 3835 }
cbdc7909 3836
0f268757
SC		 3837 size += abfd->section_count * SCNHSZ;
3838 return size;
85e0c721 3839}
0f268757 3840
6590a8c9
SC		 3841static bfd_vma
3842DEFUN(get_value,(reloc, seclet),
3843 arelent *reloc AND
3844 bfd_seclet_type *seclet)
3845{
3846 bfd_vma value;
3847 asymbol *symbol = *(reloc->sym_ptr_ptr);
3848 /* A symbol holds a pointer to a section, and an offset from the
3849 base of the section. To relocate, we find where the section will
3850 live in the output and add that in */
3851
3852 if (symbol->section == &bfd_und_section)
3853 {
3854 /* Ouch, this is an undefined symbol.. */
3855 bfd_error_vector.undefined_symbol(reloc, seclet);
3856 value = symbol->value;
3857 }
3858 else
3859 {
3860 value = symbol->value +
3861 symbol->section->output_offset +
3862 symbol->section->output_section->vma;
3863 }
3864
3865
3866 /* Add the value contained in the relocation */
3867 value += (short)((reloc->addend) & 0xffff);
3868
3869 return value;
3870}
3871
3872static void
3873DEFUN(perform_slip,(s, slip, input_section, value),
3874 asymbol **s AND
3875 unsigned int slip AND
3876 asection *input_section AND
3877 bfd_vma value)
3878{
3879
3880 /* Find all symbols past this point, and make them know
3881 what's happened */
3882 while (*s)
3883 {
3884 asymbol *p = *s;
3885 if (p->section == input_section)
3886 {
3887 /* This was pointing into this section, so mangle it */
3888 if (p->value > value)
3889 {
9465d03e 3890 p->value -= slip;
6590a8c9
SC		 3891 }
3892 }
3893 s++;
3894
3895 }
3896}
3897static int
3898DEFUN(movb1,(input_section, symbols, r, shrink),
3899 asection *input_section AND
3900 asymbol **symbols AND
3901 arelent *r AND
3902 unsigned int shrink)
3903{
3904 bfd_vma value = get_value(r,0);
3905
3906 if (value >= 0xff00)
3907 {
3908
3909 /* Change the reloc type from 16bit, possible 8 to 8bit
3910 possible 16 */
3911 r->howto = r->howto + 1;
3912 /* The place to relc moves back by one */
3913 r->address -=1;
3914
3915 /* This will be two bytes smaller in the long run */
3916 shrink +=2 ;
3917 perform_slip(symbols, 2, input_section, r->address - shrink +1);
3918
3919
3920 }
3921 return shrink;
3922}
3923
3924static int
3925DEFUN(jmp1,(input_section, symbols, r, shrink),
3926 asection *input_section AND
3927 asymbol **symbols AND
3928 arelent *r AND
3929 unsigned int shrink)
3930{
3931
3932
3933 bfd_vma value = get_value(r, 0);
3934
3935 bfd_vma dot = input_section->output_section->vma +
3936 input_section->output_offset + r->address;
3937 bfd_vma gap;
3938
3939 /* See if the address we're looking at within 127 bytes of where
3940 we are, if so then we can use a small branch rather than the
3941 jump we were going to */
3942
3943 gap = value - (dot - shrink);
3944
3945
3946 if (-120 < (long)gap && (long)gap < 120 )
3947 {
3948
3949 /* Change the reloc type from 16bit, possible 8 to 8bit
3950 possible 16 */
3951 r->howto = r->howto + 1;
3952 /* The place to relc moves back by one */
3953 r->address -=1;
3954
3955 /* This will be two bytes smaller in the long run */
3956 shrink +=2 ;
3957 perform_slip(symbols, 2, input_section, r->address-shrink +1);
3958
3959
3960 }
3961 return shrink;
3962}
3963
2f8640fe 3964static boolean
a0f3f080 3965DEFUN(bfd_coff_relax_section,(abfd, i, symbols),
6590a8c9
SC		 3966 bfd *abfd AND
3967 asection *i AND
a0f3f080 3968 asymbol **symbols)
6590a8c9
SC		 3969{
3970
3971 /* Get enough memory to hold the stuff */
3972 bfd *input_bfd = i->owner;
3973 asection *input_section = i;
3974 int shrink = 0 ;
2f8640fe 3975 boolean new = false;
6590a8c9
SC		 3976
3977 bfd_size_type reloc_size = bfd_get_reloc_upper_bound(input_bfd,
3978 input_section);
3979 arelent **reloc_vector = (arelent **)bfd_xmalloc(reloc_size);
3980
3981 /* Get the relocs and think about them */
3982 if (bfd_canonicalize_reloc(input_bfd,
3983 input_section,
3984 reloc_vector,
3985 symbols))
3986 {
3987 arelent **parent;
3988 for (parent = reloc_vector; *parent; parent++)
3989 {
3990 arelent *r = *parent;
3991 switch (r->howto->type) {
3992 case R_MOVB2:
3993 case R_JMP2:
3994
3995 shrink+=2;
3996 break;
3997
3998 case R_MOVB1:
3999 shrink = movb1(input_section, symbols, r, shrink);
2f8640fe 4000 new = true;
6590a8c9
SC		 4001
4002 break;
4003 case R_JMP1:
4004 shrink = jmp1(input_section, symbols, r, shrink);
2f8640fe 4005 new = true;
6590a8c9
SC		 4006
4007 break;
4008 }
4009 }
4010
4011 }
4012 input_section->_cooked_size -= shrink;
4013 free((char *)reloc_vector);
4014 return new;
4015}
4016
4017static bfd_byte *
8070f29d 4018DEFUN(bfd_coff_get_relocated_section_contents,(in_abfd, seclet, data),
6590a8c9 4019 bfd *in_abfd AND
8070f29d
KR		 4020 bfd_seclet_type *seclet AND
4021 bfd_byte *data)
6590a8c9
SC		 4022
4023{
6590a8c9
SC		 4024 /* Get enough memory to hold the stuff */
4025 bfd *input_bfd = seclet->u.indirect.section->owner;
4026 asection *input_section = seclet->u.indirect.section;
6590a8c9
SC		 4027 bfd_size_type reloc_size = bfd_get_reloc_upper_bound(input_bfd,
4028 input_section);
4029 arelent **reloc_vector = (arelent **)bfd_xmalloc(reloc_size);
4030
4031 /* read in the section */
4032 bfd_get_section_contents(input_bfd,
4033 input_section,
4034 data,
4035 0,
4036 input_section->_raw_size);
4037
4038
4039 if (bfd_canonicalize_reloc(input_bfd,
4040 input_section,
4041 reloc_vector,
4042 seclet->u.indirect.symbols) )
4043 {
4044 arelent **parent = reloc_vector;
4045 arelent *reloc ;
4046
4047
4048
4049 unsigned int dst_address = 0;
4050 unsigned int src_address = 0;
4051 unsigned int run;
4052 unsigned int idx;
4053
4054 /* Find how long a run we can do */
4055 while (dst_address < seclet->size)
4056 {
4057
4058 reloc = *parent;
4059 if (reloc)
4060 {
4061 /* Note that the relaxing didn't tie up the addresses in the
4062 relocation, so we use the original address to work out the
4063 run of non-relocated data */
4064 run = reloc->address - src_address;
4065 parent++;
4066
4067 }
4068 else
4069 {
4070 run = seclet->size - dst_address;
4071 }
4072 /* Copy the bytes */
4073 for (idx = 0; idx < run; idx++)
4074 {
4075 data[dst_address++] = data[src_address++];
4076 }
4077
4078 /* Now do the relocation */
4079
4080 if (reloc)
4081 {
4082 switch (reloc->howto->type)
4083 {
4084 case R_JMP2:
4085 /* Speciial relaxed type */
4086 {
4087 bfd_vma dot = seclet->offset + dst_address + seclet->u.indirect.section->output_section->vma;
4088 int gap = get_value(reloc,seclet)-dot-1;
4089 if ((gap & ~0xff ) != 0 &&((gap & 0xff00)!= 0xff00)) abort();
4090
4091 bfd_put_8(in_abfd,gap, data+dst_address);
4092
4093 switch (data[dst_address-1])
4094 {
4095
4096 case 0x5e:
4097 /* jsr -> bsr */
4098 bfd_put_8(in_abfd, 0x55, data+dst_address-1);
4099 break;
4100 case 0x5a:
4101 /* jmp ->bra */
4102 bfd_put_8(in_abfd, 0x40, data+dst_address-1);
4103 break;
4104
4105 default:
4106 abort();
4107
4108 }
4109
4110
4111
4112
4113 dst_address++;
4114 src_address+=3;
4115
4116 break;
4117 }
4118
4119
4120 case R_MOVB2:
4121 /* Special relaxed type, there will be a gap between where we
4122 get stuff from and where we put stuff to now
4123
4124 for a mov.b @aa:16 -> mov.b @aa:8
4125 opcode 0x6a 0x0y offset
4126 -> 0x2y off
4127 */
4128 if (data[dst_address-1] != 0x6a)
4129 abort();
9465d03e 4130 switch (data[src_address] & 0xf0)
6590a8c9
SC		 4131 {
4132 case 0x00:
4133 /* Src is memory */
4134 data[dst_address-1] = (data[src_address] & 0xf) | 0x20;
4135 break;
4136 case 0x80:
4137 /* Src is reg */
4138 data[dst_address-1] = (data[src_address] & 0xf) | 0x30;
4139 break;
4140 default:
4141 abort();
4142 }
4143
4144 /* the offset must fit ! after all, what was all the relaxing
4145 about ? */
4146
4147 bfd_put_8(in_abfd, get_value(reloc, seclet), data + dst_address);
4148
4149 /* Note the magic - src goes up by two bytes, but dst by only
4150 one */
4151 dst_address+=1;
4152 src_address+=3;
4153
4154 break;
4155 /* PCrel 8 bits */
4156 case R_PCRBYTE:
4157 {
4158 bfd_vma dot = seclet->offset + dst_address + seclet->u.indirect.section->output_section->vma;
4159 int gap = get_value(reloc,seclet)-dot;
4160 if (gap > 127 || gap < -128)
4161 {
4162 bfd_error_vector.reloc_value_truncated(reloc, seclet);
4163 }
4164
4165 bfd_put_8(in_abfd,gap, data+dst_address);
4166 dst_address++;
4167 src_address++;
4168
4169 break;
4170 }
4171
4172 case R_RELBYTE:
4173 {
4174 unsigned int gap =get_value(reloc,seclet);
9465d03e 4175 if (gap > 0xff && gap < ~0xff)
6590a8c9
SC		 4176 {
4177 bfd_error_vector.reloc_value_truncated(reloc, seclet);
4178 }
4179
4180 bfd_put_8(in_abfd, gap, data+dst_address);
4181 dst_address+=1;
4182 src_address+=1;
4183
4184
4185 }
4186 break;
4187 case R_JMP1:
4188 /* A relword which would have like to have been a pcrel */
4189 case R_MOVB1:
4190 /* A relword which would like to have been modified but
4191 didn't make it */
4192 case R_RELWORD:
4193 bfd_put_16(in_abfd, get_value(reloc,seclet), data+dst_address);
4194 dst_address+=2;
4195 src_address+=2;
4196 break;
8ad2a31d
SC		 4197#ifdef EXTRA_CASES
4198 EXTRA_CASES
4199#else
4200
6590a8c9
SC		 4201 default:
4202 abort();
8ad2a31d 4203#endif
6590a8c9
SC		 4204 }
4205 }
4206 }
4207 }
4208 free((char *)reloc_vector);
4209 return data;
4210
4211}
4212
0f268757
SC		 4213
4214#define coff_core_file_failing_command _bfd_dummy_core_file_failing_command
4215#define coff_core_file_failing_signal _bfd_dummy_core_file_failing_signal
4216#define coff_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
4217#define coff_slurp_armap bfd_slurp_coff_armap
4218#define coff_slurp_extended_name_table _bfd_slurp_extended_name_table
4219#define coff_truncate_arname bfd_dont_truncate_arname
4220#define coff_openr_next_archived_file bfd_generic_openr_next_archived_file
4221#define coff_generic_stat_arch_elt bfd_generic_stat_arch_elt
4222#define coff_get_section_contents bfd_generic_get_section_contents
4223#define coff_close_and_cleanup bfd_generic_close_and_cleanup
6f715d66
SC		 4224
4225#define coff_bfd_debug_info_start bfd_void
4226#define coff_bfd_debug_info_end bfd_void
41f50af0 4227#define coff_bfd_debug_info_accumulate (PROTO(void,(*),(bfd*, struct sec *))) bfd_void
6590a8c9
SC		 4228#define coff_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
4229#define coff_bfd_relax_section bfd_generic_relax_section
4230
GDB Binutils - Deliverables
This page took 0.380104 seconds and 4 git commands to generate.