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