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