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