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