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