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