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