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