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