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