/usr/src/gnu/usr.bin/binutils/bfd/coffcode.h

Bug Summary

File:	src/gnu/usr.bin/binutils/bfd/coffcode.h
Warning:	line 5179, column 12 Value stored to 'tblptr' during its initialization is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name coff-i386.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/binutils/obj/bfd -resource-dir /usr/local/lib/clang/13.0.0 -D HAVE_CONFIG_H -I . -I /usr/src/gnu/usr.bin/binutils/bfd -I . -D _GNU_SOURCE -D NETBSD_CORE -I . -I /usr/src/gnu/usr.bin/binutils/bfd -I /usr/src/gnu/usr.bin/binutils/bfd/../include -I /usr/src/gnu/usr.bin/binutils/bfd/../intl -I ../intl -D PIE_DEFAULT=1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/gnu/usr.bin/binutils/obj/bfd -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/gnu/usr.bin/binutils/bfd/coff-i386.c

1	/* Support for the generic parts of most COFF variants, for BFD.
2	Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3	2000, 2001, 2002, 2003
4	Free Software Foundation, Inc.
5	Written by Cygnus Support.
6
7	This file is part of BFD, the Binary File Descriptor library.
8
9	This program is free software; you can redistribute it and/or modify
10	it under the terms of the GNU General Public License as published by
11	the Free Software Foundation; either version 2 of the License, or
12	(at your option) any later version.
13
14	This program is distributed in the hope that it will be useful,
15	but WITHOUT ANY WARRANTY; without even the implied warranty of
16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17	GNU General Public License for more details.
18
19	You should have received a copy of the GNU General Public License
20	along with this program; if not, write to the Free Software
21	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22
23	/*
24	Most of this hacked by Steve Chamberlain,
25	sac@cygnus.com
26	*/
27	/*
28
29	SECTION
30	coff backends
31
32	BFD supports a number of different flavours of coff format.
33	The major differences between formats are the sizes and
34	alignments of fields in structures on disk, and the occasional
35	extra field.
36
37	Coff in all its varieties is implemented with a few common
38	files and a number of implementation specific files. For
39	example, The 88k bcs coff format is implemented in the file
40	@file{coff-m88k.c}. This file @code{#include}s
41	@file{coff/m88k.h} which defines the external structure of the
42	coff format for the 88k, and @file{coff/internal.h} which
43	defines the internal structure. @file{coff-m88k.c} also
44	defines the relocations used by the 88k format
45	@xref{Relocations}.
46
47	The Intel i960 processor version of coff is implemented in
48	@file{coff-i960.c}. This file has the same structure as
49	@file{coff-m88k.c}, except that it includes @file{coff/i960.h}
50	rather than @file{coff-m88k.h}.
51
52	SUBSECTION
53	Porting to a new version of coff
54
55	The recommended method is to select from the existing
56	implementations the version of coff which is most like the one
57	you want to use. For example, we'll say that i386 coff is
58	the one you select, and that your coff flavour is called foo.
59	Copy @file{i386coff.c} to @file{foocoff.c}, copy
60	@file{../include/coff/i386.h} to @file{../include/coff/foo.h},
61	and add the lines to @file{targets.c} and @file{Makefile.in}
62	so that your new back end is used. Alter the shapes of the
63	structures in @file{../include/coff/foo.h} so that they match
64	what you need. You will probably also have to add
65	@code{#ifdef}s to the code in @file{coff/internal.h} and
66	@file{coffcode.h} if your version of coff is too wild.
67
68	You can verify that your new BFD backend works quite simply by
69	building @file{objdump} from the @file{binutils} directory,
70	and making sure that its version of what's going on and your
71	host system's idea (assuming it has the pretty standard coff
72	dump utility, usually called @code{att-dump} or just
73	@code{dump}) are the same. Then clean up your code, and send
74	what you've done to Cygnus. Then your stuff will be in the
75	next release, and you won't have to keep integrating it.
76
77	SUBSECTION
78	How the coff backend works
79
80	SUBSUBSECTION
81	File layout
82
83	The Coff backend is split into generic routines that are
84	applicable to any Coff target and routines that are specific
85	to a particular target. The target-specific routines are
86	further split into ones which are basically the same for all
87	Coff targets except that they use the external symbol format
88	or use different values for certain constants.
89
90	The generic routines are in @file{coffgen.c}. These routines
91	work for any Coff target. They use some hooks into the target
92	specific code; the hooks are in a @code{bfd_coff_backend_data}
93	structure, one of which exists for each target.
94
95	The essentially similar target-specific routines are in
96	@file{coffcode.h}. This header file includes executable C code.
97	The various Coff targets first include the appropriate Coff
98	header file, make any special defines that are needed, and
99	then include @file{coffcode.h}.
100
101	Some of the Coff targets then also have additional routines in
102	the target source file itself.
103
104	For example, @file{coff-i960.c} includes
105	@file{coff/internal.h} and @file{coff/i960.h}. It then
106	defines a few constants, such as @code{I960}, and includes
107	@file{coffcode.h}. Since the i960 has complex relocation
108	types, @file{coff-i960.c} also includes some code to
109	manipulate the i960 relocs. This code is not in
110	@file{coffcode.h} because it would not be used by any other
111	target.
112
113	SUBSUBSECTION
114	Bit twiddling
115
116	Each flavour of coff supported in BFD has its own header file
117	describing the external layout of the structures. There is also
118	an internal description of the coff layout, in
119	@file{coff/internal.h}. A major function of the
120	coff backend is swapping the bytes and twiddling the bits to
121	translate the external form of the structures into the normal
122	internal form. This is all performed in the
123	@code{bfd_swap}_@i{thing}_@i{direction} routines. Some
124	elements are different sizes between different versions of
125	coff; it is the duty of the coff version specific include file
126	to override the definitions of various packing routines in
127	@file{coffcode.h}. E.g., the size of line number entry in coff is
128	sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
129	@code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
130	correct one. No doubt, some day someone will find a version of
131	coff which has a varying field size not catered to at the
132	moment. To port BFD, that person will have to add more @code{#defines}.
133	Three of the bit twiddling routines are exported to
134	@code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
135	and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol
136	table on its own, but uses BFD to fix things up. More of the
137	bit twiddlers are exported for @code{gas};
138	@code{coff_swap_aux_out}, @code{coff_swap_sym_out},
139	@code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
140	@code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
141	@code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
142	of all the symbol table and reloc drudgery itself, thereby
143	saving the internal BFD overhead, but uses BFD to swap things
144	on the way out, making cross ports much safer. Doing so also
145	allows BFD (and thus the linker) to use the same header files
146	as @code{gas}, which makes one avenue to disaster disappear.
147
148	SUBSUBSECTION
149	Symbol reading
150
151	The simple canonical form for symbols used by BFD is not rich
152	enough to keep all the information available in a coff symbol
153	table. The back end gets around this problem by keeping the original
154	symbol table around, "behind the scenes".
155
156	When a symbol table is requested (through a call to
157	@code{bfd_canonicalize_symtab}), a request gets through to
158	@code{coff_get_normalized_symtab}. This reads the symbol table from
159	the coff file and swaps all the structures inside into the
160	internal form. It also fixes up all the pointers in the table
161	(represented in the file by offsets from the first symbol in
162	the table) into physical pointers to elements in the new
163	internal table. This involves some work since the meanings of
164	fields change depending upon context: a field that is a
165	pointer to another structure in the symbol table at one moment
166	may be the size in bytes of a structure at the next. Another
167	pass is made over the table. All symbols which mark file names
168	(<<C_FILE>> symbols) are modified so that the internal
169	string points to the value in the auxent (the real filename)
170	rather than the normal text associated with the symbol
171	(@code{".file"}).
172
173	At this time the symbol names are moved around. Coff stores
174	all symbols less than nine characters long physically
175	within the symbol table; longer strings are kept at the end of
176	the file in the string table. This pass moves all strings
177	into memory and replaces them with pointers to the strings.
178
179	The symbol table is massaged once again, this time to create
180	the canonical table used by the BFD application. Each symbol
181	is inspected in turn, and a decision made (using the
182	@code{sclass} field) about the various flags to set in the
183	@code{asymbol}. @xref{Symbols}. The generated canonical table
184	shares strings with the hidden internal symbol table.
185
186	Any linenumbers are read from the coff file too, and attached
187	to the symbols which own the functions the linenumbers belong to.
188
189	SUBSUBSECTION
190	Symbol writing
191
192	Writing a symbol to a coff file which didn't come from a coff
193	file will lose any debugging information. The @code{asymbol}
194	structure remembers the BFD from which the symbol was taken, and on
195	output the back end makes sure that the same destination target as
196	source target is present.
197
198	When the symbols have come from a coff file then all the
199	debugging information is preserved.
200
201	Symbol tables are provided for writing to the back end in a
202	vector of pointers to pointers. This allows applications like
203	the linker to accumulate and output large symbol tables
204	without having to do too much byte copying.
205
206	This function runs through the provided symbol table and
207	patches each symbol marked as a file place holder
208	(@code{C_FILE}) to point to the next file place holder in the
209	list. It also marks each @code{offset} field in the list with
210	the offset from the first symbol of the current symbol.
211
212	Another function of this procedure is to turn the canonical
213	value form of BFD into the form used by coff. Internally, BFD
214	expects symbol values to be offsets from a section base; so a
215	symbol physically at 0x120, but in a section starting at
216	0x100, would have the value 0x20. Coff expects symbols to
217	contain their final value, so symbols have their values
218	changed at this point to reflect their sum with their owning
219	section. This transformation uses the
220	<<output_section>> field of the @code{asymbol}'s
221	@code{asection} @xref{Sections}.
222
223	o <<coff_mangle_symbols>>
224
225	This routine runs though the provided symbol table and uses
226	the offsets generated by the previous pass and the pointers
227	generated when the symbol table was read in to create the
228	structured hierarchy required by coff. It changes each pointer
229	to a symbol into the index into the symbol table of the asymbol.
230
231	o <<coff_write_symbols>>
232
233	This routine runs through the symbol table and patches up the
234	symbols from their internal form into the coff way, calls the
235	bit twiddlers, and writes out the table to the file.
236
237	*/
238
239	/*
240	INTERNAL_DEFINITION
241	coff_symbol_type
242
243	DESCRIPTION
244	The hidden information for an <<asymbol>> is described in a
245	<<combined_entry_type>>:
246
247	CODE_FRAGMENT
248	.
249	.typedef struct coff_ptr_struct
250	.{
251	. {* Remembers the offset from the first symbol in the file for
252	. this symbol. Generated by coff_renumber_symbols. *}
253	. unsigned int offset;
254	.
255	. {* Should the value of this symbol be renumbered. Used for
256	. XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
257	. unsigned int fix_value : 1;
258	.
259	. {* Should the tag field of this symbol be renumbered.
260	. Created by coff_pointerize_aux. *}
261	. unsigned int fix_tag : 1;
262	.
263	. {* Should the endidx field of this symbol be renumbered.
264	. Created by coff_pointerize_aux. *}
265	. unsigned int fix_end : 1;
266	.
267	. {* Should the x_csect.x_scnlen field be renumbered.
268	. Created by coff_pointerize_aux. *}
269	. unsigned int fix_scnlen : 1;
270	.
271	. {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
272	. index into the line number entries. Set by coff_slurp_symbol_table. *}
273	. unsigned int fix_line : 1;
274	.
275	. {* The container for the symbol structure as read and translated
276	. from the file. *}
277	. union
278	. {
279	. union internal_auxent auxent;
280	. struct internal_syment syment;
281	. } u;
282	.} combined_entry_type;
283	.
284	.
285	.{* Each canonical asymbol really looks like this: *}
286	.
287	.typedef struct coff_symbol_struct
288	.{
289	. {* The actual symbol which the rest of BFD works with *}
290	. asymbol symbol;
291	.
292	. {* A pointer to the hidden information for this symbol *}
293	. combined_entry_type *native;
294	.
295	. {* A pointer to the linenumber information for this symbol *}
296	. struct lineno_cache_entry *lineno;
297	.
298	. {* Have the line numbers been relocated yet ? *}
299	. bfd_boolean done_lineno;
300	.} coff_symbol_type;
301
302	*/
303
304	#ifdef COFF_WITH_PE
305	#include "peicode.h"
306	#else
307	#include "coffswap.h"
308	#endif
309
310	#define STRING_SIZE_SIZE(4) (4)
311
312	static long sec_to_styp_flags
313	PARAMS ((const char , flagword))(const char , flagword);
314	static bfd_boolean styp_to_sec_flags
315	PARAMS ((bfd , PTR, const char , asection , flagword ))(bfd , void , const char , asection , flagword *);
316	static bfd_boolean coff_bad_format_hook
317	PARAMS ((bfd , PTR))(bfd , void *);
318	static void coff_set_custom_section_alignment
319	PARAMS ((bfd , asection , const struct coff_section_alignment_entry ,(bfd , asection , const struct coff_section_alignment_entry , const unsigned int)
320	const unsigned int))(bfd , asection , const struct coff_section_alignment_entry *, const unsigned int);
321	static bfd_boolean coff_new_section_hook
322	PARAMS ((bfd , asection ))(bfd , asection );
323	static bfd_boolean coff_set_arch_mach_hook
324	PARAMS ((bfd , PTR))(bfd , void *);
325	static bfd_boolean coff_write_relocs
326	PARAMS ((bfd , int))(bfd , int);
327	static bfd_boolean coff_set_flags
328	PARAMS ((bfd , unsigned int , unsigned short ))(bfd , unsigned int , unsigned short );
329	static bfd_boolean coff_set_arch_mach
330	PARAMS ((bfd , enum bfd_architecture, unsigned long))(bfd , enum bfd_architecture, unsigned long) ATTRIBUTE_UNUSED__attribute__ ((__unused__));
331	static bfd_boolean coff_compute_section_file_positions
332	PARAMS ((bfd ))(bfd );
333	static bfd_boolean coff_write_object_contents
334	PARAMS ((bfd ))(bfd ) ATTRIBUTE_UNUSED__attribute__ ((__unused__));
335	static bfd_boolean coff_set_section_contents
336	PARAMS ((bfd , asection , const PTR, file_ptr, bfd_size_type))(bfd , asection , const void *, file_ptr, bfd_size_type);
337	static PTRvoid * buy_and_read
338	PARAMS ((bfd , file_ptr, bfd_size_type))(bfd , file_ptr, bfd_size_type);
339	static bfd_boolean coff_slurp_line_table
340	PARAMS ((bfd , asection ))(bfd , asection );
341	static bfd_boolean coff_slurp_symbol_table
342	PARAMS ((bfd ))(bfd );
343	static enum coff_symbol_classification coff_classify_symbol
344	PARAMS ((bfd , struct internal_syment ))(bfd , struct internal_syment );
345	static bfd_boolean coff_slurp_reloc_table
346	PARAMS ((bfd , asection , asymbol *))(bfd , asection , asymbol *);
347	static long coff_canonicalize_reloc
348	PARAMS ((bfd , asection , arelent , asymbol ))(bfd , asection , arelent , asymbol );
349	#ifndef coff_mkobject_hook
350	static PTRvoid * coff_mkobject_hook
351	PARAMS ((bfd , PTR, PTR))(bfd , void , void );
352	#endif
353	#ifdef COFF_WITH_PE
354	static flagword handle_COMDAT
355	PARAMS ((bfd , flagword, PTR, const char , asection ))(bfd , flagword, void , const char , asection *);
356	#endif
357	#ifdef COFF_IMAGE_WITH_PE
358	static bfd_boolean coff_read_word
359	PARAMS ((bfd , unsigned int ))(bfd , unsigned int );
360	static unsigned int coff_compute_checksum
361	PARAMS ((bfd ))(bfd );
362	static bfd_boolean coff_apply_checksum
363	PARAMS ((bfd ))(bfd );
364	#endif
365	#ifdef TICOFF
366	static bfd_boolean ticoff0_bad_format_hook
367	PARAMS ((bfd , PTR ))(bfd , void * );
368	static bfd_boolean ticoff1_bad_format_hook
369	PARAMS ((bfd , PTR ))(bfd , void * );
370	#endif
371
372	/* void warning(); */
373
374	/* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
375	the incoming SEC_* flags. The inverse of this function is
376	styp_to_sec_flags(). NOTE: If you add to/change this routine, you
377	should probably mirror the changes in styp_to_sec_flags(). */
378
379	#ifndef COFF_WITH_PE
380
381	/* Macros for setting debugging flags. */
382	#ifdef STYP_DEBUG
383	#define STYP_XCOFF_DEBUG(0x0200) STYP_DEBUG
384	#else
385	#define STYP_XCOFF_DEBUG(0x0200) STYP_INFO(0x0200)
386	#endif
387
388	#ifdef COFF_ALIGN_IN_S_FLAGS
389	#define STYP_DEBUG_INFO(0x0200) STYP_DSECT(0x0001)
390	#else
391	#define STYP_DEBUG_INFO(0x0200) STYP_INFO(0x0200)
392	#endif
393
394	static long
395	sec_to_styp_flags (sec_name, sec_flags)
396	const char *sec_name;
397	flagword sec_flags;
398	{
399	long styp_flags = 0;
400
401	if (!strcmp (sec_name, _TEXT".text"))
402	{
403	styp_flags = STYP_TEXT(0x0020);
404	}
405	else if (!strcmp (sec_name, _DATA".data"))
406	{
407	styp_flags = STYP_DATA(0x0040);
408	}
409	else if (!strcmp (sec_name, _BSS".bss"))
410	{
411	styp_flags = STYP_BSS(0x0080);
412	#ifdef _COMMENT".comment"
413	}
414	else if (!strcmp (sec_name, _COMMENT".comment"))
415	{
416	styp_flags = STYP_INFO(0x0200);
417	#endif /* _COMMENT */
418	#ifdef _LIB".lib"
419	}
420	else if (!strcmp (sec_name, _LIB".lib"))
421	{
422	styp_flags = STYP_LIB(0x0800);
423	#endif /* _LIB */
424	#ifdef _LIT
425	}
426	else if (!strcmp (sec_name, _LIT))
427	{
428	styp_flags = STYP_LIT0x8020;
429	#endif /* _LIT */
430	}
431	else if (!strncmp (sec_name, ".debug", 6))
432	{
433	/* Handle the XCOFF debug section and DWARF2 debug sections. */
434	if (!sec_name[6])
435	styp_flags = STYP_XCOFF_DEBUG(0x0200);
436	else
437	styp_flags = STYP_DEBUG_INFO(0x0200);
438	}
439	else if (!strncmp (sec_name, ".stab", 5))
440	{
441	styp_flags = STYP_DEBUG_INFO(0x0200);
442	}
443	#ifdef COFF_LONG_SECTION_NAMES
444	else if (!strncmp (sec_name, ".gnu.linkonce.wi.", 17))
445	{
446	styp_flags = STYP_DEBUG_INFO(0x0200);
447	}
448	#endif
449	#ifdef RS6000COFF_C
450	else if (!strcmp (sec_name, _PAD))
451	{
452	styp_flags = STYP_PAD(0x0008);
453	}
454	else if (!strcmp (sec_name, _LOADER))
455	{
456	styp_flags = STYP_LOADER;
457	}
458	else if (!strcmp (sec_name, _EXCEPT))
459	{
460	styp_flags = STYP_EXCEPT;
461	}
462	else if (!strcmp (sec_name, _TYPCHK))
463	{
464	styp_flags = STYP_TYPCHK;
465	}
466	#endif
467	/* Try and figure out what it should be */
468	else if (sec_flags & SEC_CODE0x020)
469	{
470	styp_flags = STYP_TEXT(0x0020);
471	}
472	else if (sec_flags & SEC_DATA0x040)
473	{
474	styp_flags = STYP_DATA(0x0040);
475	}
476	else if (sec_flags & SEC_READONLY0x010)
477	{
478	#ifdef STYP_LIT0x8020 /* 29k readonly text/data section */
479	styp_flags = STYP_LIT0x8020;
480	#else
481	styp_flags = STYP_TEXT(0x0020);
482	#endif /* STYP_LIT */
483	}
484	else if (sec_flags & SEC_LOAD0x002)
485	{
486	styp_flags = STYP_TEXT(0x0020);
487	}
488	else if (sec_flags & SEC_ALLOC0x001)
489	{
490	styp_flags = STYP_BSS(0x0080);
491	}
492
493	#ifdef STYP_CLINK
494	if (sec_flags & SEC_CLINK0x10000000)
495	styp_flags \|= STYP_CLINK;
496	#endif
497
498	#ifdef STYP_BLOCK
499	if (sec_flags & SEC_BLOCK0x8000000)
500	styp_flags \|= STYP_BLOCK;
501	#endif
502
503	#ifdef STYP_NOLOAD(0x0002)
504	if ((sec_flags & (SEC_NEVER_LOAD0x400 \| SEC_COFF_SHARED_LIBRARY0x800)) != 0)
505	styp_flags \|= STYP_NOLOAD(0x0002);
506	#endif
507
508	return styp_flags;
509	}
510
511	#else /* COFF_WITH_PE */
512
513	/* The PE version; see above for the general comments. The non-PE
514	case seems to be more guessing, and breaks PE format; specifically,
515	.rdata is readonly, but it sure ain't text. Really, all this
516	should be set up properly in gas (or whatever assembler is in use),
517	and honor whatever objcopy/strip, etc. sent us as input. */
518
519	static long
520	sec_to_styp_flags (sec_name, sec_flags)
521	const char *sec_name ATTRIBUTE_UNUSED__attribute__ ((__unused__));
522	flagword sec_flags;
523	{
524	long styp_flags = 0;
525
526	/* caution: there are at least three groups of symbols that have
527	very similar bits and meanings: IMAGE_SCN, SEC_, and STYP_*.
528	SEC_* are the BFD internal flags, used for generic BFD
529	information. STYP_* are the COFF section flags which appear in
530	COFF files. IMAGE_SCN_* are the PE section flags which appear in
531	PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
532	but there are more IMAGE_SCN_* flags. */
533
534	/* skip LOAD */
535	/* READONLY later */
536	/* skip RELOC */
537	if ((sec_flags & SEC_CODE0x020) != 0)
538	styp_flags \|= IMAGE_SCN_CNT_CODE;
539	if ((sec_flags & SEC_DATA0x040) != 0)
540	styp_flags \|= IMAGE_SCN_CNT_INITIALIZED_DATA;
541	if ((sec_flags & SEC_ALLOC0x001) != 0 && (sec_flags & SEC_LOAD0x002) == 0)
542	styp_flags \|= IMAGE_SCN_CNT_UNINITIALIZED_DATA; /* ==STYP_BSS */
543	/* skip ROM */
544	/* skip constRUCTOR */
545	/* skip CONTENTS */
546	#ifdef STYP_NOLOAD(0x0002)
547	if ((sec_flags & (SEC_NEVER_LOAD0x400 \| SEC_COFF_SHARED_LIBRARY0x800)) != 0)
548	styp_flags \|= STYP_NOLOAD(0x0002);
549	#endif
550	if ((sec_flags & SEC_IS_COMMON0x8000) != 0)
551	styp_flags \|= IMAGE_SCN_LNK_COMDAT;
552	if ((sec_flags & SEC_DEBUGGING0x10000) != 0)
553	styp_flags \|= IMAGE_SCN_MEM_DISCARDABLE;
554	if ((sec_flags & SEC_EXCLUDE0x40000) != 0)
555	styp_flags \|= IMAGE_SCN_LNK_REMOVE;
556	if ((sec_flags & SEC_NEVER_LOAD0x400) != 0)
557	styp_flags \|= IMAGE_SCN_LNK_REMOVE;
558	/* skip IN_MEMORY */
559	/* skip SORT */
560	if (sec_flags & SEC_LINK_ONCE0x100000)
561	styp_flags \|= IMAGE_SCN_LNK_COMDAT;
562	/* skip LINK_DUPLICATES */
563	/* skip LINKER_CREATED */
564
565	/* For now, the read/write bits are mapped onto SEC_READONLY, even
566	though the semantics don't quite match. The bits from the input
567	are retained in pei_section_data(abfd, section)->pe_flags. */
568
569	styp_flags \|= IMAGE_SCN_MEM_READ; /* Always readable. */
570	if ((sec_flags & SEC_READONLY0x010) == 0)
571	styp_flags \|= IMAGE_SCN_MEM_WRITE; /* Invert READONLY for write. */
572	if (sec_flags & SEC_CODE0x020)
573	styp_flags \|= IMAGE_SCN_MEM_EXECUTE; /* CODE->EXECUTE. */
574	if (sec_flags & SEC_SHARED0x4000000)
575	styp_flags \|= IMAGE_SCN_MEM_SHARED; /* Shared remains meaningful. */
576
577	return styp_flags;
578	}
579
580	#endif /* COFF_WITH_PE */
581
582	/* Return a word with SEC_* flags set to represent the incoming STYP_*
583	flags (from scnhdr.s_flags). The inverse of this function is
584	sec_to_styp_flags(). NOTE: If you add to/change this routine, you
585	should probably mirror the changes in sec_to_styp_flags(). */
586
587	#ifndef COFF_WITH_PE
588
589	static bfd_boolean
590	styp_to_sec_flags (abfd, hdr, name, section, flags_ptr)
591	bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__));
592	PTRvoid * hdr;
593	const char *name;
594	asection *section ATTRIBUTE_UNUSED__attribute__ ((__unused__));
595	flagword *flags_ptr;
596	{
597	struct internal_scnhdr internal_s = (struct internal_scnhdr ) hdr;
598	long styp_flags = internal_s->s_flags;
599	flagword sec_flags = 0;
600
601	#ifdef STYP_BLOCK
602	if (styp_flags & STYP_BLOCK)
603	sec_flags \|= SEC_BLOCK0x8000000;
604	#endif
605
606	#ifdef STYP_CLINK
607	if (styp_flags & STYP_CLINK)
608	sec_flags \|= SEC_CLINK0x10000000;
609	#endif
610
611	#ifdef STYP_NOLOAD(0x0002)
612	if (styp_flags & STYP_NOLOAD(0x0002))
613	sec_flags \|= SEC_NEVER_LOAD0x400;
614	#endif /* STYP_NOLOAD */
615
616	/* For 386 COFF, at least, an unloadable text or data section is
617	actually a shared library section. */
618	if (styp_flags & STYP_TEXT(0x0020))
619	{
620	if (sec_flags & SEC_NEVER_LOAD0x400)
621	sec_flags \|= SEC_CODE0x020 \| SEC_COFF_SHARED_LIBRARY0x800;
622	else
623	sec_flags \|= SEC_CODE0x020 \| SEC_LOAD0x002 \| SEC_ALLOC0x001;
624	}
625	else if (styp_flags & STYP_DATA(0x0040))
626	{
627	if (sec_flags & SEC_NEVER_LOAD0x400)
628	sec_flags \|= SEC_DATA0x040 \| SEC_COFF_SHARED_LIBRARY0x800;
629	else
630	sec_flags \|= SEC_DATA0x040 \| SEC_LOAD0x002 \| SEC_ALLOC0x001;
631	}
632	else if (styp_flags & STYP_BSS(0x0080))
633	{
634	#ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
635	if (sec_flags & SEC_NEVER_LOAD0x400)
636	sec_flags \|= SEC_ALLOC0x001 \| SEC_COFF_SHARED_LIBRARY0x800;
637	else
638	#endif
639	sec_flags \|= SEC_ALLOC0x001;
640	}
641	else if (styp_flags & STYP_INFO(0x0200))
642	{
643	/* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
644	defined. coff_compute_section_file_positions uses
645	COFF_PAGE_SIZE to ensure that the low order bits of the
646	section VMA and the file offset match. If we don't know
647	COFF_PAGE_SIZE, we can't ensure the correct correspondence,
648	and demand page loading of the file will fail. */
649	#if defined (COFF_PAGE_SIZE0x1000) && !defined (COFF_ALIGN_IN_S_FLAGS)
650	sec_flags \|= SEC_DEBUGGING0x10000;
651	#endif
652	}
653	else if (styp_flags & STYP_PAD(0x0008))
654	sec_flags = 0;
655	else if (strcmp (name, _TEXT".text") == 0)
656	{
657	if (sec_flags & SEC_NEVER_LOAD0x400)
658	sec_flags \|= SEC_CODE0x020 \| SEC_COFF_SHARED_LIBRARY0x800;
659	else
660	sec_flags \|= SEC_CODE0x020 \| SEC_LOAD0x002 \| SEC_ALLOC0x001;
661	}
662	else if (strcmp (name, _DATA".data") == 0)
663	{
664	if (sec_flags & SEC_NEVER_LOAD0x400)
665	sec_flags \|= SEC_DATA0x040 \| SEC_COFF_SHARED_LIBRARY0x800;
666	else
667	sec_flags \|= SEC_DATA0x040 \| SEC_LOAD0x002 \| SEC_ALLOC0x001;
668	}
669	else if (strcmp (name, _BSS".bss") == 0)
670	{
671	#ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
672	if (sec_flags & SEC_NEVER_LOAD0x400)
673	sec_flags \|= SEC_ALLOC0x001 \| SEC_COFF_SHARED_LIBRARY0x800;
674	else
675	#endif
676	sec_flags \|= SEC_ALLOC0x001;
677	}
678	else if (strncmp (name, ".debug", 6) == 0
679	#ifdef _COMMENT".comment"
680	\|\| strcmp (name, _COMMENT".comment") == 0
681	#endif
682	#ifdef COFF_LONG_SECTION_NAMES
683	\|\| strncmp (name, ".gnu.linkonce.wi.", 17) == 0
684	#endif
685	\|\| strncmp (name, ".stab", 5) == 0)
686	{
687	#ifdef COFF_PAGE_SIZE0x1000
688	sec_flags \|= SEC_DEBUGGING0x10000;
689	#endif
690	}
691	#ifdef _LIB".lib"
692	else if (strcmp (name, _LIB".lib") == 0)
693	;
694	#endif
695	#ifdef _LIT
696	else if (strcmp (name, _LIT) == 0)
697	sec_flags = SEC_LOAD0x002 \| SEC_ALLOC0x001 \| SEC_READONLY0x010;
698	#endif
699	else
700	sec_flags \|= SEC_ALLOC0x001 \| SEC_LOAD0x002;
701
702	#ifdef STYP_LIT0x8020 /* A29k readonly text/data section type. */
703	if ((styp_flags & STYP_LIT0x8020) == STYP_LIT0x8020)
704	sec_flags = (SEC_LOAD0x002 \| SEC_ALLOC0x001 \| SEC_READONLY0x010);
705	#endif /* STYP_LIT */
706
707	#ifdef STYP_OTHER_LOAD /* Other loaded sections. */
708	if (styp_flags & STYP_OTHER_LOAD)
709	sec_flags = (SEC_LOAD0x002 \| SEC_ALLOC0x001);
710	#endif /* STYP_SDATA */
711
712	#if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
713	/* As a GNU extension, if the name begins with .gnu.linkonce, we
714	only link a single copy of the section. This is used to support
715	g++. g++ will emit each template expansion in its own section.
716	The symbols will be defined as weak, so that multiple definitions
717	are permitted. The GNU linker extension is to actually discard
718	all but one of the sections. */
719	if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
720	sec_flags \|= SEC_LINK_ONCE0x100000 \| SEC_LINK_DUPLICATES_DISCARD0x0;
721	#endif
722
723	if (flags_ptr == NULL((void*)0))
724	return FALSE0;
725
726	* flags_ptr = sec_flags;
727	return TRUE1;
728	}
729
730	#else /* COFF_WITH_PE */
731
732	static flagword
733	handle_COMDAT (abfd, sec_flags, hdr, name, section)
734	bfd * abfd;
735	flagword sec_flags;
736	PTRvoid * hdr;
737	const char *name;
738	asection *section;
739	{
740	struct internal_scnhdr internal_s = (struct internal_scnhdr ) hdr;
741	bfd_byte esymstart, esym, *esymend;
742	int seen_state = 0;
743	char target_name = NULL((void)0);
744
745	sec_flags \|= SEC_LINK_ONCE0x100000;
746
747	/* Unfortunately, the PE format stores essential information in
748	the symbol table, of all places. We need to extract that
749	information now, so that objdump and the linker will know how
750	to handle the section without worrying about the symbols. We
751	can't call slurp_symtab, because the linker doesn't want the
752	swapped symbols. */
753
754	/* COMDAT sections are special. The first symbol is the section
755	symbol, which tells what kind of COMDAT section it is. The
756	second symbol is the "comdat symbol" - the one with the
757	unique name. GNU uses the section symbol for the unique
758	name; MS uses ".text" for every comdat section. Sigh. - DJ */
759
760	/* This is not mirrored in sec_to_styp_flags(), but there
761	doesn't seem to be a need to, either, and it would at best be
762	rather messy. */
763
764	if (! _bfd_coff_get_external_symbols (abfd))
765	return sec_flags;
766
767	esymstart = esym = (bfd_byte *) obj_coff_external_syms (abfd)(((abfd)->tdata.coff_obj_data)->external_syms);
768	esymend = esym + obj_raw_syment_count (abfd)(((abfd)->tdata.coff_obj_data)->raw_syment_count) * bfd_coff_symesz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_symesz);
769
770	while (esym < esymend)
771	{
772	struct internal_syment isym;
773	char buf[SYMNMLEN8 + 1];
774	const char *symname;
775
776	bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &isym)((((bfd_coff_backend_data ) (abfd)->xvec->backend_data )->_bfd_coff_swap_sym_in) (abfd,(void ) esym,(void *) & isym));
777
778	if (sizeof (internal_s->s_name) > SYMNMLEN8)
779	{
780	/* This case implies that the matching
781	symbol name will be in the string table. */
782	abort ()_bfd_abort ("/usr/src/gnu/usr.bin/binutils/bfd/coffcode.h", 782 , __PRETTY_FUNCTION__);
783	}
784
785	if (isym.n_scnum == section->target_index)
786	{
787	/* According to the MSVC documentation, the first
788	TWO entries with the section # are both of
789	interest to us. The first one is the "section
790	symbol" (section name). The second is the comdat
791	symbol name. Here, we've found the first
792	qualifying entry; we distinguish it from the
793	second with a state flag.
794
795	In the case of gas-generated (at least until that
796	is fixed) .o files, it isn't necessarily the
797	second one. It may be some other later symbol.
798
799	Since gas also doesn't follow MS conventions and
800	emits the section similar to .text$<name>, where
801	<something> is the name we're looking for, we
802	distinguish the two as follows:
803
804	If the section name is simply a section name (no
805	$) we presume it's MS-generated, and look at
806	precisely the second symbol for the comdat name.
807	If the section name has a $, we assume it's
808	gas-generated, and look for <something> (whatever
809	follows the $) as the comdat symbol. */
810
811	/* All 3 branches use this. */
812	symname = _bfd_coff_internal_syment_name (abfd, &isym, buf);
813
814	if (symname == NULL((void*)0))
815	abort ()_bfd_abort ("/usr/src/gnu/usr.bin/binutils/bfd/coffcode.h", 815 , __PRETTY_FUNCTION__);
816
817	switch (seen_state)
818	{
819	case 0:
820	{
821	/* The first time we've seen the symbol. */
822	union internal_auxent aux;
823
824	seen_state = 1;
825
826	/* If it isn't the stuff we're expecting, die;
827	The MS documentation is vague, but it
828	appears that the second entry serves BOTH
829	as the comdat symbol and the defining
830	symbol record (either C_STAT or C_EXT,
831	possibly with an aux entry with debug
832	information if it's a function.) It
833	appears the only way to find the second one
834	is to count. (On Intel, they appear to be
835	adjacent, but on Alpha, they have been
836	found separated.)
837
838	Here, we think we've found the first one,
839	but there's some checking we can do to be
840	sure. */
841
842	if (! (isym.n_sclass == C_STAT3
843	&& isym.n_type == T_NULL0
844	&& isym.n_value == 0))
845	abort ()_bfd_abort ("/usr/src/gnu/usr.bin/binutils/bfd/coffcode.h", 845 , __PRETTY_FUNCTION__);
846
847	/* FIXME LATER: MSVC generates section names
848	like .text for comdats. Gas generates
849	names like .text$foo__Fv (in the case of a
850	function). See comment above for more. */
851
852	if (strcmp (name, symname) != 0)
853	abort ()_bfd_abort ("/usr/src/gnu/usr.bin/binutils/bfd/coffcode.h", 853 , __PRETTY_FUNCTION__);
854
855	/* This is the section symbol. */
856	bfd_coff_swap_aux_in (abfd, (PTR) (esym + bfd_coff_symesz (abfd)),((((bfd_coff_backend_data ) (abfd)->xvec->backend_data )->_bfd_coff_swap_aux_in) (abfd,(void ) (esym + (((bfd_coff_backend_data ) (abfd)->xvec->backend_data)->_bfd_symesz)),isym. n_type,isym.n_sclass,0,isym.n_numaux,(void ) &aux))
857	isym.n_type, isym.n_sclass,((((bfd_coff_backend_data ) (abfd)->xvec->backend_data )->_bfd_coff_swap_aux_in) (abfd,(void ) (esym + (((bfd_coff_backend_data ) (abfd)->xvec->backend_data)->_bfd_symesz)),isym. n_type,isym.n_sclass,0,isym.n_numaux,(void ) &aux))
858	0, isym.n_numaux, (PTR) &aux)((((bfd_coff_backend_data ) (abfd)->xvec->backend_data )->_bfd_coff_swap_aux_in) (abfd,(void ) (esym + (((bfd_coff_backend_data ) (abfd)->xvec->backend_data)->_bfd_symesz)),isym. n_type,isym.n_sclass,0,isym.n_numaux,(void ) &aux));
859
860	target_name = strchr (name, '$');
861	if (target_name != NULL((void*)0))
862	{
863	/* Gas mode. */
864	seen_state = 2;
865	/* Skip the `$'. */
866	target_name += 1;
867	}
868
869	/* FIXME: Microsoft uses NODUPLICATES and
870	ASSOCIATIVE, but gnu uses ANY and
871	SAME_SIZE. Unfortunately, gnu doesn't do
872	the comdat symbols right. So, until we can
873	fix it to do the right thing, we are
874	temporarily disabling comdats for the MS
875	types (they're used in DLLs and C++, but we
876	don't support their C++ libraries anyway
877	- DJ. */
878
879	/* Cygwin does not follow the MS style, and
880	uses ANY and SAME_SIZE where NODUPLICATES
881	and ASSOCIATIVE should be used. For
882	Interix, we just do the right thing up
883	front. */
884
885	switch (aux.x_scn.x_comdat)
886	{
887	case IMAGE_COMDAT_SELECT_NODUPLICATES:
888	#ifdef STRICT_PE_FORMAT
889	sec_flags \|= SEC_LINK_DUPLICATES_ONE_ONLY0x200000;
890	#else
891	sec_flags &= ~SEC_LINK_ONCE0x100000;
892	#endif
893	break;
894
895	case IMAGE_COMDAT_SELECT_ANY:
896	sec_flags \|= SEC_LINK_DUPLICATES_DISCARD0x0;
897	break;
898
899	case IMAGE_COMDAT_SELECT_SAME_SIZE:
900	sec_flags \|= SEC_LINK_DUPLICATES_SAME_SIZE0x400000;
901	break;
902
903	case IMAGE_COMDAT_SELECT_EXACT_MATCH:
904	/* Not yet fully implemented ??? */
905	sec_flags \|= SEC_LINK_DUPLICATES_SAME_CONTENTS0x600000;
906	break;
907
908	/* debug$S gets this case; other
909	implications ??? */
910
911	/* There may be no symbol... we'll search
912	the whole table... Is this the right
913	place to play this game? Or should we do
914	it when reading it in. */
915	case IMAGE_COMDAT_SELECT_ASSOCIATIVE:
916	#ifdef STRICT_PE_FORMAT
917	/* FIXME: This is not currently implemented. */
918	sec_flags \|= SEC_LINK_DUPLICATES_DISCARD0x0;
919	#else
920	sec_flags &= ~SEC_LINK_ONCE0x100000;
921	#endif
922	break;
923
924	default: /* 0 means "no symbol" */
925	/* debug$F gets this case; other
926	implications ??? */
927	sec_flags \|= SEC_LINK_DUPLICATES_DISCARD0x0;
928	break;
929	}
930	}
931	break;
932
933	case 2:
934	/* Gas mode: the first matching on partial name. */
935
936	#ifndef TARGET_UNDERSCORE
937	#define TARGET_UNDERSCORE 0
938	#endif
939	/* Is this the name we're looking for ? */
940	if (strcmp (target_name,
941	symname + (TARGET_UNDERSCORE ? 1 : 0)) != 0)
942	{
943	/* Not the name we're looking for */
944	esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_symesz);
945	continue;
946	}
947	/* Fall through. */
948	case 1:
949	/* MSVC mode: the lexically second symbol (or
950	drop through from the above). */
951	{
952	char *newname;
953	bfd_size_type amt;
954
955	/* This must the second symbol with the
956	section #. It is the actual symbol name.
957	Intel puts the two adjacent, but Alpha (at
958	least) spreads them out. */
959
960	amt = sizeof (struct bfd_comdat_info);
961	section->comdat = bfd_alloc (abfd, amt);
962	if (section->comdat == NULL((void*)0))
963	abort ()_bfd_abort ("/usr/src/gnu/usr.bin/binutils/bfd/coffcode.h", 963 , __PRETTY_FUNCTION__);
964
965	section->comdat->symbol =
966	(esym - esymstart) / bfd_coff_symesz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_symesz);
967
968	amt = strlen (symname) + 1;
969	newname = bfd_alloc (abfd, amt);
970	if (newname == NULL((void*)0))
971	abort ()_bfd_abort ("/usr/src/gnu/usr.bin/binutils/bfd/coffcode.h", 971 , __PRETTY_FUNCTION__);
972
973	strcpy (newname, symname);
974	section->comdat->name = newname;
975	}
976
977	goto breakloop;
978	}
979	}
980
981	esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_symesz);
982	}
983
984	breakloop:
985	return sec_flags;
986	}
987
988
989	/* The PE version; see above for the general comments.
990
991	Since to set the SEC_LINK_ONCE and associated flags, we have to
992	look at the symbol table anyway, we return the symbol table index
993	of the symbol being used as the COMDAT symbol. This is admittedly
994	ugly, but there's really nowhere else that we have access to the
995	required information. FIXME: Is the COMDAT symbol index used for
996	any purpose other than objdump? */
997
998	static bfd_boolean
999	styp_to_sec_flags (abfd, hdr, name, section, flags_ptr)
1000	bfd *abfd;
1001	PTRvoid * hdr;
1002	const char *name;
1003	asection *section;
1004	flagword *flags_ptr;
1005	{
1006	struct internal_scnhdr internal_s = (struct internal_scnhdr ) hdr;
1007	long styp_flags = internal_s->s_flags;
1008	flagword sec_flags;
1009	bfd_boolean result = TRUE1;
1010
1011	/* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
1012	sec_flags = SEC_READONLY0x010;
1013
1014	/* Process each flag bit in styp_flags in turn. */
1015	while (styp_flags)
1016	{
1017	long flag = styp_flags & - styp_flags;
1018	char * unhandled = NULL((void*)0);
1019
1020	styp_flags &= ~ flag;
1021
1022	/* We infer from the distinct read/write/execute bits the settings
1023	of some of the bfd flags; the actual values, should we need them,
1024	are also in pei_section_data (abfd, section)->pe_flags. */
1025
1026	switch (flag)
1027	{
1028	case STYP_DSECT(0x0001):
1029	unhandled = "STYP_DSECT";
1030	break;
1031	case STYP_GROUP(0x0004):
1032	unhandled = "STYP_GROUP";
1033	break;
1034	case STYP_COPY(0x0010):
1035	unhandled = "STYP_COPY";
1036	break;
1037	case STYP_OVER(0x0400):
1038	unhandled = "STYP_OVER";
1039	break;
1040	#ifdef SEC_NEVER_LOAD0x400
1041	case STYP_NOLOAD(0x0002):
1042	sec_flags \|= SEC_NEVER_LOAD0x400;
1043	break;
1044	#endif
1045	case IMAGE_SCN_MEM_READ:
1046	/* Ignored, assume it always to be true. */
1047	break;
1048	case IMAGE_SCN_TYPE_NO_PAD:
1049	/* Skip. */
1050	break;
1051	case IMAGE_SCN_LNK_OTHER:
1052	unhandled = "IMAGE_SCN_LNK_OTHER";
1053	break;
1054	case IMAGE_SCN_MEM_NOT_CACHED:
1055	unhandled = "IMAGE_SCN_MEM_NOT_CACHED";
1056	break;
1057	case IMAGE_SCN_MEM_NOT_PAGED:
1058	unhandled = "IMAGE_SCN_MEM_NOT_PAGED";
1059	break;
1060	case IMAGE_SCN_MEM_EXECUTE:
1061	sec_flags \|= SEC_CODE0x020;
1062	break;
1063	case IMAGE_SCN_MEM_WRITE:
1064	sec_flags &= ~ SEC_READONLY0x010;
1065	break;
1066	case IMAGE_SCN_MEM_DISCARDABLE:
1067	/* The MS PE spec sets the DISCARDABLE flag on .reloc sections
1068	but we do not want them to be labelled as debug section, since
1069	then strip would remove them. */
1070	if (strncmp (name, ".reloc", sizeof ".reloc" - 1) != 0)
1071	sec_flags \|= SEC_DEBUGGING0x10000;
1072	break;
1073	case IMAGE_SCN_MEM_SHARED:
1074	sec_flags \|= SEC_SHARED0x4000000;
1075	break;
1076	case IMAGE_SCN_LNK_REMOVE:
1077	sec_flags \|= SEC_EXCLUDE0x40000;
1078	break;
1079	case IMAGE_SCN_CNT_CODE:
1080	sec_flags \|= SEC_CODE0x020 \| SEC_ALLOC0x001 \| SEC_LOAD0x002;
1081	break;
1082	case IMAGE_SCN_CNT_INITIALIZED_DATA:
1083	sec_flags \|= SEC_DATA0x040 \| SEC_ALLOC0x001 \| SEC_LOAD0x002;
1084	break;
1085	case IMAGE_SCN_CNT_UNINITIALIZED_DATA:
1086	sec_flags \|= SEC_ALLOC0x001;
1087	break;
1088	case IMAGE_SCN_LNK_INFO:
1089	/* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1090	defined. coff_compute_section_file_positions uses
1091	COFF_PAGE_SIZE to ensure that the low order bits of the
1092	section VMA and the file offset match. If we don't know
1093	COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1094	and demand page loading of the file will fail. */
1095	#ifdef COFF_PAGE_SIZE0x1000
1096	sec_flags \|= SEC_DEBUGGING0x10000;
1097	#endif
1098	break;
1099	case IMAGE_SCN_LNK_COMDAT:
1100	/* COMDAT gets very special treatment. */
1101	sec_flags = handle_COMDAT (abfd, sec_flags, hdr, name, section);
1102	break;
1103	default:
1104	/* Silently ignore for now. */
1105	break;
1106	}
1107
1108	/* If the section flag was not handled, report it here. */
1109	if (unhandled != NULL((void*)0))
1110	{
1111	(*_bfd_error_handler)
1112	(_("%s (%s): Section flag %s (0x%x) ignored")("%s (%s): Section flag %s (0x%x) ignored"),
1113	bfd_archive_filename (abfd), name, unhandled, flag);
1114	result = FALSE0;
1115	}
1116	}
1117
1118	#if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1119	/* As a GNU extension, if the name begins with .gnu.linkonce, we
1120	only link a single copy of the section. This is used to support
1121	g++. g++ will emit each template expansion in its own section.
1122	The symbols will be defined as weak, so that multiple definitions
1123	are permitted. The GNU linker extension is to actually discard
1124	all but one of the sections. */
1125	if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
1126	sec_flags \|= SEC_LINK_ONCE0x100000 \| SEC_LINK_DUPLICATES_DISCARD0x0;
1127	#endif
1128
1129	if (flags_ptr)
1130	* flags_ptr = sec_flags;
1131
1132	return result;
1133	}
1134
1135	#endif /* COFF_WITH_PE */
1136
1137	#define get_index(symbol)((symbol)->udata.i) ((symbol)->udata.i)
1138
1139	/*
1140	INTERNAL_DEFINITION
1141	bfd_coff_backend_data
1142
1143	CODE_FRAGMENT
1144
1145	.{* COFF symbol classifications. *}
1146	.
1147	.enum coff_symbol_classification
1148	.{
1149	. {* Global symbol. *}
1150	. COFF_SYMBOL_GLOBAL,
1151	. {* Common symbol. *}
1152	. COFF_SYMBOL_COMMON,
1153	. {* Undefined symbol. *}
1154	. COFF_SYMBOL_UNDEFINED,
1155	. {* Local symbol. *}
1156	. COFF_SYMBOL_LOCAL,
1157	. {* PE section symbol. *}
1158	. COFF_SYMBOL_PE_SECTION
1159	.};
1160	.
1161	Special entry points for gdb to swap in coff symbol table parts:
1162	.typedef struct
1163	.{
1164	. void (*_bfd_coff_swap_aux_in)
1165	. PARAMS ((bfd *, PTR, int, int, int, int, PTR));
1166	.
1167	. void (*_bfd_coff_swap_sym_in)
1168	. PARAMS ((bfd *, PTR, PTR));
1169	.
1170	. void (*_bfd_coff_swap_lineno_in)
1171	. PARAMS ((bfd *, PTR, PTR));
1172	.
1173	. unsigned int (*_bfd_coff_swap_aux_out)
1174	. PARAMS ((bfd *, PTR, int, int, int, int, PTR));
1175	.
1176	. unsigned int (*_bfd_coff_swap_sym_out)
1177	. PARAMS ((bfd *, PTR, PTR));
1178	.
1179	. unsigned int (*_bfd_coff_swap_lineno_out)
1180	. PARAMS ((bfd *, PTR, PTR));
1181	.
1182	. unsigned int (*_bfd_coff_swap_reloc_out)
1183	. PARAMS ((bfd *, PTR, PTR));
1184	.
1185	. unsigned int (*_bfd_coff_swap_filehdr_out)
1186	. PARAMS ((bfd *, PTR, PTR));
1187	.
1188	. unsigned int (*_bfd_coff_swap_aouthdr_out)
1189	. PARAMS ((bfd *, PTR, PTR));
1190	.
1191	. unsigned int (*_bfd_coff_swap_scnhdr_out)
1192	. PARAMS ((bfd *, PTR, PTR));
1193	.
1194	. unsigned int _bfd_filhsz;
1195	. unsigned int _bfd_aoutsz;
1196	. unsigned int _bfd_scnhsz;
1197	. unsigned int _bfd_symesz;
1198	. unsigned int _bfd_auxesz;
1199	. unsigned int _bfd_relsz;
1200	. unsigned int _bfd_linesz;
1201	. unsigned int _bfd_filnmlen;
1202	. bfd_boolean _bfd_coff_long_filenames;
1203	. bfd_boolean _bfd_coff_long_section_names;
1204	. unsigned int _bfd_coff_default_section_alignment_power;
1205	. bfd_boolean _bfd_coff_force_symnames_in_strings;
1206	. unsigned int _bfd_coff_debug_string_prefix_length;
1207	.
1208	. void (*_bfd_coff_swap_filehdr_in)
1209	. PARAMS ((bfd *, PTR, PTR));
1210	.
1211	. void (*_bfd_coff_swap_aouthdr_in)
1212	. PARAMS ((bfd *, PTR, PTR));
1213	.
1214	. void (*_bfd_coff_swap_scnhdr_in)
1215	. PARAMS ((bfd *, PTR, PTR));
1216	.
1217	. void (*_bfd_coff_swap_reloc_in)
1218	. PARAMS ((bfd *abfd, PTR, PTR));
1219	.
1220	. bfd_boolean (*_bfd_coff_bad_format_hook)
1221	. PARAMS ((bfd *, PTR));
1222	.
1223	. bfd_boolean (*_bfd_coff_set_arch_mach_hook)
1224	. PARAMS ((bfd *, PTR));
1225	.
1226	. PTR (*_bfd_coff_mkobject_hook)
1227	. PARAMS ((bfd *, PTR, PTR));
1228	.
1229	. bfd_boolean (*_bfd_styp_to_sec_flags_hook)
1230	. PARAMS ((bfd , PTR, const char , asection , flagword ));
1231	.
1232	. void (*_bfd_set_alignment_hook)
1233	. PARAMS ((bfd , asection , PTR));
1234	.
1235	. bfd_boolean (*_bfd_coff_slurp_symbol_table)
1236	. PARAMS ((bfd *));
1237	.
1238	. bfd_boolean (*_bfd_coff_symname_in_debug)
1239	. PARAMS ((bfd , struct internal_syment ));
1240	.
1241	. bfd_boolean (*_bfd_coff_pointerize_aux_hook)
1242	. PARAMS ((bfd , combined_entry_type , combined_entry_type *,
1243	. unsigned int, combined_entry_type *));
1244	.
1245	. bfd_boolean (*_bfd_coff_print_aux)
1246	. PARAMS ((bfd , FILE , combined_entry_type , combined_entry_type ,
1247	. combined_entry_type *, unsigned int));
1248	.
1249	. void (*_bfd_coff_reloc16_extra_cases)
1250	. PARAMS ((bfd , struct bfd_link_info , struct bfd_link_order , arelent ,
1251	. bfd_byte , unsigned int , unsigned int *));
1252	.
1253	. int (*_bfd_coff_reloc16_estimate)
1254	. PARAMS ((bfd , asection , arelent *, unsigned int,
1255	. struct bfd_link_info *));
1256	.
1257	. enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1258	. PARAMS ((bfd , struct internal_syment ));
1259	.
1260	. bfd_boolean (*_bfd_coff_compute_section_file_positions)
1261	. PARAMS ((bfd *));
1262	.
1263	. bfd_boolean (*_bfd_coff_start_final_link)
1264	. PARAMS ((bfd , struct bfd_link_info ));
1265	.
1266	. bfd_boolean (*_bfd_coff_relocate_section)
1267	. PARAMS ((bfd , struct bfd_link_info , bfd , asection , bfd_byte *,
1268	. struct internal_reloc , struct internal_syment , asection **));
1269	.
1270	. reloc_howto_type (_bfd_coff_rtype_to_howto)
1271	. PARAMS ((bfd , asection , struct internal_reloc *,
1272	. struct coff_link_hash_entry , struct internal_syment ,
1273	. bfd_vma *));
1274	.
1275	. bfd_boolean (*_bfd_coff_adjust_symndx)
1276	. PARAMS ((bfd , struct bfd_link_info , bfd , asection ,
1277	. struct internal_reloc , bfd_boolean ));
1278	.
1279	. bfd_boolean (*_bfd_coff_link_add_one_symbol)
1280	. PARAMS ((struct bfd_link_info , bfd , const char *, flagword,
1281	. asection , bfd_vma, const char , bfd_boolean, bfd_boolean,
1282	. struct bfd_link_hash_entry **));
1283	.
1284	. bfd_boolean (*_bfd_coff_link_output_has_begun)
1285	. PARAMS ((bfd , struct coff_final_link_info ));
1286	.
1287	. bfd_boolean (*_bfd_coff_final_link_postscript)
1288	. PARAMS ((bfd , struct coff_final_link_info ));
1289	.
1290	.} bfd_coff_backend_data;
1291	.
1292	.#define coff_backend_info(abfd) \
1293	. ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1294	.
1295	.#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1296	. ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1297	.
1298	.#define bfd_coff_swap_sym_in(a,e,i) \
1299	. ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1300	.
1301	.#define bfd_coff_swap_lineno_in(a,e,i) \
1302	. ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1303	.
1304	.#define bfd_coff_swap_reloc_out(abfd, i, o) \
1305	. ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1306	.
1307	.#define bfd_coff_swap_lineno_out(abfd, i, o) \
1308	. ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1309	.
1310	.#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1311	. ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1312	.
1313	.#define bfd_coff_swap_sym_out(abfd, i,o) \
1314	. ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1315	.
1316	.#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1317	. ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1318	.
1319	.#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1320	. ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1321	.
1322	.#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1323	. ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1324	.
1325	.#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1326	.#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1327	.#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1328	.#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1329	.#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1330	.#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1331	.#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1332	.#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1333	.#define bfd_coff_long_filenames(abfd) \
1334	. (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1335	.#define bfd_coff_long_section_names(abfd) \
1336	. (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1337	.#define bfd_coff_default_section_alignment_power(abfd) \
1338	. (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1339	.#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1340	. ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1341	.
1342	.#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1343	. ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1344	.
1345	.#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1346	. ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1347	.
1348	.#define bfd_coff_swap_reloc_in(abfd, i, o) \
1349	. ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1350	.
1351	.#define bfd_coff_bad_format_hook(abfd, filehdr) \
1352	. ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1353	.
1354	.#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1355	. ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1356	.#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1357	. ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1358	. (abfd, filehdr, aouthdr))
1359	.
1360	.#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1361	. ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1362	. (abfd, scnhdr, name, section, flags_ptr))
1363	.
1364	.#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1365	. ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1366	.
1367	.#define bfd_coff_slurp_symbol_table(abfd)\
1368	. ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1369	.
1370	.#define bfd_coff_symname_in_debug(abfd, sym)\
1371	. ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1372	.
1373	.#define bfd_coff_force_symnames_in_strings(abfd)\
1374	. (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1375	.
1376	.#define bfd_coff_debug_string_prefix_length(abfd)\
1377	. (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1378	.
1379	.#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1380	. ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1381	. (abfd, file, base, symbol, aux, indaux))
1382	.
1383	.#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1384	. reloc, data, src_ptr, dst_ptr)\
1385	. ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1386	. (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1387	.
1388	.#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1389	. ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1390	. (abfd, section, reloc, shrink, link_info))
1391	.
1392	.#define bfd_coff_classify_symbol(abfd, sym)\
1393	. ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1394	. (abfd, sym))
1395	.
1396	.#define bfd_coff_compute_section_file_positions(abfd)\
1397	. ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1398	. (abfd))
1399	.
1400	.#define bfd_coff_start_final_link(obfd, info)\
1401	. ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1402	. (obfd, info))
1403	.#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1404	. ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1405	. (obfd, info, ibfd, o, con, rel, isyms, secs))
1406	.#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1407	. ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1408	. (abfd, sec, rel, h, sym, addendp))
1409	.#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1410	. ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1411	. (obfd, info, ibfd, sec, rel, adjustedp))
1412	.#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1413	. value, string, cp, coll, hashp)\
1414	. ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1415	. (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1416	.
1417	.#define bfd_coff_link_output_has_begun(a,p) \
1418	. ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p))
1419	.#define bfd_coff_final_link_postscript(a,p) \
1420	. ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
1421	.
1422	*/
1423
1424	/* See whether the magic number matches. */
1425
1426	static bfd_boolean
1427	coff_bad_format_hook (abfd, filehdr)
1428	bfd * abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__));
1429	PTRvoid * filehdr;
1430	{
1431	struct internal_filehdr internal_f = (struct internal_filehdr ) filehdr;
1432
1433	if (BADMAG (internal_f)( ((internal_f).f_magic != 0x14c) && (internal_f).f_magic != 0x175 && (internal_f).f_magic != 0x154 && (*internal_f).f_magic != 0415))
1434	return FALSE0;
1435
1436	/* If the optional header is NULL or not the correct size then
1437	quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1438	and Intel 960 readwrite headers (I960WRMAGIC) is that the
1439	optional header is of a different size.
1440
1441	But the mips keeps extra stuff in it's opthdr, so dont check
1442	when doing that. */
1443
1444	#if defined(M88) \|\| defined(I960)
1445	if (internal_f->f_opthdr != 0 && bfd_coff_aoutsz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_aoutsz) != internal_f->f_opthdr)
1446	return FALSE0;
1447	#endif
1448
1449	return TRUE1;
1450	}
1451
1452	#ifdef TICOFF
1453	static bfd_boolean
1454	ticoff0_bad_format_hook (abfd, filehdr)
1455	bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__));
1456	PTRvoid * filehdr;
1457	{
1458	struct internal_filehdr internal_f = (struct internal_filehdr ) filehdr;
1459
1460	if (COFF0_BADMAG (*internal_f))
1461	return FALSE0;
1462
1463	return TRUE1;
1464	}
1465	#endif
1466
1467	#ifdef TICOFF
1468	static bfd_boolean
1469	ticoff1_bad_format_hook (abfd, filehdr)
1470	bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__));
1471	PTRvoid * filehdr;
1472	{
1473	struct internal_filehdr internal_f = (struct internal_filehdr ) filehdr;
1474
1475	if (COFF1_BADMAG (*internal_f))
1476	return FALSE0;
1477
1478	return TRUE1;
1479	}
1480	#endif
1481
1482	/* Check whether this section uses an alignment other than the
1483	default. */
1484
1485	static void
1486	coff_set_custom_section_alignment (abfd, section, alignment_table, table_size)
1487	bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__));
1488	asection *section;
1489	const struct coff_section_alignment_entry *alignment_table;
1490	const unsigned int table_size;
1491	{
1492	const unsigned int default_alignment = COFF_DEFAULT_SECTION_ALIGNMENT_POWER(2);
1493	unsigned int i;
1494
1495	for (i = 0; i < table_size; ++i)
1496	{
1497	const char *secname = bfd_get_section_name (abfd, section)((section)->name + 0);
1498
1499	if (alignment_table[i].comparison_length == (unsigned int) -1
1500	? strcmp (alignment_table[i].name, secname) == 0
1501	: strncmp (alignment_table[i].name, secname,
1502	alignment_table[i].comparison_length) == 0)
1503	break;
1504	}
1505	if (i >= table_size)
1506	return;
1507
1508	if (alignment_table[i].default_alignment_min != COFF_ALIGNMENT_FIELD_EMPTY((unsigned int) -1)
1509	&& default_alignment < alignment_table[i].default_alignment_min)
1510	return;
1511
1512	if (alignment_table[i].default_alignment_max != COFF_ALIGNMENT_FIELD_EMPTY((unsigned int) -1)
1513	#if COFF_DEFAULT_SECTION_ALIGNMENT_POWER(2) != 0
1514	&& default_alignment > alignment_table[i].default_alignment_max
1515	#endif
1516	)
1517	return;
1518
1519	section->alignment_power = alignment_table[i].alignment_power;
1520	}
1521
1522	/* Custom section alignment records. */
1523
1524	static const struct coff_section_alignment_entry
1525	coff_section_alignment_table[] =
1526	{
1527	#ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1528	COFF_SECTION_ALIGNMENT_ENTRIES,
1529	#endif
1530	/* There must not be any gaps between .stabstr sections. */
1531	{ COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr")(".stabstr"), (sizeof (".stabstr") - 1),
1532	1, COFF_ALIGNMENT_FIELD_EMPTY((unsigned int) -1), 0 },
1533	/* The .stab section must be aligned to 2*2 at most, to avoid gaps. /
1534	{ COFF_SECTION_NAME_PARTIAL_MATCH (".stab")(".stab"), (sizeof (".stab") - 1),
1535	3, COFF_ALIGNMENT_FIELD_EMPTY((unsigned int) -1), 2 },
1536	/* Similarly for the .ctors and .dtors sections. */
1537	{ COFF_SECTION_NAME_EXACT_MATCH (".ctors")(".ctors"), ((unsigned int) -1),
1538	3, COFF_ALIGNMENT_FIELD_EMPTY((unsigned int) -1), 2 },
1539	{ COFF_SECTION_NAME_EXACT_MATCH (".dtors")(".dtors"), ((unsigned int) -1),
1540	3, COFF_ALIGNMENT_FIELD_EMPTY((unsigned int) -1), 2 }
1541	};
1542
1543	static const unsigned int coff_section_alignment_table_size =
1544	sizeof coff_section_alignment_table / sizeof coff_section_alignment_table[0];
1545
1546	/* Initialize a section structure with information peculiar to this
1547	particular implementation of COFF. */
1548
1549	static bfd_boolean
1550	coff_new_section_hook (abfd, section)
1551	bfd * abfd;
1552	asection * section;
1553	{
1554	combined_entry_type *native;
1555	bfd_size_type amt;
1556
1557	section->alignment_power = COFF_DEFAULT_SECTION_ALIGNMENT_POWER(2);
1558
1559	#ifdef RS6000COFF_C
1560	if (bfd_xcoff_text_align_power (abfd) != 0
1561	&& strcmp (bfd_get_section_name (abfd, section)((section)->name + 0), ".text") == 0)
1562	section->alignment_power = bfd_xcoff_text_align_power (abfd);
1563	if (bfd_xcoff_data_align_power (abfd) != 0
1564	&& strcmp (bfd_get_section_name (abfd, section)((section)->name + 0), ".data") == 0)
1565	section->alignment_power = bfd_xcoff_data_align_power (abfd);
1566	#endif
1567
1568	/* Allocate aux records for section symbols, to store size and
1569	related info.
1570
1571	@@ The 10 is a guess at a plausible maximum number of aux entries
1572	(but shouldn't be a constant). */
1573	amt = sizeof (combined_entry_type) * 10;
1574	native = (combined_entry_type *) bfd_zalloc (abfd, amt);
1575	if (native == NULL((void*)0))
1576	return FALSE0;
1577
1578	/* We don't need to set up n_name, n_value, or n_scnum in the native
1579	symbol information, since they'll be overridden by the BFD symbol
1580	anyhow. However, we do need to set the type and storage class,
1581	in case this symbol winds up getting written out. The value 0
1582	for n_numaux is already correct. */
1583
1584	native->u.syment.n_type = T_NULL0;
1585	native->u.syment.n_sclass = C_STAT3;
1586
1587	coffsymbol (section->symbol)((coff_symbol_type *)(&((section->symbol)->the_bfd) ))->native = native;
1588
1589	coff_set_custom_section_alignment (abfd, section,
1590	coff_section_alignment_table,
1591	coff_section_alignment_table_size);
1592
1593	return TRUE1;
1594	}
1595
1596	#ifdef COFF_ALIGN_IN_SECTION_HEADER
1597
1598	/* Set the alignment of a BFD section. */
1599
1600	static void coff_set_alignment_hook((void () (bfd , asection , void )) bfd_void) PARAMS ((bfd , asection , PTR))(bfd , asection , void *);
1601
1602	static void
1603	coff_set_alignment_hook((void () (bfd , asection , void )) bfd_void) (abfd, section, scnhdr)
1604	bfd * abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__));
1605	asection * section;
1606	PTRvoid * scnhdr;
1607	{
1608	struct internal_scnhdr hdr = (struct internal_scnhdr ) scnhdr;
1609	unsigned int i;
1610
1611	#ifdef I960
1612	/* Extract ALIGN from 2*ALIGN stored in section header. /
1613	for (i = 0; i < 32; i++)
1614	if ((1 << i) >= hdr->s_align)
1615	break;
1616	#endif
1617	#ifdef TIC80COFF
1618	/* TI tools puts the alignment power in bits 8-11. */
1619	i = (hdr->s_flags >> 8) & 0xF ;
1620	#endif
1621	#ifdef COFF_DECODE_ALIGNMENT
1622	i = COFF_DECODE_ALIGNMENT(hdr->s_flags);
1623	#endif
1624	section->alignment_power = i;
1625
1626	#ifdef coff_set_section_load_page
1627	coff_set_section_load_page (section, hdr->s_page);
1628	#endif
1629	}
1630
1631	#else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1632	#ifdef COFF_WITH_PE
1633
1634	/* A couple of macros to help setting the alignment power field. */
1635	#define ALIGN_SET(field,x,y) \
1636	if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1637	{\
1638	section->alignment_power = y;\
1639	}
1640
1641	#define ELIFALIGN_SET(field,x,y) \
1642	else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1643	{\
1644	section->alignment_power = y;\
1645	}
1646
1647	static void coff_set_alignment_hook((void () (bfd , asection , void )) bfd_void) PARAMS ((bfd , asection , PTR))(bfd , asection , void *);
1648
1649	static void
1650	coff_set_alignment_hook((void () (bfd , asection , void )) bfd_void) (abfd, section, scnhdr)
1651	bfd * abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__));
1652	asection * section;
1653	PTRvoid * scnhdr;
1654	{
1655	struct internal_scnhdr hdr = (struct internal_scnhdr ) scnhdr;
1656	bfd_size_type amt;
1657
1658	ALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_64BYTES, 6)
1659	ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_32BYTES, 5)
1660	ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_16BYTES, 4)
1661	ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_8BYTES, 3)
1662	ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_4BYTES, 2)
1663	ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_2BYTES, 1)
1664	ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_1BYTES, 0)
1665
1666	/* In a PE image file, the s_paddr field holds the virtual size of a
1667	section, while the s_size field holds the raw size. We also keep
1668	the original section flag value, since not every bit can be
1669	mapped onto a generic BFD section bit. */
1670	if (coff_section_data (abfd, section)((struct coff_section_tdata ) (section)->used_by_bfd) == NULL((void)0))
1671	{
1672	amt = sizeof (struct coff_section_tdata);
1673	section->used_by_bfd = (PTRvoid *) bfd_zalloc (abfd, amt);
1674	if (section->used_by_bfd == NULL((void*)0))
1675	{
1676	/* FIXME: Return error. */
1677	abort ()_bfd_abort ("/usr/src/gnu/usr.bin/binutils/bfd/coffcode.h", 1677 , __PRETTY_FUNCTION__);
1678	}
1679	}
1680	if (pei_section_data (abfd, section)((struct pei_section_tdata ) ((struct coff_section_tdata ) ( (section))->used_by_bfd)->tdata) == NULL((void*)0))
1681	{
1682	amt = sizeof (struct pei_section_tdata);
1683	coff_section_data (abfd, section)((struct coff_section_tdata ) (section)->used_by_bfd)->tdata = (PTRvoid ) bfd_zalloc (abfd, amt);
1684	if (coff_section_data (abfd, section)((struct coff_section_tdata ) (section)->used_by_bfd)->tdata == NULL((void)0))
1685	{
1686	/* FIXME: Return error. */
1687	abort ()_bfd_abort ("/usr/src/gnu/usr.bin/binutils/bfd/coffcode.h", 1687 , __PRETTY_FUNCTION__);
1688	}
1689	}
1690	pei_section_data (abfd, section)((struct pei_section_tdata ) ((struct coff_section_tdata ) ( (section))->used_by_bfd)->tdata)->virt_size = hdr->s_paddr;
1691	pei_section_data (abfd, section)((struct pei_section_tdata ) ((struct coff_section_tdata ) ( (section))->used_by_bfd)->tdata)->pe_flags = hdr->s_flags;
1692
1693	section->lma = hdr->s_vaddr;
1694
1695	/* Check for extended relocs. */
1696	if (hdr->s_flags & IMAGE_SCN_LNK_NRELOC_OVFL)
1697	{
1698	struct external_reloc dst;
1699	struct internal_reloc n;
1700	file_ptr oldpos = bfd_tell (abfd);
1701	bfd_size_type relsz = bfd_coff_relsz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_relsz);
1702
1703	bfd_seek (abfd, (file_ptr) hdr->s_relptr, 0);
1704	if (bfd_bread ((PTRvoid *) &dst, relsz, abfd) != relsz)
1705	return;
1706
1707	coff_swap_reloc_in (abfd, &dst, &n);
1708	bfd_seek (abfd, oldpos, 0);
1709	section->reloc_count = hdr->s_nreloc = n.r_vaddr - 1;
1710	section->rel_filepos += relsz;
1711	}
1712	else if (hdr->s_nreloc == 0xffff)
1713	(*_bfd_error_handler)
1714	("%s: warning: claims to have 0xffff relocs, without overflow",
1715	bfd_get_filename (abfd)((char *) (abfd)->filename));
1716	}
1717	#undef ALIGN_SET
1718	#undef ELIFALIGN_SET
1719
1720	#else /* ! COFF_WITH_PE */
1721	#ifdef RS6000COFF_C
1722
1723	/* We grossly abuse this function to handle XCOFF overflow headers.
1724	When we see one, we correct the reloc and line number counts in the
1725	real header, and remove the section we just created. */
1726
1727	static void coff_set_alignment_hook((void () (bfd , asection , void )) bfd_void) PARAMS ((bfd , asection , PTR))(bfd , asection , void *);
1728
1729	static void
1730	coff_set_alignment_hook((void () (bfd , asection , void )) bfd_void) (abfd, section, scnhdr)
1731	bfd *abfd;
1732	asection *section;
1733	PTRvoid * scnhdr;
1734	{
1735	struct internal_scnhdr hdr = (struct internal_scnhdr ) scnhdr;
1736	asection *real_sec;
1737	asection **ps;
1738
1739	if ((hdr->s_flags & STYP_OVRFLO) == 0)
1740	return;
1741
1742	real_sec = coff_section_from_bfd_index (abfd, (int) hdr->s_nreloc);
1743	if (real_sec == NULL((void*)0))
1744	return;
1745
1746	real_sec->reloc_count = hdr->s_paddr;
1747	real_sec->lineno_count = hdr->s_vaddr;
1748
1749	for (ps = &abfd->sections; ps != NULL((void)0); ps = &(*ps)->next)
1750	{
1751	if (*ps == section)
1752	{
1753	bfd_section_list_remove (abfd, ps)do { asection *_ps = ps; asection _s = _ps; _ps = _s-> next; if (_s->next == ((void*)0)) (abfd)->section_tail = _ps; } while (0);
1754	--abfd->section_count;
1755	break;
1756	}
1757	}
1758	}
1759
1760	#else /* ! RS6000COFF_C */
1761
1762	#define coff_set_alignment_hook((void () (bfd , asection , void )) bfd_void) \
1763	((void () PARAMS ((bfd , asection , PTR))(bfd , asection , void )) bfd_void)
1764
1765	#endif /* ! RS6000COFF_C */
1766	#endif /* ! COFF_WITH_PE */
1767	#endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1768
1769	#ifndef coff_mkobject
1770
1771	static bfd_boolean coff_mkobject PARAMS ((bfd ))(bfd );
1772
1773	static bfd_boolean
1774	coff_mkobject (abfd)
1775	bfd * abfd;
1776	{
1777	coff_data_type *coff;
1778	bfd_size_type amt = sizeof (coff_data_type);
1779
1780	abfd->tdata.coff_obj_data = (struct coff_tdata *) bfd_zalloc (abfd, amt);
1781	if (abfd->tdata.coff_obj_data == 0)
1782	return FALSE0;
1783	coff = coff_data (abfd)((abfd)->tdata.coff_obj_data);
1784	coff->symbols = (coff_symbol_type ) NULL((void)0);
1785	coff->conversion_table = (unsigned int ) NULL((void)0);
1786	coff->raw_syments = (struct coff_ptr_struct ) NULL((void)0);
1787	coff->relocbase = 0;
1788	coff->local_toc_sym_map = 0;
1789
1790	/* make_abs_section(abfd);*/
1791
1792	return TRUE1;
1793	}
1794	#endif
1795
1796	/* Create the COFF backend specific information. */
1797
1798	#ifndef coff_mkobject_hook
1799	static PTRvoid *
1800	coff_mkobject_hook (abfd, filehdr, aouthdr)
1801	bfd * abfd;
1802	PTRvoid * filehdr;
1803	PTRvoid * aouthdr ATTRIBUTE_UNUSED__attribute__ ((__unused__));
1804	{
1805	struct internal_filehdr internal_f = (struct internal_filehdr ) filehdr;
1806	coff_data_type *coff;
1807
1808	if (! coff_mkobject (abfd))
1809	return NULL((void*)0);
1810
1811	coff = coff_data (abfd)((abfd)->tdata.coff_obj_data);
1812
1813	coff->sym_filepos = internal_f->f_symptr;
1814
1815	/* These members communicate important constants about the symbol
1816	table to GDB's symbol-reading code. These `constants'
1817	unfortunately vary among coff implementations... */
1818	coff->local_n_btmask = N_BTMASK0xf;
1819	coff->local_n_btshft = N_BTSHFT4;
1820	coff->local_n_tmask = N_TMASK0x30;
1821	coff->local_n_tshift = N_TSHIFT2;
1822	coff->local_symesz = bfd_coff_symesz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_symesz);
1823	coff->local_auxesz = bfd_coff_auxesz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_auxesz);
1824	coff->local_linesz = bfd_coff_linesz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_linesz);
1825
1826	coff->timestamp = internal_f->f_timdat;
1827
1828	obj_raw_syment_count (abfd)(((abfd)->tdata.coff_obj_data)->raw_syment_count) =
1829	obj_conv_table_size (abfd)(((abfd)->tdata.coff_obj_data)->conv_table_size) =
1830	internal_f->f_nsyms;
1831
1832	#ifdef RS6000COFF_C
1833	if ((internal_f->f_flags & F_SHROBJ(0x2000)) != 0)
1834	abfd->flags \|= DYNAMIC0x40;
1835	if (aouthdr != NULL((void)0) && internal_f->f_opthdr >= bfd_coff_aoutsz (abfd)(((bfd_coff_backend_data ) (abfd)->xvec->backend_data) ->_bfd_aoutsz))
1836	{
1837	struct internal_aouthdr *internal_a =
1838	(struct internal_aouthdr *) aouthdr;
1839	struct xcoff_tdata *xcoff;
1840
1841	xcoff = xcoff_data (abfd)((abfd)->tdata.xcoff_obj_data);
1842	# ifdef U803XTOCMAGIC
1843	xcoff->xcoff64 = internal_f->f_magic == U803XTOCMAGIC;
1844	# else
1845	xcoff->xcoff64 = 0;
1846	# endif
1847	xcoff->full_aouthdr = TRUE1;
1848	xcoff->toc = internal_a->o_toc;
1849	xcoff->sntoc = internal_a->o_sntoc;
1850	xcoff->snentry = internal_a->o_snentry;
1851	bfd_xcoff_text_align_power (abfd) = internal_a->o_algntext;
1852	bfd_xcoff_data_align_power (abfd) = internal_a->o_algndata;
1853	xcoff->modtype = internal_a->o_modtype;
1854	xcoff->cputype = internal_a->o_cputype;
1855	xcoff->maxdata = internal_a->o_maxdata;
1856	xcoff->maxstack = internal_a->o_maxstack;
1857	}
1858	#endif
1859
1860	#ifdef ARM
1861	/* Set the flags field from the COFF header read in. */
1862	if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags))
1863	coff->flags = 0;
1864	#endif
1865
1866	#ifdef COFF_WITH_PE
1867	/* FIXME: I'm not sure this is ever executed, since peicode.h
1868	defines coff_mkobject_hook. */
1869	if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0)
1870	abfd->flags \|= HAS_DEBUG0x08;
1871	#endif
1872
1873	return (PTRvoid *) coff;
1874	}
1875	#endif
1876
1877	/* Determine the machine architecture and type. FIXME: This is target
1878	dependent because the magic numbers are defined in the target
1879	dependent header files. But there is no particular need for this.
1880	If the magic numbers were moved to a separate file, this function
1881	would be target independent and would also be much more successful
1882	at linking together COFF files for different architectures. */
1883
1884	static bfd_boolean
1885	coff_set_arch_mach_hook (abfd, filehdr)
1886	bfd *abfd;
1887	PTRvoid * filehdr;
1888	{
1889	unsigned long machine;
1890	enum bfd_architecture arch;
1891	struct internal_filehdr internal_f = (struct internal_filehdr ) filehdr;
1892
1893	/* Zero selects the default machine for an arch. */
1894	machine = 0;
1895	switch (internal_f->f_magic)
1896	{
1897	#ifdef OR32_MAGIC_BIG
1898	case OR32_MAGIC_BIG:
1899	case OR32_MAGIC_LITTLE:
1900	arch = bfd_arch_or32;
1901	break;
1902	#endif
1903	#ifdef PPCMAGIC
1904	case PPCMAGIC:
1905	arch = bfd_arch_powerpc;
1906	break;
1907	#endif
1908	#ifdef I386MAGIC0x14c
1909	case I386MAGIC0x14c:
1910	case I386PTXMAGIC0x154:
1911	case I386AIXMAGIC0x175: /* Danbury PS/2 AIX C Compiler */
1912	case LYNXCOFFMAGIC0415: /* shadows the m68k Lynx number below, sigh */
1913	arch = bfd_arch_i386;
1914	break;
1915	#endif
1916	#ifdef AMD64MAGIC
1917	case AMD64MAGIC:
1918	arch = bfd_arch_i386;
1919	machine = bfd_mach_x86_6464;
1920	break;
1921	#endif
1922	#ifdef IA64MAGIC
1923	case IA64MAGIC:
1924	arch = bfd_arch_ia64;
1925	break;
1926	#endif
1927	#ifdef A29K_MAGIC_BIG
1928	case A29K_MAGIC_BIG:
1929	case A29K_MAGIC_LITTLE:
1930	arch = bfd_arch_a29k;
1931	break;
1932	#endif
1933	#ifdef ARMMAGIC
1934	case ARMMAGIC:
1935	case ARMPEMAGIC:
1936	case THUMBPEMAGIC:
1937	arch = bfd_arch_arm;
1938	machine = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
1939	if (machine == bfd_mach_arm_unknown0)
1940	{
1941	switch (internal_f->f_flags & F_ARM_ARCHITECTURE_MASK)
1942	{
1943	case F_ARM_2: machine = bfd_mach_arm_21; break;
1944	case F_ARM_2a: machine = bfd_mach_arm_2a2; break;
1945	case F_ARM_3: machine = bfd_mach_arm_33; break;
1946	default:
1947	case F_ARM_3M: machine = bfd_mach_arm_3M4; break;
1948	case F_ARM_4: machine = bfd_mach_arm_45; break;
1949	case F_ARM_4T: machine = bfd_mach_arm_4T6; break;
1950	/* The COFF header does not have enough bits available
1951	to cover all the different ARM architectures. So
1952	we interpret F_ARM_5, the highest flag value to mean
1953	"the highest ARM architecture known to BFD" which is
1954	currently the XScale. */
1955	case F_ARM_5: machine = bfd_mach_arm_XScale10; break;
1956	}
1957	}
1958	break;
1959	#endif
1960	#ifdef MC68MAGIC
1961	case MC68MAGIC:
1962	case M68MAGIC:
1963	#ifdef MC68KBCSMAGIC
1964	case MC68KBCSMAGIC:
1965	#endif
1966	#ifdef APOLLOM68KMAGIC
1967	case APOLLOM68KMAGIC:
1968	#endif
1969	#ifdef LYNXCOFFMAGIC0415
1970	case LYNXCOFFMAGIC0415:
1971	#endif
1972	arch = bfd_arch_m68k;
1973	machine = bfd_mach_m680204;
1974	break;
1975	#endif
1976	#ifdef MC88MAGIC
1977	case MC88MAGIC:
1978	case MC88DMAGIC:
1979	case MC88OMAGIC:
1980	arch = bfd_arch_m88k;
1981	machine = 88100;
1982	break;
1983	#endif
1984	#ifdef Z8KMAGIC
1985	case Z8KMAGIC:
1986	arch = bfd_arch_z8k;
1987	switch (internal_f->f_flags & F_MACHMASK)
1988	{
1989	case F_Z8001:
1990	machine = bfd_mach_z80011;
1991	break;
1992	case F_Z8002:
1993	machine = bfd_mach_z80022;
1994	break;
1995	default:
1996	return FALSE0;
1997	}
1998	break;
1999	#endif
2000	#ifdef I860
2001	case I860MAGIC:
2002	arch = bfd_arch_i860;
2003	break;
2004	#endif
2005	#ifdef I960
2006	#ifdef I960ROMAGIC
2007	case I960ROMAGIC:
2008	case I960RWMAGIC:
2009	arch = bfd_arch_i960;
2010	switch (F_I960TYPE & internal_f->f_flags)
2011	{
2012	default:
2013	case F_I960CORE:
2014	machine = bfd_mach_i960_core1;
2015	break;
2016	case F_I960KB:
2017	machine = bfd_mach_i960_kb_sb3;
2018	break;
2019	case F_I960MC:
2020	machine = bfd_mach_i960_mc4;
2021	break;
2022	case F_I960XA:
2023	machine = bfd_mach_i960_xa5;
2024	break;
2025	case F_I960CA:
2026	machine = bfd_mach_i960_ca6;
2027	break;
2028	case F_I960KA:
2029	machine = bfd_mach_i960_ka_sa2;
2030	break;
2031	case F_I960JX:
2032	machine = bfd_mach_i960_jx7;
2033	break;
2034	case F_I960HX:
2035	machine = bfd_mach_i960_hx8;
2036	break;
2037	}
2038	break;
2039	#endif
2040	#endif
2041
2042	#ifdef RS6000COFF_C
2043	#ifdef XCOFF64
2044	case U64_TOCMAGIC:
2045	case U803XTOCMAGIC:
2046	#else
2047	case U802ROMAGIC:
2048	case U802WRMAGIC:
2049	case U802TOCMAGIC:
2050	#endif
2051	{
2052	int cputype;
2053
2054	if (xcoff_data (abfd)((abfd)->tdata.xcoff_obj_data)->cputype != -1)
2055	cputype = xcoff_data (abfd)((abfd)->tdata.xcoff_obj_data)->cputype & 0xff;
2056	else
2057	{
2058	/* We did not get a value from the a.out header. If the
2059	file has not been stripped, we may be able to get the
2060	architecture information from the first symbol, if it
2061	is a .file symbol. */
2062	if (obj_raw_syment_count (abfd)(((abfd)->tdata.coff_obj_data)->raw_syment_count) == 0)
2063	cputype = 0;
2064	else
2065	{
2066	bfd_byte *buf;
2067	struct internal_syment sym;
2068	bfd_size_type amt = bfd_coff_symesz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_symesz);
2069
2070	buf = (bfd_byte *) bfd_malloc (amt);
2071	if (bfd_seek (abfd, obj_sym_filepos (abfd)(((abfd)->tdata.coff_obj_data)->sym_filepos), SEEK_SET0) != 0
2072	\|\| bfd_bread (buf, amt, abfd) != amt)
2073	{
2074	free (buf);
2075	return FALSE0;
2076	}
2077	bfd_coff_swap_sym_in (abfd, (PTR) buf, (PTR) &sym)((((bfd_coff_backend_data ) (abfd)->xvec->backend_data )->_bfd_coff_swap_sym_in) (abfd,(void ) buf,(void *) & sym));
2078	if (sym.n_sclass == C_FILE103)
2079	cputype = sym.n_type & 0xff;
2080	else
2081	cputype = 0;
2082	free (buf);
2083	}
2084	}
2085
2086	/* FIXME: We don't handle all cases here. */
2087	switch (cputype)
2088	{
2089	default:
2090	case 0:
2091	arch = bfd_xcoff_architecture (abfd);
2092	machine = bfd_xcoff_machine (abfd);
2093	break;
2094
2095	case 1:
2096	arch = bfd_arch_powerpc;
2097	machine = bfd_mach_ppc_601601;
2098	break;
2099	case 2: /* 64 bit PowerPC */
2100	arch = bfd_arch_powerpc;
2101	machine = bfd_mach_ppc_620620;
2102	break;
2103	case 3:
2104	arch = bfd_arch_powerpc;
2105	machine = bfd_mach_ppc32;
2106	break;
2107	case 4:
2108	arch = bfd_arch_rs6000;
2109	machine = bfd_mach_rs6k6000;
2110	break;
2111	}
2112	}
2113	break;
2114	#endif
2115
2116	#ifdef WE32KMAGIC
2117	case WE32KMAGIC:
2118	arch = bfd_arch_we32k;
2119	break;
2120	#endif
2121
2122	#ifdef H8300MAGIC
2123	case H8300MAGIC:
2124	arch = bfd_arch_h8300;
2125	machine = bfd_mach_h83001;
2126	/* !! FIXME this probably isn't the right place for this. */
2127	abfd->flags \|= BFD_IS_RELAXABLE0x200;
2128	break;
2129	#endif
2130
2131	#ifdef H8300HMAGIC
2132	case H8300HMAGIC:
2133	arch = bfd_arch_h8300;
2134	machine = bfd_mach_h8300h2;
2135	/* !! FIXME this probably isn't the right place for this. */
2136	abfd->flags \|= BFD_IS_RELAXABLE0x200;
2137	break;
2138	#endif
2139
2140	#ifdef H8300SMAGIC
2141	case H8300SMAGIC:
2142	arch = bfd_arch_h8300;
2143	machine = bfd_mach_h8300s3;
2144	/* !! FIXME this probably isn't the right place for this. */
2145	abfd->flags \|= BFD_IS_RELAXABLE0x200;
2146	break;
2147	#endif
2148
2149	#ifdef H8300HNMAGIC
2150	case H8300HNMAGIC:
2151	arch = bfd_arch_h8300;
2152	machine = bfd_mach_h8300hn4;
2153	/* !! FIXME this probably isn't the right place for this. */
2154	abfd->flags \|= BFD_IS_RELAXABLE0x200;
2155	break;
2156	#endif
2157
2158	#ifdef H8300SNMAGIC
2159	case H8300SNMAGIC:
2160	arch = bfd_arch_h8300;
2161	machine = bfd_mach_h8300sn5;
2162	/* !! FIXME this probably isn't the right place for this. */
2163	abfd->flags \|= BFD_IS_RELAXABLE0x200;
2164	break;
2165	#endif
2166
2167	#ifdef SH_ARCH_MAGIC_BIG
2168	case SH_ARCH_MAGIC_BIG:
2169	case SH_ARCH_MAGIC_LITTLE:
2170	#ifdef COFF_WITH_PE
2171	case SH_ARCH_MAGIC_WINCE:
2172	#endif
2173	arch = bfd_arch_sh;
2174	break;
2175	#endif
2176
2177	#ifdef MIPS_ARCH_MAGIC_WINCE
2178	case MIPS_ARCH_MAGIC_WINCE:
2179	arch = bfd_arch_mips;
2180	break;
2181	#endif
2182
2183	#ifdef H8500MAGIC
2184	case H8500MAGIC:
2185	arch = bfd_arch_h8500;
2186	break;
2187	#endif
2188
2189	#ifdef SPARCMAGIC
2190	case SPARCMAGIC:
2191	#ifdef LYNXCOFFMAGIC0415
2192	case LYNXCOFFMAGIC0415:
2193	#endif
2194	arch = bfd_arch_sparc;
2195	break;
2196	#endif
2197
2198	#ifdef TIC30MAGIC
2199	case TIC30MAGIC:
2200	arch = bfd_arch_tic30;
2201	break;
2202	#endif
2203
2204	#ifdef TICOFF0MAGIC
2205	#ifdef TICOFF_TARGET_ARCH
2206	/* This TI COFF section should be used by all new TI COFF v0 targets. */
2207	case TICOFF0MAGIC:
2208	arch = TICOFF_TARGET_ARCH;
2209	machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags);
2210	break;
2211	#endif
2212	#endif
2213
2214	#ifdef TICOFF1MAGIC
2215	/* This TI COFF section should be used by all new TI COFF v1/2 targets. */
2216	/* TI COFF1 and COFF2 use the target_id field to specify which arch. */
2217	case TICOFF1MAGIC:
2218	case TICOFF2MAGIC:
2219	switch (internal_f->f_target_id)
2220	{
2221	#ifdef TI_TARGET_ID
2222	case TI_TARGET_ID:
2223	arch = TICOFF_TARGET_ARCH;
2224	machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags);
2225	break;
2226	#endif
2227	default:
2228	arch = bfd_arch_obscure;
2229	(*_bfd_error_handler)
2230	(_("Unrecognized TI COFF target id '0x%x'")("Unrecognized TI COFF target id '0x%x'"),
2231	internal_f->f_target_id);
2232	break;
2233	}
2234	break;
2235	#endif
2236
2237	#ifdef TIC80_ARCH_MAGIC
2238	case TIC80_ARCH_MAGIC:
2239	arch = bfd_arch_tic80;
2240	break;
2241	#endif
2242
2243	#ifdef MCOREMAGIC
2244	case MCOREMAGIC:
2245	arch = bfd_arch_mcore;
2246	break;
2247	#endif
2248
2249	#ifdef W65MAGIC
2250	case W65MAGIC:
2251	arch = bfd_arch_w65;
2252	break;
2253	#endif
2254
2255	default: /* Unreadable input file type. */
2256	arch = bfd_arch_obscure;
2257	break;
2258	}
2259
2260	bfd_default_set_arch_mach (abfd, arch, machine);
2261	return TRUE1;
2262	}
2263
2264	#ifdef SYMNAME_IN_DEBUG
2265
2266	static bfd_boolean symname_in_debug_hook(bfd_boolean () (bfd , struct internal_syment *)) bfd_false
2267	PARAMS ((bfd , struct internal_syment ))(bfd , struct internal_syment );
2268
2269	static bfd_boolean
2270	symname_in_debug_hook(bfd_boolean () (bfd , struct internal_syment *)) bfd_false (abfd, sym)
2271	bfd * abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__));
2272	struct internal_syment *sym;
2273	{
2274	return SYMNAME_IN_DEBUG (sym) != 0;
2275	}
2276
2277	#else
2278
2279	#define symname_in_debug_hook(bfd_boolean () (bfd , struct internal_syment *)) bfd_false \
2280	(bfd_boolean () PARAMS ((bfd , struct internal_syment ))(bfd , struct internal_syment *)) bfd_false
2281
2282	#endif
2283
2284	#ifdef RS6000COFF_C
2285
2286	#ifdef XCOFF64
2287	#define FORCE_SYMNAMES_IN_STRINGS
2288	#endif
2289
2290	/* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
2291
2292	static bfd_boolean coff_pointerize_aux_hook0
2293	PARAMS ((bfd , combined_entry_type , combined_entry_type ,(bfd , combined_entry_type , combined_entry_type , unsigned int, combined_entry_type *)
2294	unsigned int, combined_entry_type ))(bfd , combined_entry_type , combined_entry_type , unsigned int, combined_entry_type *);
2295
2296	static bfd_boolean
2297	coff_pointerize_aux_hook0 (abfd, table_base, symbol, indaux, aux)
2298	bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__));
2299	combined_entry_type *table_base;
2300	combined_entry_type *symbol;
2301	unsigned int indaux;
2302	combined_entry_type *aux;
2303	{
2304	int class = symbol->u.syment.n_sclass;
2305
2306	if ((class == C_EXT2 \|\| class == C_HIDEXT107)
2307	&& indaux + 1 == symbol->u.syment.n_numaux)
2308	{
2309	if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp)((aux->u.auxent.x_csect.x_smtyp) & 0x7) == XTY_LD2)
2310	{
2311	aux->u.auxent.x_csect.x_scnlen.p =
2312	table_base + aux->u.auxent.x_csect.x_scnlen.l;
2313	aux->fix_scnlen = 1;
2314	}
2315
2316	/* Return TRUE to indicate that the caller should not do any
2317	further work on this auxent. */
2318	return TRUE1;
2319	}
2320
2321	/* Return FALSE to indicate that this auxent should be handled by
2322	the caller. */
2323	return FALSE0;
2324	}
2325
2326	#else
2327	#ifdef I960
2328
2329	/* We don't want to pointerize bal entries. */
2330
2331	static bfd_boolean coff_pointerize_aux_hook0
2332	PARAMS ((bfd , combined_entry_type , combined_entry_type ,(bfd , combined_entry_type , combined_entry_type , unsigned int, combined_entry_type *)
2333	unsigned int, combined_entry_type ))(bfd , combined_entry_type , combined_entry_type , unsigned int, combined_entry_type *);
2334
2335	static bfd_boolean
2336	coff_pointerize_aux_hook0 (abfd, table_base, symbol, indaux, aux)
2337	bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__));
2338	combined_entry_type *table_base ATTRIBUTE_UNUSED__attribute__ ((__unused__));
2339	combined_entry_type *symbol;
2340	unsigned int indaux;
2341	combined_entry_type *aux ATTRIBUTE_UNUSED__attribute__ ((__unused__));
2342	{
2343	/* Return TRUE if we don't want to pointerize this aux entry, which
2344	is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2345	return (indaux == 1
2346	&& (symbol->u.syment.n_sclass == C_LEAFPROC108
2347	\|\| symbol->u.syment.n_sclass == C_LEAFSTAT113
2348	\|\| symbol->u.syment.n_sclass == C_LEAFEXT108));
2349	}
2350
2351	#else /* ! I960 */
2352
2353	#define coff_pointerize_aux_hook0 0
2354
2355	#endif /* ! I960 */
2356	#endif /* ! RS6000COFF_C */
2357
2358	/* Print an aux entry. This returns TRUE if it has printed it. */
2359
2360	static bfd_boolean coff_print_aux
2361	PARAMS ((bfd , FILE , combined_entry_type , combined_entry_type ,(bfd , FILE , combined_entry_type , combined_entry_type , combined_entry_type *, unsigned int)
2362	combined_entry_type , unsigned int))(bfd , FILE , combined_entry_type , combined_entry_type , combined_entry_type , unsigned int);
2363
2364	static bfd_boolean
2365	coff_print_aux (abfd, file, table_base, symbol, aux, indaux)
2366	bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__));
2367	FILE *file ATTRIBUTE_UNUSED__attribute__ ((__unused__));
2368	combined_entry_type *table_base ATTRIBUTE_UNUSED__attribute__ ((__unused__));
2369	combined_entry_type *symbol ATTRIBUTE_UNUSED__attribute__ ((__unused__));
2370	combined_entry_type *aux ATTRIBUTE_UNUSED__attribute__ ((__unused__));
2371	unsigned int indaux ATTRIBUTE_UNUSED__attribute__ ((__unused__));
2372	{
2373	#ifdef RS6000COFF_C
2374	if ((symbol->u.syment.n_sclass == C_EXT2
2375	\|\| symbol->u.syment.n_sclass == C_HIDEXT107)
2376	&& indaux + 1 == symbol->u.syment.n_numaux)
2377	{
2378	/* This is a csect entry. */
2379	fprintf (file, "AUX ");
2380	if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp)((aux->u.auxent.x_csect.x_smtyp) & 0x7) != XTY_LD2)
2381	{
2382	BFD_ASSERT (! aux->fix_scnlen){ if (!(! aux->fix_scnlen)) bfd_assert("/usr/src/gnu/usr.bin/binutils/bfd/coffcode.h" ,2382); };
2383	#ifdef XCOFF64
2384	fprintf (file, "val %5lld", aux->u.auxent.x_csect.x_scnlen.l);
2385	#else
2386	fprintf (file, "val %5ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
2387	#endif
2388	}
2389	else
2390	{
2391	fprintf (file, "indx ");
2392	if (! aux->fix_scnlen)
2393	#ifdef XCOFF64
2394	fprintf (file, "%4lld", aux->u.auxent.x_csect.x_scnlen.l);
2395	#else
2396	fprintf (file, "%4ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
2397	#endif
2398	else
2399	fprintf (file, "%4ld",
2400	(long) (aux->u.auxent.x_csect.x_scnlen.p - table_base));
2401	}
2402	fprintf (file,
2403	" prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2404	aux->u.auxent.x_csect.x_parmhash,
2405	(unsigned int) aux->u.auxent.x_csect.x_snhash,
2406	SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp)((aux->u.auxent.x_csect.x_smtyp) & 0x7),
2407	SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp)((aux->u.auxent.x_csect.x_smtyp) >> 3),
2408	(unsigned int) aux->u.auxent.x_csect.x_smclas,
2409	aux->u.auxent.x_csect.x_stab,
2410	(unsigned int) aux->u.auxent.x_csect.x_snstab);
2411	return TRUE1;
2412	}
2413	#endif
2414
2415	/* Return FALSE to indicate that no special action was taken. */
2416	return FALSE0;
2417	}
2418
2419	/*
2420	SUBSUBSECTION
2421	Writing relocations
2422
2423	To write relocations, the back end steps though the
2424	canonical relocation table and create an
2425	@code{internal_reloc}. The symbol index to use is removed from
2426	the @code{offset} field in the symbol table supplied. The
2427	address comes directly from the sum of the section base
2428	address and the relocation offset; the type is dug directly
2429	from the howto field. Then the @code{internal_reloc} is
2430	swapped into the shape of an @code{external_reloc} and written
2431	out to disk.
2432
2433	*/
2434
2435	#ifdef TARG_AUX
2436
2437	static int compare_arelent_ptr PARAMS ((const PTR, const PTR))(const void , const void );
2438
2439	/* AUX's ld wants relocations to be sorted. */
2440	static int
2441	compare_arelent_ptr (x, y)
2442	const PTRvoid * x;
2443	const PTRvoid * y;
2444	{
2445	const arelent a = (const arelent ) x;
2446	const arelent b = (const arelent ) y;
2447	bfd_size_type aadr = (*a)->address;
2448	bfd_size_type badr = (*b)->address;
2449
2450	return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
2451	}
2452
2453	#endif /* TARG_AUX */
2454
2455	static bfd_boolean
2456	coff_write_relocs (abfd, first_undef)
2457	bfd * abfd;
2458	int first_undef;
2459	{
2460	asection *s;
2461
2462	for (s = abfd->sections; s != (asection ) NULL((void)0); s = s->next)
2463	{
2464	unsigned int i;
2465	struct external_reloc dst;
2466	arelent **p;
2467
2468	#ifndef TARG_AUX
2469	p = s->orelocation;
2470	#else
2471	{
2472	/* Sort relocations before we write them out. */
2473	bfd_size_type amt;
2474
2475	amt = s->reloc_count;
2476	amt = sizeof (arelent );
2477	p = (arelent **) bfd_malloc (amt);
2478	if (p == NULL((void*)0) && s->reloc_count > 0)
2479	return FALSE0;
2480	memcpy (p, s->orelocation, (size_t) amt);
2481	qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr);
2482	}
2483	#endif
2484
2485	if (bfd_seek (abfd, s->rel_filepos, SEEK_SET0) != 0)
2486	return FALSE0;
2487
2488	#ifdef COFF_WITH_PE
2489	if (obj_pe (abfd)(((abfd)->tdata.coff_obj_data)->pe) && s->reloc_count >= 0xffff)
2490	{
2491	/* Encode real count here as first reloc. */
2492	struct internal_reloc n;
2493
2494	memset ((PTRvoid *) & n, 0, sizeof (n));
2495	/* Add one to count this reloc (grr). */
2496	n.r_vaddr = s->reloc_count + 1;
2497	coff_swap_reloc_out (abfd, &n, &dst);
2498	if (bfd_bwrite ((PTRvoid ) & dst, (bfd_size_type) bfd_coff_relsz (abfd)(((bfd_coff_backend_data ) (abfd)->xvec->backend_data) ->_bfd_relsz),
2499	abfd) != bfd_coff_relsz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_relsz))
2500	return FALSE0;
2501	}
2502	#endif
2503
2504	for (i = 0; i < s->reloc_count; i++)
2505	{
2506	struct internal_reloc n;
2507	arelent *q = p[i];
2508
2509	memset ((PTRvoid *) & n, 0, sizeof (n));
2510
2511	/* Now we've renumbered the symbols we know where the
2512	undefined symbols live in the table. Check the reloc
2513	entries for symbols who's output bfd isn't the right one.
2514	This is because the symbol was undefined (which means
2515	that all the pointers are never made to point to the same
2516	place). This is a bad thing,'cause the symbols attached
2517	to the output bfd are indexed, so that the relocation
2518	entries know which symbol index they point to. So we
2519	have to look up the output symbol here. */
2520
2521	if (q->sym_ptr_ptr[0]->the_bfd != abfd)
2522	{
2523	int j;
2524	const char *sname = q->sym_ptr_ptr[0]->name;
2525	asymbol **outsyms = abfd->outsymbols;
2526
2527	for (j = first_undef; outsyms[j]; j++)
2528	{
2529	const char *intable = outsyms[j]->name;
2530
2531	if (strcmp (intable, sname) == 0) {
2532	/* Got a hit, so repoint the reloc. */
2533	q->sym_ptr_ptr = outsyms + j;
2534	break;
2535	}
2536	}
2537	}
2538
2539	n.r_vaddr = q->address + s->vma;
2540
2541	#ifdef R_IHCONST
2542	/* The 29k const/consth reloc pair is a real kludge. The consth
2543	part doesn't have a symbol; it has an offset. So rebuilt
2544	that here. */
2545	if (q->howto->type == R_IHCONST)
2546	n.r_symndx = q->addend;
2547	else
2548	#endif
2549	if (q->sym_ptr_ptr)
2550	{
2551	#ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2552	if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q,s))
2553	#else
2554	if ((q->sym_ptr_ptr)->section == bfd_abs_section_ptr((asection ) &bfd_abs_section)
2555	&& ((*q->sym_ptr_ptr)->flags & BSF_SECTION_SYM0x100) != 0)
2556	#endif
2557	/* This is a relocation relative to the absolute symbol. */
2558	n.r_symndx = -1;
2559	else
2560	{
2561	n.r_symndx = get_index (((q->sym_ptr_ptr)))((((q->sym_ptr_ptr)))->udata.i);
2562	/* Take notice if the symbol reloc points to a symbol
2563	we don't have in our symbol table. What should we
2564	do for this?? */
2565	if (n.r_symndx > obj_conv_table_size (abfd)(((abfd)->tdata.coff_obj_data)->conv_table_size))
2566	abort ()_bfd_abort ("/usr/src/gnu/usr.bin/binutils/bfd/coffcode.h", 2566 , __PRETTY_FUNCTION__);
2567	}
2568	}
2569
2570	#ifdef SWAP_OUT_RELOC_OFFSET
2571	n.r_offset = q->addend;
2572	#endif
2573
2574	#ifdef SELECT_RELOC
2575	/* Work out reloc type from what is required. */
2576	SELECT_RELOC (n, q->howto){ n.r_type = q->howto->type; };
2577	#else
2578	n.r_type = q->howto->type;
2579	#endif
2580	coff_swap_reloc_out (abfd, &n, &dst);
2581
2582	if (bfd_bwrite ((PTRvoid ) & dst, (bfd_size_type) bfd_coff_relsz (abfd)(((bfd_coff_backend_data ) (abfd)->xvec->backend_data) ->_bfd_relsz),
2583	abfd) != bfd_coff_relsz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_relsz))
2584	return FALSE0;
2585	}
2586
2587	#ifdef TARG_AUX
2588	if (p != NULL((void*)0))
2589	free (p);
2590	#endif
2591	}
2592
2593	return TRUE1;
2594	}
2595
2596	/* Set flags and magic number of a coff file from architecture and machine
2597	type. Result is TRUE if we can represent the arch&type, FALSE if not. */
2598
2599	static bfd_boolean
2600	coff_set_flags (abfd, magicp, flagsp)
2601	bfd * abfd;
2602	unsigned int *magicp ATTRIBUTE_UNUSED__attribute__ ((__unused__));
2603	unsigned short *flagsp ATTRIBUTE_UNUSED__attribute__ ((__unused__));
2604	{
2605	switch (bfd_get_arch (abfd))
2606	{
2607	#ifdef Z8KMAGIC
2608	case bfd_arch_z8k:
2609	*magicp = Z8KMAGIC;
2610	switch (bfd_get_mach (abfd))
2611	{
2612	case bfd_mach_z80011:
2613	*flagsp = F_Z8001;
2614	break;
2615	case bfd_mach_z80022:
2616	*flagsp = F_Z8002;
2617	break;
2618	default:
2619	return FALSE0;
2620	}
2621	return TRUE1;
2622	#endif
2623	#ifdef I960ROMAGIC
2624
2625	case bfd_arch_i960:
2626
2627	{
2628	unsigned flags;
2629	*magicp = I960ROMAGIC;
2630	/*
2631	((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2632	I960RWMAGIC); FIXME???
2633	*/
2634	switch (bfd_get_mach (abfd))
2635	{
2636	case bfd_mach_i960_core1:
2637	flags = F_I960CORE;
2638	break;
2639	case bfd_mach_i960_kb_sb3:
2640	flags = F_I960KB;
2641	break;
2642	case bfd_mach_i960_mc4:
2643	flags = F_I960MC;
2644	break;
2645	case bfd_mach_i960_xa5:
2646	flags = F_I960XA;
2647	break;
2648	case bfd_mach_i960_ca6:
2649	flags = F_I960CA;
2650	break;
2651	case bfd_mach_i960_ka_sa2:
2652	flags = F_I960KA;
2653	break;
2654	case bfd_mach_i960_jx7:
2655	flags = F_I960JX;
2656	break;
2657	case bfd_mach_i960_hx8:
2658	flags = F_I960HX;
2659	break;
2660	default:
2661	return FALSE0;
2662	}
2663	*flagsp = flags;
2664	return TRUE1;
2665	}
2666	break;
2667	#endif
2668
2669	#ifdef TIC30MAGIC
2670	case bfd_arch_tic30:
2671	*magicp = TIC30MAGIC;
2672	return TRUE1;
2673	#endif
2674
2675	#ifdef TICOFF_DEFAULT_MAGIC
2676	case TICOFF_TARGET_ARCH:
2677	/* If there's no indication of which version we want, use the default. */
2678	if (!abfd->xvec )
2679	*magicp = TICOFF_DEFAULT_MAGIC;
2680	else
2681	{
2682	/* We may want to output in a different COFF version. */
2683	switch (abfd->xvec->name[4])
2684	{
2685	case '0':
2686	*magicp = TICOFF0MAGIC;
2687	break;
2688	case '1':
2689	*magicp = TICOFF1MAGIC;
2690	break;
2691	case '2':
2692	*magicp = TICOFF2MAGIC;
2693	break;
2694	default:
2695	return FALSE0;
2696	}
2697	}
2698	TICOFF_TARGET_MACHINE_SET (flagsp, bfd_get_mach (abfd));
2699	return TRUE1;
2700	#endif
2701
2702	#ifdef TIC80_ARCH_MAGIC
2703	case bfd_arch_tic80:
2704	*magicp = TIC80_ARCH_MAGIC;
2705	return TRUE1;
2706	#endif
2707	#ifdef ARMMAGIC
2708	case bfd_arch_arm:
2709	#ifdef ARM_WINCE
2710	* magicp = ARMPEMAGIC;
2711	#else
2712	* magicp = ARMMAGIC;
2713	#endif
2714	* flagsp = 0;
2715	if (APCS_SET (abfd))
2716	{
2717	if (APCS_26_FLAG (abfd))
2718	* flagsp \|= F_APCS26;
2719
2720	if (APCS_FLOAT_FLAG (abfd))
2721	* flagsp \|= F_APCS_FLOAT;
2722
2723	if (PIC_FLAG (abfd))
2724	* flagsp \|= F_PIC;
2725	}
2726	if (INTERWORK_SET (abfd) && INTERWORK_FLAG (abfd))
2727	* flagsp \|= F_INTERWORK;
2728	switch (bfd_get_mach (abfd))
2729	{
2730	case bfd_mach_arm_21: * flagsp \|= F_ARM_2; break;
2731	case bfd_mach_arm_2a2: * flagsp \|= F_ARM_2a; break;
2732	case bfd_mach_arm_33: * flagsp \|= F_ARM_3; break;
2733	case bfd_mach_arm_3M4: * flagsp \|= F_ARM_3M; break;
2734	case bfd_mach_arm_45: * flagsp \|= F_ARM_4; break;
2735	case bfd_mach_arm_4T6: * flagsp \|= F_ARM_4T; break;
2736	case bfd_mach_arm_57: * flagsp \|= F_ARM_5; break;
2737	/* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2738	See also the comment in coff_set_arch_mach_hook(). */
2739	case bfd_mach_arm_5T8: * flagsp \|= F_ARM_5; break;
2740	case bfd_mach_arm_5TE9: * flagsp \|= F_ARM_5; break;
2741	case bfd_mach_arm_XScale10: * flagsp \|= F_ARM_5; break;
2742	}
2743	return TRUE1;
2744	#endif
2745	#ifdef PPCMAGIC
2746	case bfd_arch_powerpc:
2747	*magicp = PPCMAGIC;
2748	return TRUE1;
2749	break;
2750	#endif
2751	#if defined(I386MAGIC0x14c) \|\| defined(AMD64MAGIC)
2752	case bfd_arch_i386:
2753	#if defined(I386MAGIC0x14c)
2754	*magicp = I386MAGIC0x14c;
2755	#endif
2756	#ifdef LYNXOS
2757	/* Just overwrite the usual value if we're doing Lynx. */
2758	*magicp = LYNXCOFFMAGIC0415;
2759	#endif
2760	#if defined AMD64MAGIC
2761	*magicp = AMD64MAGIC;
2762	#endif
2763	return TRUE1;
2764	break;
2765	#endif
2766	#ifdef I860MAGIC
2767	case bfd_arch_i860:
2768	*magicp = I860MAGIC;
2769	return TRUE1;
2770	break;
2771	#endif
2772	#ifdef IA64MAGIC
2773	case bfd_arch_ia64:
2774	*magicp = IA64MAGIC;
2775	return TRUE1;
2776	break;
2777	#endif
2778	#ifdef MC68MAGIC
2779	case bfd_arch_m68k:
2780	#ifdef APOLLOM68KMAGIC
2781	*magicp = APOLLO_COFF_VERSION_NUMBER;
2782	#else
2783	/* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2784	#ifdef NAMES_HAVE_UNDERSCORE
2785	*magicp = MC68KBCSMAGIC;
2786	#else
2787	*magicp = MC68MAGIC;
2788	#endif
2789	#endif
2790	#ifdef LYNXOS
2791	/* Just overwrite the usual value if we're doing Lynx. */
2792	*magicp = LYNXCOFFMAGIC0415;
2793	#endif
2794	return TRUE1;
2795	break;
2796	#endif
2797
2798	#ifdef MC88MAGIC
2799	case bfd_arch_m88k:
2800	*magicp = MC88OMAGIC;
2801	return TRUE1;
2802	break;
2803	#endif
2804	#ifdef H8300MAGIC
2805	case bfd_arch_h8300:
2806	switch (bfd_get_mach (abfd))
2807	{
2808	case bfd_mach_h83001:
2809	*magicp = H8300MAGIC;
2810	return TRUE1;
2811	case bfd_mach_h8300h2:
2812	*magicp = H8300HMAGIC;
2813	return TRUE1;
2814	case bfd_mach_h8300s3:
2815	*magicp = H8300SMAGIC;
2816	return TRUE1;
2817	case bfd_mach_h8300hn4:
2818	*magicp = H8300HNMAGIC;
2819	return TRUE1;
2820	case bfd_mach_h8300sn5:
2821	*magicp = H8300SNMAGIC;
2822	return TRUE1;
2823	}
2824	break;
2825	#endif
2826
2827	#ifdef SH_ARCH_MAGIC_BIG
2828	case bfd_arch_sh:
2829	#ifdef COFF_IMAGE_WITH_PE
2830	*magicp = SH_ARCH_MAGIC_WINCE;
2831	#else
2832	if (bfd_big_endian (abfd)((abfd)->xvec->byteorder == BFD_ENDIAN_BIG))
2833	*magicp = SH_ARCH_MAGIC_BIG;
2834	else
2835	*magicp = SH_ARCH_MAGIC_LITTLE;
2836	#endif
2837	return TRUE1;
2838	break;
2839	#endif
2840
2841	#ifdef MIPS_ARCH_MAGIC_WINCE
2842	case bfd_arch_mips:
2843	*magicp = MIPS_ARCH_MAGIC_WINCE;
2844	return TRUE1;
2845	break;
2846	#endif
2847
2848	#ifdef SPARCMAGIC
2849	case bfd_arch_sparc:
2850	*magicp = SPARCMAGIC;
2851	#ifdef LYNXOS
2852	/* Just overwrite the usual value if we're doing Lynx. */
2853	*magicp = LYNXCOFFMAGIC0415;
2854	#endif
2855	return TRUE1;
2856	break;
2857	#endif
2858
2859	#ifdef H8500MAGIC
2860	case bfd_arch_h8500:
2861	*magicp = H8500MAGIC;
2862	return TRUE1;
2863	break;
2864	#endif
2865	#ifdef A29K_MAGIC_BIG
2866	case bfd_arch_a29k:
2867	if (bfd_big_endian (abfd)((abfd)->xvec->byteorder == BFD_ENDIAN_BIG))
2868	*magicp = A29K_MAGIC_BIG;
2869	else
2870	*magicp = A29K_MAGIC_LITTLE;
2871	return TRUE1;
2872	break;
2873	#endif
2874
2875	#ifdef WE32KMAGIC
2876	case bfd_arch_we32k:
2877	*magicp = WE32KMAGIC;
2878	return TRUE1;
2879	break;
2880	#endif
2881
2882	#ifdef RS6000COFF_C
2883	case bfd_arch_rs6000:
2884	#ifndef PPCMAGIC
2885	case bfd_arch_powerpc:
2886	#endif
2887	BFD_ASSERT (bfd_get_flavour (abfd) == bfd_target_xcoff_flavour){ if (!(((abfd)->xvec->flavour) == bfd_target_xcoff_flavour )) bfd_assert("/usr/src/gnu/usr.bin/binutils/bfd/coffcode.h", 2887); };
2888	*magicp = bfd_xcoff_magic_number (abfd);
2889	return TRUE1;
2890	break;
2891	#endif
2892
2893	#ifdef MCOREMAGIC
2894	case bfd_arch_mcore:
2895	* magicp = MCOREMAGIC;
2896	return TRUE1;
2897	#endif
2898
2899	#ifdef W65MAGIC
2900	case bfd_arch_w65:
2901	*magicp = W65MAGIC;
2902	return TRUE1;
2903	#endif
2904
2905	#ifdef OR32_MAGIC_BIG
2906	case bfd_arch_or32:
2907	if (bfd_big_endian (abfd)((abfd)->xvec->byteorder == BFD_ENDIAN_BIG))
2908	* magicp = OR32_MAGIC_BIG;
2909	else
2910	* magicp = OR32_MAGIC_LITTLE;
2911	return TRUE1;
2912	#endif
2913
2914	default: /* Unknown architecture. */
2915	/* Fall through to "return FALSE" below, to avoid
2916	"statement never reached" errors on the one below. */
2917	break;
2918	}
2919
2920	return FALSE0;
2921	}
2922
2923	static bfd_boolean
2924	coff_set_arch_mach (abfd, arch, machine)
2925	bfd * abfd;
2926	enum bfd_architecture arch;
2927	unsigned long machine;
2928	{
2929	unsigned dummy1;
2930	unsigned short dummy2;
2931
2932	if (! bfd_default_set_arch_mach (abfd, arch, machine))
2933	return FALSE0;
2934
2935	if (arch != bfd_arch_unknown
2936	&& ! coff_set_flags (abfd, &dummy1, &dummy2))
2937	return FALSE0; /* We can't represent this type */
2938
2939	return TRUE1; /* We're easy ... */
2940	}
2941
2942	#ifdef COFF_IMAGE_WITH_PE
2943
2944	/* This is used to sort sections by VMA, as required by PE image
2945	files. */
2946
2947	static int sort_by_secaddr PARAMS ((const PTR, const PTR))(const void , const void );
2948
2949	static int
2950	sort_by_secaddr (arg1, arg2)
2951	const PTRvoid * arg1;
2952	const PTRvoid * arg2;
2953	{
2954	const asection a = (const asection **) arg1;
2955	const asection b = (const asection **) arg2;
2956
2957	if (a->vma < b->vma)
2958	return -1;
2959	else if (a->vma > b->vma)
2960	return 1;
2961	else
2962	return 0;
2963	}
2964
2965	#endif /* COFF_IMAGE_WITH_PE */
2966
2967	/* Calculate the file position for each section. */
2968
2969	#ifndef I960
2970	#define ALIGN_SECTIONS_IN_FILE
2971	#endif
2972	#if defined(TIC80COFF) \|\| defined(TICOFF)
2973	#undef ALIGN_SECTIONS_IN_FILE
2974	#endif
2975
2976	static bfd_boolean
2977	coff_compute_section_file_positions (abfd)
2978	bfd * abfd;
2979	{
2980	asection *current;
2981	asection previous = (asection ) NULL((void*)0);
2982	file_ptr sofar = bfd_coff_filhsz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_filhsz);
2983	bfd_boolean align_adjust;
2984	#ifdef ALIGN_SECTIONS_IN_FILE
2985	file_ptr old_sofar;
2986	#endif
2987
2988	#ifdef RS6000COFF_C
2989	/* On XCOFF, if we have symbols, set up the .debug section. */
2990	if (bfd_get_symcount (abfd)((abfd)->symcount) > 0)
2991	{
2992	bfd_size_type sz;
2993	bfd_size_type i, symcount;
2994	asymbol **symp;
2995
2996	sz = 0;
2997	symcount = bfd_get_symcount (abfd)((abfd)->symcount);
2998	for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++)
2999	{
3000	coff_symbol_type *cf;
3001
3002	cf = coff_symbol_from (abfd, *symp);
3003	if (cf != NULL((void*)0)
3004	&& cf->native != NULL((void*)0)
3005	&& SYMNAME_IN_DEBUG (&cf->native->u.syment))
3006	{
3007	size_t len;
3008
3009	len = strlen (bfd_asymbol_name (symp)((symp)->name));
3010	if (len > SYMNMLEN8 \|\| bfd_coff_force_symnames_in_strings (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_coff_force_symnames_in_strings))
3011	sz += len + 1 + bfd_coff_debug_string_prefix_length (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_coff_debug_string_prefix_length);
3012	}
3013	}
3014	if (sz > 0)
3015	{
3016	asection *dsec;
3017
3018	dsec = bfd_make_section_old_way (abfd, ".debug");
3019	if (dsec == NULL((void*)0))
3020	abort ()_bfd_abort ("/usr/src/gnu/usr.bin/binutils/bfd/coffcode.h", 3020 , __PRETTY_FUNCTION__);
3021	dsec->_raw_size = sz;
3022	dsec->flags \|= SEC_HAS_CONTENTS0x200;
3023	}
3024	}
3025	#endif
3026
3027	#ifdef COFF_IMAGE_WITH_PE
3028	int page_size;
3029	if (coff_data (abfd)((abfd)->tdata.coff_obj_data)->link_info)
3030	{
3031	page_size = pe_data (abfd)((abfd)->tdata.pe_obj_data)->pe_opthdr.FileAlignment;
3032
3033	/* If no file alignment has been set, default to one.
3034	This repairs 'ld -r' for arm-wince-pe target. */
3035	if (page_size == 0)
3036	page_size = 1;
3037	}
3038	else
3039	page_size = PE_DEF_FILE_ALIGNMENT0x200;
3040	#else
3041	#ifdef COFF_PAGE_SIZE0x1000
3042	int page_size = COFF_PAGE_SIZE0x1000;
3043	#endif
3044	#endif
3045
3046	if (bfd_get_start_address (abfd)((abfd)->start_address))
3047	{
3048	/* A start address may have been added to the original file. In this
3049	case it will need an optional header to record it. */
3050	abfd->flags \|= EXEC_P0x02;
3051	}
3052
3053	if (abfd->flags & EXEC_P0x02)
3054	sofar += bfd_coff_aoutsz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_aoutsz);
3055	#ifdef RS6000COFF_C
3056	else if (xcoff_data (abfd)((abfd)->tdata.xcoff_obj_data)->full_aouthdr)
3057	sofar += bfd_coff_aoutsz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_aoutsz);
3058	else
3059	sofar += SMALL_AOUTSZ;
3060	#endif
3061
3062	sofar += abfd->section_count * bfd_coff_scnhsz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_scnhsz);
3063
3064	#ifdef RS6000COFF_C
3065	/* XCOFF handles overflows in the reloc and line number count fields
3066	by allocating a new section header to hold the correct counts. */
3067	for (current = abfd->sections; current != NULL((void*)0); current = current->next)
3068	if (current->reloc_count >= 0xffff \|\| current->lineno_count >= 0xffff)
3069	sofar += bfd_coff_scnhsz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_scnhsz);
3070	#endif
3071
3072	#ifdef COFF_IMAGE_WITH_PE
3073	{
3074	/* PE requires the sections to be in memory order when listed in
3075	the section headers. It also does not like empty loadable
3076	sections. The sections apparently do not have to be in the
3077	right order in the image file itself, but we do need to get the
3078	target_index values right. */
3079
3080	unsigned int count;
3081	asection **section_list;
3082	unsigned int i;
3083	int target_index;
3084	bfd_size_type amt;
3085
3086	count = 0;
3087	for (current = abfd->sections; current != NULL((void*)0); current = current->next)
3088	++count;
3089
3090	/* We allocate an extra cell to simplify the final loop. */
3091	amt = sizeof (struct asection ) (count + 1);
3092	section_list = bfd_malloc (amt);
3093	if (section_list == NULL((void*)0))
3094	return FALSE0;
3095
3096	i = 0;
3097	for (current = abfd->sections; current != NULL((void*)0); current = current->next)
3098	{
3099	section_list[i] = current;
3100	++i;
3101	}
3102	section_list[i] = NULL((void*)0);
3103
3104	qsort (section_list, count, sizeof (asection *), sort_by_secaddr);
3105
3106	/* Rethread the linked list into sorted order; at the same time,
3107	assign target_index values. */
3108	target_index = 1;
3109	abfd->sections = section_list[0];
3110	for (i = 0; i < count; i++)
3111	{
3112	current = section_list[i];
3113	current->next = section_list[i + 1];
3114
3115	/* Later, if the section has zero size, we'll be throwing it
3116	away, so we don't want to number it now. Note that having
3117	a zero size and having real contents are different
3118	concepts: .bss has no contents, but (usually) non-zero
3119	size. */
3120	if (current->_raw_size == 0)
3121	{
3122	/* Discard. However, it still might have (valid) symbols
3123	in it, so arbitrarily set it to section 1 (indexing is
3124	1-based here; usually .text). __end__ and other
3125	contents of .endsection really have this happen.
3126	FIXME: This seems somewhat dubious. */
3127	current->target_index = 1;
3128	}
3129	else
3130	current->target_index = target_index++;
3131	}
3132	abfd->section_tail = &current->next;
3133
3134	free (section_list);
3135	}
3136	#else /* ! COFF_IMAGE_WITH_PE */
3137	{
3138	/* Set the target_index field. */
3139	int target_index;
3140
3141	target_index = 1;
3142	for (current = abfd->sections; current != NULL((void*)0); current = current->next)
3143	current->target_index = target_index++;
3144	}
3145	#endif /* ! COFF_IMAGE_WITH_PE */
3146
3147	align_adjust = FALSE0;
3148	for (current = abfd->sections;
3149	current != (asection ) NULL((void)0);
3150	current = current->next)
3151	{
3152	#ifdef COFF_IMAGE_WITH_PE
3153	/* With PE we have to pad each section to be a multiple of its
3154	page size too, and remember both sizes. */
3155	if (coff_section_data (abfd, current)((struct coff_section_tdata ) (current)->used_by_bfd) == NULL((void)0))
3156	{
3157	bfd_size_type amt = sizeof (struct coff_section_tdata);
3158	current->used_by_bfd = (PTRvoid *) bfd_zalloc (abfd, amt);
3159	if (current->used_by_bfd == NULL((void*)0))
3160	return FALSE0;
3161	}
3162	if (pei_section_data (abfd, current)((struct pei_section_tdata ) ((struct coff_section_tdata ) ( (current))->used_by_bfd)->tdata) == NULL((void*)0))
3163	{
3164	bfd_size_type amt = sizeof (struct pei_section_tdata);
3165	coff_section_data (abfd, current)((struct coff_section_tdata *) (current)->used_by_bfd)->tdata
3166	= (PTRvoid *) bfd_zalloc (abfd, amt);
3167	if (coff_section_data (abfd, current)((struct coff_section_tdata ) (current)->used_by_bfd)->tdata == NULL((void)0))
3168	return FALSE0;
3169	}
3170	if (pei_section_data (abfd, current)((struct pei_section_tdata ) ((struct coff_section_tdata ) ( (current))->used_by_bfd)->tdata)->virt_size == 0)
3171	pei_section_data (abfd, current)((struct pei_section_tdata ) ((struct coff_section_tdata ) ( (current))->used_by_bfd)->tdata)->virt_size = current->_raw_size;
3172	#endif
3173
3174	/* Only deal with sections which have contents. */
3175	if (!(current->flags & SEC_HAS_CONTENTS0x200))
3176	continue;
3177
3178	#ifdef COFF_IMAGE_WITH_PE
3179	/* Make sure we skip empty sections in a PE image. */
3180	if (current->_raw_size == 0)
3181	continue;
3182	#endif
3183
3184	/* Align the sections in the file to the same boundary on
3185	which they are aligned in virtual memory. I960 doesn't
3186	do this (FIXME) so we can stay in sync with Intel. 960
3187	doesn't yet page from files... */
3188	#ifdef ALIGN_SECTIONS_IN_FILE
3189	if ((abfd->flags & EXEC_P0x02) != 0)
3190	{
3191	/* Make sure this section is aligned on the right boundary - by
3192	padding the previous section up if necessary. */
3193
3194	old_sofar = sofar;
3195	#ifdef RS6000COFF_C
3196	/* AIX loader checks the text section alignment of (vma - filepos)
3197	So even though the filepos may be aligned wrt the o_algntext, for
3198	AIX executables, this check fails. This shows up when a native
3199	AIX executable is stripped with gnu strip because the default vma
3200	of native is 0x10000150 but default for gnu is 0x10000140. Gnu
3201	stripped gnu excutable passes this check because the filepos is
3202	0x0140. This problem also show up with 64 bit shared objects. The
3203	data section must also be aligned. */
3204	if (!strcmp (current->name, _TEXT".text")
3205	\|\| !strcmp (current->name, _DATA".data"))
3206	{
3207	bfd_vma pad;
3208	bfd_vma align;
3209
3210	sofar = BFD_ALIGN (sofar, 1 << current->alignment_power)((((bfd_vma) (sofar) + (1 << current->alignment_power ) - 1) >= (bfd_vma) (sofar)) ? (((bfd_vma) (sofar) + ((1 << current->alignment_power) - 1)) & ~ (bfd_vma) ((1 << current->alignment_power)-1)) : ~ (bfd_vma) 0);
3211
3212	align = 1 << current->alignment_power;
3213	pad = abs (current->vma - sofar) % align;
3214
3215	if (pad)
3216	{
3217	pad = align - pad;
3218	sofar += pad;
3219	}
3220	}
3221	else
3222	#else
3223	{
3224	sofar = BFD_ALIGN (sofar, 1 << current->alignment_power)((((bfd_vma) (sofar) + (1 << current->alignment_power ) - 1) >= (bfd_vma) (sofar)) ? (((bfd_vma) (sofar) + ((1 << current->alignment_power) - 1)) & ~ (bfd_vma) ((1 << current->alignment_power)-1)) : ~ (bfd_vma) 0);
3225	}
3226	#endif
3227	if (previous != (asection ) NULL((void)0))
3228	previous->_raw_size += sofar - old_sofar;
3229	}
3230
3231	#endif
3232
3233	/* In demand paged files the low order bits of the file offset
3234	must match the low order bits of the virtual address. */
3235	#ifdef COFF_PAGE_SIZE0x1000
3236	if ((abfd->flags & D_PAGED0x100) != 0
3237	&& (current->flags & SEC_ALLOC0x001) != 0)
3238	sofar += (current->vma - sofar) % page_size;
3239	#endif
3240	current->filepos = sofar;
3241
3242	#ifdef COFF_IMAGE_WITH_PE
3243	/* Set the padded size. */
3244	current->_raw_size = (current->_raw_size + page_size -1) & -page_size;
3245	#endif
3246
3247	sofar += current->_raw_size;
3248
3249	#ifdef ALIGN_SECTIONS_IN_FILE
3250	/* Make sure that this section is of the right size too. */
3251	if ((abfd->flags & EXEC_P0x02) == 0)
3252	{
3253	bfd_size_type old_size;
3254
3255	old_size = current->_raw_size;
3256	current->_raw_size = BFD_ALIGN (current->_raw_size,((((bfd_vma) (current->_raw_size) + (1 << current-> alignment_power) - 1) >= (bfd_vma) (current->_raw_size) ) ? (((bfd_vma) (current->_raw_size) + ((1 << current ->alignment_power) - 1)) & ~ (bfd_vma) ((1 << current ->alignment_power)-1)) : ~ (bfd_vma) 0)
3257	1 << current->alignment_power)((((bfd_vma) (current->_raw_size) + (1 << current-> alignment_power) - 1) >= (bfd_vma) (current->_raw_size) ) ? (((bfd_vma) (current->_raw_size) + ((1 << current ->alignment_power) - 1)) & ~ (bfd_vma) ((1 << current ->alignment_power)-1)) : ~ (bfd_vma) 0);
3258	align_adjust = current->_raw_size != old_size;
3259	sofar += current->_raw_size - old_size;
3260	}
3261	else
3262	{
3263	old_sofar = sofar;
3264	sofar = BFD_ALIGN (sofar, 1 << current->alignment_power)((((bfd_vma) (sofar) + (1 << current->alignment_power ) - 1) >= (bfd_vma) (sofar)) ? (((bfd_vma) (sofar) + ((1 << current->alignment_power) - 1)) & ~ (bfd_vma) ((1 << current->alignment_power)-1)) : ~ (bfd_vma) 0);
3265	align_adjust = sofar != old_sofar;
3266	current->_raw_size += sofar - old_sofar;
3267	}
3268	#endif
3269
3270	#ifdef COFF_IMAGE_WITH_PE
3271	/* For PE we need to make sure we pad out to the aligned
3272	_raw_size, in case the caller only writes out data to the
3273	unaligned _raw_size. */
3274	if (pei_section_data (abfd, current)((struct pei_section_tdata ) ((struct coff_section_tdata ) ( (current))->used_by_bfd)->tdata)->virt_size < current->_raw_size)
3275	align_adjust = TRUE1;
3276	#endif
3277
3278	#ifdef _LIB".lib"
3279	/* Force .lib sections to start at zero. The vma is then
3280	incremented in coff_set_section_contents. This is right for
3281	SVR3.2. */
3282	if (strcmp (current->name, _LIB".lib") == 0)
3283	bfd_set_section_vma (abfd, current, 0)(((current)->vma = (current)->lma = (0)), ((current)-> user_set_vma = 1), 1);
3284	#endif
3285
3286	previous = current;
3287	}
3288
3289	/* It is now safe to write to the output file. If we needed an
3290	alignment adjustment for the last section, then make sure that
3291	there is a byte at offset sofar. If there are no symbols and no
3292	relocs, then nothing follows the last section. If we don't force
3293	the last byte out, then the file may appear to be truncated. */
3294	if (align_adjust)
3295	{
3296	bfd_byte b;
3297
3298	b = 0;
3299	if (bfd_seek (abfd, sofar - 1, SEEK_SET0) != 0
3300	\|\| bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
3301	return FALSE0;
3302	}
3303
3304	/* Make sure the relocations are aligned. We don't need to make
3305	sure that this byte exists, because it will only matter if there
3306	really are relocs. */
3307	sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER)((((bfd_vma) (sofar) + (1 << (2)) - 1) >= (bfd_vma) ( sofar)) ? (((bfd_vma) (sofar) + ((1 << (2)) - 1)) & ~ (bfd_vma) ((1 << (2))-1)) : ~ (bfd_vma) 0);
3308
3309	obj_relocbase (abfd)(((abfd)->tdata.coff_obj_data)->relocbase) = sofar;
3310	abfd->output_has_begun = TRUE1;
3311
3312	return TRUE1;
3313	}
3314
3315	#if 0
3316
3317	/* This can never work, because it is called too late--after the
3318	section positions have been set. I can't figure out what it is
3319	for, so I am going to disable it--Ian Taylor 20 March 1996. */
3320
3321	/* If .file, .text, .data, .bss symbols are missing, add them. */
3322	/* @@ Should we only be adding missing symbols, or overriding the aux
3323	values for existing section symbols? */
3324	static bfd_boolean
3325	coff_add_missing_symbols (abfd)
3326	bfd *abfd;
3327	{
3328	unsigned int nsyms = bfd_get_symcount (abfd)((abfd)->symcount);
3329	asymbol **sympp = abfd->outsymbols;
3330	asymbol **sympp2;
3331	unsigned int i;
3332	int need_text = 1, need_data = 1, need_bss = 1, need_file = 1;
3333	bfd_size_type amt;
3334
3335	for (i = 0; i < nsyms; i++)
3336	{
3337	coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
3338	const char *name;
3339
3340	if (csym)
3341	{
3342	/* Only do this if there is a coff representation of the input
3343	symbol. */
3344	if (csym->native && csym->native->u.syment.n_sclass == C_FILE103)
3345	{
3346	need_file = 0;
3347	continue;
3348	}
3349	name = csym->symbol.name;
3350	if (!name)
3351	continue;
3352	if (!strcmp (name, _TEXT".text"))
3353	need_text = 0;
3354	#ifdef APOLLO_M68
3355	else if (!strcmp (name, ".wtext"))
3356	need_text = 0;
3357	#endif
3358	else if (!strcmp (name, _DATA".data"))
3359	need_data = 0;
3360	else if (!strcmp (name, _BSS".bss"))
3361	need_bss = 0;
3362	}
3363	}
3364	/* Now i == bfd_get_symcount (abfd). */
3365	/* @@ For now, don't deal with .file symbol. */
3366	need_file = 0;
3367
3368	if (!need_text && !need_data && !need_bss && !need_file)
3369	return TRUE1;
3370	nsyms += need_text + need_data + need_bss + need_file;
3371	amt = nsyms;
3372	amt = sizeof (asymbol );
3373	sympp2 = (asymbol **) bfd_alloc (abfd, amt);
3374	if (!sympp2)
3375	return FALSE0;
3376	memcpy (sympp2, sympp, i * sizeof (asymbol *));
3377
3378	if (need_file)
3379	/* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
3380	abort ()_bfd_abort ("/usr/src/gnu/usr.bin/binutils/bfd/coffcode.h", 3380 , __PRETTY_FUNCTION__);
3381
3382	if (need_text)
3383	sympp2[i++] = coff_section_symbol (abfd, _TEXT".text");
3384	if (need_data)
3385	sympp2[i++] = coff_section_symbol (abfd, _DATA".data");
3386	if (need_bss)
3387	sympp2[i++] = coff_section_symbol (abfd, _BSS".bss");
3388	BFD_ASSERT (i == nsyms){ if (!(i == nsyms)) bfd_assert("/usr/src/gnu/usr.bin/binutils/bfd/coffcode.h" ,3388); };
3389	bfd_set_symtab (abfd, sympp2, nsyms);
3390	return TRUE1;
3391	}
3392
3393	#endif /* 0 */
3394
3395	#ifdef COFF_IMAGE_WITH_PE
3396
3397	static unsigned int pelength;
3398	static unsigned int peheader;
3399
3400	static bfd_boolean
3401	coff_read_word (abfd, value)
3402	bfd *abfd;
3403	unsigned int *value;
3404	{
3405	unsigned char b[2];
3406	int status;
3407
3408	status = bfd_bread (b, (bfd_size_type) 2, abfd);
3409	if (status < 1)
3410	{
3411	*value = 0;
3412	return FALSE0;
3413	}
3414
3415	if (status == 1)
3416	*value = (unsigned int) b[0];
3417	else
3418	*value = (unsigned int) (b[0] + (b[1] << 8));
3419
3420	pelength += (unsigned int) status;
3421
3422	return TRUE1;
3423	}
3424
3425	static unsigned int
3426	coff_compute_checksum (abfd)
3427	bfd *abfd;
3428	{
3429	bfd_boolean more_data;
3430	file_ptr filepos;
3431	unsigned int value;
3432	unsigned int total;
3433
3434	total = 0;
3435	pelength = 0;
3436	filepos = (file_ptr) 0;
3437
3438	do
3439	{
3440	if (bfd_seek (abfd, filepos, SEEK_SET0) != 0)
3441	return 0;
3442
3443	more_data = coff_read_word (abfd, &value);
3444	total += value;
3445	total = 0xffff & (total + (total >> 0x10));
3446	filepos += 2;
3447	}
3448	while (more_data);
3449
3450	return (0xffff & (total + (total >> 0x10)));
3451	}
3452
3453	static bfd_boolean
3454	coff_apply_checksum (abfd)
3455	bfd *abfd;
3456	{
3457	unsigned int computed;
3458	unsigned int checksum = 0;
3459
3460	if (bfd_seek (abfd, 0x3c, SEEK_SET0) != 0)
3461	return FALSE0;
3462
3463	if (!coff_read_word (abfd, &peheader))
3464	return FALSE0;
3465
3466	if (bfd_seek (abfd, peheader + 0x58, SEEK_SET0) != 0)
3467	return FALSE0;
3468
3469	checksum = 0;
3470	bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
3471
3472	if (bfd_seek (abfd, peheader, SEEK_SET0) != 0)
3473	return FALSE0;
3474
3475	computed = coff_compute_checksum (abfd);
3476
3477	checksum = computed + pelength;
3478
3479	if (bfd_seek (abfd, peheader + 0x58, SEEK_SET0) != 0)
3480	return FALSE0;
3481
3482	bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
3483
3484	return TRUE1;
3485	}
3486
3487	#endif /* COFF_IMAGE_WITH_PE */
3488
3489	/* SUPPRESS 558 */
3490	/* SUPPRESS 529 */
3491	static bfd_boolean
3492	coff_write_object_contents (abfd)
3493	bfd * abfd;
3494	{
3495	asection *current;
3496	bfd_boolean hasrelocs = FALSE0;
3497	bfd_boolean haslinno = FALSE0;
3498	bfd_boolean hasdebug = FALSE0;
3499	file_ptr scn_base;
3500	file_ptr reloc_base;
3501	file_ptr lineno_base;
3502	file_ptr sym_base;
3503	unsigned long reloc_size = 0, reloc_count = 0;
3504	unsigned long lnno_size = 0;
3505	bfd_boolean long_section_names;
3506	asection text_sec = NULL((void)0);
3507	asection data_sec = NULL((void)0);
3508	asection bss_sec = NULL((void)0);
3509	struct internal_filehdr internal_f;
3510	struct internal_aouthdr internal_a;
3511	#ifdef COFF_LONG_SECTION_NAMES
3512	size_t string_size = STRING_SIZE_SIZE(4);
3513	#endif
3514
3515	bfd_set_error (bfd_error_system_call);
3516
3517	/* Make a pass through the symbol table to count line number entries and
3518	put them into the correct asections. */
3519
3520	lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_linesz);
3521
3522	if (! abfd->output_has_begun)
3523	{
3524	if (! coff_compute_section_file_positions (abfd))
3525	return FALSE0;
3526	}
3527
3528	reloc_base = obj_relocbase (abfd)(((abfd)->tdata.coff_obj_data)->relocbase);
3529
3530	/* Work out the size of the reloc and linno areas. */
3531
3532	for (current = abfd->sections; current != NULL((void*)0); current =
3533	current->next)
3534	{
3535	#ifdef COFF_WITH_PE
3536	/* We store the actual reloc count in the first reloc's addr. */
3537	if (obj_pe (abfd)(((abfd)->tdata.coff_obj_data)->pe) && current->reloc_count >= 0xffff)
3538	reloc_count ++;
3539	#endif
3540	reloc_count += current->reloc_count;
3541	}
3542
3543	reloc_size = reloc_count * bfd_coff_relsz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_relsz);
3544
3545	lineno_base = reloc_base + reloc_size;
3546	sym_base = lineno_base + lnno_size;
3547
3548	/* Indicate in each section->line_filepos its actual file address. */
3549	for (current = abfd->sections; current != NULL((void*)0); current =
3550	current->next)
3551	{
3552	if (current->lineno_count)
3553	{
3554	current->line_filepos = lineno_base;
3555	current->moving_line_filepos = lineno_base;
3556	lineno_base += current->lineno_count * bfd_coff_linesz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_linesz);
3557	}
3558	else
3559	{
3560	current->line_filepos = 0;
3561	}
3562	if (current->reloc_count)
3563	{
3564	current->rel_filepos = reloc_base;
3565	reloc_base += current->reloc_count * bfd_coff_relsz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_relsz);
3566	#ifdef COFF_WITH_PE
3567	/* Extra reloc to hold real count. */
3568	if (obj_pe (abfd)(((abfd)->tdata.coff_obj_data)->pe) && current->reloc_count >= 0xffff)
3569	reloc_base += bfd_coff_relsz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_relsz);
3570	#endif
3571	}
3572	else
3573	{
3574	current->rel_filepos = 0;
3575	}
3576	}
3577
3578	/* Write section headers to the file. */
3579	internal_f.f_nscns = 0;
3580
3581	if ((abfd->flags & EXEC_P0x02) != 0)
3582	scn_base = bfd_coff_filhsz (abfd)(((bfd_coff_backend_data ) (abfd)->xvec->backend_data) ->_bfd_filhsz) + bfd_coff_aoutsz (abfd)(((bfd_coff_backend_data ) (abfd)->xvec->backend_data) ->_bfd_aoutsz);
3583	else
3584	{
3585	scn_base = bfd_coff_filhsz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_filhsz);
3586	#ifdef RS6000COFF_C
3587	#ifndef XCOFF64
3588	if (xcoff_data (abfd)((abfd)->tdata.xcoff_obj_data)->full_aouthdr)
3589	scn_base += bfd_coff_aoutsz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_aoutsz);
3590	else
3591	scn_base += SMALL_AOUTSZ;
3592	#endif
3593	#endif
3594	}
3595
3596	if (bfd_seek (abfd, scn_base, SEEK_SET0) != 0)
3597	return FALSE0;
3598
3599	long_section_names = FALSE0;
3600	for (current = abfd->sections;
3601	current != NULL((void*)0);
3602	current = current->next)
3603	{
3604	struct internal_scnhdr section;
3605	bfd_boolean is_reloc_section = FALSE0;
3606
3607	#ifdef COFF_IMAGE_WITH_PE
3608	if (strcmp (current->name, ".reloc") == 0)
3609	{
3610	is_reloc_section = TRUE1;
3611	hasrelocs = TRUE1;
3612	pe_data (abfd)((abfd)->tdata.pe_obj_data)->has_reloc_section = 1;
3613	}
3614	#endif
3615
3616	internal_f.f_nscns++;
3617
3618	strncpy (section.s_name, current->name, SCNNMLEN(8));
3619
3620	#ifdef COFF_LONG_SECTION_NAMES
3621	/* Handle long section names as in PE. This must be compatible
3622	with the code in coff_write_symbols and _bfd_coff_final_link. */
3623	{
3624	size_t len;
3625
3626	len = strlen (current->name);
3627	if (len > SCNNMLEN(8))
3628	{
3629	memset (section.s_name, 0, SCNNMLEN(8));
3630	sprintf (section.s_name, "/%lu", (unsigned long) string_size);
3631	string_size += len + 1;
3632	long_section_names = TRUE1;
3633	}
3634	}
3635	#endif
3636
3637	#ifdef _LIB".lib"
3638	/* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3639	Ian Taylor <ian@cygnus.com>. */
3640	if (strcmp (current->name, _LIB".lib") == 0)
3641	section.s_vaddr = 0;
3642	else
3643	#endif
3644	section.s_vaddr = current->vma;
3645	section.s_paddr = current->lma;
3646	section.s_size = current->_raw_size;
3647	#ifdef coff_get_section_load_page
3648	section.s_page = coff_get_section_load_page (current);
3649	#endif
3650
3651	#ifdef COFF_WITH_PE
3652	section.s_paddr = 0;
3653	#endif
3654	#ifdef COFF_IMAGE_WITH_PE
3655	/* Reminder: s_paddr holds the virtual size of the section. */
3656	if (coff_section_data (abfd, current)((struct coff_section_tdata ) (current)->used_by_bfd) != NULL((void)0)
3657	&& pei_section_data (abfd, current)((struct pei_section_tdata ) ((struct coff_section_tdata ) ( (current))->used_by_bfd)->tdata) != NULL((void*)0))
3658	section.s_paddr = pei_section_data (abfd, current)((struct pei_section_tdata ) ((struct coff_section_tdata ) ( (current))->used_by_bfd)->tdata)->virt_size;
3659	else
3660	section.s_paddr = 0;
3661	#endif
3662
3663	/* If this section has no size or is unloadable then the scnptr
3664	will be 0 too. */
3665	if (current->_raw_size == 0 \|\|
3666	(current->flags & (SEC_LOAD0x002 \| SEC_HAS_CONTENTS0x200)) == 0)
3667	section.s_scnptr = 0;
3668	else
3669	section.s_scnptr = current->filepos;
3670
3671	section.s_relptr = current->rel_filepos;
3672	section.s_lnnoptr = current->line_filepos;
3673	section.s_nreloc = current->reloc_count;
3674	section.s_nlnno = current->lineno_count;
3675	#ifndef COFF_IMAGE_WITH_PE
3676	/* In PEI, relocs come in the .reloc section. */
3677	if (current->reloc_count != 0)
3678	hasrelocs = TRUE1;
3679	#endif
3680	if (current->lineno_count != 0)
3681	haslinno = TRUE1;
3682	if ((current->flags & SEC_DEBUGGING0x10000) != 0
3683	&& ! is_reloc_section)
3684	hasdebug = TRUE1;
3685
3686	#ifdef RS6000COFF_C
3687	#ifndef XCOFF64
3688	/* Indicate the use of an XCOFF overflow section header. */
3689	if (current->reloc_count >= 0xffff \|\| current->lineno_count >= 0xffff)
3690	{
3691	section.s_nreloc = 0xffff;
3692	section.s_nlnno = 0xffff;
3693	}
3694	#endif
3695	#endif
3696
3697	section.s_flags = sec_to_styp_flags (current->name, current->flags);
3698
3699	if (!strcmp (current->name, _TEXT".text"))
3700	text_sec = current;
3701	else if (!strcmp (current->name, _DATA".data"))
3702	data_sec = current;
3703	else if (!strcmp (current->name, _BSS".bss"))
3704	bss_sec = current;
3705
3706	#ifdef I960
3707	section.s_align = (current->alignment_power
3708	? 1 << current->alignment_power
3709	: 0);
3710	#endif
3711	#ifdef TIC80COFF
3712	/* TI COFF puts the alignment power in bits 8-11 of the flags. */
3713	section.s_flags \|= (current->alignment_power & 0xF) << 8;
3714	#endif
3715	#ifdef COFF_ENCODE_ALIGNMENT
3716	COFF_ENCODE_ALIGNMENT(section, current->alignment_power);
3717	#endif
3718
3719	#ifdef COFF_IMAGE_WITH_PE
3720	/* Suppress output of the sections if they are null. ld
3721	includes the bss and data sections even if there is no size
3722	assigned to them. NT loader doesn't like it if these section
3723	headers are included if the sections themselves are not
3724	needed. See also coff_compute_section_file_positions. */
3725	if (section.s_size == 0)
3726	internal_f.f_nscns--;
3727	else
3728	#endif
3729	{
3730	SCNHDRstruct external_scnhdr buff;
3731	bfd_size_type amt = bfd_coff_scnhsz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_scnhsz);
3732
3733	if (coff_swap_scnhdr_out (abfd, &section, &buff) == 0
3734	\|\| bfd_bwrite ((PTRvoid *) &buff, amt, abfd) != amt)
3735	return FALSE0;
3736	}
3737
3738	#ifdef COFF_WITH_PE
3739	/* PE stores COMDAT section information in the symbol table. If
3740	this section is supposed to have some COMDAT info, track down
3741	the symbol in the symbol table and modify it. */
3742	if ((current->flags & SEC_LINK_ONCE0x100000) != 0)
3743	{
3744	unsigned int i, count;
3745	asymbol **psym;
3746	coff_symbol_type csym = NULL((void)0);
3747	asymbol **psymsec;
3748
3749	psymsec = NULL((void*)0);
3750	count = bfd_get_symcount (abfd)((abfd)->symcount);
3751	for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++)
3752	{
3753	if ((*psym)->section != current)
3754	continue;
3755
3756	/* Remember the location of the first symbol in this
3757	section. */
3758	if (psymsec == NULL((void*)0))
3759	psymsec = psym;
3760
3761	/* See if this is the section symbol. */
3762	if (strcmp ((*psym)->name, current->name) == 0)
3763	{
3764	csym = coff_symbol_from (abfd, *psym);
3765	if (csym == NULL((void*)0)
3766	\|\| csym->native == NULL((void*)0)
3767	\|\| csym->native->u.syment.n_numaux < 1
3768	\|\| csym->native->u.syment.n_sclass != C_STAT3
3769	\|\| csym->native->u.syment.n_type != T_NULL0)
3770	continue;
3771
3772	/* Here PSYM is the section symbol for CURRENT. /
3773
3774	break;
3775	}
3776	}
3777
3778	/* Did we find it?
3779	Note that we might not if we're converting the file from
3780	some other object file format. */
3781	if (i < count)
3782	{
3783	combined_entry_type *aux;
3784
3785	/* We don't touch the x_checksum field. The
3786	x_associated field is not currently supported. */
3787
3788	aux = csym->native + 1;
3789	switch (current->flags & SEC_LINK_DUPLICATES0x600000)
3790	{
3791	case SEC_LINK_DUPLICATES_DISCARD0x0:
3792	aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY;
3793	break;
3794
3795	case SEC_LINK_DUPLICATES_ONE_ONLY0x200000:
3796	aux->u.auxent.x_scn.x_comdat =
3797	IMAGE_COMDAT_SELECT_NODUPLICATES;
3798	break;
3799
3800	case SEC_LINK_DUPLICATES_SAME_SIZE0x400000:
3801	aux->u.auxent.x_scn.x_comdat =
3802	IMAGE_COMDAT_SELECT_SAME_SIZE;
3803	break;
3804
3805	case SEC_LINK_DUPLICATES_SAME_CONTENTS0x600000:
3806	aux->u.auxent.x_scn.x_comdat =
3807	IMAGE_COMDAT_SELECT_EXACT_MATCH;
3808	break;
3809	}
3810
3811	/* The COMDAT symbol must be the first symbol from this
3812	section in the symbol table. In order to make this
3813	work, we move the COMDAT symbol before the first
3814	symbol we found in the search above. It's OK to
3815	rearrange the symbol table at this point, because
3816	coff_renumber_symbols is going to rearrange it
3817	further and fix up all the aux entries. */
3818	if (psym != psymsec)
3819	{
3820	asymbol *hold;
3821	asymbol **pcopy;
3822
3823	hold = *psym;
3824	for (pcopy = psym; pcopy > psymsec; pcopy--)
3825	pcopy[0] = pcopy[-1];
3826	*psymsec = hold;
3827	}
3828	}
3829	}
3830	#endif /* COFF_WITH_PE */
3831	}
3832
3833	#ifdef RS6000COFF_C
3834	#ifndef XCOFF64
3835	/* XCOFF handles overflows in the reloc and line number count fields
3836	by creating a new section header to hold the correct values. */
3837	for (current = abfd->sections; current != NULL((void*)0); current = current->next)
3838	{
3839	if (current->reloc_count >= 0xffff \|\| current->lineno_count >= 0xffff)
3840	{
3841	struct internal_scnhdr scnhdr;
3842	SCNHDRstruct external_scnhdr buff;
3843	bfd_size_type amt;
3844
3845	internal_f.f_nscns++;
3846	strncpy (&(scnhdr.s_name[0]), current->name, 8);
3847	scnhdr.s_paddr = current->reloc_count;
3848	scnhdr.s_vaddr = current->lineno_count;
3849	scnhdr.s_size = 0;
3850	scnhdr.s_scnptr = 0;
3851	scnhdr.s_relptr = current->rel_filepos;
3852	scnhdr.s_lnnoptr = current->line_filepos;
3853	scnhdr.s_nreloc = current->target_index;
3854	scnhdr.s_nlnno = current->target_index;
3855	scnhdr.s_flags = STYP_OVRFLO;
3856	amt = bfd_coff_scnhsz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_scnhsz);
3857	if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
3858	\|\| bfd_bwrite ((PTRvoid *) &buff, amt, abfd) != amt)
3859	return FALSE0;
3860	}
3861	}
3862	#endif
3863	#endif
3864
3865	/* OK, now set up the filehdr... */
3866
3867	/* Don't include the internal abs section in the section count */
3868
3869	/* We will NOT put a fucking timestamp in the header here. Every time you
3870	put it back, I will come in and take it out again. I'm sorry. This
3871	field does not belong here. We fill it with a 0 so it compares the
3872	same but is not a reasonable time. -- gnu@cygnus.com */
3873	internal_f.f_timdat = 0;
3874	internal_f.f_flags = 0;
3875
3876	if (abfd->flags & EXEC_P0x02)
3877	internal_f.f_opthdr = bfd_coff_aoutsz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_aoutsz);
3878	else
3879	{
3880	internal_f.f_opthdr = 0;
3881	#ifdef RS6000COFF_C
3882	#ifndef XCOFF64
3883	if (xcoff_data (abfd)((abfd)->tdata.xcoff_obj_data)->full_aouthdr)
3884	internal_f.f_opthdr = bfd_coff_aoutsz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_aoutsz);
3885	else
3886	internal_f.f_opthdr = SMALL_AOUTSZ;
3887	#endif
3888	#endif
3889	}
3890
3891	if (!hasrelocs)
3892	internal_f.f_flags \|= F_RELFLG(0x0001);
3893	if (!haslinno)
3894	internal_f.f_flags \|= F_LNNO(0x0004);
3895	if (abfd->flags & EXEC_P0x02)
3896	internal_f.f_flags \|= F_EXEC(0x0002);
3897	#ifdef COFF_IMAGE_WITH_PE
3898	if (! hasdebug)
3899	internal_f.f_flags \|= IMAGE_FILE_DEBUG_STRIPPED;
3900	#endif
3901
3902	#ifndef COFF_WITH_pex64
3903	#ifdef COFF_WITH_PE
3904	internal_f.f_flags \|= IMAGE_FILE_32BIT_MACHINE;
3905	#else
3906	if (bfd_little_endian (abfd)((abfd)->xvec->byteorder == BFD_ENDIAN_LITTLE))
3907	internal_f.f_flags \|= F_AR32WR(0x0100);
3908	else
3909	internal_f.f_flags \|= F_AR32W(0x0200);
3910	#endif
3911	#endif
3912
3913	#ifdef TI_TARGET_ID
3914	/* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
3915	but it doesn't hurt to set it internally. */
3916	internal_f.f_target_id = TI_TARGET_ID;
3917	#endif
3918	#ifdef TIC80_TARGET_ID
3919	internal_f.f_target_id = TIC80_TARGET_ID;
3920	#endif
3921
3922	/* FIXME, should do something about the other byte orders and
3923	architectures. */
3924
3925	#ifdef RS6000COFF_C
3926	if ((abfd->flags & DYNAMIC0x40) != 0)
3927	internal_f.f_flags \|= F_SHROBJ(0x2000);
3928	if (bfd_get_section_by_name (abfd, _LOADER) != NULL((void*)0))
3929	internal_f.f_flags \|= F_DYNLOAD(0x1000);
3930	#endif
3931
3932	memset (&internal_a, 0, sizeof internal_a);
3933
3934	/* Set up architecture-dependent stuff. */
3935	{
3936	unsigned int magic = 0;
3937	unsigned short flags = 0;
3938
3939	coff_set_flags (abfd, &magic, &flags);
3940	internal_f.f_magic = magic;
3941	internal_f.f_flags \|= flags;
3942	/* ...and the "opt"hdr... */
3943
3944	#ifdef A29K
3945	#ifdef ULTRA3 /* NYU's machine */
3946	/* FIXME: This is a bogus check. I really want to see if there
3947	is a .shbss or a .shdata section, if so then set the magic
3948	number to indicate a shared data executable. */
3949	if (internal_f.f_nscns >= 7)
3950	internal_a.magic = SHMAGIC0443; /* Shared magic. */
3951	else
3952	#endif /* ULTRA3 */
3953	internal_a.magic = NMAGIC; /* Assume separate i/d. */
3954	#define __A_MAGIC_SET__
3955	#endif /* A29K */
3956	#ifdef TICOFF_AOUT_MAGIC
3957	internal_a.magic = TICOFF_AOUT_MAGIC;
3958	#define __A_MAGIC_SET__
3959	#endif
3960	#ifdef TIC80COFF
3961	internal_a.magic = TIC80_ARCH_MAGIC;
3962	#define __A_MAGIC_SET__
3963	#endif /* TIC80 */
3964	#ifdef I860
3965	/* FIXME: What are the a.out magic numbers for the i860? */
3966	internal_a.magic = 0;
3967	#define __A_MAGIC_SET__
3968	#endif /* I860 */
3969	#ifdef I960
3970	internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC0404);
3971	#define __A_MAGIC_SET__
3972	#endif /* I960 */
3973	#if M88
3974	#define __A_MAGIC_SET__
3975	internal_a.magic = PAGEMAGICBCS;
3976	#endif /* M88 */
3977
3978	#if APOLLO_M68
3979	#define __A_MAGIC_SET__
3980	internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
3981	#endif
3982
3983	#if defined(M68) \|\| defined(WE32K) \|\| defined(M68K)
3984	#define __A_MAGIC_SET__
3985	#if defined(LYNXOS)
3986	internal_a.magic = LYNXCOFFMAGIC0415;
3987	#else
3988	#if defined(TARG_AUX)
3989	internal_a.magic = (abfd->flags & D_PAGED0x100 ? PAGEMAGICPEXECPAGED :
3990	abfd->flags & WP_TEXT0x80 ? PAGEMAGICPEXECSWAPPED :
3991	PAGEMAGICEXECSWAPPED);
3992	#else
3993	#if defined (PAGEMAGICPEXECPAGED)
3994	internal_a.magic = PAGEMAGICPEXECPAGED;
3995	#endif
3996	#endif /* TARG_AUX */
3997	#endif /* LYNXOS */
3998	#endif /* M68 \|\| WE32K \|\| M68K */
3999
4000	#if defined(ARM)
4001	#define __A_MAGIC_SET__
4002	internal_a.magic = ZMAGIC0413;
4003	#endif
4004
4005	#if defined(PPC_PE)
4006	#define __A_MAGIC_SET__
4007	internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
4008	#endif
4009
4010	#if defined MCORE_PE
4011	#define __A_MAGIC_SET__
4012	internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
4013	#endif
4014
4015	#if defined(I3861)
4016	#define __A_MAGIC_SET__
4017	#if defined(LYNXOS)
4018	internal_a.magic = LYNXCOFFMAGIC0415;
4019	#elif defined AMD64
4020	internal_a.magic = IMAGE_NT_OPTIONAL_HDR64_MAGIC;
4021	#else /* LYNXOS */
4022	internal_a.magic = ZMAGIC0413;
4023	#endif /* LYNXOS */
4024	#endif /* I386 */
4025
4026	#if defined(IA64)
4027	#define __A_MAGIC_SET__
4028	internal_a.magic = ZMAGIC0413;
4029	#endif /* IA64 */
4030
4031	#if defined(SPARC)
4032	#define __A_MAGIC_SET__
4033	#if defined(LYNXOS)
4034	internal_a.magic = LYNXCOFFMAGIC0415;
4035	#endif /* LYNXOS */
4036	#endif /* SPARC */
4037
4038	#ifdef RS6000COFF_C
4039	#define __A_MAGIC_SET__
4040	internal_a.magic = (abfd->flags & D_PAGED0x100) ? RS6K_AOUTHDR_ZMAGIC :
4041	(abfd->flags & WP_TEXT0x80) ? RS6K_AOUTHDR_NMAGIC :
4042	RS6K_AOUTHDR_OMAGIC;
4043	#endif
4044
4045	#if defined(SH) && defined(COFF_WITH_PE)
4046	#define __A_MAGIC_SET__
4047	internal_a.magic = SH_PE_MAGIC;
4048	#endif
4049
4050	#if defined(MIPS) && defined(COFF_WITH_PE)
4051	#define __A_MAGIC_SET__
4052	internal_a.magic = MIPS_PE_MAGIC;
4053	#endif
4054
4055	#ifdef OR32
4056	#define __A_MAGIC_SET__
4057	internal_a.magic = NMAGIC; /* Assume separate i/d. */
4058	#endif
4059
4060	#ifndef __A_MAGIC_SET__
4061	#include "Your aouthdr magic number is not being set!"
4062	#else
4063	#undef __A_MAGIC_SET__
4064	#endif
4065	}
4066
4067	/* FIXME: Does anybody ever set this to another value? */
4068	internal_a.vstamp = 0;
4069
4070	/* Now should write relocs, strings, syms. */
4071	obj_sym_filepos (abfd)(((abfd)->tdata.coff_obj_data)->sym_filepos) = sym_base;
4072
4073	if (bfd_get_symcount (abfd)((abfd)->symcount) != 0)
4074	{
4075	int firstundef;
4076	#if 0
4077	if (!coff_add_missing_symbols (abfd))
4078	return FALSE0;
4079	#endif
4080	if (!coff_renumber_symbols (abfd, &firstundef))
4081	return FALSE0;
4082	coff_mangle_symbols (abfd);
4083	if (! coff_write_symbols (abfd))
4084	return FALSE0;
4085	if (! coff_write_linenumbers (abfd))
4086	return FALSE0;
4087	if (! coff_write_relocs (abfd, firstundef))
4088	return FALSE0;
4089	}
4090	#ifdef COFF_LONG_SECTION_NAMES
4091	else if (long_section_names && ! obj_coff_strings_written (abfd)(((abfd)->tdata.coff_obj_data)->strings_written))
4092	{
4093	/* If we have long section names we have to write out the string
4094	table even if there are no symbols. */
4095	if (! coff_write_symbols (abfd))
4096	return FALSE0;
4097	}
4098	#endif
4099	#ifdef COFF_IMAGE_WITH_PE
4100	#ifdef PPC_PE
4101	else if ((abfd->flags & EXEC_P0x02) != 0)
4102	{
4103	bfd_byte b;
4104
4105	/* PowerPC PE appears to require that all executable files be
4106	rounded up to the page size. */
4107	b = 0;
4108	if (bfd_seek (abfd,
4109	(file_ptr) BFD_ALIGN (sym_base, COFF_PAGE_SIZE)((((bfd_vma) (sym_base) + (0x1000) - 1) >= (bfd_vma) (sym_base )) ? (((bfd_vma) (sym_base) + ((0x1000) - 1)) & ~ (bfd_vma ) ((0x1000)-1)) : ~ (bfd_vma) 0) - 1,
4110	SEEK_SET0) != 0
4111	\|\| bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
4112	return FALSE0;
4113	}
4114	#endif
4115	#endif
4116
4117	/* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
4118	backend linker, and obj_raw_syment_count is not valid until after
4119	coff_write_symbols is called. */
4120	if (obj_raw_syment_count (abfd)(((abfd)->tdata.coff_obj_data)->raw_syment_count) != 0)
4121	{
4122	internal_f.f_symptr = sym_base;
4123	#ifdef RS6000COFF_C
4124	/* AIX appears to require that F_RELFLG not be set if there are
4125	local symbols but no relocations. */
4126	internal_f.f_flags &=~ F_RELFLG(0x0001);
4127	#endif
4128	}
4129	else
4130	{
4131	if (long_section_names)
4132	internal_f.f_symptr = sym_base;
4133	else
4134	internal_f.f_symptr = 0;
4135	internal_f.f_flags \|= F_LSYMS(0x0008);
4136	}
4137
4138	if (text_sec)
4139	{
4140	internal_a.tsize = bfd_get_section_size_before_reloc (text_sec)((text_sec)->_raw_size);
4141	internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
4142	}
4143	if (data_sec)
4144	{
4145	internal_a.dsize = bfd_get_section_size_before_reloc (data_sec)((data_sec)->_raw_size);
4146	internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
4147	}
4148	if (bss_sec)
4149	{
4150	internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec)((bss_sec)->_raw_size);
4151	if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
4152	internal_a.data_start = bss_sec->vma;
4153	}
4154
4155	internal_a.entry = bfd_get_start_address (abfd)((abfd)->start_address);
4156	internal_f.f_nsyms = obj_raw_syment_count (abfd)(((abfd)->tdata.coff_obj_data)->raw_syment_count);
4157
4158	#ifdef RS6000COFF_C
4159	if (xcoff_data (abfd)((abfd)->tdata.xcoff_obj_data)->full_aouthdr)
4160	{
4161	bfd_vma toc;
4162	asection *loader_sec;
4163
4164	internal_a.vstamp = 1;
4165
4166	internal_a.o_snentry = xcoff_data (abfd)((abfd)->tdata.xcoff_obj_data)->snentry;
4167	if (internal_a.o_snentry == 0)
4168	internal_a.entry = (bfd_vma) -1;
4169
4170	if (text_sec != NULL((void*)0))
4171	{
4172	internal_a.o_sntext = text_sec->target_index;
4173	internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec)((text_sec)->alignment_power + 0);
4174	}
4175	else
4176	{
4177	internal_a.o_sntext = 0;
4178	internal_a.o_algntext = 0;
4179	}
4180	if (data_sec != NULL((void*)0))
4181	{
4182	internal_a.o_sndata = data_sec->target_index;
4183	internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec)((data_sec)->alignment_power + 0);
4184	}
4185	else
4186	{
4187	internal_a.o_sndata = 0;
4188	internal_a.o_algndata = 0;
4189	}
4190	loader_sec = bfd_get_section_by_name (abfd, ".loader");
4191	if (loader_sec != NULL((void*)0))
4192	internal_a.o_snloader = loader_sec->target_index;
4193	else
4194	internal_a.o_snloader = 0;
4195	if (bss_sec != NULL((void*)0))
4196	internal_a.o_snbss = bss_sec->target_index;
4197	else
4198	internal_a.o_snbss = 0;
4199
4200	toc = xcoff_data (abfd)((abfd)->tdata.xcoff_obj_data)->toc;
4201	internal_a.o_toc = toc;
4202	internal_a.o_sntoc = xcoff_data (abfd)((abfd)->tdata.xcoff_obj_data)->sntoc;
4203
4204	internal_a.o_modtype = xcoff_data (abfd)((abfd)->tdata.xcoff_obj_data)->modtype;
4205	if (xcoff_data (abfd)((abfd)->tdata.xcoff_obj_data)->cputype != -1)
4206	internal_a.o_cputype = xcoff_data (abfd)((abfd)->tdata.xcoff_obj_data)->cputype;
4207	else
4208	{
4209	switch (bfd_get_arch (abfd))
4210	{
4211	case bfd_arch_rs6000:
4212	internal_a.o_cputype = 4;
4213	break;
4214	case bfd_arch_powerpc:
4215	if (bfd_get_mach (abfd) == bfd_mach_ppc32)
4216	internal_a.o_cputype = 3;
4217	else
4218	internal_a.o_cputype = 1;
4219	break;
4220	default:
4221	abort ()_bfd_abort ("/usr/src/gnu/usr.bin/binutils/bfd/coffcode.h", 4221 , __PRETTY_FUNCTION__);
4222	}
4223	}
4224	internal_a.o_maxstack = xcoff_data (abfd)((abfd)->tdata.xcoff_obj_data)->maxstack;
4225	internal_a.o_maxdata = xcoff_data (abfd)((abfd)->tdata.xcoff_obj_data)->maxdata;
4226	}
4227	#endif
4228
4229	/* now write them */
4230	if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET0) != 0)
4231	return FALSE0;
4232
4233	{
4234	char * buff;
4235	bfd_size_type amount = bfd_coff_filhsz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_filhsz);
4236
4237	buff = bfd_malloc (amount);
4238	if (buff == NULL((void*)0))
4239	return FALSE0;
4240
4241	bfd_coff_swap_filehdr_out (abfd, (PTR) &internal_f, (PTR) buff)((((bfd_coff_backend_data ) (abfd)->xvec->backend_data )->_bfd_coff_swap_filehdr_out) (abfd, (void ) &internal_f , (void *) buff));
4242	amount = bfd_bwrite ((PTRvoid *) buff, amount, abfd);
4243
4244	free (buff);
4245
4246	if (amount != bfd_coff_filhsz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_filhsz))
4247	return FALSE0;
4248	}
4249
4250	if (abfd->flags & EXEC_P0x02)
4251	{
4252	/* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4253	include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4254	char * buff;
4255	bfd_size_type amount = bfd_coff_aoutsz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_aoutsz);
4256
4257	buff = bfd_malloc (amount);
4258	if (buff == NULL((void*)0))
4259	return FALSE0;
4260
4261	coff_swap_aouthdr_out (abfd, (PTRvoid ) &internal_a, (PTRvoid ) buff);
4262	amount = bfd_bwrite ((PTRvoid *) buff, amount, abfd);
4263
4264	free (buff);
4265
4266	if (amount != bfd_coff_aoutsz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_aoutsz))
4267	return FALSE0;
4268
4269	#ifdef COFF_IMAGE_WITH_PE
4270	if (! coff_apply_checksum (abfd))
4271	return FALSE0;
4272	#endif
4273	}
4274	#ifdef RS6000COFF_C
4275	else
4276	{
4277	AOUTHDR buff;
4278	size_t size;
4279
4280	/* XCOFF seems to always write at least a small a.out header. */
4281	coff_swap_aouthdr_out (abfd, (PTRvoid ) &internal_a, (PTRvoid ) &buff);
4282	if (xcoff_data (abfd)((abfd)->tdata.xcoff_obj_data)->full_aouthdr)
4283	size = bfd_coff_aoutsz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_aoutsz);
4284	else
4285	size = SMALL_AOUTSZ;
4286	if (bfd_bwrite ((PTRvoid *) &buff, (bfd_size_type) size, abfd) != size)
4287	return FALSE0;
4288	}
4289	#endif
4290
4291	return TRUE1;
4292	}
4293
4294	static bfd_boolean
4295	coff_set_section_contents (abfd, section, location, offset, count)
4296	bfd * abfd;
4297	sec_ptr section;
4298	const PTRvoid * location;
4299	file_ptr offset;
4300	bfd_size_type count;
4301	{
4302	if (! abfd->output_has_begun) /* Set by bfd.c handler. */
4303	{
4304	if (! coff_compute_section_file_positions (abfd))
4305	return FALSE0;
4306	}
4307
4308	#if defined(_LIB".lib") && !defined(TARG_AUX)
4309
4310	/* The physical address field of a .lib section is used to hold the
4311	number of shared libraries in the section. This code counts the
4312	number of sections being written, and increments the lma field
4313	with the number.
4314
4315	I have found no documentation on the contents of this section.
4316	Experimentation indicates that the section contains zero or more
4317	records, each of which has the following structure:
4318
4319	- a (four byte) word holding the length of this record, in words,
4320	- a word that always seems to be set to "2",
4321	- the path to a shared library, null-terminated and then padded
4322	to a whole word boundary.
4323
4324	bfd_assert calls have been added to alert if an attempt is made
4325	to write a section which doesn't follow these assumptions. The
4326	code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4327	<robertl@arnet.com> (Thanks!).
4328
4329	Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4330
4331	if (strcmp (section->name, _LIB".lib") == 0)
4332	{
4333	bfd_byte rec, recend;
4334
4335	rec = (bfd_byte *) location;
4336	recend = rec + count;
4337	while (rec < recend)
4338	{
4339	++section->lma;
4340	rec += bfd_get_32 (abfd, rec)((((abfd)->xvec->bfd_getx32)) (rec)) 4;
4341	}
4342
4343	BFD_ASSERT (rec == recend){ if (!(rec == recend)) bfd_assert("/usr/src/gnu/usr.bin/binutils/bfd/coffcode.h" ,4343); };
4344	}
4345
4346	#endif
4347
4348	/* Don't write out bss sections - one way to do this is to
4349	see if the filepos has not been set. */
4350	if (section->filepos == 0)
4351	return TRUE1;
4352
4353	if (bfd_seek (abfd, section->filepos + offset, SEEK_SET0) != 0)
4354	return FALSE0;
4355
4356	if (count == 0)
4357	return TRUE1;
4358
4359	return bfd_bwrite (location, count, abfd) == count;
4360	}
4361	#if 0
4362	static bfd_boolean
4363	coff_close_and_cleanupbfd_true (abfd)
4364	bfd *abfd;
4365	{
4366	if (!bfd_read_p (abfd)((abfd)->direction == read_direction \|\| (abfd)->direction == both_direction))
4367	switch (abfd->format)
4368	{
4369	case bfd_archive:
4370	if (!_bfd_write_archive_contents (abfd))
4371	return FALSE0;
4372	break;
4373	case bfd_object:
4374	if (!coff_write_object_contents (abfd))
4375	return FALSE0;
4376	break;
4377	default:
4378	bfd_set_error (bfd_error_invalid_operation);
4379	return FALSE0;
4380	}
4381
4382	/* We depend on bfd_close to free all the memory on the objalloc. */
4383	return TRUE1;
4384	}
4385
4386	#endif
4387
4388	static PTRvoid *
4389	buy_and_read (abfd, where, size)
4390	bfd *abfd;
4391	file_ptr where;
4392	bfd_size_type size;
4393	{
4394	PTRvoid * area = (PTRvoid *) bfd_alloc (abfd, size);
4395	if (!area)
4396	return (NULL((void*)0));
4397	if (bfd_seek (abfd, where, SEEK_SET0) != 0
4398	\|\| bfd_bread (area, size, abfd) != size)
4399	return (NULL((void*)0));
4400	return (area);
4401	} /* buy_and_read() */
4402
4403	/*
4404	SUBSUBSECTION
4405	Reading linenumbers
4406
4407	Creating the linenumber table is done by reading in the entire
4408	coff linenumber table, and creating another table for internal use.
4409
4410	A coff linenumber table is structured so that each function
4411	is marked as having a line number of 0. Each line within the
4412	function is an offset from the first line in the function. The
4413	base of the line number information for the table is stored in
4414	the symbol associated with the function.
4415
4416	Note: The PE format uses line number 0 for a flag indicating a
4417	new source file.
4418
4419	The information is copied from the external to the internal
4420	table, and each symbol which marks a function is marked by
4421	pointing its...
4422
4423	How does this work ?
4424
4425	*/
4426
4427	static bfd_boolean
4428	coff_slurp_line_table (abfd, asect)
4429	bfd *abfd;
4430	asection *asect;
4431	{
4432	LINENOstruct external_lineno *native_lineno;
4433	alent *lineno_cache;
4434	bfd_size_type amt;
4435
4436	BFD_ASSERT (asect->lineno == (alent ) NULL){ if (!(asect->lineno == (alent ) ((void*)0))) bfd_assert ("/usr/src/gnu/usr.bin/binutils/bfd/coffcode.h",4436); };
4437
4438	amt = (bfd_size_type) bfd_coff_linesz (abfd)(((bfd_coff_backend_data ) (abfd)->xvec->backend_data) ->_bfd_linesz) asect->lineno_count;
4439	native_lineno = (LINENOstruct external_lineno *) buy_and_read (abfd, asect->line_filepos, amt);
4440	if (native_lineno == NULL((void*)0))
4441	{
4442	(*_bfd_error_handler)
4443	(_("%s: warning: line number table read failed")("%s: warning: line number table read failed"),
4444	bfd_archive_filename (abfd));
4445	return FALSE0;
4446	}
4447	amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
4448	lineno_cache = (alent *) bfd_alloc (abfd, amt);
4449	if (lineno_cache == NULL((void*)0))
4450	return FALSE0;
4451	else
4452	{
4453	unsigned int counter = 0;
4454	alent *cache_ptr = lineno_cache;
4455	LINENOstruct external_lineno *src = native_lineno;
4456
4457	while (counter < asect->lineno_count)
4458	{
4459	struct internal_lineno dst;
4460
4461	bfd_coff_swap_lineno_in (abfd, src, &dst)((((bfd_coff_backend_data *) (abfd)->xvec->backend_data )->_bfd_coff_swap_lineno_in) (abfd,src,&dst));
4462	cache_ptr->line_number = dst.l_lnno;
4463
4464	if (cache_ptr->line_number == 0)
4465	{
4466	bfd_boolean warned;
4467	bfd_signed_vma symndx;
4468	coff_symbol_type *sym;
4469
4470	warned = FALSE0;
4471	symndx = dst.l_addr.l_symndx;
4472	if (symndx < 0
4473	\|\| (bfd_vma) symndx >= obj_raw_syment_count (abfd)(((abfd)->tdata.coff_obj_data)->raw_syment_count))
4474	{
4475	(*_bfd_error_handler)
4476	(_("%s: warning: illegal symbol index %ld in line numbers")("%s: warning: illegal symbol index %ld in line numbers"),
4477	bfd_archive_filename (abfd), dst.l_addr.l_symndx);
4478	symndx = 0;
4479	warned = TRUE1;
4480	}
4481	/* FIXME: We should not be casting between ints and
4482	pointers like this. */
4483	sym = ((coff_symbol_type *)
4484	((symndx + obj_raw_syments (abfd)(((abfd)->tdata.coff_obj_data)->raw_syments))
4485	->u.syment._n._n_n._n_zeroes));
4486	cache_ptr->u.sym = (asymbol *) sym;
4487	if (sym->lineno != NULL((void*)0) && ! warned)
4488	{
4489	(*_bfd_error_handler)
4490	(_("%s: warning: duplicate line number information for `%s'")("%s: warning: duplicate line number information for `%s'"),
4491	bfd_archive_filename (abfd),
4492	bfd_asymbol_name (&sym->symbol)((&sym->symbol)->name));
4493	}
4494	sym->lineno = cache_ptr;
4495	}
4496	else
4497	{
4498	cache_ptr->u.offset = dst.l_addr.l_paddr
4499	- bfd_section_vma (abfd, asect)((asect)->vma);
4500	} /* If no linenumber expect a symbol index */
4501
4502	cache_ptr++;
4503	src++;
4504	counter++;
4505	}
4506	cache_ptr->line_number = 0;
4507
4508	}
4509	asect->lineno = lineno_cache;
4510	/* FIXME, free native_lineno here, or use alloca or something. */
4511	return TRUE1;
4512	}
4513
4514	/* Slurp in the symbol table, converting it to generic form. Note
4515	that if coff_relocate_section is defined, the linker will read
4516	symbols via coff_link_add_symbols, rather than via this routine. */
4517
4518	static bfd_boolean
4519	coff_slurp_symbol_table (abfd)
4520	bfd * abfd;
4521	{
4522	combined_entry_type *native_symbols;
4523	coff_symbol_type *cached_area;
4524	unsigned int *table_ptr;
4525	bfd_size_type amt;
4526	unsigned int number_of_symbols = 0;
4527
4528	if (obj_symbols (abfd)(((abfd)->tdata.coff_obj_data)->symbols))
4529	return TRUE1;
4530
4531	/* Read in the symbol table. */
4532	if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL((void*)0))
4533	return FALSE0;
4534
4535	/* Allocate enough room for all the symbols in cached form. */
4536	amt = obj_raw_syment_count (abfd)(((abfd)->tdata.coff_obj_data)->raw_syment_count);
4537	amt *= sizeof (coff_symbol_type);
4538	cached_area = (coff_symbol_type *) bfd_alloc (abfd, amt);
4539	if (cached_area == NULL((void*)0))
4540	return FALSE0;
4541
4542	amt = obj_raw_syment_count (abfd)(((abfd)->tdata.coff_obj_data)->raw_syment_count);
4543	amt *= sizeof (unsigned int);
4544	table_ptr = (unsigned int *) bfd_alloc (abfd, amt);
4545
4546	if (table_ptr == NULL((void*)0))
4547	return FALSE0;
4548	else
4549	{
4550	coff_symbol_type *dst = cached_area;
4551	unsigned int last_native_index = obj_raw_syment_count (abfd)(((abfd)->tdata.coff_obj_data)->raw_syment_count);
4552	unsigned int this_index = 0;
4553
4554	while (this_index < last_native_index)
4555	{
4556	combined_entry_type *src = native_symbols + this_index;
4557	table_ptr[this_index] = number_of_symbols;
4558	dst->symbol.the_bfd = abfd;
4559
4560	dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
4561	/* We use the native name field to point to the cached field. */
4562	src->u.syment._n._n_n._n_zeroes = (long) dst;
4563	dst->symbol.section = coff_section_from_bfd_index (abfd,
4564	src->u.syment.n_scnum);
4565	dst->symbol.flags = 0;
4566	dst->done_lineno = FALSE0;
4567
4568	switch (src->u.syment.n_sclass)
4569	{
4570	#ifdef I960
4571	case C_LEAFEXT108:
4572	#if 0
4573	dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
4574	dst->symbol.flags = BSF_EXPORT0x02 \| BSF_GLOBAL0x02;
4575	dst->symbol.flags \|= BSF_NOT_AT_END0x400 \| BSF_FUNCTION0x10;
4576	#endif
4577	/* Fall through to next case. */
4578	#endif
4579
4580	case C_EXT2:
4581	case C_WEAKEXT127:
4582	#if defined ARM
4583	case C_THUMBEXT(128 + 2):
4584	case C_THUMBEXTFUNC((128 + 2) + 20):
4585	#endif
4586	#ifdef RS6000COFF_C
4587	case C_HIDEXT107:
4588	#endif
4589	#ifdef C_SYSTEM23
4590	case C_SYSTEM23: /* System Wide variable. */
4591	#endif
4592	#ifdef COFF_WITH_PE
4593	/* In PE, 0x68 (104) denotes a section symbol. */
4594	case C_SECTION104:
4595	/* In PE, 0x69 (105) denotes a weak external symbol. */
4596	case C_NT_WEAK105:
4597	#endif
4598	switch (coff_classify_symbol (abfd, &src->u.syment))
4599	{
4600	case COFF_SYMBOL_GLOBAL:
4601	dst->symbol.flags = BSF_EXPORT0x02 \| BSF_GLOBAL0x02;
4602	#if defined COFF_WITH_PE
4603	/* PE sets the symbol to a value relative to the
4604	start of the section. */
4605	dst->symbol.value = src->u.syment.n_value;
4606	#else
4607	dst->symbol.value = (src->u.syment.n_value
4608	- dst->symbol.section->vma);
4609	#endif
4610	if (ISFCN ((src->u.syment.n_type))(((unsigned long) ((src->u.syment.n_type)) & 0x30) == ( (unsigned long) (2) << 4)))
4611	{
4612	/* A function ext does not go at the end of a
4613	file. */
4614	dst->symbol.flags \|= BSF_NOT_AT_END0x400 \| BSF_FUNCTION0x10;
4615	}
4616	break;
4617
4618	case COFF_SYMBOL_COMMON:
4619	dst->symbol.section = bfd_com_section_ptr((asection *) &bfd_com_section);
4620	dst->symbol.value = src->u.syment.n_value;
4621	break;
4622
4623	case COFF_SYMBOL_UNDEFINED:
4624	dst->symbol.section = bfd_und_section_ptr((asection *) &bfd_und_section);
4625	dst->symbol.value = 0;
4626	break;
4627
4628	case COFF_SYMBOL_PE_SECTION:
4629	dst->symbol.flags \|= BSF_EXPORT0x02 \| BSF_SECTION_SYM0x100;
4630	dst->symbol.value = 0;
4631	break;
4632
4633	case COFF_SYMBOL_LOCAL:
4634	dst->symbol.flags = BSF_LOCAL0x01;
4635	#if defined COFF_WITH_PE
4636	/* PE sets the symbol to a value relative to the
4637	start of the section. */
4638	dst->symbol.value = src->u.syment.n_value;
4639	#else
4640	dst->symbol.value = (src->u.syment.n_value
4641	- dst->symbol.section->vma);
4642	#endif
4643	if (ISFCN ((src->u.syment.n_type))(((unsigned long) ((src->u.syment.n_type)) & 0x30) == ( (unsigned long) (2) << 4)))
4644	dst->symbol.flags \|= BSF_NOT_AT_END0x400 \| BSF_FUNCTION0x10;
4645	break;
4646	}
4647
4648	#ifdef RS6000COFF_C
4649	/* A symbol with a csect entry should not go at the end. */
4650	if (src->u.syment.n_numaux > 0)
4651	dst->symbol.flags \|= BSF_NOT_AT_END0x400;
4652	#endif
4653
4654	#ifdef COFF_WITH_PE
4655	if (src->u.syment.n_sclass == C_NT_WEAK105)
4656	dst->symbol.flags \|= BSF_WEAK0x80;
4657
4658	if (src->u.syment.n_sclass == C_SECTION104
4659	&& src->u.syment.n_scnum > 0)
4660	dst->symbol.flags = BSF_LOCAL0x01;
4661	#endif
4662	if (src->u.syment.n_sclass == C_WEAKEXT127)
4663	dst->symbol.flags \|= BSF_WEAK0x80;
4664
4665	break;
4666
4667	case C_STAT3: /* Static. */
4668	#ifdef I960
4669	case C_LEAFSTAT113: /* Static leaf procedure. */
4670	#endif
4671	#if defined ARM
4672	case C_THUMBSTAT(128 + 3): /* Thumb static. */
4673	case C_THUMBLABEL(128 + 6): /* Thumb label. */
4674	case C_THUMBSTATFUNC((128 + 3) + 20):/* Thumb static function. */
4675	#endif
4676	case C_LABEL6: /* Label. */
4677	if (src->u.syment.n_scnum == N_DEBUG((short)-2))
4678	dst->symbol.flags = BSF_DEBUGGING0x08;
4679	else
4680	dst->symbol.flags = BSF_LOCAL0x01;
4681
4682	/* Base the value as an index from the base of the
4683	section, if there is one. */
4684	if (dst->symbol.section)
4685	{
4686	#if defined COFF_WITH_PE
4687	/* PE sets the symbol to a value relative to the
4688	start of the section. */
4689	dst->symbol.value = src->u.syment.n_value;
4690	#else
4691	dst->symbol.value = (src->u.syment.n_value
4692	- dst->symbol.section->vma);
4693	#endif
4694	}
4695	else
4696	dst->symbol.value = src->u.syment.n_value;
4697	break;
4698
4699	case C_MOS8: /* Member of structure. */
4700	case C_EOS102: /* End of structure. */
4701	#ifdef NOTDEF /* C_AUTOARG has the same value. */
4702	#ifdef C_GLBLREG
4703	case C_GLBLREG: /* A29k-specific storage class. */
4704	#endif
4705	#endif
4706	case C_REGPARM17: /* Register parameter. */
4707	case C_REG4: /* register variable. */
4708	/* C_AUTOARG conflicts with TI COFF C_UEXT. */
4709	#if !defined (TIC80COFF) && !defined (TICOFF)
4710	#ifdef C_AUTOARG19
4711	case C_AUTOARG19: /* 960-specific storage class. */
4712	#endif
4713	#endif
4714	case C_TPDEF13: /* Type definition. */
4715	case C_ARG9:
4716	case C_AUTO1: /* Automatic variable. */
4717	case C_FIELD18: /* Bit field. */
4718	case C_ENTAG15: /* Enumeration tag. */
4719	case C_MOE16: /* Member of enumeration. */
4720	case C_MOU11: /* Member of union. */
4721	case C_UNTAG12: /* Union tag. */
4722	dst->symbol.flags = BSF_DEBUGGING0x08;
4723	dst->symbol.value = (src->u.syment.n_value);
4724	break;
4725
4726	case C_FILE103: /* File name. */
4727	case C_STRTAG10: /* Structure tag. */
4728	#ifdef RS6000COFF_C
4729	case C_GSYM(0x80):
4730	case C_LSYM(0x81):
4731	case C_PSYM(0x82):
4732	case C_RSYM(0x83):
4733	case C_RPSYM(0x84):
4734	case C_STSYM(0x85):
4735	case C_TCSYM(0x86):
4736	case C_BCOMM(0x87):
4737	case C_ECOML(0x88):
4738	case C_ECOMM(0x89):
4739	case C_DECL(0x8c):
4740	case C_ENTRY(0x8d):
4741	case C_FUN(0x8e):
4742	case C_ESTAT(0x90):
4743	#endif
4744	dst->symbol.flags = BSF_DEBUGGING0x08;
4745	dst->symbol.value = (src->u.syment.n_value);
4746	break;
4747
4748	#ifdef RS6000COFF_C
4749	case C_BINCL108: /* Beginning of include file. */
4750	case C_EINCL109: /* Ending of include file. */
4751	/* The value is actually a pointer into the line numbers
4752	of the file. We locate the line number entry, and
4753	set the section to the section which contains it, and
4754	the value to the index in that section. */
4755	{
4756	asection *sec;
4757
4758	dst->symbol.flags = BSF_DEBUGGING0x08;
4759	for (sec = abfd->sections; sec != NULL((void*)0); sec = sec->next)
4760	if (sec->line_filepos <= (file_ptr) src->u.syment.n_value
4761	&& ((file_ptr) (sec->line_filepos
4762	+ sec->lineno_count * bfd_coff_linesz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_linesz))
4763	> (file_ptr) src->u.syment.n_value))
4764	break;
4765	if (sec == NULL((void*)0))
4766	dst->symbol.value = 0;
4767	else
4768	{
4769	dst->symbol.section = sec;
4770	dst->symbol.value = ((src->u.syment.n_value
4771	- sec->line_filepos)
4772	/ bfd_coff_linesz (abfd)(((bfd_coff_backend_data *) (abfd)->xvec->backend_data) ->_bfd_linesz));
4773	src->fix_line = 1;
4774	}
4775	}
4776	break;
4777
4778	case C_BSTAT(0x8f):
4779	dst->symbol.flags = BSF_DEBUGGING0x08;
4780
4781	/* The value is actually a symbol index. Save a pointer
4782	to the symbol instead of the index. FIXME: This
4783	should use a union. */
4784	src->u.syment.n_value =
4785	(long) (native_symbols + src->u.syment.n_value);
4786	dst->symbol.value = src->u.syment.n_value;
4787	src->fix_value = 1;
4788	break;
4789	#endif
4790
4791	case C_BLOCK100: /* ".bb" or ".eb". */
4792	case C_FCN101: /* ".bf" or ".ef" (or PE ".lf"). */
4793	case C_EFCN0xff: /* Physical end of function. */
4794	#if defined COFF_WITH_PE
4795	/* PE sets the symbol to a value relative to the start
4796	of the section. */
4797	dst->symbol.value = src->u.syment.n_value;
4798	if (strcmp (dst->symbol.name, ".bf") != 0)
4799	{
4800	/* PE uses funny values for .ef and .lf; don't
4801	relocate them. */
4802	dst->symbol.flags = BSF_DEBUGGING0x08;
4803	}
4804	else
4805	dst->symbol.flags = BSF_DEBUGGING0x08 \| BSF_DEBUGGING_RELOC0x20000;
4806	#else
4807	/* Base the value as an index from the base of the
4808	section. */
4809	dst->symbol.flags = BSF_LOCAL0x01;
4810	dst->symbol.value = (src->u.syment.n_value
4811	- dst->symbol.section->vma);
4812	#endif
4813	break;
4814
4815	case C_STATLAB20: /* Static load time label. */
4816	dst->symbol.value = src->u.syment.n_value;
4817	dst->symbol.flags = BSF_GLOBAL0x02;
4818	break;
4819
4820	case C_NULL0:
4821	/* PE DLLs sometimes have zeroed out symbols for some
4822	reason. Just ignore them without a warning. */
4823	if (src->u.syment.n_type == 0
4824	&& src->u.syment.n_value == 0
4825	&& src->u.syment.n_scnum == 0)
4826	break;
4827	/* Fall through. */
4828	case C_EXTDEF5: /* External definition. */
4829	case C_ULABEL7: /* Undefined label. */
4830	case C_USTATIC14: /* Undefined static. */
4831	#ifndef COFF_WITH_PE
4832	/* C_LINE in regular coff is 0x68. NT has taken over this storage
4833	class to represent a section symbol. */
4834	case C_LINE104: /* line # reformatted as symbol table entry. */
4835	/* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4836	case C_ALIAS105: /* Duplicate tag. */
4837	#endif
4838	/* New storage classes for TI COFF. */
4839	#if defined(TIC80COFF) \|\| defined(TICOFF)
4840	case C_UEXT19: /* Tentative external definition. */
4841	#endif
4842	case C_EXTLAB21: /* External load time label. */
4843	case C_HIDDEN106: /* Ext symbol in dmert public lib. */
4844	default:
4845	(*_bfd_error_handler)
4846	(_("%s: Unrecognized storage class %d for %s symbol `%s'")("%s: Unrecognized storage class %d for %s symbol `%s'"),
4847	bfd_archive_filename (abfd), src->u.syment.n_sclass,
4848	dst->symbol.section->name, dst->symbol.name);
4849	dst->symbol.flags = BSF_DEBUGGING0x08;
4850	dst->symbol.value = (src->u.syment.n_value);
4851	break;
4852	}
4853
4854	/* BFD_ASSERT(dst->symbol.flags != 0);*/
4855
4856	dst->native = src;
4857
4858	dst->symbol.udata.i = 0;
4859	dst->lineno = (alent ) NULL((void)0);
4860	this_index += (src->u.syment.n_numaux) + 1;
4861	dst++;
4862	number_of_symbols++;
4863	}
4864	}
4865
4866	obj_symbols (abfd)(((abfd)->tdata.coff_obj_data)->symbols) = cached_area;
4867	obj_raw_syments (abfd)(((abfd)->tdata.coff_obj_data)->raw_syments) = native_symbols;
4868
4869	bfd_get_symcount (abfd)((abfd)->symcount) = number_of_symbols;
4870	obj_convert (abfd)(((abfd)->tdata.coff_obj_data)->conversion_table) = table_ptr;
4871	/* Slurp the line tables for each section too. */
4872	{
4873	asection *p;
4874
4875	p = abfd->sections;
4876	while (p)
4877	{
4878	coff_slurp_line_table (abfd, p);
4879	p = p->next;
4880	}
4881	}
4882
4883	return TRUE1;
4884	} /* coff_slurp_symbol_table() */
4885
4886	/* Classify a COFF symbol. A couple of targets have globally visible
4887	symbols which are not class C_EXT, and this handles those. It also
4888	recognizes some special PE cases. */
4889
4890	static enum coff_symbol_classification
4891	coff_classify_symbol (abfd, syment)
4892	bfd *abfd;
4893	struct internal_syment *syment;
4894	{
4895	/* FIXME: This partially duplicates the switch in
4896	coff_slurp_symbol_table. */
4897	switch (syment->n_sclass)
4898	{
4899	case C_EXT2:
4900	case C_WEAKEXT127:
4901	#ifdef I960
4902	case C_LEAFEXT108:
4903	#endif
4904	#ifdef ARM
4905	case C_THUMBEXT(128 + 2):
4906	case C_THUMBEXTFUNC((128 + 2) + 20):
4907	#endif
4908	#ifdef C_SYSTEM23
4909	case C_SYSTEM23:
4910	#endif
4911	#ifdef COFF_WITH_PE
4912	case C_NT_WEAK105:
4913	#endif
4914	if (syment->n_scnum == 0)
4915	{
4916	if (syment->n_value == 0)
4917	return COFF_SYMBOL_UNDEFINED;
4918	else
4919	return COFF_SYMBOL_COMMON;
4920	}
4921	return COFF_SYMBOL_GLOBAL;
4922
4923	default:
4924	break;
4925	}
4926
4927	#ifdef COFF_WITH_PE
4928	if (syment->n_sclass == C_STAT3)
4929	{
4930	if (syment->n_scnum == 0)
4931	{
4932	/* The Microsoft compiler sometimes generates these if a
4933	small static function is inlined every time it is used.
4934	The function is discarded, but the symbol table entry
4935	remains. */
4936	return COFF_SYMBOL_LOCAL;
4937	}
4938
4939	#ifdef STRICT_PE_FORMAT
4940	/* This is correct for Microsoft generated objects, but it
4941	breaks gas generated objects. */
4942
4943	if (syment->n_value == 0)
4944	{
4945	asection *sec;
4946	char buf[SYMNMLEN8 + 1];
4947
4948	sec = coff_section_from_bfd_index (abfd, syment->n_scnum);
4949	if (sec != NULL((void*)0)
4950	&& (strcmp (bfd_get_section_name (abfd, sec)((sec)->name + 0),
4951	_bfd_coff_internal_syment_name (abfd, syment, buf))
4952	== 0))
4953	return COFF_SYMBOL_PE_SECTION;
4954	}
4955	#endif
4956
4957	return COFF_SYMBOL_LOCAL;
4958	}
4959
4960	if (syment->n_sclass == C_SECTION104)
4961	{
4962	/* In some cases in a DLL generated by the Microsoft linker, the
4963	n_value field will contain garbage. FIXME: This should
4964	probably be handled by the swapping function instead. */
4965	syment->n_value = 0;
4966	if (syment->n_scnum == 0)
4967	return COFF_SYMBOL_UNDEFINED;
4968	return COFF_SYMBOL_PE_SECTION;
4969	}
4970	#endif /* COFF_WITH_PE */
4971
4972	/* If it is not a global symbol, we presume it is a local symbol. */
4973
4974	if (syment->n_scnum == 0)
4975	{
4976	char buf[SYMNMLEN8 + 1];
4977
4978	(*_bfd_error_handler)
4979	(_("warning: %s: local symbol `%s' has no section")("warning: %s: local symbol `%s' has no section"),
4980	bfd_archive_filename (abfd),
4981	_bfd_coff_internal_syment_name (abfd, syment, buf));
4982	}
4983
4984	return COFF_SYMBOL_LOCAL;
4985	}
4986
4987	/*
4988	SUBSUBSECTION
4989	Reading relocations
4990
4991	Coff relocations are easily transformed into the internal BFD form
4992	(@code{arelent}).
4993
4994	Reading a coff relocation table is done in the following stages:
4995
4996	o Read the entire coff relocation table into memory.
4997
4998	o Process each relocation in turn; first swap it from the
4999	external to the internal form.
5000
5001	o Turn the symbol referenced in the relocation's symbol index
5002	into a pointer into the canonical symbol table.
5003	This table is the same as the one returned by a call to
5004	@code{bfd_canonicalize_symtab}. The back end will call that
5005	routine and save the result if a canonicalization hasn't been done.
5006
5007	o The reloc index is turned into a pointer to a howto
5008	structure, in a back end specific way. For instance, the 386
5009	and 960 use the @code{r_type} to directly produce an index
5010	into a howto table vector; the 88k subtracts a number from the
5011	@code{r_type} field and creates an addend field.
5012
5013	*/
5014
5015	#ifndef CALC_ADDEND
5016	#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr){ coff_symbol_type coffsym = (coff_symbol_type ) ((void)0) ; if (ptr && ((ptr)->the_bfd) != abfd) coffsym = ( (((abfd)->tdata.coff_obj_data)->symbols) + (cache_ptr-> sym_ptr_ptr - symbols)); else if (ptr) coffsym = coff_symbol_from (abfd, ptr); if (coffsym != (coff_symbol_type ) ((void)0) && coffsym->native->u.syment.n_scnum == 0) cache_ptr-> addend = - coffsym->native->u.syment.n_value; else if ( ptr && ((ptr)->the_bfd) == abfd && ptr-> section != (asection ) ((void*)0)) cache_ptr->addend = - ( ptr->section->vma + ptr->value); else cache_ptr-> addend = 0; if (ptr && howto_table[reloc.r_type].pc_relative ) cache_ptr->addend += asect->vma; } \
5017	{ \
5018	coff_symbol_type coffsym = (coff_symbol_type ) NULL((void*)0); \
5019	if (ptr && bfd_asymbol_bfd (ptr)((ptr)->the_bfd) != abfd) \
5020	coffsym = (obj_symbols (abfd)(((abfd)->tdata.coff_obj_data)->symbols) \
5021	+ (cache_ptr->sym_ptr_ptr - symbols)); \
5022	else if (ptr) \
5023	coffsym = coff_symbol_from (abfd, ptr); \
5024	if (coffsym != (coff_symbol_type ) NULL((void)0) \
5025	&& coffsym->native->u.syment.n_scnum == 0) \
5026	cache_ptr->addend = 0; \
5027	else if (ptr && bfd_asymbol_bfd (ptr)((ptr)->the_bfd) == abfd \
5028	&& ptr->section != (asection ) NULL((void)0)) \
5029	cache_ptr->addend = - (ptr->section->vma + ptr->value); \
5030	else \
5031	cache_ptr->addend = 0; \
5032	}
5033	#endif
5034
5035	static bfd_boolean
5036	coff_slurp_reloc_table (abfd, asect, symbols)
5037	bfd * abfd;
5038	sec_ptr asect;
5039	asymbol ** symbols;
5040	{
5041	RELOCstruct external_reloc *native_relocs;
5042	arelent *reloc_cache;
5043	arelent *cache_ptr;
5044	unsigned int idx;
5045	bfd_size_type amt;
5046
5047	if (asect->relocation)
5048	return TRUE1;
5049	if (asect->reloc_count == 0)
5050	return TRUE1;
5051	if (asect->flags & SEC_CONSTRUCTOR0x100)
5052	return TRUE1;
5053	if (!coff_slurp_symbol_table (abfd))
5054	return FALSE0;
5055	amt = (bfd_size_type) bfd_coff_relsz (abfd)(((bfd_coff_backend_data ) (abfd)->xvec->backend_data) ->_bfd_relsz) asect->reloc_count;
5056	native_relocs = (RELOCstruct external_reloc *) buy_and_read (abfd, asect->rel_filepos, amt);
5057	amt = (bfd_size_type) asect->reloc_count * sizeof (arelent);
5058	reloc_cache = (arelent *) bfd_alloc (abfd, amt);
5059
5060	if (reloc_cache == NULL((void*)0))
5061	return FALSE0;
5062
5063	for (idx = 0; idx < asect->reloc_count; idx++)
5064	{
5065	struct internal_reloc dst;
5066	struct external_reloc *src;
5067	#ifndef RELOC_PROCESSING
5068	asymbol *ptr;
5069	#endif
5070
5071	cache_ptr = reloc_cache + idx;
5072	src = native_relocs + idx;
5073
5074	coff_swap_reloc_in (abfd, src, &dst);
5075
5076	#ifdef RELOC_PROCESSING
5077	RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
5078	#else
5079	cache_ptr->address = dst.r_vaddr;
5080
5081	if (dst.r_symndx != -1)
5082	{
5083	if (dst.r_symndx < 0 \|\| dst.r_symndx >= obj_conv_table_size (abfd)(((abfd)->tdata.coff_obj_data)->conv_table_size))
5084	{
5085	(*_bfd_error_handler)
5086	(_("%s: warning: illegal symbol index %ld in relocs")("%s: warning: illegal symbol index %ld in relocs"),
5087	bfd_archive_filename (abfd), dst.r_symndx);
5088	cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr((asection *) &bfd_abs_section)->symbol_ptr_ptr;
5089	ptr = NULL((void*)0);
5090	}
5091	else
5092	{
5093	cache_ptr->sym_ptr_ptr = (symbols
5094	+ obj_convert (abfd)(((abfd)->tdata.coff_obj_data)->conversion_table)[dst.r_symndx]);
5095	ptr = *(cache_ptr->sym_ptr_ptr);
5096	}
5097	}
5098	else
5099	{
5100	cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr((asection *) &bfd_abs_section)->symbol_ptr_ptr;
5101	ptr = NULL((void*)0);
5102	}
5103
5104	/* The symbols definitions that we have read in have been
5105	relocated as if their sections started at 0. But the offsets
5106	refering to the symbols in the raw data have not been
5107	modified, so we have to have a negative addend to compensate.
5108
5109	Note that symbols which used to be common must be left alone. */
5110
5111	/* Calculate any reloc addend by looking at the symbol. */
5112	CALC_ADDEND (abfd, ptr, dst, cache_ptr){ coff_symbol_type coffsym = (coff_symbol_type ) ((void)0) ; if (ptr && ((ptr)->the_bfd) != abfd) coffsym = ( (((abfd)->tdata.coff_obj_data)->symbols) + (cache_ptr-> sym_ptr_ptr - symbols)); else if (ptr) coffsym = coff_symbol_from (abfd, ptr); if (coffsym != (coff_symbol_type ) ((void)0) && coffsym->native->u.syment.n_scnum == 0) cache_ptr-> addend = - coffsym->native->u.syment.n_value; else if ( ptr && ((ptr)->the_bfd) == abfd && ptr-> section != (asection ) ((void*)0)) cache_ptr->addend = - ( ptr->section->vma + ptr->value); else cache_ptr-> addend = 0; if (ptr && howto_table[dst.r_type].pc_relative ) cache_ptr->addend += asect->vma; };
5113
5114	cache_ptr->address -= asect->vma;
5115	/* !! cache_ptr->section = (asection ) NULL;/
5116
5117	/* Fill in the cache_ptr->howto field from dst.r_type. */
5118	RTYPE2HOWTO (cache_ptr, &dst)((cache_ptr)->howto = ((&dst)->r_type < sizeof ( howto_table) / sizeof (howto_table[0]) ? howto_table + (& dst)->r_type : ((void*)0)));
5119	#endif /* RELOC_PROCESSING */
5120
5121	if (cache_ptr->howto == NULL((void*)0))
5122	{
5123	(*_bfd_error_handler)
5124	(_("%s: illegal relocation type %d at address 0x%lx")("%s: illegal relocation type %d at address 0x%lx"),
5125	bfd_archive_filename (abfd), dst.r_type, (long) dst.r_vaddr);
5126	bfd_set_error (bfd_error_bad_value);
5127	return FALSE0;
5128	}
5129	}
5130
5131	asect->relocation = reloc_cache;
5132	return TRUE1;
5133	}
5134
5135	#ifndef coff_rtype_to_howtocoff_i386_rtype_to_howto
5136	#ifdef RTYPE2HOWTO
5137
5138	/* Get the howto structure for a reloc. This is only used if the file
5139	including this one defines coff_relocate_section to be
5140	_bfd_coff_generic_relocate_section, so it is OK if it does not
5141	always work. It is the responsibility of the including file to
5142	make sure it is reasonable if it is needed. */
5143
5144	static reloc_howto_type *coff_rtype_to_howtocoff_i386_rtype_to_howto
5145	PARAMS ((bfd , asection , struct internal_reloc ,(bfd , asection , struct internal_reloc , struct coff_link_hash_entry , struct internal_syment , bfd_vma *)
5146	struct coff_link_hash_entry , struct internal_syment ,(bfd , asection , struct internal_reloc , struct coff_link_hash_entry , struct internal_syment , bfd_vma )
5147	bfd_vma ))(bfd , asection , struct internal_reloc , struct coff_link_hash_entry , struct internal_syment , bfd_vma *);
5148
5149	static reloc_howto_type *
5150	coff_rtype_to_howtocoff_i386_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
5151	bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__));
5152	asection *sec ATTRIBUTE_UNUSED__attribute__ ((__unused__));
5153	struct internal_reloc *rel;
5154	struct coff_link_hash_entry *h ATTRIBUTE_UNUSED__attribute__ ((__unused__));
5155	struct internal_syment *sym ATTRIBUTE_UNUSED__attribute__ ((__unused__));
5156	bfd_vma *addendp ATTRIBUTE_UNUSED__attribute__ ((__unused__));
5157	{
5158	arelent genrel;
5159
5160	RTYPE2HOWTO (&genrel, rel)((&genrel)->howto = ((rel)->r_type < sizeof (howto_table ) / sizeof (howto_table[0]) ? howto_table + (rel)->r_type : ((void*)0)));
5161	return genrel.howto;
5162	}
5163
5164	#else /* ! defined (RTYPE2HOWTO) */
5165
5166	#define coff_rtype_to_howtocoff_i386_rtype_to_howto NULL((void*)0)
5167
5168	#endif /* ! defined (RTYPE2HOWTO) */
5169	#endif /* ! defined (coff_rtype_to_howto) */
5170
5171	/* This is stupid. This function should be a boolean predicate. */
5172	static long
5173	coff_canonicalize_reloc (abfd, section, relptr, symbols)
5174	bfd * abfd;
5175	sec_ptr section;
5176	arelent ** relptr;
5177	asymbol ** symbols;
5178	{
5179	arelent *tblptr = section->relocation;
	Value stored to 'tblptr' during its initialization is never read
5180	unsigned int count = 0;
5181
5182	if (section->flags & SEC_CONSTRUCTOR0x100)
5183	{
5184	/* This section has relocs made up by us, they are not in the
5185	file, so take them out of their chain and place them into
5186	the data area provided. */
5187	arelent_chain *chain = section->constructor_chain;
5188
5189	for (count = 0; count < section->reloc_count; count++)
5190	{
5191	*relptr++ = &chain->relent;
5192	chain = chain->next;
5193	}
5194	}
5195	else
5196	{
5197	if (! coff_slurp_reloc_table (abfd, section, symbols))
5198	return -1;
5199
5200	tblptr = section->relocation;
5201
5202	for (; count++ < section->reloc_count;)
5203	*relptr++ = tblptr++;
5204	}
5205	*relptr = 0;
5206	return section->reloc_count;
5207	}
5208
5209	#ifdef GNU960
5210	file_ptr
5211	coff_sym_filepos (abfd)
5212	bfd *abfd;
5213	{
5214	return obj_sym_filepos (abfd)(((abfd)->tdata.coff_obj_data)->sym_filepos);
5215	}
5216	#endif
5217
5218	#ifndef coff_reloc16_estimatedummy_reloc16_estimate
5219	#define coff_reloc16_estimatedummy_reloc16_estimate dummy_reloc16_estimate
5220
5221	static int dummy_reloc16_estimate
5222	PARAMS ((bfd , asection , arelent , unsigned int,(bfd , asection , arelent , unsigned int, struct bfd_link_info *)
5223	struct bfd_link_info ))(bfd , asection , arelent , unsigned int, struct bfd_link_info *);
5224
5225	static int
5226	dummy_reloc16_estimate (abfd, input_section, reloc, shrink, link_info)
5227	bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__));
5228	asection *input_section ATTRIBUTE_UNUSED__attribute__ ((__unused__));
5229	arelent *reloc ATTRIBUTE_UNUSED__attribute__ ((__unused__));
5230	unsigned int shrink ATTRIBUTE_UNUSED__attribute__ ((__unused__));
5231	struct bfd_link_info *link_info ATTRIBUTE_UNUSED__attribute__ ((__unused__));
5232	{
5233	abort ()_bfd_abort ("/usr/src/gnu/usr.bin/binutils/bfd/coffcode.h", 5233 , __PRETTY_FUNCTION__);
5234	return 0;
5235	}
5236
5237	#endif
5238
5239	#ifndef coff_reloc16_extra_casesdummy_reloc16_extra_cases
5240
5241	#define coff_reloc16_extra_casesdummy_reloc16_extra_cases dummy_reloc16_extra_cases
5242
5243	/* This works even if abort is not declared in any header file. */
5244
5245	static void dummy_reloc16_extra_cases
5246	PARAMS ((bfd , struct bfd_link_info , struct bfd_link_order , arelent ,(bfd , struct bfd_link_info , struct bfd_link_order , arelent , bfd_byte , unsigned int , unsigned int *)
5247	bfd_byte , unsigned int , unsigned int ))(bfd , struct bfd_link_info , struct bfd_link_order , arelent , bfd_byte , unsigned int , unsigned int );
5248
5249	static void
5250	dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
5251	dst_ptr)
5252	bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__));
5253	struct bfd_link_info *link_info ATTRIBUTE_UNUSED__attribute__ ((__unused__));
5254	struct bfd_link_order *link_order ATTRIBUTE_UNUSED__attribute__ ((__unused__));
5255	arelent *reloc ATTRIBUTE_UNUSED__attribute__ ((__unused__));
5256	bfd_byte *data ATTRIBUTE_UNUSED__attribute__ ((__unused__));
5257	unsigned int *src_ptr ATTRIBUTE_UNUSED__attribute__ ((__unused__));
5258	unsigned int *dst_ptr ATTRIBUTE_UNUSED__attribute__ ((__unused__));
5259	{
5260	abort ()_bfd_abort ("/usr/src/gnu/usr.bin/binutils/bfd/coffcode.h", 5260 , __PRETTY_FUNCTION__);
5261	}
5262	#endif
5263
5264	#ifndef coff_bfd_link_hash_table_free_bfd_generic_link_hash_table_free
5265	#define coff_bfd_link_hash_table_free_bfd_generic_link_hash_table_free _bfd_generic_link_hash_table_free
5266	#endif
5267
5268	/* If coff_relocate_section is defined, we can use the optimized COFF
5269	backend linker. Otherwise we must continue to use the old linker. */
5270	#ifdef coff_relocate_section_bfd_coff_generic_relocate_section
5271	#ifndef coff_bfd_link_hash_table_create_bfd_coff_link_hash_table_create
5272	#define coff_bfd_link_hash_table_create_bfd_coff_link_hash_table_create _bfd_coff_link_hash_table_create
5273	#endif
5274	#ifndef coff_bfd_link_add_symbols_bfd_coff_link_add_symbols
5275	#define coff_bfd_link_add_symbols_bfd_coff_link_add_symbols _bfd_coff_link_add_symbols
5276	#endif
5277	#ifndef coff_bfd_final_link_bfd_coff_final_link
5278	#define coff_bfd_final_link_bfd_coff_final_link _bfd_coff_final_link
5279	#endif
5280	#else /* ! defined (coff_relocate_section) */
5281	#define coff_relocate_section_bfd_coff_generic_relocate_section NULL((void*)0)
5282	#ifndef coff_bfd_link_hash_table_create_bfd_coff_link_hash_table_create
5283	#define coff_bfd_link_hash_table_create_bfd_coff_link_hash_table_create _bfd_generic_link_hash_table_create
5284	#endif
5285	#ifndef coff_bfd_link_add_symbols_bfd_coff_link_add_symbols
5286	#define coff_bfd_link_add_symbols_bfd_coff_link_add_symbols _bfd_generic_link_add_symbols
5287	#endif
5288	#define coff_bfd_final_link_bfd_coff_final_link _bfd_generic_final_link
5289	#endif /* ! defined (coff_relocate_section) */
5290
5291	#define coff_bfd_link_just_syms_bfd_generic_link_just_syms _bfd_generic_link_just_syms
5292	#define coff_bfd_link_split_section_bfd_generic_link_split_section _bfd_generic_link_split_section
5293
5294	#ifndef coff_start_final_link((void*)0)
5295	#define coff_start_final_link((void)0) NULL((void)0)
5296	#endif
5297
5298	#ifndef coff_adjust_symndx((void*)0)
5299	#define coff_adjust_symndx((void)0) NULL((void)0)
5300	#endif
5301
5302	#ifndef coff_link_add_one_symbol_bfd_generic_link_add_one_symbol
5303	#define coff_link_add_one_symbol_bfd_generic_link_add_one_symbol _bfd_generic_link_add_one_symbol
5304	#endif
5305
5306	#ifndef coff_link_output_has_begun
5307
5308	static bfd_boolean coff_link_output_has_begun
5309	PARAMS ((bfd , struct coff_final_link_info ))(bfd , struct coff_final_link_info );
5310
5311	static bfd_boolean
5312	coff_link_output_has_begun (abfd, info)
5313	bfd * abfd;
5314	struct coff_final_link_info * info ATTRIBUTE_UNUSED__attribute__ ((__unused__));
5315	{
5316	return abfd->output_has_begun;
5317	}
5318	#endif
5319
5320	#ifndef coff_final_link_postscript
5321
5322	static bfd_boolean coff_final_link_postscript
5323	PARAMS ((bfd , struct coff_final_link_info ))(bfd , struct coff_final_link_info );
5324
5325	static bfd_boolean
5326	coff_final_link_postscript (abfd, pfinfo)
5327	bfd * abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__));
5328	struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED__attribute__ ((__unused__));
5329	{
5330	return TRUE1;
5331	}
5332	#endif
5333
5334	#ifndef coff_SWAP_aux_incoff_swap_aux_in
5335	#define coff_SWAP_aux_incoff_swap_aux_in coff_swap_aux_in
5336	#endif
5337	#ifndef coff_SWAP_sym_incoff_swap_sym_in
5338	#define coff_SWAP_sym_incoff_swap_sym_in coff_swap_sym_in
5339	#endif
5340	#ifndef coff_SWAP_lineno_incoff_swap_lineno_in
5341	#define coff_SWAP_lineno_incoff_swap_lineno_in coff_swap_lineno_in
5342	#endif
5343	#ifndef coff_SWAP_aux_outcoff_swap_aux_out
5344	#define coff_SWAP_aux_outcoff_swap_aux_out coff_swap_aux_out
5345	#endif
5346	#ifndef coff_SWAP_sym_outcoff_swap_sym_out
5347	#define coff_SWAP_sym_outcoff_swap_sym_out coff_swap_sym_out
5348	#endif
5349	#ifndef coff_SWAP_lineno_outcoff_swap_lineno_out
5350	#define coff_SWAP_lineno_outcoff_swap_lineno_out coff_swap_lineno_out
5351	#endif
5352	#ifndef coff_SWAP_reloc_outcoff_swap_reloc_out
5353	#define coff_SWAP_reloc_outcoff_swap_reloc_out coff_swap_reloc_out
5354	#endif
5355	#ifndef coff_SWAP_filehdr_outcoff_swap_filehdr_out
5356	#define coff_SWAP_filehdr_outcoff_swap_filehdr_out coff_swap_filehdr_out
5357	#endif
5358	#ifndef coff_SWAP_aouthdr_outcoff_swap_aouthdr_out
5359	#define coff_SWAP_aouthdr_outcoff_swap_aouthdr_out coff_swap_aouthdr_out
5360	#endif
5361	#ifndef coff_SWAP_scnhdr_outcoff_swap_scnhdr_out
5362	#define coff_SWAP_scnhdr_outcoff_swap_scnhdr_out coff_swap_scnhdr_out
5363	#endif
5364	#ifndef coff_SWAP_reloc_incoff_swap_reloc_in
5365	#define coff_SWAP_reloc_incoff_swap_reloc_in coff_swap_reloc_in
5366	#endif
5367	#ifndef coff_SWAP_filehdr_incoff_swap_filehdr_in
5368	#define coff_SWAP_filehdr_incoff_swap_filehdr_in coff_swap_filehdr_in
5369	#endif
5370	#ifndef coff_SWAP_aouthdr_incoff_swap_aouthdr_in
5371	#define coff_SWAP_aouthdr_incoff_swap_aouthdr_in coff_swap_aouthdr_in
5372	#endif
5373	#ifndef coff_SWAP_scnhdr_incoff_swap_scnhdr_in
5374	#define coff_SWAP_scnhdr_incoff_swap_scnhdr_in coff_swap_scnhdr_in
5375	#endif
5376
5377	static const bfd_coff_backend_data bfd_coff_std_swap_table =
5378	{
5379	coff_SWAP_aux_incoff_swap_aux_in, coff_SWAP_sym_incoff_swap_sym_in, coff_SWAP_lineno_incoff_swap_lineno_in,
5380	coff_SWAP_aux_outcoff_swap_aux_out, coff_SWAP_sym_outcoff_swap_sym_out,
5381	coff_SWAP_lineno_outcoff_swap_lineno_out, coff_SWAP_reloc_outcoff_swap_reloc_out,
5382	coff_SWAP_filehdr_outcoff_swap_filehdr_out, coff_SWAP_aouthdr_outcoff_swap_aouthdr_out,
5383	coff_SWAP_scnhdr_outcoff_swap_scnhdr_out,
5384	FILHSZ20, AOUTSZ28, SCNHSZ40, SYMESZ18, AUXESZ18, RELSZ10, LINESZ(4 + 2), FILNMLEN14,
5385	#ifdef COFF_LONG_FILENAMES
5386	TRUE1,
5387	#else
5388	FALSE0,
5389	#endif
5390	#ifdef COFF_LONG_SECTION_NAMES
5391	TRUE1,
5392	#else
5393	FALSE0,
5394	#endif
5395	COFF_DEFAULT_SECTION_ALIGNMENT_POWER(2),
5396	#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5397	TRUE1,
5398	#else
5399	FALSE0,
5400	#endif
5401	#ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5402	4,
5403	#else
5404	2,
5405	#endif
5406	coff_SWAP_filehdr_incoff_swap_filehdr_in, coff_SWAP_aouthdr_incoff_swap_aouthdr_in, coff_SWAP_scnhdr_incoff_swap_scnhdr_in,
5407	coff_SWAP_reloc_incoff_swap_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
5408	coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook((void () (bfd , asection , void )) bfd_void),
5409	coff_slurp_symbol_table, symname_in_debug_hook(bfd_boolean () (bfd , struct internal_syment *)) bfd_false, coff_pointerize_aux_hook0,
5410	coff_print_aux, coff_reloc16_extra_casesdummy_reloc16_extra_cases, coff_reloc16_estimatedummy_reloc16_estimate,
5411	coff_classify_symbol, coff_compute_section_file_positions,
5412	coff_start_final_link((void*)0), coff_relocate_section_bfd_coff_generic_relocate_section, coff_rtype_to_howtocoff_i386_rtype_to_howto,
5413	coff_adjust_symndx((void*)0), coff_link_add_one_symbol_bfd_generic_link_add_one_symbol,
5414	coff_link_output_has_begun, coff_final_link_postscript
5415	};
5416
5417	#ifdef TICOFF
5418	/* COFF0 differs in file/section header size and relocation entry size. */
5419	static const bfd_coff_backend_data ticoff0_swap_table =
5420	{
5421	coff_SWAP_aux_incoff_swap_aux_in, coff_SWAP_sym_incoff_swap_sym_in, coff_SWAP_lineno_incoff_swap_lineno_in,
5422	coff_SWAP_aux_outcoff_swap_aux_out, coff_SWAP_sym_outcoff_swap_sym_out,
5423	coff_SWAP_lineno_outcoff_swap_lineno_out, coff_SWAP_reloc_outcoff_swap_reloc_out,
5424	coff_SWAP_filehdr_outcoff_swap_filehdr_out, coff_SWAP_aouthdr_outcoff_swap_aouthdr_out,
5425	coff_SWAP_scnhdr_outcoff_swap_scnhdr_out,
5426	FILHSZ_V0, AOUTSZ28, SCNHSZ_V01, SYMESZ18, AUXESZ18, RELSZ_V0, LINESZ(4 + 2), FILNMLEN14,
5427	#ifdef COFF_LONG_FILENAMES
5428	TRUE1,
5429	#else
5430	FALSE0,
5431	#endif
5432	#ifdef COFF_LONG_SECTION_NAMES
5433	TRUE1,
5434	#else
5435	FALSE0,
5436	#endif
5437	COFF_DEFAULT_SECTION_ALIGNMENT_POWER(2),
5438	#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5439	TRUE1,
5440	#else
5441	FALSE0,
5442	#endif
5443	#ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5444	4,
5445	#else
5446	2,
5447	#endif
5448	coff_SWAP_filehdr_incoff_swap_filehdr_in, coff_SWAP_aouthdr_incoff_swap_aouthdr_in, coff_SWAP_scnhdr_incoff_swap_scnhdr_in,
5449	coff_SWAP_reloc_incoff_swap_reloc_in, ticoff0_bad_format_hook, coff_set_arch_mach_hook,
5450	coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook((void () (bfd , asection , void )) bfd_void),
5451	coff_slurp_symbol_table, symname_in_debug_hook(bfd_boolean () (bfd , struct internal_syment *)) bfd_false, coff_pointerize_aux_hook0,
5452	coff_print_aux, coff_reloc16_extra_casesdummy_reloc16_extra_cases, coff_reloc16_estimatedummy_reloc16_estimate,
5453	coff_classify_symbol, coff_compute_section_file_positions,
5454	coff_start_final_link((void*)0), coff_relocate_section_bfd_coff_generic_relocate_section, coff_rtype_to_howtocoff_i386_rtype_to_howto,
5455	coff_adjust_symndx((void*)0), coff_link_add_one_symbol_bfd_generic_link_add_one_symbol,
5456	coff_link_output_has_begun, coff_final_link_postscript
5457	};
5458	#endif
5459
5460	#ifdef TICOFF
5461	/* COFF1 differs in section header size. */
5462	static const bfd_coff_backend_data ticoff1_swap_table =
5463	{
5464	coff_SWAP_aux_incoff_swap_aux_in, coff_SWAP_sym_incoff_swap_sym_in, coff_SWAP_lineno_incoff_swap_lineno_in,
5465	coff_SWAP_aux_outcoff_swap_aux_out, coff_SWAP_sym_outcoff_swap_sym_out,
5466	coff_SWAP_lineno_outcoff_swap_lineno_out, coff_SWAP_reloc_outcoff_swap_reloc_out,
5467	coff_SWAP_filehdr_outcoff_swap_filehdr_out, coff_SWAP_aouthdr_outcoff_swap_aouthdr_out,
5468	coff_SWAP_scnhdr_outcoff_swap_scnhdr_out,
5469	FILHSZ20, AOUTSZ28, SCNHSZ_V01, SYMESZ18, AUXESZ18, RELSZ10, LINESZ(4 + 2), FILNMLEN14,
5470	#ifdef COFF_LONG_FILENAMES
5471	TRUE1,
5472	#else
5473	FALSE0,
5474	#endif
5475	#ifdef COFF_LONG_SECTION_NAMES
5476	TRUE1,
5477	#else
5478	FALSE0,
5479	#endif
5480	COFF_DEFAULT_SECTION_ALIGNMENT_POWER(2),
5481	#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5482	TRUE1,
5483	#else
5484	FALSE0,
5485	#endif
5486	#ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5487	4,
5488	#else
5489	2,
5490	#endif
5491	coff_SWAP_filehdr_incoff_swap_filehdr_in, coff_SWAP_aouthdr_incoff_swap_aouthdr_in, coff_SWAP_scnhdr_incoff_swap_scnhdr_in,
5492	coff_SWAP_reloc_incoff_swap_reloc_in, ticoff1_bad_format_hook, coff_set_arch_mach_hook,
5493	coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook((void () (bfd , asection , void )) bfd_void),
5494	coff_slurp_symbol_table, symname_in_debug_hook(bfd_boolean () (bfd , struct internal_syment *)) bfd_false, coff_pointerize_aux_hook0,
5495	coff_print_aux, coff_reloc16_extra_casesdummy_reloc16_extra_cases, coff_reloc16_estimatedummy_reloc16_estimate,
5496	coff_classify_symbol, coff_compute_section_file_positions,
5497	coff_start_final_link((void*)0), coff_relocate_section_bfd_coff_generic_relocate_section, coff_rtype_to_howtocoff_i386_rtype_to_howto,
5498	coff_adjust_symndx((void*)0), coff_link_add_one_symbol_bfd_generic_link_add_one_symbol,
5499	coff_link_output_has_begun, coff_final_link_postscript
5500	};
5501	#endif
5502
5503	#ifndef coff_close_and_cleanupbfd_true
5504	#define coff_close_and_cleanupbfd_true _bfd_generic_close_and_cleanupbfd_true
5505	#endif
5506
5507	#ifndef coff_bfd_free_cached_infobfd_true
5508	#define coff_bfd_free_cached_infobfd_true _bfd_generic_bfd_free_cached_infobfd_true
5509	#endif
5510
5511	#ifndef coff_get_section_contents_bfd_generic_get_section_contents
5512	#define coff_get_section_contents_bfd_generic_get_section_contents _bfd_generic_get_section_contents
5513	#endif
5514
5515	#ifndef coff_bfd_copy_private_symbol_data((bfd_boolean () (bfd , asymbol , bfd , asymbol *)) bfd_true )
5516	#define coff_bfd_copy_private_symbol_data((bfd_boolean () (bfd , asymbol , bfd , asymbol )) bfd_true ) _bfd_generic_bfd_copy_private_symbol_data((bfd_boolean () (bfd , asymbol , bfd , asymbol )) bfd_true )
5517	#endif
5518
5519	#ifndef coff_bfd_copy_private_section_data((bfd_boolean () (bfd , asection , bfd , asection *)) bfd_true )
5520	#define coff_bfd_copy_private_section_data((bfd_boolean () (bfd , asection , bfd , asection )) bfd_true ) _bfd_generic_bfd_copy_private_section_data((bfd_boolean () (bfd , asection , bfd , asection )) bfd_true )
5521	#endif
5522
5523	#ifndef coff_bfd_copy_private_bfd_data((bfd_boolean () (bfd , bfd *)) bfd_true)
5524	#define coff_bfd_copy_private_bfd_data((bfd_boolean () (bfd , bfd )) bfd_true) _bfd_generic_bfd_copy_private_bfd_data((bfd_boolean () (bfd , bfd )) bfd_true)
5525	#endif
5526
5527	#ifndef coff_bfd_merge_private_bfd_data((bfd_boolean () (bfd , bfd *)) bfd_true)
5528	#define coff_bfd_merge_private_bfd_data((bfd_boolean () (bfd , bfd )) bfd_true) _bfd_generic_bfd_merge_private_bfd_data((bfd_boolean () (bfd , bfd )) bfd_true)
5529	#endif
5530
5531	#ifndef coff_bfd_set_private_flags((bfd_boolean () (bfd , flagword)) bfd_true)
5532	#define coff_bfd_set_private_flags((bfd_boolean () (bfd , flagword)) bfd_true) _bfd_generic_bfd_set_private_flags((bfd_boolean () (bfd , flagword)) bfd_true)
5533	#endif
5534
5535	#ifndef coff_bfd_print_private_bfd_data((bfd_boolean () (bfd , void *)) bfd_true)
5536	#define coff_bfd_print_private_bfd_data((bfd_boolean () (bfd , void )) bfd_true) _bfd_generic_bfd_print_private_bfd_data((bfd_boolean () (bfd , void )) bfd_true)
5537	#endif
5538
5539	#ifndef coff_bfd_is_local_label_name_bfd_coff_is_local_label_name
5540	#define coff_bfd_is_local_label_name_bfd_coff_is_local_label_name _bfd_coff_is_local_label_name
5541	#endif
5542
5543	#ifndef coff_read_minisymbols_bfd_generic_read_minisymbols
5544	#define coff_read_minisymbols_bfd_generic_read_minisymbols _bfd_generic_read_minisymbols
5545	#endif
5546
5547	#ifndef coff_minisymbol_to_symbol_bfd_generic_minisymbol_to_symbol
5548	#define coff_minisymbol_to_symbol_bfd_generic_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5549	#endif
5550
5551	/* The reloc lookup routine must be supplied by each individual COFF
5552	backend. */
5553	#ifndef coff_bfd_reloc_type_lookupcoff_i386_reloc_type_lookup
5554	#define coff_bfd_reloc_type_lookupcoff_i386_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup((reloc_howto_type () (bfd *, bfd_reloc_code_real_type)) bfd_nullvoidptr )
5555	#endif
5556
5557	#ifndef coff_bfd_get_relocated_section_contentsbfd_generic_get_relocated_section_contents
5558	#define coff_bfd_get_relocated_section_contentsbfd_generic_get_relocated_section_contents \
5559	bfd_generic_get_relocated_section_contents
5560	#endif
5561
5562	#ifndef coff_bfd_relax_sectionbfd_generic_relax_section
5563	#define coff_bfd_relax_sectionbfd_generic_relax_section bfd_generic_relax_section
5564	#endif
5565
5566	#ifndef coff_bfd_gc_sectionsbfd_generic_gc_sections
5567	#define coff_bfd_gc_sectionsbfd_generic_gc_sections bfd_generic_gc_sections
5568	#endif
5569
5570	#ifndef coff_bfd_merge_sectionsbfd_generic_merge_sections
5571	#define coff_bfd_merge_sectionsbfd_generic_merge_sections bfd_generic_merge_sections
5572	#endif
5573
5574	#ifndef coff_bfd_discard_groupbfd_generic_discard_group
5575	#define coff_bfd_discard_groupbfd_generic_discard_group bfd_generic_discard_group
5576	#endif
5577
5578	#define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE)const bfd_target VAR = { NAME , bfd_target_coff_flavour, BFD_ENDIAN_BIG , BFD_ENDIAN_BIG, (0x01 \| 0x02 \| 0x04 \| 0x08 \| 0x10 \| 0x20 \| 0x80 \| EXTRA_O_FLAGS), (0x200 \| 0x001 \| 0x002 \| 0x004 \| EXTRA_S_FLAGS ), UNDER, '/', 15, bfd_getb64, bfd_getb_signed_64, bfd_putb64 , bfd_getb32, bfd_getb_signed_32, bfd_putb32, bfd_getb16, bfd_getb_signed_16 , bfd_putb16, bfd_getb64, bfd_getb_signed_64, bfd_putb64, bfd_getb32 , bfd_getb_signed_32, bfd_putb32, bfd_getb16, bfd_getb_signed_16 , bfd_putb16, { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p , _bfd_dummy_target }, { bfd_false, coff_mkobject, _bfd_generic_mkarchive , bfd_false }, { bfd_false, coff_write_object_contents, _bfd_write_archive_contents , bfd_false }, bfd_true, bfd_true, coff_new_section_hook, _bfd_generic_get_section_contents , _bfd_generic_get_section_contents_in_window, ((bfd_boolean ( ) (bfd , bfd )) bfd_true), ((bfd_boolean () (bfd , bfd )) bfd_true), ((bfd_boolean () (bfd , asection , bfd , asection )) bfd_true), ((bfd_boolean () (bfd , asymbol , bfd , asymbol )) bfd_true), ((bfd_boolean () (bfd , flagword)) bfd_true ), ((bfd_boolean () (bfd , void )) bfd_true), _bfd_nocore_core_file_failing_command , _bfd_nocore_core_file_failing_signal, _bfd_nocore_core_file_matches_executable_p , bfd_slurp_armap, _bfd_slurp_extended_name_table, _bfd_archive_coff_construct_extended_name_table , bfd_dont_truncate_arname, coff_write_armap, _bfd_generic_read_ar_hdr , bfd_generic_openr_next_archived_file, _bfd_generic_get_elt_at_index , bfd_generic_stat_arch_elt, bfd_true, coff_get_symtab_upper_bound , coff_canonicalize_symtab, coff_make_empty_symbol, coff_print_symbol , coff_get_symbol_info, _bfd_coff_is_local_label_name, coff_get_lineno , coff_find_nearest_line, coff_bfd_make_debug_symbol, _bfd_generic_read_minisymbols , _bfd_generic_minisymbol_to_symbol, coff_get_reloc_upper_bound , coff_canonicalize_reloc, coff_i386_reloc_type_lookup, coff_set_arch_mach , coff_set_section_contents, coff_sizeof_headers, bfd_generic_get_relocated_section_contents , bfd_generic_relax_section, _bfd_coff_link_hash_table_create , _bfd_generic_link_hash_table_free, _bfd_coff_link_add_symbols , _bfd_generic_link_just_syms, _bfd_coff_final_link, _bfd_generic_link_split_section , bfd_generic_gc_sections, bfd_generic_merge_sections, bfd_generic_discard_group , _bfd_n1, ((long () (bfd , asymbol )) _bfd_n1), _bfd_n1, ((long () (bfd , arelent , asymbol *)) _bfd_n1), ALTERNATIVE , SWAP_TABLE }; \
5579	const bfd_target VAR = \
5580	{ \
5581	NAME , \
5582	bfd_target_coff_flavour, \
5583	BFD_ENDIAN_BIG, /* data byte order is big */ \
5584	BFD_ENDIAN_BIG, /* header byte order is big */ \
5585	/* object flags */ \
5586	(HAS_RELOC0x01 \| EXEC_P0x02 \| HAS_LINENO0x04 \| HAS_DEBUG0x08 \| \
5587	HAS_SYMS0x10 \| HAS_LOCALS0x20 \| WP_TEXT0x80 \| EXTRA_O_FLAGS), \
5588	/* section flags */ \
5589	(SEC_HAS_CONTENTS0x200 \| SEC_ALLOC0x001 \| SEC_LOAD0x002 \| SEC_RELOC0x004 \| EXTRA_S_FLAGS),\
5590	UNDER, /* leading symbol underscore */ \
5591	'/', /* ar_pad_char */ \
5592	15, /* ar_max_namelen */ \
5593	\
5594	/* Data conversion functions. */ \
5595	bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5596	bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5597	bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5598	\
5599	/* Header conversion functions. */ \
5600	bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5601	bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5602	bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5603	\
5604	/* bfd_check_format */ \
5605	{ _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5606	_bfd_dummy_target }, \
5607	/* bfd_set_format */ \
5608	{ bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5609	/* bfd_write_contents */ \
5610	{ bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5611	bfd_false }, \
5612	\
5613	BFD_JUMP_TABLE_GENERIC (coff)bfd_true, bfd_true, coff_new_section_hook, _bfd_generic_get_section_contents , _bfd_generic_get_section_contents_in_window, \
5614	BFD_JUMP_TABLE_COPY (coff)((bfd_boolean () (bfd , bfd )) bfd_true), ((bfd_boolean ( ) (bfd , bfd )) bfd_true), ((bfd_boolean () (bfd , asection , bfd , asection )) bfd_true), ((bfd_boolean () (bfd , asymbol , bfd , asymbol )) bfd_true), ((bfd_boolean () (bfd , flagword )) bfd_true), ((bfd_boolean () (bfd , void *)) bfd_true), \
5615	BFD_JUMP_TABLE_CORE (_bfd_nocore)_bfd_nocore_core_file_failing_command, _bfd_nocore_core_file_failing_signal , _bfd_nocore_core_file_matches_executable_p, \
5616	BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff)bfd_slurp_armap, _bfd_slurp_extended_name_table, _bfd_archive_coff_construct_extended_name_table , bfd_dont_truncate_arname, coff_write_armap, _bfd_generic_read_ar_hdr , bfd_generic_openr_next_archived_file, _bfd_generic_get_elt_at_index , bfd_generic_stat_arch_elt, bfd_true, \
5617	BFD_JUMP_TABLE_SYMBOLS (coff)coff_get_symtab_upper_bound, coff_canonicalize_symtab, coff_make_empty_symbol , coff_print_symbol, coff_get_symbol_info, _bfd_coff_is_local_label_name , coff_get_lineno, coff_find_nearest_line, coff_bfd_make_debug_symbol , _bfd_generic_read_minisymbols, _bfd_generic_minisymbol_to_symbol, \
5618	BFD_JUMP_TABLE_RELOCS (coff)coff_get_reloc_upper_bound, coff_canonicalize_reloc, coff_i386_reloc_type_lookup, \
5619	BFD_JUMP_TABLE_WRITE (coff)coff_set_arch_mach, coff_set_section_contents, \
5620	BFD_JUMP_TABLE_LINK (coff)coff_sizeof_headers, bfd_generic_get_relocated_section_contents , bfd_generic_relax_section, _bfd_coff_link_hash_table_create , _bfd_generic_link_hash_table_free, _bfd_coff_link_add_symbols , _bfd_generic_link_just_syms, _bfd_coff_final_link, _bfd_generic_link_split_section , bfd_generic_gc_sections, bfd_generic_merge_sections, bfd_generic_discard_group, \
5621	BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic)_bfd_n1, ((long () (bfd , asymbol *)) _bfd_n1), _bfd_n1, ( (long () (bfd , arelent , asymbol *)) _bfd_n1), \
5622	\
5623	ALTERNATIVE, \
5624	\
5625	SWAP_TABLE \
5626	};
5627
5628	#define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE)const bfd_target VAR = { NAME , bfd_target_coff_flavour, BFD_ENDIAN_LITTLE , BFD_ENDIAN_BIG, (0x01 \| 0x02 \| 0x04 \| 0x08 \| 0x10 \| 0x20 \| 0x80 \| EXTRA_O_FLAGS), (0x200 \| 0x001 \| 0x002 \| 0x004 \| EXTRA_S_FLAGS ), UNDER, '/', 15, bfd_getb64, bfd_getb_signed_64, bfd_putb64 , bfd_getb32, bfd_getb_signed_32, bfd_putb32, bfd_getb16, bfd_getb_signed_16 , bfd_putb16, bfd_getb64, bfd_getb_signed_64, bfd_putb64, bfd_getb32 , bfd_getb_signed_32, bfd_putb32, bfd_getb16, bfd_getb_signed_16 , bfd_putb16, { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p , _bfd_dummy_target }, { bfd_false, coff_mkobject, _bfd_generic_mkarchive , bfd_false }, { bfd_false, coff_write_object_contents, _bfd_write_archive_contents , bfd_false }, bfd_true, bfd_true, coff_new_section_hook, _bfd_generic_get_section_contents , _bfd_generic_get_section_contents_in_window, ((bfd_boolean ( ) (bfd , bfd )) bfd_true), ((bfd_boolean () (bfd , bfd )) bfd_true), ((bfd_boolean () (bfd , asection , bfd , asection )) bfd_true), ((bfd_boolean () (bfd , asymbol , bfd , asymbol )) bfd_true), ((bfd_boolean () (bfd , flagword)) bfd_true ), ((bfd_boolean () (bfd , void )) bfd_true), _bfd_nocore_core_file_failing_command , _bfd_nocore_core_file_failing_signal, _bfd_nocore_core_file_matches_executable_p , bfd_slurp_armap, _bfd_slurp_extended_name_table, _bfd_archive_coff_construct_extended_name_table , bfd_dont_truncate_arname, coff_write_armap, _bfd_generic_read_ar_hdr , bfd_generic_openr_next_archived_file, _bfd_generic_get_elt_at_index , bfd_generic_stat_arch_elt, bfd_true, coff_get_symtab_upper_bound , coff_canonicalize_symtab, coff_make_empty_symbol, coff_print_symbol , coff_get_symbol_info, _bfd_coff_is_local_label_name, coff_get_lineno , coff_find_nearest_line, coff_bfd_make_debug_symbol, _bfd_generic_read_minisymbols , _bfd_generic_minisymbol_to_symbol, coff_get_reloc_upper_bound , coff_canonicalize_reloc, coff_i386_reloc_type_lookup, coff_set_arch_mach , coff_set_section_contents, coff_sizeof_headers, bfd_generic_get_relocated_section_contents , bfd_generic_relax_section, _bfd_coff_link_hash_table_create , _bfd_generic_link_hash_table_free, _bfd_coff_link_add_symbols , _bfd_generic_link_just_syms, _bfd_coff_final_link, _bfd_generic_link_split_section , bfd_generic_gc_sections, bfd_generic_merge_sections, bfd_generic_discard_group , _bfd_n1, ((long () (bfd , asymbol )) _bfd_n1), _bfd_n1, ((long () (bfd , arelent , asymbol *)) _bfd_n1), ALTERNATIVE , SWAP_TABLE }; \
5629	const bfd_target VAR = \
5630	{ \
5631	NAME , \
5632	bfd_target_coff_flavour, \
5633	BFD_ENDIAN_LITTLE, /* data byte order is little */ \
5634	BFD_ENDIAN_BIG, /* header byte order is big */ \
5635	/* object flags */ \
5636	(HAS_RELOC0x01 \| EXEC_P0x02 \| HAS_LINENO0x04 \| HAS_DEBUG0x08 \| \
5637	HAS_SYMS0x10 \| HAS_LOCALS0x20 \| WP_TEXT0x80 \| EXTRA_O_FLAGS), \
5638	/* section flags */ \
5639	(SEC_HAS_CONTENTS0x200 \| SEC_ALLOC0x001 \| SEC_LOAD0x002 \| SEC_RELOC0x004 \| EXTRA_S_FLAGS),\
5640	UNDER, /* leading symbol underscore */ \
5641	'/', /* ar_pad_char */ \
5642	15, /* ar_max_namelen */ \
5643	\
5644	/* Data conversion functions. */ \
5645	bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5646	bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5647	bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5648	\
5649	/* Header conversion functions. */ \
5650	bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5651	bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5652	bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5653	\
5654	/* bfd_check_format */ \
5655	{ _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5656	_bfd_dummy_target }, \
5657	/* bfd_set_format */ \
5658	{ bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5659	/* bfd_write_contents */ \
5660	{ bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5661	bfd_false }, \
5662	\
5663	BFD_JUMP_TABLE_GENERIC (coff)bfd_true, bfd_true, coff_new_section_hook, _bfd_generic_get_section_contents , _bfd_generic_get_section_contents_in_window, \
5664	BFD_JUMP_TABLE_COPY (coff)((bfd_boolean () (bfd , bfd )) bfd_true), ((bfd_boolean ( ) (bfd , bfd )) bfd_true), ((bfd_boolean () (bfd , asection , bfd , asection )) bfd_true), ((bfd_boolean () (bfd , asymbol , bfd , asymbol )) bfd_true), ((bfd_boolean () (bfd , flagword )) bfd_true), ((bfd_boolean () (bfd , void *)) bfd_true), \
5665	BFD_JUMP_TABLE_CORE (_bfd_nocore)_bfd_nocore_core_file_failing_command, _bfd_nocore_core_file_failing_signal , _bfd_nocore_core_file_matches_executable_p, \
5666	BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff)bfd_slurp_armap, _bfd_slurp_extended_name_table, _bfd_archive_coff_construct_extended_name_table , bfd_dont_truncate_arname, coff_write_armap, _bfd_generic_read_ar_hdr , bfd_generic_openr_next_archived_file, _bfd_generic_get_elt_at_index , bfd_generic_stat_arch_elt, bfd_true, \
5667	BFD_JUMP_TABLE_SYMBOLS (coff)coff_get_symtab_upper_bound, coff_canonicalize_symtab, coff_make_empty_symbol , coff_print_symbol, coff_get_symbol_info, _bfd_coff_is_local_label_name , coff_get_lineno, coff_find_nearest_line, coff_bfd_make_debug_symbol , _bfd_generic_read_minisymbols, _bfd_generic_minisymbol_to_symbol, \
5668	BFD_JUMP_TABLE_RELOCS (coff)coff_get_reloc_upper_bound, coff_canonicalize_reloc, coff_i386_reloc_type_lookup, \
5669	BFD_JUMP_TABLE_WRITE (coff)coff_set_arch_mach, coff_set_section_contents, \
5670	BFD_JUMP_TABLE_LINK (coff)coff_sizeof_headers, bfd_generic_get_relocated_section_contents , bfd_generic_relax_section, _bfd_coff_link_hash_table_create , _bfd_generic_link_hash_table_free, _bfd_coff_link_add_symbols , _bfd_generic_link_just_syms, _bfd_coff_final_link, _bfd_generic_link_split_section , bfd_generic_gc_sections, bfd_generic_merge_sections, bfd_generic_discard_group, \
5671	BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic)_bfd_n1, ((long () (bfd , asymbol *)) _bfd_n1), _bfd_n1, ( (long () (bfd , arelent , asymbol *)) _bfd_n1), \
5672	\
5673	ALTERNATIVE, \
5674	\
5675	SWAP_TABLE \
5676	};
5677
5678	#define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE)const bfd_target VAR = { NAME , bfd_target_coff_flavour, BFD_ENDIAN_LITTLE , BFD_ENDIAN_LITTLE, (0x01 \| 0x02 \| 0x04 \| 0x08 \| 0x10 \| 0x20 \| 0x80 \| EXTRA_O_FLAGS), (0x200 \| 0x001 \| 0x002 \| 0x004 \| EXTRA_S_FLAGS ), UNDER, '/', 15, bfd_getl64, bfd_getl_signed_64, bfd_putl64 , bfd_getl32, bfd_getl_signed_32, bfd_putl32, bfd_getl16, bfd_getl_signed_16 , bfd_putl16, bfd_getl64, bfd_getl_signed_64, bfd_putl64, bfd_getl32 , bfd_getl_signed_32, bfd_putl32, bfd_getl16, bfd_getl_signed_16 , bfd_putl16, { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p , _bfd_dummy_target }, { bfd_false, coff_mkobject, _bfd_generic_mkarchive , bfd_false }, { bfd_false, coff_write_object_contents, _bfd_write_archive_contents , bfd_false }, bfd_true, bfd_true, coff_new_section_hook, _bfd_generic_get_section_contents , _bfd_generic_get_section_contents_in_window, ((bfd_boolean ( ) (bfd , bfd )) bfd_true), ((bfd_boolean () (bfd , bfd )) bfd_true), ((bfd_boolean () (bfd , asection , bfd , asection )) bfd_true), ((bfd_boolean () (bfd , asymbol , bfd , asymbol )) bfd_true), ((bfd_boolean () (bfd , flagword)) bfd_true ), ((bfd_boolean () (bfd , void )) bfd_true), _bfd_nocore_core_file_failing_command , _bfd_nocore_core_file_failing_signal, _bfd_nocore_core_file_matches_executable_p , bfd_slurp_armap, _bfd_slurp_extended_name_table, _bfd_archive_coff_construct_extended_name_table , bfd_dont_truncate_arname, coff_write_armap, _bfd_generic_read_ar_hdr , bfd_generic_openr_next_archived_file, _bfd_generic_get_elt_at_index , bfd_generic_stat_arch_elt, bfd_true, coff_get_symtab_upper_bound , coff_canonicalize_symtab, coff_make_empty_symbol, coff_print_symbol , coff_get_symbol_info, _bfd_coff_is_local_label_name, coff_get_lineno , coff_find_nearest_line, coff_bfd_make_debug_symbol, _bfd_generic_read_minisymbols , _bfd_generic_minisymbol_to_symbol, coff_get_reloc_upper_bound , coff_canonicalize_reloc, coff_i386_reloc_type_lookup, coff_set_arch_mach , coff_set_section_contents, coff_sizeof_headers, bfd_generic_get_relocated_section_contents , bfd_generic_relax_section, _bfd_coff_link_hash_table_create , _bfd_generic_link_hash_table_free, _bfd_coff_link_add_symbols , _bfd_generic_link_just_syms, _bfd_coff_final_link, _bfd_generic_link_split_section , bfd_generic_gc_sections, bfd_generic_merge_sections, bfd_generic_discard_group , _bfd_n1, ((long () (bfd , asymbol )) _bfd_n1), _bfd_n1, ((long () (bfd , arelent , asymbol *)) _bfd_n1), ALTERNATIVE , SWAP_TABLE }; \
5679	const bfd_target VAR = \
5680	{ \
5681	NAME , \
5682	bfd_target_coff_flavour, \
5683	BFD_ENDIAN_LITTLE, /* data byte order is little */ \
5684	BFD_ENDIAN_LITTLE, /* header byte order is little */ \
5685	/* object flags */ \
5686	(HAS_RELOC0x01 \| EXEC_P0x02 \| HAS_LINENO0x04 \| HAS_DEBUG0x08 \| \
5687	HAS_SYMS0x10 \| HAS_LOCALS0x20 \| WP_TEXT0x80 \| EXTRA_O_FLAGS), \
5688	/* section flags */ \
5689	(SEC_HAS_CONTENTS0x200 \| SEC_ALLOC0x001 \| SEC_LOAD0x002 \| SEC_RELOC0x004 \| EXTRA_S_FLAGS),\
5690	UNDER, /* leading symbol underscore */ \
5691	'/', /* ar_pad_char */ \
5692	15, /* ar_max_namelen */ \
5693	\
5694	/* Data conversion functions. */ \
5695	bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5696	bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5697	bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5698	/* Header conversion functions. */ \
5699	bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5700	bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5701	bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5702	/* bfd_check_format */ \
5703	{ _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5704	_bfd_dummy_target }, \
5705	/* bfd_set_format */ \
5706	{ bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5707	/* bfd_write_contents */ \
5708	{ bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5709	bfd_false }, \
5710	\
5711	BFD_JUMP_TABLE_GENERIC (coff)bfd_true, bfd_true, coff_new_section_hook, _bfd_generic_get_section_contents , _bfd_generic_get_section_contents_in_window, \
5712	BFD_JUMP_TABLE_COPY (coff)((bfd_boolean () (bfd , bfd )) bfd_true), ((bfd_boolean ( ) (bfd , bfd )) bfd_true), ((bfd_boolean () (bfd , asection , bfd , asection )) bfd_true), ((bfd_boolean () (bfd , asymbol , bfd , asymbol )) bfd_true), ((bfd_boolean () (bfd , flagword )) bfd_true), ((bfd_boolean () (bfd , void *)) bfd_true), \
5713	BFD_JUMP_TABLE_CORE (_bfd_nocore)_bfd_nocore_core_file_failing_command, _bfd_nocore_core_file_failing_signal , _bfd_nocore_core_file_matches_executable_p, \
5714	BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff)bfd_slurp_armap, _bfd_slurp_extended_name_table, _bfd_archive_coff_construct_extended_name_table , bfd_dont_truncate_arname, coff_write_armap, _bfd_generic_read_ar_hdr , bfd_generic_openr_next_archived_file, _bfd_generic_get_elt_at_index , bfd_generic_stat_arch_elt, bfd_true, \
5715	BFD_JUMP_TABLE_SYMBOLS (coff)coff_get_symtab_upper_bound, coff_canonicalize_symtab, coff_make_empty_symbol , coff_print_symbol, coff_get_symbol_info, _bfd_coff_is_local_label_name , coff_get_lineno, coff_find_nearest_line, coff_bfd_make_debug_symbol , _bfd_generic_read_minisymbols, _bfd_generic_minisymbol_to_symbol, \
5716	BFD_JUMP_TABLE_RELOCS (coff)coff_get_reloc_upper_bound, coff_canonicalize_reloc, coff_i386_reloc_type_lookup, \
5717	BFD_JUMP_TABLE_WRITE (coff)coff_set_arch_mach, coff_set_section_contents, \
5718	BFD_JUMP_TABLE_LINK (coff)coff_sizeof_headers, bfd_generic_get_relocated_section_contents , bfd_generic_relax_section, _bfd_coff_link_hash_table_create , _bfd_generic_link_hash_table_free, _bfd_coff_link_add_symbols , _bfd_generic_link_just_syms, _bfd_coff_final_link, _bfd_generic_link_split_section , bfd_generic_gc_sections, bfd_generic_merge_sections, bfd_generic_discard_group, \
5719	BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic)_bfd_n1, ((long () (bfd , asymbol *)) _bfd_n1), _bfd_n1, ( (long () (bfd , arelent , asymbol *)) _bfd_n1), \
5720	\
5721	ALTERNATIVE, \
5722	\
5723	SWAP_TABLE \
5724	};