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