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