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