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