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