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