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