Don't call bfd_link_hash_table_free
[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     {
3139       page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
3140
3141       /* If no file alignment has been set, default to one.
3142          This repairs 'ld -r' for arm-wince-pe target.  */
3143       if (page_size == 0)
3144         page_size = 1;
3145     }
3146   else
3147     page_size = PE_DEF_FILE_ALIGNMENT;
3148 #else
3149 #ifdef COFF_PAGE_SIZE
3150   int page_size = COFF_PAGE_SIZE;
3151 #endif
3152 #endif
3153
3154 #ifdef RS6000COFF_C
3155   /* On XCOFF, if we have symbols, set up the .debug section.  */
3156   if (bfd_get_symcount (abfd) > 0)
3157     {
3158       bfd_size_type sz;
3159       bfd_size_type i, symcount;
3160       asymbol **symp;
3161
3162       sz = 0;
3163       symcount = bfd_get_symcount (abfd);
3164       for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++)
3165         {
3166           coff_symbol_type *cf;
3167
3168           cf = coff_symbol_from (abfd, *symp);
3169           if (cf != NULL
3170               && cf->native != NULL
3171               && SYMNAME_IN_DEBUG (&cf->native->u.syment))
3172             {
3173               size_t len;
3174
3175               len = strlen (bfd_asymbol_name (*symp));
3176               if (len > SYMNMLEN || bfd_coff_force_symnames_in_strings (abfd))
3177                 sz += len + 1 + bfd_coff_debug_string_prefix_length (abfd);
3178             }
3179         }
3180       if (sz > 0)
3181         {
3182           asection *dsec;
3183
3184           dsec = bfd_make_section_old_way (abfd, DOT_DEBUG);
3185           if (dsec == NULL)
3186             abort ();
3187           dsec->size = sz;
3188           dsec->flags |= SEC_HAS_CONTENTS;
3189         }
3190     }
3191 #endif
3192
3193   if (bfd_get_start_address (abfd))
3194     /*  A start address may have been added to the original file. In this
3195         case it will need an optional header to record it.  */
3196     abfd->flags |= EXEC_P;
3197
3198   if (abfd->flags & EXEC_P)
3199     sofar += bfd_coff_aoutsz (abfd);
3200 #ifdef RS6000COFF_C
3201   else if (xcoff_data (abfd)->full_aouthdr)
3202     sofar += bfd_coff_aoutsz (abfd);
3203   else
3204     sofar += SMALL_AOUTSZ;
3205 #endif
3206
3207   sofar += abfd->section_count * bfd_coff_scnhsz (abfd);
3208
3209 #ifdef RS6000COFF_C
3210   /* XCOFF handles overflows in the reloc and line number count fields
3211      by allocating a new section header to hold the correct counts.  */
3212   for (current = abfd->sections; current != NULL; current = current->next)
3213     if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3214       sofar += bfd_coff_scnhsz (abfd);
3215 #endif
3216
3217 #ifdef COFF_IMAGE_WITH_PE
3218   {
3219     /* PE requires the sections to be in memory order when listed in
3220        the section headers.  It also does not like empty loadable
3221        sections.  The sections apparently do not have to be in the
3222        right order in the image file itself, but we do need to get the
3223        target_index values right.  */
3224
3225     unsigned int count;
3226     asection **section_list;
3227     unsigned int i;
3228     bfd_size_type amt;
3229
3230 #ifdef COFF_PAGE_SIZE
3231     /* Clear D_PAGED if section alignment is smaller than
3232        COFF_PAGE_SIZE.  */
3233    if (pe_data (abfd)->pe_opthdr.SectionAlignment < COFF_PAGE_SIZE)
3234      abfd->flags &= ~D_PAGED;
3235 #endif
3236
3237     count = 0;
3238     for (current = abfd->sections; current != NULL; current = current->next)
3239       ++count;
3240
3241     /* We allocate an extra cell to simplify the final loop.  */
3242     amt = sizeof (struct asection *) * (count + 1);
3243     section_list = (asection **) bfd_malloc (amt);
3244     if (section_list == NULL)
3245       return FALSE;
3246
3247     i = 0;
3248     for (current = abfd->sections; current != NULL; current = current->next)
3249       {
3250         section_list[i] = current;
3251         ++i;
3252       }
3253     section_list[i] = NULL;
3254
3255     qsort (section_list, count, sizeof (asection *), sort_by_secaddr);
3256
3257     /* Rethread the linked list into sorted order; at the same time,
3258        assign target_index values.  */
3259     target_index = 1;
3260     abfd->sections = NULL;
3261     abfd->section_last = NULL;
3262     for (i = 0; i < count; i++)
3263       {
3264         current = section_list[i];
3265         bfd_section_list_append (abfd, current);
3266
3267         /* Later, if the section has zero size, we'll be throwing it
3268            away, so we don't want to number it now.  Note that having
3269            a zero size and having real contents are different
3270            concepts: .bss has no contents, but (usually) non-zero
3271            size.  */
3272         if (current->size == 0)
3273           {
3274             /* Discard.  However, it still might have (valid) symbols
3275                in it, so arbitrarily set it to section 1 (indexing is
3276                1-based here; usually .text).  __end__ and other
3277                contents of .endsection really have this happen.
3278                FIXME: This seems somewhat dubious.  */
3279             current->target_index = 1;
3280           }
3281         else
3282           current->target_index = target_index++;
3283       }
3284
3285     free (section_list);
3286   }
3287 #else /* ! COFF_IMAGE_WITH_PE */
3288   {
3289     /* Set the target_index field.  */
3290     target_index = 1;
3291     for (current = abfd->sections; current != NULL; current = current->next)
3292       current->target_index = target_index++;
3293   }
3294 #endif /* ! COFF_IMAGE_WITH_PE */
3295
3296   if (target_index >= bfd_coff_max_nscns (abfd))
3297     {
3298       bfd_set_error (bfd_error_file_too_big);
3299       (*_bfd_error_handler)
3300         (_("%B: too many sections (%d)"), abfd, target_index);
3301       return FALSE;
3302     }
3303
3304   align_adjust = FALSE;
3305   for (current = abfd->sections;
3306        current != NULL;
3307        current = current->next)
3308     {
3309 #ifdef COFF_IMAGE_WITH_PE
3310       /* With PE we have to pad each section to be a multiple of its
3311          page size too, and remember both sizes.  */
3312       if (coff_section_data (abfd, current) == NULL)
3313         {
3314           bfd_size_type amt = sizeof (struct coff_section_tdata);
3315
3316           current->used_by_bfd = bfd_zalloc (abfd, amt);
3317           if (current->used_by_bfd == NULL)
3318             return FALSE;
3319         }
3320       if (pei_section_data (abfd, current) == NULL)
3321         {
3322           bfd_size_type amt = sizeof (struct pei_section_tdata);
3323
3324           coff_section_data (abfd, current)->tdata = bfd_zalloc (abfd, amt);
3325           if (coff_section_data (abfd, current)->tdata == NULL)
3326             return FALSE;
3327         }
3328       if (pei_section_data (abfd, current)->virt_size == 0)
3329         pei_section_data (abfd, current)->virt_size = current->size;
3330 #endif
3331
3332       /* Only deal with sections which have contents.  */
3333       if (!(current->flags & SEC_HAS_CONTENTS))
3334         continue;
3335
3336       current->rawsize = current->size;
3337
3338 #ifdef COFF_IMAGE_WITH_PE
3339       /* Make sure we skip empty sections in a PE image.  */
3340       if (current->size == 0)
3341         continue;
3342 #endif
3343
3344       /* Align the sections in the file to the same boundary on
3345          which they are aligned in virtual memory.  I960 doesn't
3346          do this (FIXME) so we can stay in sync with Intel.  960
3347          doesn't yet page from files...  */
3348 #ifdef ALIGN_SECTIONS_IN_FILE
3349       if ((abfd->flags & EXEC_P) != 0)
3350         {
3351           /* Make sure this section is aligned on the right boundary - by
3352              padding the previous section up if necessary.  */
3353           old_sofar = sofar;
3354
3355           sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3356
3357 #ifdef RS6000COFF_C
3358           /* Make sure the file offset and the vma of .text/.data are at the
3359              same page offset, so that the file can be mmap'ed without being
3360              relocated.  Failing that, AIX is able to load and execute the
3361              program, but it will be silently relocated (possible as
3362              executables are PIE).  But the relocation is slightly costly and
3363              complexify the use of addr2line or gdb.  So better to avoid it,
3364              like does the native linker.  Usually gnu ld makes sure that
3365              the vma of .text is the file offset so this issue shouldn't
3366              appear unless you are stripping such an executable.
3367
3368              AIX loader checks the text section alignment of (vma - filepos),
3369              and the native linker doesn't try to align the text sections.
3370              For example:
3371
3372              0 .text         000054cc  10000128  10000128  00000128  2**5
3373                              CONTENTS, ALLOC, LOAD, CODE
3374           */
3375
3376           if (!strcmp (current->name, _TEXT)
3377               || !strcmp (current->name, _DATA))
3378             {
3379               bfd_vma align = 4096;
3380               bfd_vma sofar_off = sofar % align;
3381               bfd_vma vma_off = current->vma % align;
3382
3383               if (vma_off > sofar_off)
3384                 sofar += vma_off - sofar_off;
3385               else if (vma_off < sofar_off)
3386                 sofar += align + vma_off - sofar_off;
3387             }
3388 #endif
3389           if (previous != NULL)
3390             previous->size += sofar - old_sofar;
3391         }
3392
3393 #endif
3394
3395       /* In demand paged files the low order bits of the file offset
3396          must match the low order bits of the virtual address.  */
3397 #ifdef COFF_PAGE_SIZE
3398       if ((abfd->flags & D_PAGED) != 0
3399           && (current->flags & SEC_ALLOC) != 0)
3400         sofar += (current->vma - (bfd_vma) sofar) % page_size;
3401 #endif
3402       current->filepos = sofar;
3403
3404 #ifdef COFF_IMAGE_WITH_PE
3405       /* Set the padded size.  */
3406       current->size = (current->size + page_size - 1) & -page_size;
3407 #endif
3408
3409       sofar += current->size;
3410
3411 #ifdef ALIGN_SECTIONS_IN_FILE
3412       /* Make sure that this section is of the right size too.  */
3413       if ((abfd->flags & EXEC_P) == 0)
3414         {
3415           bfd_size_type old_size;
3416
3417           old_size = current->size;
3418           current->size = BFD_ALIGN (current->size,
3419                                      1 << current->alignment_power);
3420           align_adjust = current->size != old_size;
3421           sofar += current->size - old_size;
3422         }
3423       else
3424         {
3425           old_sofar = sofar;
3426           sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3427           align_adjust = sofar != old_sofar;
3428           current->size += sofar - old_sofar;
3429         }
3430 #endif
3431
3432 #ifdef COFF_IMAGE_WITH_PE
3433       /* For PE we need to make sure we pad out to the aligned
3434          size, in case the caller only writes out data to the
3435          unaligned size.  */
3436       if (pei_section_data (abfd, current)->virt_size < current->size)
3437         align_adjust = TRUE;
3438 #endif
3439
3440 #ifdef _LIB
3441       /* Force .lib sections to start at zero.  The vma is then
3442          incremented in coff_set_section_contents.  This is right for
3443          SVR3.2.  */
3444       if (strcmp (current->name, _LIB) == 0)
3445         (void) bfd_set_section_vma (abfd, current, 0);
3446 #endif
3447
3448 #ifdef ALIGN_SECTIONS_IN_FILE
3449       previous = current;
3450 #endif
3451     }
3452
3453   /* It is now safe to write to the output file.  If we needed an
3454      alignment adjustment for the last section, then make sure that
3455      there is a byte at offset sofar.  If there are no symbols and no
3456      relocs, then nothing follows the last section.  If we don't force
3457      the last byte out, then the file may appear to be truncated.  */
3458   if (align_adjust)
3459     {
3460       bfd_byte b;
3461
3462       b = 0;
3463       if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0
3464           || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
3465         return FALSE;
3466     }
3467
3468   /* Make sure the relocations are aligned.  We don't need to make
3469      sure that this byte exists, because it will only matter if there
3470      really are relocs.  */
3471   sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER);
3472
3473   obj_relocbase (abfd) = sofar;
3474   abfd->output_has_begun = TRUE;
3475
3476   return TRUE;
3477 }
3478
3479 #ifdef COFF_IMAGE_WITH_PE
3480
3481 static unsigned int pelength;
3482 static unsigned int peheader;
3483
3484 static bfd_boolean
3485 coff_read_word (bfd *abfd, unsigned int *value)
3486 {
3487   unsigned char b[2];
3488   int status;
3489
3490   status = bfd_bread (b, (bfd_size_type) 2, abfd);
3491   if (status < 1)
3492     {
3493       *value = 0;
3494       return FALSE;
3495     }
3496
3497   if (status == 1)
3498     *value = (unsigned int) b[0];
3499   else
3500     *value = (unsigned int) (b[0] + (b[1] << 8));
3501
3502   pelength += (unsigned int) status;
3503
3504   return TRUE;
3505 }
3506
3507 static unsigned int
3508 coff_compute_checksum (bfd *abfd)
3509 {
3510   bfd_boolean more_data;
3511   file_ptr filepos;
3512   unsigned int value;
3513   unsigned int total;
3514
3515   total = 0;
3516   pelength = 0;
3517   filepos = (file_ptr) 0;
3518
3519   do
3520     {
3521       if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
3522         return 0;
3523
3524       more_data = coff_read_word (abfd, &value);
3525       total += value;
3526       total = 0xffff & (total + (total >> 0x10));
3527       filepos += 2;
3528     }
3529   while (more_data);
3530
3531   return (0xffff & (total + (total >> 0x10)));
3532 }
3533
3534 static bfd_boolean
3535 coff_apply_checksum (bfd *abfd)
3536 {
3537   unsigned int computed;
3538   unsigned int checksum = 0;
3539
3540   if (bfd_seek (abfd, 0x3c, SEEK_SET) != 0)
3541     return FALSE;
3542
3543   if (!coff_read_word (abfd, &peheader))
3544     return FALSE;
3545
3546   if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
3547     return FALSE;
3548
3549   checksum = 0;
3550   bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
3551
3552   if (bfd_seek (abfd, peheader, SEEK_SET) != 0)
3553     return FALSE;
3554
3555   computed = coff_compute_checksum (abfd);
3556
3557   checksum = computed + pelength;
3558
3559   if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
3560     return FALSE;
3561
3562   bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
3563
3564   return TRUE;
3565 }
3566
3567 #endif /* COFF_IMAGE_WITH_PE */
3568
3569 static bfd_boolean
3570 coff_write_object_contents (bfd * abfd)
3571 {
3572   asection *current;
3573   bfd_boolean hasrelocs = FALSE;
3574   bfd_boolean haslinno = FALSE;
3575 #ifdef COFF_IMAGE_WITH_PE
3576   bfd_boolean hasdebug = FALSE;
3577 #endif
3578   file_ptr scn_base;
3579   file_ptr reloc_base;
3580   file_ptr lineno_base;
3581   file_ptr sym_base;
3582   unsigned long reloc_size = 0, reloc_count = 0;
3583   unsigned long lnno_size = 0;
3584   bfd_boolean long_section_names;
3585   asection *text_sec = NULL;
3586   asection *data_sec = NULL;
3587   asection *bss_sec = NULL;
3588   struct internal_filehdr internal_f;
3589   struct internal_aouthdr internal_a;
3590 #ifdef COFF_LONG_SECTION_NAMES
3591   size_t string_size = STRING_SIZE_SIZE;
3592 #endif
3593
3594   bfd_set_error (bfd_error_system_call);
3595
3596   /* Make a pass through the symbol table to count line number entries and
3597      put them into the correct asections.  */
3598   lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd);
3599
3600   if (! abfd->output_has_begun)
3601     {
3602       if (! coff_compute_section_file_positions (abfd))
3603         return FALSE;
3604     }
3605
3606   reloc_base = obj_relocbase (abfd);
3607
3608   /* Work out the size of the reloc and linno areas.  */
3609
3610   for (current = abfd->sections; current != NULL; current =
3611        current->next)
3612     {
3613 #ifdef COFF_WITH_PE
3614       /* We store the actual reloc count in the first reloc's addr.  */
3615       if (obj_pe (abfd) && current->reloc_count >= 0xffff)
3616         reloc_count ++;
3617 #endif
3618       reloc_count += current->reloc_count;
3619     }
3620
3621   reloc_size = reloc_count * bfd_coff_relsz (abfd);
3622
3623   lineno_base = reloc_base + reloc_size;
3624   sym_base = lineno_base + lnno_size;
3625
3626   /* Indicate in each section->line_filepos its actual file address.  */
3627   for (current = abfd->sections; current != NULL; current =
3628        current->next)
3629     {
3630       if (current->lineno_count)
3631         {
3632           current->line_filepos = lineno_base;
3633           current->moving_line_filepos = lineno_base;
3634           lineno_base += current->lineno_count * bfd_coff_linesz (abfd);
3635         }
3636       else
3637         current->line_filepos = 0;
3638
3639       if (current->reloc_count)
3640         {
3641           current->rel_filepos = reloc_base;
3642           reloc_base += current->reloc_count * bfd_coff_relsz (abfd);
3643 #ifdef COFF_WITH_PE
3644           /* Extra reloc to hold real count.  */
3645           if (obj_pe (abfd) && current->reloc_count >= 0xffff)
3646             reloc_base += bfd_coff_relsz (abfd);
3647 #endif
3648         }
3649       else
3650         current->rel_filepos = 0;
3651     }
3652
3653   /* Write section headers to the file.  */
3654   internal_f.f_nscns = 0;
3655
3656   if ((abfd->flags & EXEC_P) != 0)
3657     scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
3658   else
3659     {
3660       scn_base = bfd_coff_filhsz (abfd);
3661 #ifdef RS6000COFF_C
3662 #ifndef XCOFF64
3663       if (xcoff_data (abfd)->full_aouthdr)
3664         scn_base += bfd_coff_aoutsz (abfd);
3665       else
3666         scn_base += SMALL_AOUTSZ;
3667 #endif
3668 #endif
3669     }
3670
3671   if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
3672     return FALSE;
3673
3674   long_section_names = FALSE;
3675   for (current = abfd->sections;
3676        current != NULL;
3677        current = current->next)
3678     {
3679       struct internal_scnhdr section;
3680 #ifdef COFF_IMAGE_WITH_PE
3681       bfd_boolean is_reloc_section = FALSE;
3682
3683       if (strcmp (current->name, DOT_RELOC) == 0)
3684         {
3685           is_reloc_section = TRUE;
3686           hasrelocs = TRUE;
3687           pe_data (abfd)->has_reloc_section = 1;
3688         }
3689 #endif
3690
3691       internal_f.f_nscns++;
3692
3693       strncpy (section.s_name, current->name, SCNNMLEN);
3694
3695 #ifdef COFF_LONG_SECTION_NAMES
3696       /* Handle long section names as in PE.  This must be compatible
3697          with the code in coff_write_symbols and _bfd_coff_final_link.  */
3698       if (bfd_coff_long_section_names (abfd))
3699         {
3700           size_t len;
3701
3702           len = strlen (current->name);
3703           if (len > SCNNMLEN)
3704             {
3705               /* The s_name field is defined to be NUL-padded but need not be
3706                  NUL-terminated.  We use a temporary buffer so that we can still
3707                  sprintf all eight chars without splatting a terminating NUL
3708                  over the first byte of the following member (s_paddr).  */
3709               char s_name_buf[SCNNMLEN + 1];
3710
3711               /* An inherent limitation of the /nnnnnnn notation used to indicate
3712                  the offset of the long name in the string table is that we
3713                  cannot address entries beyone the ten million byte boundary.  */
3714               if (string_size >= 10000000)
3715                 {
3716                   bfd_set_error (bfd_error_file_too_big);
3717                   (*_bfd_error_handler)
3718                     (_("%B: section %s: string table overflow at offset %ld"),
3719                     abfd, current->name, string_size);
3720                   return FALSE;
3721                 }
3722
3723               /* snprintf not strictly necessary now we've verified the value
3724                  has less than eight ASCII digits, but never mind.  */
3725               snprintf (s_name_buf, SCNNMLEN + 1, "/%lu", (unsigned long) string_size);
3726               /* Then strncpy takes care of any padding for us.  */
3727               strncpy (section.s_name, s_name_buf, SCNNMLEN);
3728               string_size += len + 1;
3729               long_section_names = TRUE;
3730             }
3731         }
3732 #endif
3733
3734 #ifdef _LIB
3735       /* Always set s_vaddr of .lib to 0.  This is right for SVR3.2
3736          Ian Taylor <ian@cygnus.com>.  */
3737       if (strcmp (current->name, _LIB) == 0)
3738         section.s_vaddr = 0;
3739       else
3740 #endif
3741       section.s_vaddr = current->vma;
3742       section.s_paddr = current->lma;
3743       section.s_size =  current->size;
3744 #ifdef coff_get_section_load_page
3745       section.s_page = coff_get_section_load_page (current);
3746 #else
3747       section.s_page = 0;
3748 #endif
3749
3750 #ifdef COFF_WITH_PE
3751       section.s_paddr = 0;
3752 #endif
3753 #ifdef COFF_IMAGE_WITH_PE
3754       /* Reminder: s_paddr holds the virtual size of the section.  */
3755       if (coff_section_data (abfd, current) != NULL
3756           && pei_section_data (abfd, current) != NULL)
3757         section.s_paddr = pei_section_data (abfd, current)->virt_size;
3758       else
3759         section.s_paddr = 0;
3760 #endif
3761
3762       /* If this section has no size or is unloadable then the scnptr
3763          will be 0 too.  */
3764       if (current->size == 0
3765           || (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
3766         section.s_scnptr = 0;
3767       else
3768         section.s_scnptr = current->filepos;
3769
3770       section.s_relptr = current->rel_filepos;
3771       section.s_lnnoptr = current->line_filepos;
3772       section.s_nreloc = current->reloc_count;
3773       section.s_nlnno = current->lineno_count;
3774 #ifndef COFF_IMAGE_WITH_PE
3775       /* In PEI, relocs come in the .reloc section.  */
3776       if (current->reloc_count != 0)
3777         hasrelocs = TRUE;
3778 #endif
3779       if (current->lineno_count != 0)
3780         haslinno = TRUE;
3781 #ifdef COFF_IMAGE_WITH_PE
3782       if ((current->flags & SEC_DEBUGGING) != 0
3783           && ! is_reloc_section)
3784         hasdebug = TRUE;
3785 #endif
3786
3787 #ifdef RS6000COFF_C
3788 #ifndef XCOFF64
3789       /* Indicate the use of an XCOFF overflow section header.  */
3790       if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3791         {
3792           section.s_nreloc = 0xffff;
3793           section.s_nlnno = 0xffff;
3794         }
3795 #endif
3796 #endif
3797
3798       section.s_flags = sec_to_styp_flags (current->name, current->flags);
3799
3800       if (!strcmp (current->name, _TEXT))
3801         text_sec = current;
3802       else if (!strcmp (current->name, _DATA))
3803         data_sec = current;
3804       else if (!strcmp (current->name, _BSS))
3805         bss_sec = current;
3806
3807 #ifdef I960
3808       section.s_align = (current->alignment_power
3809                          ? 1 << current->alignment_power
3810                          : 0);
3811 #endif
3812 #ifdef TIC80COFF
3813       /* TI COFF puts the alignment power in bits 8-11 of the flags.  */
3814       section.s_flags |= (current->alignment_power & 0xF) << 8;
3815 #endif
3816 #ifdef COFF_ENCODE_ALIGNMENT
3817       COFF_ENCODE_ALIGNMENT(section, current->alignment_power);
3818 #endif
3819
3820 #ifdef COFF_IMAGE_WITH_PE
3821       /* Suppress output of the sections if they are null.  ld
3822          includes the bss and data sections even if there is no size
3823          assigned to them.  NT loader doesn't like it if these section
3824          headers are included if the sections themselves are not
3825          needed.  See also coff_compute_section_file_positions.  */
3826       if (section.s_size == 0)
3827         internal_f.f_nscns--;
3828       else
3829 #endif
3830         {
3831           SCNHDR buff;
3832           bfd_size_type amt = bfd_coff_scnhsz (abfd);
3833
3834           if (coff_swap_scnhdr_out (abfd, &section, &buff) == 0
3835               || bfd_bwrite (& buff, amt, abfd) != amt)
3836             return FALSE;
3837         }
3838
3839 #ifdef COFF_WITH_PE
3840       /* PE stores COMDAT section information in the symbol table.  If
3841          this section is supposed to have some COMDAT info, track down
3842          the symbol in the symbol table and modify it.  */
3843       if ((current->flags & SEC_LINK_ONCE) != 0)
3844         {
3845           unsigned int i, count;
3846           asymbol **psym;
3847           coff_symbol_type *csym = NULL;
3848           asymbol **psymsec;
3849
3850           psymsec = NULL;
3851           count = bfd_get_symcount (abfd);
3852           for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++)
3853             {
3854               if ((*psym)->section != current)
3855                 continue;
3856
3857               /* Remember the location of the first symbol in this
3858                  section.  */
3859               if (psymsec == NULL)
3860                 psymsec = psym;
3861
3862               /* See if this is the section symbol.  */
3863               if (strcmp ((*psym)->name, current->name) == 0)
3864                 {
3865                   csym = coff_symbol_from (abfd, *psym);
3866                   if (csym == NULL
3867                       || csym->native == NULL
3868                       || csym->native->u.syment.n_numaux < 1
3869                       || csym->native->u.syment.n_sclass != C_STAT
3870                       || csym->native->u.syment.n_type != T_NULL)
3871                     continue;
3872
3873                   /* Here *PSYM is the section symbol for CURRENT.  */
3874
3875                   break;
3876                 }
3877             }
3878
3879           /* Did we find it?
3880              Note that we might not if we're converting the file from
3881              some other object file format.  */
3882           if (i < count)
3883             {
3884               combined_entry_type *aux;
3885
3886               /* We don't touch the x_checksum field.  The
3887                  x_associated field is not currently supported.  */
3888
3889               aux = csym->native + 1;
3890               switch (current->flags & SEC_LINK_DUPLICATES)
3891                 {
3892                 case SEC_LINK_DUPLICATES_DISCARD:
3893                   aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY;
3894                   break;
3895
3896                 case SEC_LINK_DUPLICATES_ONE_ONLY:
3897                   aux->u.auxent.x_scn.x_comdat =
3898                     IMAGE_COMDAT_SELECT_NODUPLICATES;
3899                   break;
3900
3901                 case SEC_LINK_DUPLICATES_SAME_SIZE:
3902                   aux->u.auxent.x_scn.x_comdat =
3903                     IMAGE_COMDAT_SELECT_SAME_SIZE;
3904                   break;
3905
3906                 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
3907                   aux->u.auxent.x_scn.x_comdat =
3908                     IMAGE_COMDAT_SELECT_EXACT_MATCH;
3909                   break;
3910                 }
3911
3912               /* The COMDAT symbol must be the first symbol from this
3913                  section in the symbol table.  In order to make this
3914                  work, we move the COMDAT symbol before the first
3915                  symbol we found in the search above.  It's OK to
3916                  rearrange the symbol table at this point, because
3917                  coff_renumber_symbols is going to rearrange it
3918                  further and fix up all the aux entries.  */
3919               if (psym != psymsec)
3920                 {
3921                   asymbol *hold;
3922                   asymbol **pcopy;
3923
3924                   hold = *psym;
3925                   for (pcopy = psym; pcopy > psymsec; pcopy--)
3926                     pcopy[0] = pcopy[-1];
3927                   *psymsec = hold;
3928                 }
3929             }
3930         }
3931 #endif /* COFF_WITH_PE */
3932     }
3933
3934 #ifdef RS6000COFF_C
3935 #ifndef XCOFF64
3936   /* XCOFF handles overflows in the reloc and line number count fields
3937      by creating a new section header to hold the correct values.  */
3938   for (current = abfd->sections; current != NULL; current = current->next)
3939     {
3940       if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3941         {
3942           struct internal_scnhdr scnhdr;
3943           SCNHDR buff;
3944           bfd_size_type amt;
3945
3946           internal_f.f_nscns++;
3947           memcpy (scnhdr.s_name, ".ovrflo", 8);
3948           scnhdr.s_paddr = current->reloc_count;
3949           scnhdr.s_vaddr = current->lineno_count;
3950           scnhdr.s_size = 0;
3951           scnhdr.s_scnptr = 0;
3952           scnhdr.s_relptr = current->rel_filepos;
3953           scnhdr.s_lnnoptr = current->line_filepos;
3954           scnhdr.s_nreloc = current->target_index;
3955           scnhdr.s_nlnno = current->target_index;
3956           scnhdr.s_flags = STYP_OVRFLO;
3957           amt = bfd_coff_scnhsz (abfd);
3958           if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
3959               || bfd_bwrite (& buff, amt, abfd) != amt)
3960             return FALSE;
3961         }
3962     }
3963 #endif
3964 #endif
3965
3966   /* OK, now set up the filehdr...  */
3967
3968   /* Don't include the internal abs section in the section count */
3969
3970   /* We will NOT put a fucking timestamp in the header here. Every time you
3971      put it back, I will come in and take it out again.  I'm sorry.  This
3972      field does not belong here.  We fill it with a 0 so it compares the
3973      same but is not a reasonable time. -- gnu@cygnus.com  */
3974   internal_f.f_timdat = 0;
3975   internal_f.f_flags = 0;
3976
3977   if (abfd->flags & EXEC_P)
3978     internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3979   else
3980     {
3981       internal_f.f_opthdr = 0;
3982 #ifdef RS6000COFF_C
3983 #ifndef XCOFF64
3984       if (xcoff_data (abfd)->full_aouthdr)
3985         internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3986       else
3987         internal_f.f_opthdr = SMALL_AOUTSZ;
3988 #endif
3989 #endif
3990     }
3991
3992   if (!hasrelocs)
3993     internal_f.f_flags |= F_RELFLG;
3994   if (!haslinno)
3995     internal_f.f_flags |= F_LNNO;
3996   if (abfd->flags & EXEC_P)
3997     internal_f.f_flags |= F_EXEC;
3998 #ifdef COFF_IMAGE_WITH_PE
3999   if (! hasdebug)
4000     internal_f.f_flags |= IMAGE_FILE_DEBUG_STRIPPED;
4001   if (pe_data (abfd)->real_flags & IMAGE_FILE_LARGE_ADDRESS_AWARE)
4002     internal_f.f_flags |= IMAGE_FILE_LARGE_ADDRESS_AWARE;
4003 #endif
4004
4005 #ifndef COFF_WITH_pex64
4006 #ifdef COFF_WITH_PE
4007   internal_f.f_flags |= IMAGE_FILE_32BIT_MACHINE;
4008 #else
4009   if (bfd_little_endian (abfd))
4010     internal_f.f_flags |= F_AR32WR;
4011   else
4012     internal_f.f_flags |= F_AR32W;
4013 #endif
4014 #endif
4015
4016 #ifdef TI_TARGET_ID
4017   /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
4018      but it doesn't hurt to set it internally.  */
4019   internal_f.f_target_id = TI_TARGET_ID;
4020 #endif
4021 #ifdef TIC80_TARGET_ID
4022   internal_f.f_target_id = TIC80_TARGET_ID;
4023 #endif
4024
4025   /* FIXME, should do something about the other byte orders and
4026      architectures.  */
4027
4028 #ifdef RS6000COFF_C
4029   if ((abfd->flags & DYNAMIC) != 0)
4030     internal_f.f_flags |= F_SHROBJ;
4031   if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
4032     internal_f.f_flags |= F_DYNLOAD;
4033 #endif
4034
4035   memset (&internal_a, 0, sizeof internal_a);
4036
4037   /* Set up architecture-dependent stuff.  */
4038   {
4039     unsigned int magic = 0;
4040     unsigned short flags = 0;
4041
4042     coff_set_flags (abfd, &magic, &flags);
4043     internal_f.f_magic = magic;
4044     internal_f.f_flags |= flags;
4045     /* ...and the "opt"hdr...  */
4046
4047 #ifdef TICOFF_AOUT_MAGIC
4048     internal_a.magic = TICOFF_AOUT_MAGIC;
4049 #define __A_MAGIC_SET__
4050 #endif
4051 #ifdef TIC80COFF
4052     internal_a.magic = TIC80_ARCH_MAGIC;
4053 #define __A_MAGIC_SET__
4054 #endif /* TIC80 */
4055 #ifdef I860
4056     /* FIXME: What are the a.out magic numbers for the i860?  */
4057     internal_a.magic = 0;
4058 #define __A_MAGIC_SET__
4059 #endif /* I860 */
4060 #ifdef I960
4061     internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
4062 #define __A_MAGIC_SET__
4063 #endif /* I960 */
4064 #if M88
4065 #define __A_MAGIC_SET__
4066     internal_a.magic = PAGEMAGICBCS;
4067 #endif /* M88 */
4068
4069 #if APOLLO_M68
4070 #define __A_MAGIC_SET__
4071     internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
4072 #endif
4073
4074 #if defined(M68) || defined(WE32K) || defined(M68K)
4075 #define __A_MAGIC_SET__
4076 #if defined(LYNXOS)
4077     internal_a.magic = LYNXCOFFMAGIC;
4078 #else
4079 #if defined(TARG_AUX)
4080     internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED :
4081                         abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED :
4082                         PAGEMAGICEXECSWAPPED);
4083 #else
4084 #if defined (PAGEMAGICPEXECPAGED)
4085     internal_a.magic = PAGEMAGICPEXECPAGED;
4086 #endif
4087 #endif /* TARG_AUX */
4088 #endif /* LYNXOS */
4089 #endif /* M68 || WE32K || M68K */
4090
4091 #if defined(ARM)
4092 #define __A_MAGIC_SET__
4093     internal_a.magic = ZMAGIC;
4094 #endif
4095
4096 #if defined(PPC_PE)
4097 #define __A_MAGIC_SET__
4098     internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
4099 #endif
4100
4101 #if defined MCORE_PE
4102 #define __A_MAGIC_SET__
4103     internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
4104 #endif
4105
4106 #if defined(I386)
4107 #define __A_MAGIC_SET__
4108 #if defined LYNXOS
4109     internal_a.magic = LYNXCOFFMAGIC;
4110 #elif defined AMD64
4111     internal_a.magic = IMAGE_NT_OPTIONAL_HDR64_MAGIC;
4112 #else
4113     internal_a.magic = ZMAGIC;
4114 #endif
4115 #endif /* I386 */
4116
4117 #if defined(IA64)
4118 #define __A_MAGIC_SET__
4119     internal_a.magic = PE32PMAGIC;
4120 #endif /* IA64 */
4121
4122 #if defined(SPARC)
4123 #define __A_MAGIC_SET__
4124 #if defined(LYNXOS)
4125     internal_a.magic = LYNXCOFFMAGIC;
4126 #endif /* LYNXOS */
4127 #endif /* SPARC */
4128
4129 #ifdef RS6000COFF_C
4130 #define __A_MAGIC_SET__
4131     internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
4132     (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
4133     RS6K_AOUTHDR_OMAGIC;
4134 #endif
4135
4136 #if defined(SH) && defined(COFF_WITH_PE)
4137 #define __A_MAGIC_SET__
4138     internal_a.magic = SH_PE_MAGIC;
4139 #endif
4140
4141 #if defined(MIPS) && defined(COFF_WITH_PE)
4142 #define __A_MAGIC_SET__
4143     internal_a.magic = MIPS_PE_MAGIC;
4144 #endif
4145
4146 #ifndef __A_MAGIC_SET__
4147 #include "Your aouthdr magic number is not being set!"
4148 #else
4149 #undef __A_MAGIC_SET__
4150 #endif
4151   }
4152
4153   /* FIXME: Does anybody ever set this to another value?  */
4154   internal_a.vstamp = 0;
4155
4156   /* Now should write relocs, strings, syms.  */
4157   obj_sym_filepos (abfd) = sym_base;
4158
4159   if (bfd_get_symcount (abfd) != 0)
4160     {
4161       int firstundef;
4162
4163       if (!coff_renumber_symbols (abfd, &firstundef))
4164         return FALSE;
4165       coff_mangle_symbols (abfd);
4166       if (! coff_write_symbols (abfd))
4167         return FALSE;
4168       if (! coff_write_linenumbers (abfd))
4169         return FALSE;
4170       if (! coff_write_relocs (abfd, firstundef))
4171         return FALSE;
4172     }
4173 #ifdef COFF_LONG_SECTION_NAMES
4174   else if (long_section_names && ! obj_coff_strings_written (abfd))
4175     {
4176       /* If we have long section names we have to write out the string
4177          table even if there are no symbols.  */
4178       if (! coff_write_symbols (abfd))
4179         return FALSE;
4180     }
4181 #endif
4182 #ifdef COFF_IMAGE_WITH_PE
4183 #ifdef PPC_PE
4184   else if ((abfd->flags & EXEC_P) != 0)
4185     {
4186       bfd_byte b;
4187
4188       /* PowerPC PE appears to require that all executable files be
4189          rounded up to the page size.  */
4190       b = 0;
4191       if (bfd_seek (abfd,
4192                     (file_ptr) BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1,
4193                     SEEK_SET) != 0
4194           || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
4195         return FALSE;
4196     }
4197 #endif
4198 #endif
4199
4200   /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
4201      backend linker, and obj_raw_syment_count is not valid until after
4202      coff_write_symbols is called.  */
4203   if (obj_raw_syment_count (abfd) != 0)
4204     {
4205       internal_f.f_symptr = sym_base;
4206 #ifdef RS6000COFF_C
4207       /* AIX appears to require that F_RELFLG not be set if there are
4208          local symbols but no relocations.  */
4209       internal_f.f_flags &=~ F_RELFLG;
4210 #endif
4211     }
4212   else
4213     {
4214       if (long_section_names)
4215         internal_f.f_symptr = sym_base;
4216       else
4217         internal_f.f_symptr = 0;
4218       internal_f.f_flags |= F_LSYMS;
4219     }
4220
4221   if (text_sec)
4222     {
4223       internal_a.tsize = text_sec->size;
4224       internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
4225     }
4226   if (data_sec)
4227     {
4228       internal_a.dsize = data_sec->size;
4229       internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
4230     }
4231   if (bss_sec)
4232     {
4233       internal_a.bsize = bss_sec->size;
4234       if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
4235         internal_a.data_start = bss_sec->vma;
4236     }
4237
4238   internal_a.entry = bfd_get_start_address (abfd);
4239   internal_f.f_nsyms = obj_raw_syment_count (abfd);
4240
4241 #ifdef RS6000COFF_C
4242   if (xcoff_data (abfd)->full_aouthdr)
4243     {
4244       bfd_vma toc;
4245       asection *loader_sec;
4246
4247       internal_a.vstamp = 1;
4248
4249       internal_a.o_snentry = xcoff_data (abfd)->snentry;
4250       if (internal_a.o_snentry == 0)
4251         internal_a.entry = (bfd_vma) -1;
4252
4253       if (text_sec != NULL)
4254         {
4255           internal_a.o_sntext = text_sec->target_index;
4256           internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
4257         }
4258       else
4259         {
4260           internal_a.o_sntext = 0;
4261           internal_a.o_algntext = 0;
4262         }
4263       if (data_sec != NULL)
4264         {
4265           internal_a.o_sndata = data_sec->target_index;
4266           internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
4267         }
4268       else
4269         {
4270           internal_a.o_sndata = 0;
4271           internal_a.o_algndata = 0;
4272         }
4273       loader_sec = bfd_get_section_by_name (abfd, ".loader");
4274       if (loader_sec != NULL)
4275         internal_a.o_snloader = loader_sec->target_index;
4276       else
4277         internal_a.o_snloader = 0;
4278       if (bss_sec != NULL)
4279         internal_a.o_snbss = bss_sec->target_index;
4280       else
4281         internal_a.o_snbss = 0;
4282
4283       toc = xcoff_data (abfd)->toc;
4284       internal_a.o_toc = toc;
4285       internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
4286
4287       internal_a.o_modtype = xcoff_data (abfd)->modtype;
4288       if (xcoff_data (abfd)->cputype != -1)
4289         internal_a.o_cputype = xcoff_data (abfd)->cputype;
4290       else
4291         {
4292           switch (bfd_get_arch (abfd))
4293             {
4294             case bfd_arch_rs6000:
4295               internal_a.o_cputype = 4;
4296               break;
4297             case bfd_arch_powerpc:
4298               if (bfd_get_mach (abfd) == bfd_mach_ppc)
4299                 internal_a.o_cputype = 3;
4300               else
4301                 internal_a.o_cputype = 1;
4302               break;
4303             default:
4304               abort ();
4305             }
4306         }
4307       internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
4308       internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
4309     }
4310 #endif
4311
4312 #ifdef COFF_WITH_PE
4313   {
4314     /* After object contents are finalized so we can compute a reasonable hash,
4315        but before header is written so we can update it to point to debug directory.  */
4316     struct pe_tdata *pe = pe_data (abfd);
4317
4318     if (pe->build_id.after_write_object_contents != NULL)
4319       (*pe->build_id.after_write_object_contents) (abfd);
4320   }
4321 #endif
4322
4323   /* Now write header.  */
4324   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
4325     return FALSE;
4326
4327   {
4328     char * buff;
4329     bfd_size_type amount = bfd_coff_filhsz (abfd);
4330
4331     buff = (char *) bfd_malloc (amount);
4332     if (buff == NULL)
4333       return FALSE;
4334
4335     bfd_coff_swap_filehdr_out (abfd, & internal_f, buff);
4336     amount = bfd_bwrite (buff, amount, abfd);
4337
4338     free (buff);
4339
4340     if (amount != bfd_coff_filhsz (abfd))
4341       return FALSE;
4342   }
4343
4344   if (abfd->flags & EXEC_P)
4345     {
4346       /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4347          include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)).  */
4348       char * buff;
4349       bfd_size_type amount = bfd_coff_aoutsz (abfd);
4350
4351       buff = (char *) bfd_malloc (amount);
4352       if (buff == NULL)
4353         return FALSE;
4354
4355       coff_swap_aouthdr_out (abfd, & internal_a, buff);
4356       amount = bfd_bwrite (buff, amount, abfd);
4357
4358       free (buff);
4359
4360       if (amount != bfd_coff_aoutsz (abfd))
4361         return FALSE;
4362
4363 #ifdef COFF_IMAGE_WITH_PE
4364       if (! coff_apply_checksum (abfd))
4365         return FALSE;
4366 #endif
4367     }
4368 #ifdef RS6000COFF_C
4369   else
4370     {
4371       AOUTHDR buff;
4372       size_t size;
4373
4374       /* XCOFF seems to always write at least a small a.out header.  */
4375       coff_swap_aouthdr_out (abfd, & internal_a, & buff);
4376       if (xcoff_data (abfd)->full_aouthdr)
4377         size = bfd_coff_aoutsz (abfd);
4378       else
4379         size = SMALL_AOUTSZ;
4380       if (bfd_bwrite (& buff, (bfd_size_type) size, abfd) != size)
4381         return FALSE;
4382     }
4383 #endif
4384
4385   return TRUE;
4386 }
4387
4388 static bfd_boolean
4389 coff_set_section_contents (bfd * abfd,
4390                            sec_ptr section,
4391                            const void * location,
4392                            file_ptr offset,
4393                            bfd_size_type count)
4394 {
4395   if (! abfd->output_has_begun) /* Set by bfd.c handler.  */
4396     {
4397       if (! coff_compute_section_file_positions (abfd))
4398         return FALSE;
4399     }
4400
4401 #if defined(_LIB) && !defined(TARG_AUX)
4402    /* The physical address field of a .lib section is used to hold the
4403       number of shared libraries in the section.  This code counts the
4404       number of sections being written, and increments the lma field
4405       with the number.
4406
4407       I have found no documentation on the contents of this section.
4408       Experimentation indicates that the section contains zero or more
4409       records, each of which has the following structure:
4410
4411       - a (four byte) word holding the length of this record, in words,
4412       - a word that always seems to be set to "2",
4413       - the path to a shared library, null-terminated and then padded
4414         to a whole word boundary.
4415
4416       bfd_assert calls have been added to alert if an attempt is made
4417       to write a section which doesn't follow these assumptions.  The
4418       code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4419       <robertl@arnet.com> (Thanks!).
4420
4421       Gvran Uddeborg <gvran@uddeborg.pp.se>.  */
4422     if (strcmp (section->name, _LIB) == 0)
4423       {
4424         bfd_byte *rec, *recend;
4425
4426         rec = (bfd_byte *) location;
4427         recend = rec + count;
4428         while (rec < recend)
4429           {
4430             ++section->lma;
4431             rec += bfd_get_32 (abfd, rec) * 4;
4432           }
4433
4434         BFD_ASSERT (rec == recend);
4435       }
4436 #endif
4437
4438   /* Don't write out bss sections - one way to do this is to
4439        see if the filepos has not been set.  */
4440   if (section->filepos == 0)
4441     return TRUE;
4442
4443   if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
4444     return FALSE;
4445
4446   if (count == 0)
4447     return TRUE;
4448
4449   return bfd_bwrite (location, count, abfd) == count;
4450 }
4451
4452 static void *
4453 buy_and_read (bfd *abfd, file_ptr where, bfd_size_type size)
4454 {
4455   void * area = bfd_alloc (abfd, size);
4456
4457   if (!area)
4458     return (NULL);
4459   if (bfd_seek (abfd, where, SEEK_SET) != 0
4460       || bfd_bread (area, size, abfd) != size)
4461     return (NULL);
4462   return (area);
4463 }
4464
4465 /*
4466 SUBSUBSECTION
4467         Reading linenumbers
4468
4469         Creating the linenumber table is done by reading in the entire
4470         coff linenumber table, and creating another table for internal use.
4471
4472         A coff linenumber table is structured so that each function
4473         is marked as having a line number of 0. Each line within the
4474         function is an offset from the first line in the function. The
4475         base of the line number information for the table is stored in
4476         the symbol associated with the function.
4477
4478         Note: The PE format uses line number 0 for a flag indicating a
4479         new source file.
4480
4481         The information is copied from the external to the internal
4482         table, and each symbol which marks a function is marked by
4483         pointing its...
4484
4485         How does this work ?
4486 */
4487
4488 static int
4489 coff_sort_func_alent (const void * arg1, const void * arg2)
4490 {
4491   const alent *al1 = *(const alent **) arg1;
4492   const alent *al2 = *(const alent **) arg2;
4493   const coff_symbol_type *s1 = (const coff_symbol_type *) (al1->u.sym);
4494   const coff_symbol_type *s2 = (const coff_symbol_type *) (al2->u.sym);
4495
4496   if (s1->symbol.value < s2->symbol.value)
4497     return -1;
4498   else if (s1->symbol.value > s2->symbol.value)
4499     return 1;
4500
4501   return 0;
4502 }
4503
4504 static bfd_boolean
4505 coff_slurp_line_table (bfd *abfd, asection *asect)
4506 {
4507   LINENO *native_lineno;
4508   alent *lineno_cache;
4509   bfd_size_type amt;
4510   unsigned int counter;
4511   alent *cache_ptr;
4512   bfd_vma prev_offset = 0;
4513   int ordered = 1;
4514   unsigned int nbr_func;
4515   LINENO *src;
4516
4517   BFD_ASSERT (asect->lineno == NULL);
4518
4519   amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
4520   lineno_cache = (alent *) bfd_alloc (abfd, amt);
4521   if (lineno_cache == NULL)
4522     return FALSE;
4523
4524   amt = (bfd_size_type) bfd_coff_linesz (abfd) * asect->lineno_count;
4525   native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos, amt);
4526   if (native_lineno == NULL)
4527     {
4528       (*_bfd_error_handler)
4529         (_("%B: warning: line number table read failed"), abfd);
4530       bfd_release (abfd, lineno_cache);
4531       return FALSE;
4532     }
4533
4534   cache_ptr = lineno_cache;
4535   asect->lineno = lineno_cache;
4536   src = native_lineno;
4537   nbr_func = 0;
4538
4539   for (counter = 0; counter < asect->lineno_count; counter++)
4540     {
4541       struct internal_lineno dst;
4542
4543       bfd_coff_swap_lineno_in (abfd, src, &dst);
4544       cache_ptr->line_number = dst.l_lnno;
4545
4546       if (cache_ptr->line_number == 0)
4547         {
4548           bfd_boolean warned;
4549           bfd_signed_vma symndx;
4550           coff_symbol_type *sym;
4551
4552           nbr_func++;
4553           warned = FALSE;
4554           symndx = dst.l_addr.l_symndx;
4555           if (symndx < 0
4556               || (bfd_vma) symndx >= obj_raw_syment_count (abfd))
4557             {
4558               (*_bfd_error_handler)
4559                 (_("%B: warning: illegal symbol index %ld in line numbers"),
4560                  abfd, (long) symndx);
4561               symndx = 0;
4562               warned = TRUE;
4563             }
4564
4565           /* FIXME: We should not be casting between ints and
4566              pointers like this.  */
4567           sym = ((coff_symbol_type *)
4568                  ((symndx + obj_raw_syments (abfd))
4569                   ->u.syment._n._n_n._n_zeroes));
4570           cache_ptr->u.sym = (asymbol *) sym;
4571           if (sym->lineno != NULL && ! warned)
4572             (*_bfd_error_handler)
4573               (_("%B: warning: duplicate line number information for `%s'"),
4574                abfd, bfd_asymbol_name (&sym->symbol));
4575
4576           sym->lineno = cache_ptr;
4577           if (sym->symbol.value < prev_offset)
4578             ordered = 0;
4579           prev_offset = sym->symbol.value;
4580         }
4581       else
4582         cache_ptr->u.offset = dst.l_addr.l_paddr
4583           - bfd_section_vma (abfd, asect);
4584
4585       cache_ptr++;
4586       src++;
4587     }
4588   cache_ptr->line_number = 0;
4589   bfd_release (abfd, native_lineno);
4590
4591   /* On some systems (eg AIX5.3) the lineno table may not be sorted.  */
4592   if (!ordered)
4593     {
4594       /* Sort the table.  */
4595       alent **func_table;
4596       alent *n_lineno_cache;
4597
4598       /* Create a table of functions.  */
4599       func_table = (alent **) bfd_alloc (abfd, nbr_func * sizeof (alent *));
4600       if (func_table != NULL)
4601         {
4602           alent **p = func_table;
4603           unsigned int i;
4604
4605           for (i = 0; i < counter; i++)
4606             if (lineno_cache[i].line_number == 0)
4607               *p++ = &lineno_cache[i];
4608
4609           /* Sort by functions.  */
4610           qsort (func_table, nbr_func, sizeof (alent *), coff_sort_func_alent);
4611
4612           /* Create the new sorted table.  */
4613           amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
4614           n_lineno_cache = (alent *) bfd_alloc (abfd, amt);
4615           if (n_lineno_cache != NULL)
4616             {
4617               alent *n_cache_ptr = n_lineno_cache;
4618
4619               for (i = 0; i < nbr_func; i++)
4620                 {
4621                   coff_symbol_type *sym;
4622                   alent *old_ptr = func_table[i];
4623
4624                   /* Copy the function entry and update it.  */
4625                   *n_cache_ptr = *old_ptr;
4626                   sym = (coff_symbol_type *)n_cache_ptr->u.sym;
4627                   sym->lineno = n_cache_ptr;
4628                   n_cache_ptr++;
4629                   old_ptr++;
4630
4631                   /* Copy the line number entries.  */
4632                   while (old_ptr->line_number != 0)
4633                     *n_cache_ptr++ = *old_ptr++;
4634                 }
4635               n_cache_ptr->line_number = 0;
4636               memcpy (lineno_cache, n_lineno_cache, amt);
4637             }
4638           bfd_release (abfd, func_table);
4639         }
4640     }
4641
4642   return TRUE;
4643 }
4644
4645 /* Slurp in the symbol table, converting it to generic form.  Note
4646    that if coff_relocate_section is defined, the linker will read
4647    symbols via coff_link_add_symbols, rather than via this routine.  */
4648
4649 static bfd_boolean
4650 coff_slurp_symbol_table (bfd * abfd)
4651 {
4652   combined_entry_type *native_symbols;
4653   coff_symbol_type *cached_area;
4654   unsigned int *table_ptr;
4655   bfd_size_type amt;
4656   unsigned int number_of_symbols = 0;
4657
4658   if (obj_symbols (abfd))
4659     return TRUE;
4660
4661   /* Read in the symbol table.  */
4662   if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
4663     return FALSE;
4664
4665   /* Allocate enough room for all the symbols in cached form.  */
4666   amt = obj_raw_syment_count (abfd);
4667   amt *= sizeof (coff_symbol_type);
4668   cached_area = (coff_symbol_type *) bfd_alloc (abfd, amt);
4669   if (cached_area == NULL)
4670     return FALSE;
4671
4672   amt = obj_raw_syment_count (abfd);
4673   amt *= sizeof (unsigned int);
4674   table_ptr = (unsigned int *) bfd_alloc (abfd, amt);
4675
4676   if (table_ptr == NULL)
4677     return FALSE;
4678   else
4679     {
4680       coff_symbol_type *dst = cached_area;
4681       unsigned int last_native_index = obj_raw_syment_count (abfd);
4682       unsigned int this_index = 0;
4683
4684       while (this_index < last_native_index)
4685         {
4686           combined_entry_type *src = native_symbols + this_index;
4687           table_ptr[this_index] = number_of_symbols;
4688           dst->symbol.the_bfd = abfd;
4689
4690           dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
4691           /* We use the native name field to point to the cached field.  */
4692           src->u.syment._n._n_n._n_zeroes = (bfd_hostptr_t) dst;
4693           dst->symbol.section = coff_section_from_bfd_index (abfd,
4694                                                      src->u.syment.n_scnum);
4695           dst->symbol.flags = 0;
4696           dst->done_lineno = FALSE;
4697
4698           switch (src->u.syment.n_sclass)
4699             {
4700 #ifdef I960
4701             case C_LEAFEXT:
4702               /* Fall through to next case.  */
4703 #endif
4704
4705             case C_EXT:
4706             case C_WEAKEXT:
4707 #if defined ARM
4708             case C_THUMBEXT:
4709             case C_THUMBEXTFUNC:
4710 #endif
4711 #ifdef RS6000COFF_C
4712             case C_HIDEXT:
4713 #endif
4714 #ifdef C_SYSTEM
4715             case C_SYSTEM:      /* System Wide variable.  */
4716 #endif
4717 #ifdef COFF_WITH_PE
4718             /* In PE, 0x68 (104) denotes a section symbol.  */
4719             case C_SECTION:
4720             /* In PE, 0x69 (105) denotes a weak external symbol.  */
4721             case C_NT_WEAK:
4722 #endif
4723               switch (coff_classify_symbol (abfd, &src->u.syment))
4724                 {
4725                 case COFF_SYMBOL_GLOBAL:
4726                   dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
4727 #if defined COFF_WITH_PE
4728                   /* PE sets the symbol to a value relative to the
4729                      start of the section.  */
4730                   dst->symbol.value = src->u.syment.n_value;
4731 #else
4732                   dst->symbol.value = (src->u.syment.n_value
4733                                        - dst->symbol.section->vma);
4734 #endif
4735                   if (ISFCN ((src->u.syment.n_type)))
4736                     /* A function ext does not go at the end of a
4737                        file.  */
4738                     dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4739                   break;
4740
4741                 case COFF_SYMBOL_COMMON:
4742                   dst->symbol.section = bfd_com_section_ptr;
4743                   dst->symbol.value = src->u.syment.n_value;
4744                   break;
4745
4746                 case COFF_SYMBOL_UNDEFINED:
4747                   dst->symbol.section = bfd_und_section_ptr;
4748                   dst->symbol.value = 0;
4749                   break;
4750
4751                 case COFF_SYMBOL_PE_SECTION:
4752                   dst->symbol.flags |= BSF_EXPORT | BSF_SECTION_SYM;
4753                   dst->symbol.value = 0;
4754                   break;
4755
4756                 case COFF_SYMBOL_LOCAL:
4757                   dst->symbol.flags = BSF_LOCAL;
4758 #if defined COFF_WITH_PE
4759                   /* PE sets the symbol to a value relative to the
4760                      start of the section.  */
4761                   dst->symbol.value = src->u.syment.n_value;
4762 #else
4763                   dst->symbol.value = (src->u.syment.n_value
4764                                        - dst->symbol.section->vma);
4765 #endif
4766                   if (ISFCN ((src->u.syment.n_type)))
4767                     dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4768                   break;
4769                 }
4770
4771 #ifdef RS6000COFF_C
4772               /* A symbol with a csect entry should not go at the end.  */
4773               if (src->u.syment.n_numaux > 0)
4774                 dst->symbol.flags |= BSF_NOT_AT_END;
4775 #endif
4776
4777 #ifdef COFF_WITH_PE
4778               if (src->u.syment.n_sclass == C_NT_WEAK)
4779                 dst->symbol.flags |= BSF_WEAK;
4780
4781               if (src->u.syment.n_sclass == C_SECTION
4782                   && src->u.syment.n_scnum > 0)
4783                 dst->symbol.flags = BSF_LOCAL;
4784 #endif
4785               if (src->u.syment.n_sclass == C_WEAKEXT)
4786                 dst->symbol.flags |= BSF_WEAK;
4787
4788               break;
4789
4790             case C_STAT:         /* Static.  */
4791 #ifdef I960
4792             case C_LEAFSTAT:     /* Static leaf procedure.  */
4793 #endif
4794 #if defined ARM
4795             case C_THUMBSTAT:    /* Thumb static.  */
4796             case C_THUMBLABEL:   /* Thumb label.  */
4797             case C_THUMBSTATFUNC:/* Thumb static function.  */
4798 #endif
4799 #ifdef RS6000COFF_C
4800             case C_DWARF:        /* A label in a dwarf section.  */
4801             case C_INFO:         /* A label in a comment section.  */
4802 #endif
4803             case C_LABEL:        /* Label.  */
4804               if (src->u.syment.n_scnum == N_DEBUG)
4805                 dst->symbol.flags = BSF_DEBUGGING;
4806               else
4807                 dst->symbol.flags = BSF_LOCAL;
4808
4809               /* Base the value as an index from the base of the
4810                  section, if there is one.  */
4811               if (dst->symbol.section)
4812                 {
4813 #if defined COFF_WITH_PE
4814                   /* PE sets the symbol to a value relative to the
4815                      start of the section.  */
4816                   dst->symbol.value = src->u.syment.n_value;
4817 #else
4818                   dst->symbol.value = (src->u.syment.n_value
4819                                        - dst->symbol.section->vma);
4820 #endif
4821                 }
4822               else
4823                 dst->symbol.value = src->u.syment.n_value;
4824               break;
4825
4826             case C_MOS:         /* Member of structure.  */
4827             case C_EOS:         /* End of structure.  */
4828             case C_REGPARM:     /* Register parameter.  */
4829             case C_REG:         /* register variable.  */
4830               /* C_AUTOARG conflicts with TI COFF C_UEXT.  */
4831 #if !defined (TIC80COFF) && !defined (TICOFF)
4832 #ifdef C_AUTOARG
4833             case C_AUTOARG:     /* 960-specific storage class.  */
4834 #endif
4835 #endif
4836             case C_TPDEF:       /* Type definition.  */
4837             case C_ARG:
4838             case C_AUTO:        /* Automatic variable.  */
4839             case C_FIELD:       /* Bit field.  */
4840             case C_ENTAG:       /* Enumeration tag.  */
4841             case C_MOE:         /* Member of enumeration.  */
4842             case C_MOU:         /* Member of union.  */
4843             case C_UNTAG:       /* Union tag.  */
4844               dst->symbol.flags = BSF_DEBUGGING;
4845               dst->symbol.value = (src->u.syment.n_value);
4846               break;
4847
4848             case C_FILE:        /* File name.  */
4849             case C_STRTAG:      /* Structure tag.  */
4850 #ifdef RS6000COFF_C
4851             case C_GSYM:
4852             case C_LSYM:
4853             case C_PSYM:
4854             case C_RSYM:
4855             case C_RPSYM:
4856             case C_STSYM:
4857             case C_TCSYM:
4858             case C_BCOMM:
4859             case C_ECOML:
4860             case C_ECOMM:
4861             case C_DECL:
4862             case C_ENTRY:
4863             case C_FUN:
4864             case C_ESTAT:
4865 #endif
4866               dst->symbol.flags = BSF_DEBUGGING;
4867               dst->symbol.value = (src->u.syment.n_value);
4868               break;
4869
4870 #ifdef RS6000COFF_C
4871             case C_BINCL:       /* Beginning of include file.  */
4872             case C_EINCL:       /* Ending of include file.  */
4873               /* The value is actually a pointer into the line numbers
4874                  of the file.  We locate the line number entry, and
4875                  set the section to the section which contains it, and
4876                  the value to the index in that section.  */
4877               {
4878                 asection *sec;
4879
4880                 dst->symbol.flags = BSF_DEBUGGING;
4881                 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4882                   if (sec->line_filepos <= (file_ptr) src->u.syment.n_value
4883                       && ((file_ptr) (sec->line_filepos
4884                                       + sec->lineno_count * bfd_coff_linesz (abfd))
4885                           > (file_ptr) src->u.syment.n_value))
4886                     break;
4887                 if (sec == NULL)
4888                   dst->symbol.value = 0;
4889                 else
4890                   {
4891                     dst->symbol.section = sec;
4892                     dst->symbol.value = ((src->u.syment.n_value
4893                                           - sec->line_filepos)
4894                                          / bfd_coff_linesz (abfd));
4895                     src->fix_line = 1;
4896                   }
4897               }
4898               break;
4899
4900             case C_BSTAT:
4901               dst->symbol.flags = BSF_DEBUGGING;
4902
4903               /* The value is actually a symbol index.  Save a pointer
4904                  to the symbol instead of the index.  FIXME: This
4905                  should use a union.  */
4906               src->u.syment.n_value =
4907                 (long) (intptr_t) (native_symbols + src->u.syment.n_value);
4908               dst->symbol.value = src->u.syment.n_value;
4909               src->fix_value = 1;
4910               break;
4911 #endif
4912
4913             case C_BLOCK:       /* ".bb" or ".eb".  */
4914             case C_FCN:         /* ".bf" or ".ef" (or PE ".lf").  */
4915             case C_EFCN:        /* Physical end of function.  */
4916 #if defined COFF_WITH_PE
4917               /* PE sets the symbol to a value relative to the start
4918                  of the section.  */
4919               dst->symbol.value = src->u.syment.n_value;
4920               if (strcmp (dst->symbol.name, ".bf") != 0)
4921                 {
4922                   /* PE uses funny values for .ef and .lf; don't
4923                      relocate them.  */
4924                   dst->symbol.flags = BSF_DEBUGGING;
4925                 }
4926               else
4927                 dst->symbol.flags = BSF_DEBUGGING | BSF_DEBUGGING_RELOC;
4928 #else
4929               /* Base the value as an index from the base of the
4930                  section.  */
4931               dst->symbol.flags = BSF_LOCAL;
4932               dst->symbol.value = (src->u.syment.n_value
4933                                    - dst->symbol.section->vma);
4934 #endif
4935               break;
4936
4937             case C_STATLAB:     /* Static load time label.  */
4938               dst->symbol.value = src->u.syment.n_value;
4939               dst->symbol.flags = BSF_GLOBAL;
4940               break;
4941
4942             case C_NULL:
4943               /* PE DLLs sometimes have zeroed out symbols for some
4944                  reason.  Just ignore them without a warning.  */
4945               if (src->u.syment.n_type == 0
4946                   && src->u.syment.n_value == 0
4947                   && src->u.syment.n_scnum == 0)
4948                 break;
4949 #ifdef RS6000COFF_C
4950               /* XCOFF specific: deleted entry.  */
4951               if (src->u.syment.n_value == C_NULL_VALUE)
4952                 break;
4953 #endif
4954               /* Fall through.  */
4955             case C_EXTDEF:      /* External definition.  */
4956             case C_ULABEL:      /* Undefined label.  */
4957             case C_USTATIC:     /* Undefined static.  */
4958 #ifndef COFF_WITH_PE
4959             /* C_LINE in regular coff is 0x68.  NT has taken over this storage
4960                class to represent a section symbol.  */
4961             case C_LINE:        /* line # reformatted as symbol table entry.  */
4962               /* NT uses 0x67 for a weak symbol, not C_ALIAS.  */
4963             case C_ALIAS:       /* Duplicate tag.  */
4964 #endif
4965               /* New storage classes for TI COFF.  */
4966 #if defined(TIC80COFF) || defined(TICOFF)
4967             case C_UEXT:        /* Tentative external definition.  */
4968 #endif
4969             case C_EXTLAB:      /* External load time label.  */
4970             case C_HIDDEN:      /* Ext symbol in dmert public lib.  */
4971             default:
4972               (*_bfd_error_handler)
4973                 (_("%B: Unrecognized storage class %d for %s symbol `%s'"),
4974                  abfd, src->u.syment.n_sclass,
4975                  dst->symbol.section->name, dst->symbol.name);
4976               dst->symbol.flags = BSF_DEBUGGING;
4977               dst->symbol.value = (src->u.syment.n_value);
4978               break;
4979             }
4980
4981           dst->native = src;
4982
4983           dst->symbol.udata.i = 0;
4984           dst->lineno = NULL;
4985           this_index += (src->u.syment.n_numaux) + 1;
4986           dst++;
4987           number_of_symbols++;
4988         }
4989     }
4990
4991   obj_symbols (abfd) = cached_area;
4992   obj_raw_syments (abfd) = native_symbols;
4993
4994   bfd_get_symcount (abfd) = number_of_symbols;
4995   obj_convert (abfd) = table_ptr;
4996   /* Slurp the line tables for each section too.  */
4997   {
4998     asection *p;
4999
5000     p = abfd->sections;
5001     while (p)
5002       {
5003         coff_slurp_line_table (abfd, p);
5004         p = p->next;
5005       }
5006   }
5007
5008   return TRUE;
5009 }
5010
5011 /* Classify a COFF symbol.  A couple of targets have globally visible
5012    symbols which are not class C_EXT, and this handles those.  It also
5013    recognizes some special PE cases.  */
5014
5015 static enum coff_symbol_classification
5016 coff_classify_symbol (bfd *abfd,
5017                       struct internal_syment *syment)
5018 {
5019   /* FIXME: This partially duplicates the switch in
5020      coff_slurp_symbol_table.  */
5021   switch (syment->n_sclass)
5022     {
5023     case C_EXT:
5024     case C_WEAKEXT:
5025 #ifdef I960
5026     case C_LEAFEXT:
5027 #endif
5028 #ifdef ARM
5029     case C_THUMBEXT:
5030     case C_THUMBEXTFUNC:
5031 #endif
5032 #ifdef C_SYSTEM
5033     case C_SYSTEM:
5034 #endif
5035 #ifdef COFF_WITH_PE
5036     case C_NT_WEAK:
5037 #endif
5038       if (syment->n_scnum == 0)
5039         {
5040           if (syment->n_value == 0)
5041             return COFF_SYMBOL_UNDEFINED;
5042           else
5043             return COFF_SYMBOL_COMMON;
5044         }
5045       return COFF_SYMBOL_GLOBAL;
5046
5047     default:
5048       break;
5049     }
5050
5051 #ifdef COFF_WITH_PE
5052   if (syment->n_sclass == C_STAT)
5053     {
5054       if (syment->n_scnum == 0)
5055         /* The Microsoft compiler sometimes generates these if a
5056            small static function is inlined every time it is used.
5057            The function is discarded, but the symbol table entry
5058            remains.  */
5059         return COFF_SYMBOL_LOCAL;
5060
5061 #ifdef STRICT_PE_FORMAT
5062       /* This is correct for Microsoft generated objects, but it
5063          breaks gas generated objects.  */
5064       if (syment->n_value == 0)
5065         {
5066           asection *sec;
5067           char buf[SYMNMLEN + 1];
5068
5069           sec = coff_section_from_bfd_index (abfd, syment->n_scnum);
5070           if (sec != NULL
5071               && (strcmp (bfd_get_section_name (abfd, sec),
5072                           _bfd_coff_internal_syment_name (abfd, syment, buf))
5073                   == 0))
5074             return COFF_SYMBOL_PE_SECTION;
5075         }
5076 #endif
5077
5078       return COFF_SYMBOL_LOCAL;
5079     }
5080
5081   if (syment->n_sclass == C_SECTION)
5082     {
5083       /* In some cases in a DLL generated by the Microsoft linker, the
5084          n_value field will contain garbage.  FIXME: This should
5085          probably be handled by the swapping function instead.  */
5086       syment->n_value = 0;
5087       if (syment->n_scnum == 0)
5088         return COFF_SYMBOL_UNDEFINED;
5089       return COFF_SYMBOL_PE_SECTION;
5090     }
5091 #endif /* COFF_WITH_PE */
5092
5093   /* If it is not a global symbol, we presume it is a local symbol.  */
5094   if (syment->n_scnum == 0)
5095     {
5096       char buf[SYMNMLEN + 1];
5097
5098       (*_bfd_error_handler)
5099         (_("warning: %B: local symbol `%s' has no section"),
5100          abfd, _bfd_coff_internal_syment_name (abfd, syment, buf));
5101     }
5102
5103   return COFF_SYMBOL_LOCAL;
5104 }
5105
5106 /*
5107 SUBSUBSECTION
5108         Reading relocations
5109
5110         Coff relocations are easily transformed into the internal BFD form
5111         (@code{arelent}).
5112
5113         Reading a coff relocation table is done in the following stages:
5114
5115         o Read the entire coff relocation table into memory.
5116
5117         o Process each relocation in turn; first swap it from the
5118         external to the internal form.
5119
5120         o Turn the symbol referenced in the relocation's symbol index
5121         into a pointer into the canonical symbol table.
5122         This table is the same as the one returned by a call to
5123         @code{bfd_canonicalize_symtab}. The back end will call that
5124         routine and save the result if a canonicalization hasn't been done.
5125
5126         o The reloc index is turned into a pointer to a howto
5127         structure, in a back end specific way. For instance, the 386
5128         and 960 use the @code{r_type} to directly produce an index
5129         into a howto table vector; the 88k subtracts a number from the
5130         @code{r_type} field and creates an addend field.
5131 */
5132
5133 #ifndef CALC_ADDEND
5134 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)                \
5135   {                                                             \
5136     coff_symbol_type *coffsym = NULL;                           \
5137                                                                 \
5138     if (ptr && bfd_asymbol_bfd (ptr) != abfd)                   \
5139       coffsym = (obj_symbols (abfd)                             \
5140                  + (cache_ptr->sym_ptr_ptr - symbols));         \
5141     else if (ptr)                                               \
5142       coffsym = coff_symbol_from (abfd, ptr);                   \
5143     if (coffsym != NULL                                         \
5144         && coffsym->native->u.syment.n_scnum == 0)              \
5145       cache_ptr->addend = 0;                                    \
5146     else if (ptr && bfd_asymbol_bfd (ptr) == abfd               \
5147              && ptr->section != NULL)                           \
5148       cache_ptr->addend = - (ptr->section->vma + ptr->value);   \
5149     else                                                        \
5150       cache_ptr->addend = 0;                                    \
5151   }
5152 #endif
5153
5154 static bfd_boolean
5155 coff_slurp_reloc_table (bfd * abfd, sec_ptr asect, asymbol ** symbols)
5156 {
5157   RELOC *native_relocs;
5158   arelent *reloc_cache;
5159   arelent *cache_ptr;
5160   unsigned int idx;
5161   bfd_size_type amt;
5162
5163   if (asect->relocation)
5164     return TRUE;
5165   if (asect->reloc_count == 0)
5166     return TRUE;
5167   if (asect->flags & SEC_CONSTRUCTOR)
5168     return TRUE;
5169   if (!coff_slurp_symbol_table (abfd))
5170     return FALSE;
5171
5172   amt = (bfd_size_type) bfd_coff_relsz (abfd) * asect->reloc_count;
5173   native_relocs = (RELOC *) buy_and_read (abfd, asect->rel_filepos, amt);
5174   amt = (bfd_size_type) asect->reloc_count * sizeof (arelent);
5175   reloc_cache = (arelent *) bfd_alloc (abfd, amt);
5176
5177   if (reloc_cache == NULL || native_relocs == NULL)
5178     return FALSE;
5179
5180   for (idx = 0; idx < asect->reloc_count; idx++)
5181     {
5182       struct internal_reloc dst;
5183       struct external_reloc *src;
5184 #ifndef RELOC_PROCESSING
5185       asymbol *ptr;
5186 #endif
5187
5188       cache_ptr = reloc_cache + idx;
5189       src = native_relocs + idx;
5190
5191       dst.r_offset = 0;
5192       coff_swap_reloc_in (abfd, src, &dst);
5193
5194 #ifdef RELOC_PROCESSING
5195       RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
5196 #else
5197       cache_ptr->address = dst.r_vaddr;
5198
5199       if (dst.r_symndx != -1)
5200         {
5201           if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd))
5202             {
5203               (*_bfd_error_handler)
5204                 (_("%B: warning: illegal symbol index %ld in relocs"),
5205                  abfd, (long) dst.r_symndx);
5206               cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
5207               ptr = NULL;
5208             }
5209           else
5210             {
5211               cache_ptr->sym_ptr_ptr = (symbols
5212                                         + obj_convert (abfd)[dst.r_symndx]);
5213               ptr = *(cache_ptr->sym_ptr_ptr);
5214             }
5215         }
5216       else
5217         {
5218           cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
5219           ptr = NULL;
5220         }
5221
5222       /* The symbols definitions that we have read in have been
5223          relocated as if their sections started at 0. But the offsets
5224          refering to the symbols in the raw data have not been
5225          modified, so we have to have a negative addend to compensate.
5226
5227          Note that symbols which used to be common must be left alone.  */
5228
5229       /* Calculate any reloc addend by looking at the symbol.  */
5230       CALC_ADDEND (abfd, ptr, dst, cache_ptr);
5231       (void) ptr;
5232
5233       cache_ptr->address -= asect->vma;
5234       /* !! cache_ptr->section = NULL;*/
5235
5236       /* Fill in the cache_ptr->howto field from dst.r_type.  */
5237       RTYPE2HOWTO (cache_ptr, &dst);
5238 #endif  /* RELOC_PROCESSING */
5239
5240       if (cache_ptr->howto == NULL)
5241         {
5242           (*_bfd_error_handler)
5243             (_("%B: illegal relocation type %d at address 0x%lx"),
5244              abfd, dst.r_type, (long) dst.r_vaddr);
5245           bfd_set_error (bfd_error_bad_value);
5246           return FALSE;
5247         }
5248     }
5249
5250   asect->relocation = reloc_cache;
5251   return TRUE;
5252 }
5253
5254 #ifndef coff_rtype_to_howto
5255 #ifdef RTYPE2HOWTO
5256
5257 /* Get the howto structure for a reloc.  This is only used if the file
5258    including this one defines coff_relocate_section to be
5259    _bfd_coff_generic_relocate_section, so it is OK if it does not
5260    always work.  It is the responsibility of the including file to
5261    make sure it is reasonable if it is needed.  */
5262
5263 static reloc_howto_type *
5264 coff_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
5265                      asection *sec ATTRIBUTE_UNUSED,
5266                      struct internal_reloc *rel,
5267                      struct coff_link_hash_entry *h ATTRIBUTE_UNUSED,
5268                      struct internal_syment *sym ATTRIBUTE_UNUSED,
5269                      bfd_vma *addendp ATTRIBUTE_UNUSED)
5270 {
5271   arelent genrel;
5272
5273   genrel.howto = NULL;
5274   RTYPE2HOWTO (&genrel, rel);
5275   return genrel.howto;
5276 }
5277
5278 #else /* ! defined (RTYPE2HOWTO) */
5279
5280 #define coff_rtype_to_howto NULL
5281
5282 #endif /* ! defined (RTYPE2HOWTO) */
5283 #endif /* ! defined (coff_rtype_to_howto) */
5284
5285 /* This is stupid.  This function should be a boolean predicate.  */
5286
5287 static long
5288 coff_canonicalize_reloc (bfd * abfd,
5289                          sec_ptr section,
5290                          arelent ** relptr,
5291                          asymbol ** symbols)
5292 {
5293   arelent *tblptr = section->relocation;
5294   unsigned int count = 0;
5295
5296   if (section->flags & SEC_CONSTRUCTOR)
5297     {
5298       /* This section has relocs made up by us, they are not in the
5299          file, so take them out of their chain and place them into
5300          the data area provided.  */
5301       arelent_chain *chain = section->constructor_chain;
5302
5303       for (count = 0; count < section->reloc_count; count++)
5304         {
5305           *relptr++ = &chain->relent;
5306           chain = chain->next;
5307         }
5308     }
5309   else
5310     {
5311       if (! coff_slurp_reloc_table (abfd, section, symbols))
5312         return -1;
5313
5314       tblptr = section->relocation;
5315
5316       for (; count++ < section->reloc_count;)
5317         *relptr++ = tblptr++;
5318     }
5319   *relptr = 0;
5320   return section->reloc_count;
5321 }
5322
5323 #ifndef coff_reloc16_estimate
5324 #define coff_reloc16_estimate dummy_reloc16_estimate
5325
5326 static int
5327 dummy_reloc16_estimate (bfd *abfd ATTRIBUTE_UNUSED,
5328                         asection *input_section ATTRIBUTE_UNUSED,
5329                         arelent *reloc ATTRIBUTE_UNUSED,
5330                         unsigned int shrink ATTRIBUTE_UNUSED,
5331                         struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
5332 {
5333   abort ();
5334   return 0;
5335 }
5336
5337 #endif
5338
5339 #ifndef coff_reloc16_extra_cases
5340
5341 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5342
5343 /* This works even if abort is not declared in any header file.  */
5344
5345 static void
5346 dummy_reloc16_extra_cases (bfd *abfd ATTRIBUTE_UNUSED,
5347                            struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
5348                            struct bfd_link_order *link_order ATTRIBUTE_UNUSED,
5349                            arelent *reloc ATTRIBUTE_UNUSED,
5350                            bfd_byte *data ATTRIBUTE_UNUSED,
5351                            unsigned int *src_ptr ATTRIBUTE_UNUSED,
5352                            unsigned int *dst_ptr ATTRIBUTE_UNUSED)
5353 {
5354   abort ();
5355 }
5356 #endif
5357
5358 /* If coff_relocate_section is defined, we can use the optimized COFF
5359    backend linker.  Otherwise we must continue to use the old linker.  */
5360
5361 #ifdef coff_relocate_section
5362
5363 #ifndef coff_bfd_link_hash_table_create
5364 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5365 #endif
5366 #ifndef coff_bfd_link_add_symbols
5367 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5368 #endif
5369 #ifndef coff_bfd_final_link
5370 #define coff_bfd_final_link _bfd_coff_final_link
5371 #endif
5372
5373 #else /* ! defined (coff_relocate_section) */
5374
5375 #define coff_relocate_section NULL
5376 #ifndef coff_bfd_link_hash_table_create
5377 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5378 #endif
5379 #ifndef coff_bfd_link_add_symbols
5380 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5381 #endif
5382 #define coff_bfd_final_link _bfd_generic_final_link
5383
5384 #endif /* ! defined (coff_relocate_section) */
5385
5386 #define coff_bfd_link_just_syms      _bfd_generic_link_just_syms
5387 #define coff_bfd_copy_link_hash_symbol_type \
5388   _bfd_generic_copy_link_hash_symbol_type
5389 #define coff_bfd_link_split_section  _bfd_generic_link_split_section
5390
5391 #ifndef coff_start_final_link
5392 #define coff_start_final_link NULL
5393 #endif
5394
5395 #ifndef coff_adjust_symndx
5396 #define coff_adjust_symndx NULL
5397 #endif
5398
5399 #ifndef coff_link_add_one_symbol
5400 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5401 #endif
5402
5403 #ifndef coff_link_output_has_begun
5404
5405 static bfd_boolean
5406 coff_link_output_has_begun (bfd * abfd,
5407                             struct coff_final_link_info * info ATTRIBUTE_UNUSED)
5408 {
5409   return abfd->output_has_begun;
5410 }
5411 #endif
5412
5413 #ifndef coff_final_link_postscript
5414
5415 static bfd_boolean
5416 coff_final_link_postscript (bfd * abfd ATTRIBUTE_UNUSED,
5417                             struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED)
5418 {
5419   return TRUE;
5420 }
5421 #endif
5422
5423 #ifndef coff_SWAP_aux_in
5424 #define coff_SWAP_aux_in coff_swap_aux_in
5425 #endif
5426 #ifndef coff_SWAP_sym_in
5427 #define coff_SWAP_sym_in coff_swap_sym_in
5428 #endif
5429 #ifndef coff_SWAP_lineno_in
5430 #define coff_SWAP_lineno_in coff_swap_lineno_in
5431 #endif
5432 #ifndef coff_SWAP_aux_out
5433 #define coff_SWAP_aux_out coff_swap_aux_out
5434 #endif
5435 #ifndef coff_SWAP_sym_out
5436 #define coff_SWAP_sym_out coff_swap_sym_out
5437 #endif
5438 #ifndef coff_SWAP_lineno_out
5439 #define coff_SWAP_lineno_out coff_swap_lineno_out
5440 #endif
5441 #ifndef coff_SWAP_reloc_out
5442 #define coff_SWAP_reloc_out coff_swap_reloc_out
5443 #endif
5444 #ifndef coff_SWAP_filehdr_out
5445 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5446 #endif
5447 #ifndef coff_SWAP_aouthdr_out
5448 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5449 #endif
5450 #ifndef coff_SWAP_scnhdr_out
5451 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5452 #endif
5453 #ifndef coff_SWAP_reloc_in
5454 #define coff_SWAP_reloc_in coff_swap_reloc_in
5455 #endif
5456 #ifndef coff_SWAP_filehdr_in
5457 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5458 #endif
5459 #ifndef coff_SWAP_aouthdr_in
5460 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5461 #endif
5462 #ifndef coff_SWAP_scnhdr_in
5463 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5464 #endif
5465
5466 static bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED =
5467 {
5468   coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5469   coff_SWAP_aux_out, coff_SWAP_sym_out,
5470   coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5471   coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5472   coff_SWAP_scnhdr_out,
5473   FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
5474 #ifdef COFF_LONG_FILENAMES
5475   TRUE,
5476 #else
5477   FALSE,
5478 #endif
5479   COFF_DEFAULT_LONG_SECTION_NAMES,
5480   COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5481 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5482   TRUE,
5483 #else
5484   FALSE,
5485 #endif
5486 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5487   4,
5488 #else
5489   2,
5490 #endif
5491   32768,
5492   coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5493   coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
5494   coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5495   coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5496   coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5497   coff_classify_symbol, coff_compute_section_file_positions,
5498   coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5499   coff_adjust_symndx, coff_link_add_one_symbol,
5500   coff_link_output_has_begun, coff_final_link_postscript,
5501   bfd_pe_print_pdata
5502 };
5503
5504 #ifdef TICOFF
5505 /* COFF0 differs in file/section header size and relocation entry size.  */
5506
5507 static bfd_coff_backend_data ticoff0_swap_table =
5508 {
5509   coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5510   coff_SWAP_aux_out, coff_SWAP_sym_out,
5511   coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5512   coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5513   coff_SWAP_scnhdr_out,
5514   FILHSZ_V0, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ_V0, LINESZ, FILNMLEN,
5515 #ifdef COFF_LONG_FILENAMES
5516   TRUE,
5517 #else
5518   FALSE,
5519 #endif
5520   COFF_DEFAULT_LONG_SECTION_NAMES,
5521   COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5522 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5523   TRUE,
5524 #else
5525   FALSE,
5526 #endif
5527 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5528   4,
5529 #else
5530   2,
5531 #endif
5532   32768,
5533   coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5534   coff_SWAP_reloc_in, ticoff0_bad_format_hook, coff_set_arch_mach_hook,
5535   coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5536   coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5537   coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5538   coff_classify_symbol, coff_compute_section_file_positions,
5539   coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5540   coff_adjust_symndx, coff_link_add_one_symbol,
5541   coff_link_output_has_begun, coff_final_link_postscript,
5542   bfd_pe_print_pdata
5543 };
5544 #endif
5545
5546 #ifdef TICOFF
5547 /* COFF1 differs in section header size.  */
5548
5549 static bfd_coff_backend_data ticoff1_swap_table =
5550 {
5551   coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5552   coff_SWAP_aux_out, coff_SWAP_sym_out,
5553   coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5554   coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5555   coff_SWAP_scnhdr_out,
5556   FILHSZ, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
5557 #ifdef COFF_LONG_FILENAMES
5558   TRUE,
5559 #else
5560   FALSE,
5561 #endif
5562   COFF_DEFAULT_LONG_SECTION_NAMES,
5563   COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5564 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5565   TRUE,
5566 #else
5567   FALSE,
5568 #endif
5569 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5570   4,
5571 #else
5572   2,
5573 #endif
5574   32768,
5575   coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5576   coff_SWAP_reloc_in, ticoff1_bad_format_hook, coff_set_arch_mach_hook,
5577   coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5578   coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5579   coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5580   coff_classify_symbol, coff_compute_section_file_positions,
5581   coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5582   coff_adjust_symndx, coff_link_add_one_symbol,
5583   coff_link_output_has_begun, coff_final_link_postscript,
5584   bfd_pe_print_pdata    /* huh */
5585 };
5586 #endif
5587
5588 #ifdef COFF_WITH_PE_BIGOBJ
5589 /* The UUID for bigobj files.  */
5590
5591 static const char header_bigobj_classid[16] =
5592 {
5593   0xC7, 0xA1, 0xBA, 0xD1,
5594   0xEE, 0xBA,
5595   0xa9, 0x4b,
5596   0xAF, 0x20,
5597   0xFA, 0xF6, 0x6A, 0xA4, 0xDC, 0xB8
5598 };
5599
5600 /* Swap routines.  */
5601
5602 static void
5603 coff_bigobj_swap_filehdr_in (bfd * abfd, void * src, void * dst)
5604 {
5605   struct external_ANON_OBJECT_HEADER_BIGOBJ *filehdr_src =
5606     (struct external_ANON_OBJECT_HEADER_BIGOBJ *) src;
5607   struct internal_filehdr *filehdr_dst = (struct internal_filehdr *) dst;
5608
5609   filehdr_dst->f_magic  = H_GET_16 (abfd, filehdr_src->Machine);
5610   filehdr_dst->f_nscns  = H_GET_32 (abfd, filehdr_src->NumberOfSections);
5611   filehdr_dst->f_timdat = H_GET_32 (abfd, filehdr_src->TimeDateStamp);
5612   filehdr_dst->f_symptr =
5613     GET_FILEHDR_SYMPTR (abfd, filehdr_src->PointerToSymbolTable);
5614   filehdr_dst->f_nsyms  = H_GET_32 (abfd, filehdr_src->NumberOfSymbols);
5615   filehdr_dst->f_opthdr = 0;
5616   filehdr_dst->f_flags  = 0;
5617
5618   /* Check other magic numbers.  */
5619   if (H_GET_16 (abfd, filehdr_src->Sig1) != IMAGE_FILE_MACHINE_UNKNOWN
5620       || H_GET_16 (abfd, filehdr_src->Sig2) != 0xffff
5621       || H_GET_16 (abfd, filehdr_src->Version) != 2
5622       || memcmp (filehdr_src->ClassID, header_bigobj_classid, 16) != 0)
5623     filehdr_dst->f_opthdr = 0xffff;
5624
5625   /* Note that CLR metadata are ignored.  */
5626 }
5627
5628 static unsigned int
5629 coff_bigobj_swap_filehdr_out (bfd *abfd, void * in, void * out)
5630 {
5631   struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
5632   struct external_ANON_OBJECT_HEADER_BIGOBJ *filehdr_out =
5633     (struct external_ANON_OBJECT_HEADER_BIGOBJ *) out;
5634
5635   memset (filehdr_out, 0, sizeof (*filehdr_out));
5636
5637   H_PUT_16 (abfd, IMAGE_FILE_MACHINE_UNKNOWN, filehdr_out->Sig1);
5638   H_PUT_16 (abfd, 0xffff, filehdr_out->Sig2);
5639   H_PUT_16 (abfd, 2, filehdr_out->Version);
5640   memcpy (filehdr_out->ClassID, header_bigobj_classid, 16);
5641   H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->Machine);
5642   H_PUT_32 (abfd, filehdr_in->f_nscns, filehdr_out->NumberOfSections);
5643   H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->TimeDateStamp);
5644   PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
5645                       filehdr_out->PointerToSymbolTable);
5646   H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->NumberOfSymbols);
5647
5648   return bfd_coff_filhsz (abfd);
5649 }
5650
5651 static void
5652 coff_bigobj_swap_sym_in (bfd * abfd, void * ext1, void * in1)
5653 {
5654   SYMENT_BIGOBJ *ext = (SYMENT_BIGOBJ *) ext1;
5655   struct internal_syment *in = (struct internal_syment *) in1;
5656
5657   if (ext->e.e_name[0] == 0)
5658     {
5659       in->_n._n_n._n_zeroes = 0;
5660       in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset);
5661     }
5662   else
5663     {
5664 #if SYMNMLEN != E_SYMNMLEN
5665 #error we need to cope with truncating or extending SYMNMLEN
5666 #else
5667       memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN);
5668 #endif
5669     }
5670
5671   in->n_value = H_GET_32 (abfd, ext->e_value);
5672   in->n_scnum = H_GET_32 (abfd, ext->e_scnum);
5673   in->n_type = H_GET_16 (abfd, ext->e_type);
5674   in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
5675   in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
5676 }
5677
5678 static unsigned int
5679 coff_bigobj_swap_sym_out (bfd * abfd, void * inp, void * extp)
5680 {
5681   struct internal_syment *in = (struct internal_syment *) inp;
5682   SYMENT_BIGOBJ *ext = (SYMENT_BIGOBJ *) extp;
5683
5684   if (in->_n._n_name[0] == 0)
5685     {
5686       H_PUT_32 (abfd, 0, ext->e.e.e_zeroes);
5687       H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset);
5688     }
5689   else
5690     {
5691 #if SYMNMLEN != E_SYMNMLEN
5692 #error we need to cope with truncating or extending SYMNMLEN
5693 #else
5694       memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN);
5695 #endif
5696     }
5697
5698   H_PUT_32 (abfd, in->n_value, ext->e_value);
5699   H_PUT_32 (abfd, in->n_scnum, ext->e_scnum);
5700
5701   H_PUT_16 (abfd, in->n_type, ext->e_type);
5702   H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
5703   H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
5704
5705   return SYMESZ_BIGOBJ;
5706 }
5707
5708 static void
5709 coff_bigobj_swap_aux_in (bfd *abfd,
5710                          void * ext1,
5711                          int type,
5712                          int in_class,
5713                          int indx,
5714                          int numaux,
5715                          void * in1)
5716 {
5717   AUXENT_BIGOBJ *ext = (AUXENT_BIGOBJ *) ext1;
5718   union internal_auxent *in = (union internal_auxent *) in1;
5719
5720   switch (in_class)
5721     {
5722     case C_FILE:
5723       if (numaux > 1)
5724         {
5725           if (indx == 0)
5726             memcpy (in->x_file.x_fname, ext->File.Name,
5727                     numaux * sizeof (AUXENT_BIGOBJ));
5728         }
5729       else
5730         memcpy (in->x_file.x_fname, ext->File.Name, sizeof (ext->File.Name));
5731       break;
5732
5733     case C_STAT:
5734     case C_LEAFSTAT:
5735     case C_HIDDEN:
5736       if (type == T_NULL)
5737         {
5738           in->x_scn.x_scnlen = H_GET_32 (abfd, ext->Section.Length);
5739           in->x_scn.x_nreloc =
5740             H_GET_16 (abfd, ext->Section.NumberOfRelocations);
5741           in->x_scn.x_nlinno =
5742             H_GET_16 (abfd, ext->Section.NumberOfLinenumbers);
5743           in->x_scn.x_checksum = H_GET_32 (abfd, ext->Section.Checksum);
5744           in->x_scn.x_associated = H_GET_16 (abfd, ext->Section.Number)
5745             | (H_GET_16 (abfd, ext->Section.HighNumber) << 16);
5746           in->x_scn.x_comdat = H_GET_8 (abfd, ext->Section.Selection);
5747           return;
5748         }
5749       break;
5750
5751     default:
5752       in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->Sym.WeakDefaultSymIndex);
5753       /* Characteristics is ignored.  */
5754       break;
5755     }
5756 }
5757
5758 static unsigned int
5759 coff_bigobj_swap_aux_out (bfd * abfd,
5760                           void * inp,
5761                           int type,
5762                           int in_class,
5763                           int indx ATTRIBUTE_UNUSED,
5764                           int numaux ATTRIBUTE_UNUSED,
5765                           void * extp)
5766 {
5767   union internal_auxent * in = (union internal_auxent *) inp;
5768   AUXENT_BIGOBJ *ext = (AUXENT_BIGOBJ *) extp;
5769
5770   memset (ext, 0, AUXESZ);
5771
5772   switch (in_class)
5773     {
5774     case C_FILE:
5775       memcpy (ext->File.Name, in->x_file.x_fname, sizeof (ext->File.Name));
5776
5777       return AUXESZ;
5778
5779     case C_STAT:
5780     case C_LEAFSTAT:
5781     case C_HIDDEN:
5782       if (type == T_NULL)
5783         {
5784           H_PUT_32 (abfd, in->x_scn.x_scnlen, ext->Section.Length);
5785           H_PUT_16 (abfd, in->x_scn.x_nreloc,
5786                     ext->Section.NumberOfRelocations);
5787           H_PUT_16 (abfd, in->x_scn.x_nlinno,
5788                     ext->Section.NumberOfLinenumbers);
5789           H_PUT_32 (abfd, in->x_scn.x_checksum, ext->Section.Checksum);
5790           H_PUT_16 (abfd, in->x_scn.x_associated & 0xffff,
5791                     ext->Section.Number);
5792           H_PUT_16 (abfd, (in->x_scn.x_associated >> 16),
5793                     ext->Section.HighNumber);
5794           H_PUT_8 (abfd, in->x_scn.x_comdat, ext->Section.Selection);
5795           return AUXESZ;
5796         }
5797       break;
5798     }
5799
5800   H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->Sym.WeakDefaultSymIndex);
5801   H_PUT_32 (abfd, 1, ext->Sym.WeakSearchType);
5802
5803   return AUXESZ;
5804 }
5805
5806 static bfd_coff_backend_data bigobj_swap_table =
5807 {
5808   coff_bigobj_swap_aux_in, coff_bigobj_swap_sym_in, coff_SWAP_lineno_in,
5809   coff_bigobj_swap_aux_out, coff_bigobj_swap_sym_out,
5810   coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5811   coff_bigobj_swap_filehdr_out, coff_SWAP_aouthdr_out,
5812   coff_SWAP_scnhdr_out,
5813   FILHSZ_BIGOBJ, AOUTSZ, SCNHSZ, SYMESZ_BIGOBJ, AUXESZ_BIGOBJ,
5814    RELSZ, LINESZ, FILNMLEN_BIGOBJ,
5815   TRUE,
5816   COFF_DEFAULT_LONG_SECTION_NAMES,
5817   COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5818   FALSE,
5819   2,
5820   1U << 31,
5821   coff_bigobj_swap_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5822   coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
5823   coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5824   coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5825   coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5826   coff_classify_symbol, coff_compute_section_file_positions,
5827   coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5828   coff_adjust_symndx, coff_link_add_one_symbol,
5829   coff_link_output_has_begun, coff_final_link_postscript,
5830   bfd_pe_print_pdata    /* huh */
5831 };
5832
5833 #endif /* COFF_WITH_PE_BIGOBJ */
5834
5835 #ifndef coff_close_and_cleanup
5836 #define coff_close_and_cleanup              _bfd_generic_close_and_cleanup
5837 #endif
5838
5839 #ifndef coff_bfd_free_cached_info
5840 #define coff_bfd_free_cached_info           _bfd_generic_bfd_free_cached_info
5841 #endif
5842
5843 #ifndef coff_get_section_contents
5844 #define coff_get_section_contents           _bfd_generic_get_section_contents
5845 #endif
5846
5847 #ifndef coff_bfd_copy_private_symbol_data
5848 #define coff_bfd_copy_private_symbol_data   _bfd_generic_bfd_copy_private_symbol_data
5849 #endif
5850
5851 #ifndef coff_bfd_copy_private_header_data
5852 #define coff_bfd_copy_private_header_data   _bfd_generic_bfd_copy_private_header_data
5853 #endif
5854
5855 #ifndef coff_bfd_copy_private_section_data
5856 #define coff_bfd_copy_private_section_data  _bfd_generic_bfd_copy_private_section_data
5857 #endif
5858
5859 #ifndef coff_bfd_copy_private_bfd_data
5860 #define coff_bfd_copy_private_bfd_data      _bfd_generic_bfd_copy_private_bfd_data
5861 #endif
5862
5863 #ifndef coff_bfd_merge_private_bfd_data
5864 #define coff_bfd_merge_private_bfd_data     _bfd_generic_bfd_merge_private_bfd_data
5865 #endif
5866
5867 #ifndef coff_bfd_set_private_flags
5868 #define coff_bfd_set_private_flags          _bfd_generic_bfd_set_private_flags
5869 #endif
5870
5871 #ifndef coff_bfd_print_private_bfd_data
5872 #define coff_bfd_print_private_bfd_data     _bfd_generic_bfd_print_private_bfd_data
5873 #endif
5874
5875 #ifndef coff_bfd_is_local_label_name
5876 #define coff_bfd_is_local_label_name        _bfd_coff_is_local_label_name
5877 #endif
5878
5879 #ifndef coff_bfd_is_target_special_symbol
5880 #define coff_bfd_is_target_special_symbol   ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
5881 #endif
5882
5883 #ifndef coff_read_minisymbols
5884 #define coff_read_minisymbols               _bfd_generic_read_minisymbols
5885 #endif
5886
5887 #ifndef coff_minisymbol_to_symbol
5888 #define coff_minisymbol_to_symbol           _bfd_generic_minisymbol_to_symbol
5889 #endif
5890
5891 /* The reloc lookup routine must be supplied by each individual COFF
5892    backend.  */
5893 #ifndef coff_bfd_reloc_type_lookup
5894 #define coff_bfd_reloc_type_lookup          _bfd_norelocs_bfd_reloc_type_lookup
5895 #endif
5896 #ifndef coff_bfd_reloc_name_lookup
5897 #define coff_bfd_reloc_name_lookup    _bfd_norelocs_bfd_reloc_name_lookup
5898 #endif
5899
5900 #ifndef coff_bfd_get_relocated_section_contents
5901 #define coff_bfd_get_relocated_section_contents \
5902   bfd_generic_get_relocated_section_contents
5903 #endif
5904
5905 #ifndef coff_bfd_relax_section
5906 #define coff_bfd_relax_section              bfd_generic_relax_section
5907 #endif
5908
5909 #ifndef coff_bfd_gc_sections
5910 #define coff_bfd_gc_sections                bfd_generic_gc_sections
5911 #endif
5912
5913 #ifndef coff_bfd_lookup_section_flags
5914 #define coff_bfd_lookup_section_flags       bfd_generic_lookup_section_flags
5915 #endif
5916
5917 #ifndef coff_bfd_merge_sections
5918 #define coff_bfd_merge_sections             bfd_generic_merge_sections
5919 #endif
5920
5921 #ifndef coff_bfd_is_group_section
5922 #define coff_bfd_is_group_section           bfd_generic_is_group_section
5923 #endif
5924
5925 #ifndef coff_bfd_discard_group
5926 #define coff_bfd_discard_group              bfd_generic_discard_group
5927 #endif
5928
5929 #ifndef coff_section_already_linked
5930 #define coff_section_already_linked \
5931   _bfd_coff_section_already_linked
5932 #endif
5933
5934 #ifndef coff_bfd_define_common_symbol
5935 #define coff_bfd_define_common_symbol       bfd_generic_define_common_symbol
5936 #endif
5937
5938 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE)     \
5939 const bfd_target VAR =                                                  \
5940 {                                                                       \
5941   NAME ,                                                                \
5942   bfd_target_coff_flavour,                                              \
5943   BFD_ENDIAN_BIG,               /* Data byte order is big.  */          \
5944   BFD_ENDIAN_BIG,               /* Header byte order is big.  */        \
5945   /* object flags */                                                    \
5946   (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG |                        \
5947    HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS),                    \
5948   /* section flags */                                                   \
5949   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5950   UNDER,                        /* Leading symbol underscore.  */       \
5951   '/',                          /* AR_pad_char.  */                     \
5952   15,                           /* AR_max_namelen.  */                  \
5953   0,                            /* match priority.  */                  \
5954                                                                         \
5955   /* Data conversion functions.  */                                     \
5956   bfd_getb64, bfd_getb_signed_64, bfd_putb64,                           \
5957   bfd_getb32, bfd_getb_signed_32, bfd_putb32,                           \
5958   bfd_getb16, bfd_getb_signed_16, bfd_putb16,                           \
5959                                                                         \
5960   /* Header conversion functions.  */                                   \
5961   bfd_getb64, bfd_getb_signed_64, bfd_putb64,                           \
5962   bfd_getb32, bfd_getb_signed_32, bfd_putb32,                           \
5963   bfd_getb16, bfd_getb_signed_16, bfd_putb16,                           \
5964                                                                         \
5965         /* bfd_check_format.  */                                        \
5966   { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p,            \
5967     _bfd_dummy_target },                                                \
5968         /* bfd_set_format.  */                                          \
5969   { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false },      \
5970         /* bfd_write_contents.  */                                      \
5971   { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5972     bfd_false },                                                        \
5973                                                                         \
5974   BFD_JUMP_TABLE_GENERIC (coff),                                        \
5975   BFD_JUMP_TABLE_COPY (coff),                                           \
5976   BFD_JUMP_TABLE_CORE (_bfd_nocore),                                    \
5977   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),                           \
5978   BFD_JUMP_TABLE_SYMBOLS (coff),                                        \
5979   BFD_JUMP_TABLE_RELOCS (coff),                                         \
5980   BFD_JUMP_TABLE_WRITE (coff),                                          \
5981   BFD_JUMP_TABLE_LINK (coff),                                           \
5982   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),                              \
5983                                                                         \
5984   ALTERNATIVE,                                                          \
5985                                                                         \
5986   SWAP_TABLE                                                            \
5987 };
5988
5989 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE)  \
5990 const bfd_target VAR =                                                  \
5991 {                                                                       \
5992   NAME ,                                                                \
5993   bfd_target_coff_flavour,                                              \
5994   BFD_ENDIAN_LITTLE,            /* Data byte order is little.  */       \
5995   BFD_ENDIAN_BIG,               /* Header byte order is big.  */        \
5996   /* object flags */                                                    \
5997   (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG |                        \
5998    HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS),                    \
5999   /* section flags */                                                   \
6000   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
6001   UNDER,                        /* Leading symbol underscore.  */       \
6002   '/',                          /* AR_pad_char.  */                     \
6003   15,                           /* AR_max_namelen.  */                  \
6004   0,                            /* match priority.  */                  \
6005                                                                         \
6006   /* Data conversion functions.  */                                     \
6007   bfd_getb64, bfd_getb_signed_64, bfd_putb64,                           \
6008   bfd_getb32, bfd_getb_signed_32, bfd_putb32,                           \
6009   bfd_getb16, bfd_getb_signed_16, bfd_putb16,                           \
6010                                                                         \
6011   /* Header conversion functions.  */                                   \
6012   bfd_getb64, bfd_getb_signed_64, bfd_putb64,                           \
6013   bfd_getb32, bfd_getb_signed_32, bfd_putb32,                           \
6014   bfd_getb16, bfd_getb_signed_16, bfd_putb16,                           \
6015                                                                         \
6016         /* bfd_check_format.  */                                        \
6017   { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p,            \
6018     _bfd_dummy_target },                                                \
6019         /* bfd_set_format.  */                                          \
6020   { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false },      \
6021         /* bfd_write_contents.  */                                      \
6022   { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
6023     bfd_false },                                                        \
6024                                                                         \
6025   BFD_JUMP_TABLE_GENERIC (coff),                                        \
6026   BFD_JUMP_TABLE_COPY (coff),                                           \
6027   BFD_JUMP_TABLE_CORE (_bfd_nocore),                                    \
6028   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),                           \
6029   BFD_JUMP_TABLE_SYMBOLS (coff),                                        \
6030   BFD_JUMP_TABLE_RELOCS (coff),                                         \
6031   BFD_JUMP_TABLE_WRITE (coff),                                          \
6032   BFD_JUMP_TABLE_LINK (coff),                                           \
6033   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),                              \
6034                                                                         \
6035   ALTERNATIVE,                                                          \
6036                                                                         \
6037   SWAP_TABLE                                                            \
6038 };
6039
6040 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE)  \
6041 const bfd_target VAR =                                                  \
6042 {                                                                       \
6043   NAME ,                                                                \
6044   bfd_target_coff_flavour,                                              \
6045   BFD_ENDIAN_LITTLE,            /* Data byte order is little.  */       \
6046   BFD_ENDIAN_LITTLE,            /* Header byte order is little.  */     \
6047         /* object flags */                                              \
6048   (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG |                        \
6049    HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS),                    \
6050         /* section flags */                                             \
6051   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
6052   UNDER,                        /* Leading symbol underscore.  */       \
6053   '/',                          /* AR_pad_char.  */                     \
6054   15,                           /* AR_max_namelen.  */                  \
6055   0,                            /* match priority.  */                  \
6056                                                                         \
6057   /* Data conversion functions.  */                                     \
6058   bfd_getl64, bfd_getl_signed_64, bfd_putl64,                           \
6059   bfd_getl32, bfd_getl_signed_32, bfd_putl32,                           \
6060   bfd_getl16, bfd_getl_signed_16, bfd_putl16,                           \
6061   /* Header conversion functions.  */                                   \
6062   bfd_getl64, bfd_getl_signed_64, bfd_putl64,                           \
6063   bfd_getl32, bfd_getl_signed_32, bfd_putl32,                           \
6064   bfd_getl16, bfd_getl_signed_16, bfd_putl16,                           \
6065         /* bfd_check_format.  */                                        \
6066   { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p,            \
6067     _bfd_dummy_target },                                                \
6068        /* bfd_set_format.  */                                           \
6069   { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false },      \
6070         /* bfd_write_contents.  */                                      \
6071   { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
6072     bfd_false },                                                        \
6073                                                                         \
6074   BFD_JUMP_TABLE_GENERIC (coff),                                        \
6075   BFD_JUMP_TABLE_COPY (coff),                                           \
6076   BFD_JUMP_TABLE_CORE (_bfd_nocore),                                    \
6077   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),                           \
6078   BFD_JUMP_TABLE_SYMBOLS (coff),                                        \
6079   BFD_JUMP_TABLE_RELOCS (coff),                                         \
6080   BFD_JUMP_TABLE_WRITE (coff),                                          \
6081   BFD_JUMP_TABLE_LINK (coff),                                           \
6082   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),                              \
6083                                                                         \
6084   ALTERNATIVE,                                                          \
6085                                                                         \
6086   SWAP_TABLE                                                            \
6087 };