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