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