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