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
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,
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
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
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}.
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.
76 How the coff backend works
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
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.
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
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.
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.
242 The hidden information for an <<asymbol>> is described in a
243 <<combined_entry_type>>:
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
277 . union internal_auxent auxent;
278 . struct internal_syment syment;
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 *}
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;
305 #include "coffswap.h"
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
319 static void coff_set_custom_section_alignment
320 (bfd *, asection *, const struct coff_section_alignment_entry *,
322 static bfd_boolean coff_new_section_hook
324 static bfd_boolean coff_set_arch_mach_hook
326 static bfd_boolean coff_write_relocs
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
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
342 static bfd_boolean coff_slurp_symbol_table
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 *);
355 static flagword handle_COMDAT
356 (bfd *, flagword, void *, const char *, asection *);
358 #ifdef COFF_IMAGE_WITH_PE
359 static bfd_boolean coff_read_word
360 (bfd *, unsigned int *);
361 static unsigned int coff_compute_checksum
363 static bfd_boolean coff_apply_checksum
367 static bfd_boolean ticoff0_bad_format_hook
369 static bfd_boolean ticoff1_bad_format_hook
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(). */
382 /* Macros for setting debugging flags. */
385 #define STYP_XCOFF_DEBUG STYP_DEBUG
387 #define STYP_XCOFF_DEBUG STYP_INFO
390 #ifdef COFF_ALIGN_IN_S_FLAGS
391 #define STYP_DEBUG_INFO STYP_DSECT
393 #define STYP_DEBUG_INFO STYP_INFO
397 sec_to_styp_flags (const char *sec_name, flagword sec_flags)
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;
414 else if (!strcmp (sec_name, _COMMENT))
416 styp_flags = STYP_INFO;
417 #endif /* _COMMENT */
420 else if (!strcmp (sec_name, _LIB))
422 styp_flags = STYP_LIB;
426 else if (!strcmp (sec_name, _LIT))
428 styp_flags = STYP_LIT;
431 else if (CONST_STRNEQ (sec_name, DOT_DEBUG))
433 /* Handle the XCOFF debug section and DWARF2 debug sections. */
435 styp_flags = STYP_XCOFF_DEBUG;
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;
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;
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;
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;
494 if (sec_flags & SEC_TIC54X_CLINK)
495 styp_flags |= STYP_CLINK;
499 if (sec_flags & SEC_TIC54X_BLOCK)
500 styp_flags |= STYP_BLOCK;
504 if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
505 styp_flags |= STYP_NOLOAD;
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. */
520 sec_to_styp_flags (const char *sec_name, flagword sec_flags)
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;
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 */
547 /* skip constRUCTOR */
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;
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. */
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(). */
591 styp_to_sec_flags (bfd *abfd ATTRIBUTE_UNUSED,
594 asection *section ATTRIBUTE_UNUSED,
597 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
598 long styp_flags = internal_s->s_flags;
599 flagword sec_flags = 0;
602 if (styp_flags & STYP_BLOCK)
603 sec_flags |= SEC_TIC54X_BLOCK;
607 if (styp_flags & STYP_CLINK)
608 sec_flags |= SEC_TIC54X_CLINK;
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;
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;
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;
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;
653 else if (styp_flags & STYP_PAD)
655 else if (strcmp (name, _TEXT) == 0)
657 if (sec_flags & SEC_NEVER_LOAD)
658 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
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;
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;
676 sec_flags |= SEC_ALLOC;
678 else if (CONST_STRNEQ (name, DOT_DEBUG)
680 || strcmp (name, _COMMENT) == 0
682 #ifdef COFF_LONG_SECTION_NAMES
683 || CONST_STRNEQ (name, GNU_LINKONCE_WI)
685 || CONST_STRNEQ (name, ".stab"))
687 #ifdef COFF_PAGE_SIZE
688 sec_flags |= SEC_DEBUGGING;
692 else if (strcmp (name, _LIB) == 0)
696 else if (strcmp (name, _LIT) == 0)
697 sec_flags = SEC_LOAD | SEC_ALLOC | SEC_READONLY;
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;
723 if (flags_ptr == NULL)
726 * flags_ptr = sec_flags;
730 #else /* COFF_WITH_PE */
733 handle_COMDAT (bfd * abfd,
739 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
740 bfd_byte *esymstart, *esym, *esymend;
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
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
763 if (! _bfd_coff_get_external_symbols (abfd))
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];
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. */
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);
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
835 Here, we think we've found the first one,
836 but there's some checking we can do to be
839 if (! (isym.n_sclass == C_STAT
840 && isym.n_type == T_NULL
841 && isym.n_value == 0))
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);
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)
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
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
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;
891 sec_flags &= ~SEC_LINK_ONCE;
895 case IMAGE_COMDAT_SELECT_ANY:
896 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
899 case IMAGE_COMDAT_SELECT_SAME_SIZE:
900 sec_flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
903 case IMAGE_COMDAT_SELECT_EXACT_MATCH:
904 /* Not yet fully implemented ??? */
905 sec_flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
908 /* debug$S gets this case; other
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;
920 sec_flags &= ~SEC_LINK_ONCE;
924 default: /* 0 means "no symbol" */
925 /* debug$F gets this case; other
927 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
934 /* Gas mode: the first matching on partial name. */
936 #ifndef TARGET_UNDERSCORE
937 #define TARGET_UNDERSCORE 0
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);
949 /* MSVC mode: the lexically second symbol (or
950 drop through from the above). */
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)
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);
974 strcpy (newname, symname);
975 coff_section_data (abfd, section)->comdat->name
983 esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd);
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? */
1001 styp_to_sec_flags (bfd *abfd,
1005 flagword *flags_ptr)
1007 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
1008 long styp_flags = internal_s->s_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. */
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. */
1030 unhandled = "STYP_DSECT";
1033 unhandled = "STYP_GROUP";
1036 unhandled = "STYP_COPY";
1039 unhandled = "STYP_OVER";
1041 #ifdef SEC_NEVER_LOAD
1043 sec_flags |= SEC_NEVER_LOAD;
1046 case IMAGE_SCN_MEM_READ:
1047 /* Ignored, assume it always to be true. */
1049 case IMAGE_SCN_TYPE_NO_PAD:
1052 case IMAGE_SCN_LNK_OTHER:
1053 unhandled = "IMAGE_SCN_LNK_OTHER";
1055 case IMAGE_SCN_MEM_NOT_CACHED:
1056 unhandled = "IMAGE_SCN_MEM_NOT_CACHED";
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"),
1065 case IMAGE_SCN_MEM_EXECUTE:
1066 sec_flags |= SEC_CODE;
1068 case IMAGE_SCN_MEM_WRITE:
1069 sec_flags &= ~ SEC_READONLY;
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;
1078 case IMAGE_SCN_MEM_SHARED:
1079 sec_flags |= SEC_COFF_SHARED;
1081 case IMAGE_SCN_LNK_REMOVE:
1082 sec_flags |= SEC_EXCLUDE;
1084 case IMAGE_SCN_CNT_CODE:
1085 sec_flags |= SEC_CODE | SEC_ALLOC | SEC_LOAD;
1087 case IMAGE_SCN_CNT_INITIALIZED_DATA:
1088 sec_flags |= SEC_DATA | SEC_ALLOC | SEC_LOAD;
1090 case IMAGE_SCN_CNT_UNINITIALIZED_DATA:
1091 sec_flags |= SEC_ALLOC;
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;
1104 case IMAGE_SCN_LNK_COMDAT:
1105 /* COMDAT gets very special treatment. */
1106 sec_flags = handle_COMDAT (abfd, sec_flags, hdr, name, section);
1109 /* Silently ignore for now. */
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);
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;
1135 * flags_ptr = sec_flags;
1140 #endif /* COFF_WITH_PE */
1142 #define get_index(symbol) ((symbol)->udata.i)
1146 bfd_coff_backend_data
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:
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)
1228 . bfd_boolean (*_bfd_coff_set_arch_mach_hook)
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)
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)
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 *,
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_coff_backend_data;
1297 .#define coff_backend_info(abfd) \
1298 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1300 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1301 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1303 .#define bfd_coff_swap_sym_in(a,e,i) \
1304 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1306 .#define bfd_coff_swap_lineno_in(a,e,i) \
1307 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1309 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1310 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1312 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1313 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1315 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1316 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1318 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1319 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1321 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1322 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1324 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1325 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1327 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1328 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1330 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1331 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1332 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1333 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1334 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1335 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1336 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1337 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1338 .#define bfd_coff_long_filenames(abfd) \
1339 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1340 .#define bfd_coff_long_section_names(abfd) \
1341 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1342 .#define bfd_coff_default_section_alignment_power(abfd) \
1343 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1344 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1345 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1347 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1348 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1350 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1351 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1353 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1354 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1356 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1357 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1359 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1360 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1361 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1362 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1363 . (abfd, filehdr, aouthdr))
1365 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1366 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1367 . (abfd, scnhdr, name, section, flags_ptr))
1369 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1370 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1372 .#define bfd_coff_slurp_symbol_table(abfd)\
1373 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1375 .#define bfd_coff_symname_in_debug(abfd, sym)\
1376 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1378 .#define bfd_coff_force_symnames_in_strings(abfd)\
1379 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1381 .#define bfd_coff_debug_string_prefix_length(abfd)\
1382 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1384 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1385 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1386 . (abfd, file, base, symbol, aux, indaux))
1388 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1389 . reloc, data, src_ptr, dst_ptr)\
1390 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1391 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1393 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1394 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1395 . (abfd, section, reloc, shrink, link_info))
1397 .#define bfd_coff_classify_symbol(abfd, sym)\
1398 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1401 .#define bfd_coff_compute_section_file_positions(abfd)\
1402 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1405 .#define bfd_coff_start_final_link(obfd, info)\
1406 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1408 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1409 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1410 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1411 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1412 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1413 . (abfd, sec, rel, h, sym, addendp))
1414 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1415 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1416 . (obfd, info, ibfd, sec, rel, adjustedp))
1417 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1418 . value, string, cp, coll, hashp)\
1419 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1420 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1422 .#define bfd_coff_link_output_has_begun(a,p) \
1423 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p))
1424 .#define bfd_coff_final_link_postscript(a,p) \
1425 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p))
1429 /* See whether the magic number matches. */
1432 coff_bad_format_hook (bfd * abfd ATTRIBUTE_UNUSED, void * filehdr)
1434 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1436 if (BADMAG (*internal_f))
1439 /* If the optional header is NULL or not the correct size then
1440 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1441 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1442 optional header is of a different size.
1444 But the mips keeps extra stuff in it's opthdr, so dont check
1447 #if defined(M88) || defined(I960)
1448 if (internal_f->f_opthdr != 0 && bfd_coff_aoutsz (abfd) != internal_f->f_opthdr)
1457 ticoff0_bad_format_hook (bfd *abfd ATTRIBUTE_UNUSED, void * filehdr)
1459 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1461 if (COFF0_BADMAG (*internal_f))
1470 ticoff1_bad_format_hook (bfd *abfd ATTRIBUTE_UNUSED, void * filehdr)
1472 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1474 if (COFF1_BADMAG (*internal_f))
1481 /* Check whether this section uses an alignment other than the
1485 coff_set_custom_section_alignment (bfd *abfd ATTRIBUTE_UNUSED,
1487 const struct coff_section_alignment_entry *alignment_table,
1488 const unsigned int table_size)
1490 const unsigned int default_alignment = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1493 for (i = 0; i < table_size; ++i)
1495 const char *secname = bfd_get_section_name (abfd, section);
1497 if (alignment_table[i].comparison_length == (unsigned int) -1
1498 ? strcmp (alignment_table[i].name, secname) == 0
1499 : strncmp (alignment_table[i].name, secname,
1500 alignment_table[i].comparison_length) == 0)
1503 if (i >= table_size)
1506 if (alignment_table[i].default_alignment_min != COFF_ALIGNMENT_FIELD_EMPTY
1507 && default_alignment < alignment_table[i].default_alignment_min)
1510 if (alignment_table[i].default_alignment_max != COFF_ALIGNMENT_FIELD_EMPTY
1511 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1512 && default_alignment > alignment_table[i].default_alignment_max
1517 section->alignment_power = alignment_table[i].alignment_power;
1520 /* Custom section alignment records. */
1522 static const struct coff_section_alignment_entry
1523 coff_section_alignment_table[] =
1525 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1526 COFF_SECTION_ALIGNMENT_ENTRIES,
1528 /* There must not be any gaps between .stabstr sections. */
1529 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1530 1, COFF_ALIGNMENT_FIELD_EMPTY, 0 },
1531 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1532 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1533 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1534 /* Similarly for the .ctors and .dtors sections. */
1535 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1536 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1537 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1538 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 }
1541 static const unsigned int coff_section_alignment_table_size =
1542 sizeof coff_section_alignment_table / sizeof coff_section_alignment_table[0];
1544 /* Initialize a section structure with information peculiar to this
1545 particular implementation of COFF. */
1548 coff_new_section_hook (bfd * abfd, asection * section)
1550 combined_entry_type *native;
1553 section->alignment_power = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1556 if (bfd_xcoff_text_align_power (abfd) != 0
1557 && strcmp (bfd_get_section_name (abfd, section), ".text") == 0)
1558 section->alignment_power = bfd_xcoff_text_align_power (abfd);
1559 if (bfd_xcoff_data_align_power (abfd) != 0
1560 && strcmp (bfd_get_section_name (abfd, section), ".data") == 0)
1561 section->alignment_power = bfd_xcoff_data_align_power (abfd);
1564 /* Set up the section symbol. */
1565 if (!_bfd_generic_new_section_hook (abfd, section))
1568 /* Allocate aux records for section symbols, to store size and
1571 @@ The 10 is a guess at a plausible maximum number of aux entries
1572 (but shouldn't be a constant). */
1573 amt = sizeof (combined_entry_type) * 10;
1574 native = bfd_zalloc (abfd, amt);
1578 /* We don't need to set up n_name, n_value, or n_scnum in the native
1579 symbol information, since they'll be overridden by the BFD symbol
1580 anyhow. However, we do need to set the type and storage class,
1581 in case this symbol winds up getting written out. The value 0
1582 for n_numaux is already correct. */
1584 native->u.syment.n_type = T_NULL;
1585 native->u.syment.n_sclass = C_STAT;
1587 coffsymbol (section->symbol)->native = native;
1589 coff_set_custom_section_alignment (abfd, section,
1590 coff_section_alignment_table,
1591 coff_section_alignment_table_size);
1596 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1598 /* Set the alignment of a BFD section. */
1601 coff_set_alignment_hook (bfd * abfd ATTRIBUTE_UNUSED,
1605 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1609 /* Extract ALIGN from 2**ALIGN stored in section header. */
1610 for (i = 0; i < 32; i++)
1611 if ((1 << i) >= hdr->s_align)
1615 /* TI tools puts the alignment power in bits 8-11. */
1616 i = (hdr->s_flags >> 8) & 0xF ;
1618 #ifdef COFF_DECODE_ALIGNMENT
1619 i = COFF_DECODE_ALIGNMENT(hdr->s_flags);
1621 section->alignment_power = i;
1623 #ifdef coff_set_section_load_page
1624 coff_set_section_load_page (section, hdr->s_page);
1628 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1631 /* A couple of macros to help setting the alignment power field. */
1632 #define ALIGN_SET(field, x, y) \
1633 if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x)\
1635 section->alignment_power = y;\
1638 #define ELIFALIGN_SET(field, x, y) \
1639 else if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x) \
1641 section->alignment_power = y;\
1645 coff_set_alignment_hook (bfd * abfd ATTRIBUTE_UNUSED,
1649 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1652 ALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_64BYTES, 6)
1653 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_32BYTES, 5)
1654 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_16BYTES, 4)
1655 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_8BYTES, 3)
1656 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_4BYTES, 2)
1657 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_2BYTES, 1)
1658 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_1BYTES, 0)
1660 /* In a PE image file, the s_paddr field holds the virtual size of a
1661 section, while the s_size field holds the raw size. We also keep
1662 the original section flag value, since not every bit can be
1663 mapped onto a generic BFD section bit. */
1664 if (coff_section_data (abfd, section) == NULL)
1666 amt = sizeof (struct coff_section_tdata);
1667 section->used_by_bfd = bfd_zalloc (abfd, amt);
1668 if (section->used_by_bfd == NULL)
1669 /* FIXME: Return error. */
1673 if (pei_section_data (abfd, section) == NULL)
1675 amt = sizeof (struct pei_section_tdata);
1676 coff_section_data (abfd, section)->tdata = bfd_zalloc (abfd, amt);
1677 if (coff_section_data (abfd, section)->tdata == NULL)
1678 /* FIXME: Return error. */
1681 pei_section_data (abfd, section)->virt_size = hdr->s_paddr;
1682 pei_section_data (abfd, section)->pe_flags = hdr->s_flags;
1684 section->lma = hdr->s_vaddr;
1686 /* Check for extended relocs. */
1687 if (hdr->s_flags & IMAGE_SCN_LNK_NRELOC_OVFL)
1689 struct external_reloc dst;
1690 struct internal_reloc n;
1691 file_ptr oldpos = bfd_tell (abfd);
1692 bfd_size_type relsz = bfd_coff_relsz (abfd);
1694 bfd_seek (abfd, (file_ptr) hdr->s_relptr, 0);
1695 if (bfd_bread (& dst, relsz, abfd) != relsz)
1698 coff_swap_reloc_in (abfd, &dst, &n);
1699 bfd_seek (abfd, oldpos, 0);
1700 section->reloc_count = hdr->s_nreloc = n.r_vaddr - 1;
1701 section->rel_filepos += relsz;
1703 else if (hdr->s_nreloc == 0xffff)
1704 (*_bfd_error_handler)
1705 ("%s: warning: claims to have 0xffff relocs, without overflow",
1706 bfd_get_filename (abfd));
1709 #undef ELIFALIGN_SET
1711 #else /* ! COFF_WITH_PE */
1714 /* We grossly abuse this function to handle XCOFF overflow headers.
1715 When we see one, we correct the reloc and line number counts in the
1716 real header, and remove the section we just created. */
1719 coff_set_alignment_hook (bfd *abfd, asection *section, void * scnhdr)
1721 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1724 if ((hdr->s_flags & STYP_OVRFLO) == 0)
1727 real_sec = coff_section_from_bfd_index (abfd, (int) hdr->s_nreloc);
1728 if (real_sec == NULL)
1731 real_sec->reloc_count = hdr->s_paddr;
1732 real_sec->lineno_count = hdr->s_vaddr;
1734 if (!bfd_section_removed_from_list (abfd, section))
1736 bfd_section_list_remove (abfd, section);
1737 --abfd->section_count;
1741 #else /* ! RS6000COFF_C */
1743 #define coff_set_alignment_hook \
1744 ((void (*) (bfd *, asection *, void *)) bfd_void)
1746 #endif /* ! RS6000COFF_C */
1747 #endif /* ! COFF_WITH_PE */
1748 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1750 #ifndef coff_mkobject
1753 coff_mkobject (bfd * abfd)
1755 coff_data_type *coff;
1756 bfd_size_type amt = sizeof (coff_data_type);
1758 abfd->tdata.coff_obj_data = bfd_zalloc (abfd, amt);
1759 if (abfd->tdata.coff_obj_data == NULL)
1761 coff = coff_data (abfd);
1762 coff->symbols = NULL;
1763 coff->conversion_table = NULL;
1764 coff->raw_syments = NULL;
1765 coff->relocbase = 0;
1766 coff->local_toc_sym_map = 0;
1768 /* make_abs_section(abfd);*/
1774 /* Create the COFF backend specific information. */
1776 #ifndef coff_mkobject_hook
1778 coff_mkobject_hook (bfd * abfd,
1780 void * aouthdr ATTRIBUTE_UNUSED)
1782 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1783 coff_data_type *coff;
1785 if (! coff_mkobject (abfd))
1788 coff = coff_data (abfd);
1790 coff->sym_filepos = internal_f->f_symptr;
1792 /* These members communicate important constants about the symbol
1793 table to GDB's symbol-reading code. These `constants'
1794 unfortunately vary among coff implementations... */
1795 coff->local_n_btmask = N_BTMASK;
1796 coff->local_n_btshft = N_BTSHFT;
1797 coff->local_n_tmask = N_TMASK;
1798 coff->local_n_tshift = N_TSHIFT;
1799 coff->local_symesz = bfd_coff_symesz (abfd);
1800 coff->local_auxesz = bfd_coff_auxesz (abfd);
1801 coff->local_linesz = bfd_coff_linesz (abfd);
1803 coff->timestamp = internal_f->f_timdat;
1805 obj_raw_syment_count (abfd) =
1806 obj_conv_table_size (abfd) =
1807 internal_f->f_nsyms;
1810 if ((internal_f->f_flags & F_SHROBJ) != 0)
1811 abfd->flags |= DYNAMIC;
1812 if (aouthdr != NULL && internal_f->f_opthdr >= bfd_coff_aoutsz (abfd))
1814 struct internal_aouthdr *internal_a =
1815 (struct internal_aouthdr *) aouthdr;
1816 struct xcoff_tdata *xcoff;
1818 xcoff = xcoff_data (abfd);
1819 # ifdef U803XTOCMAGIC
1820 xcoff->xcoff64 = internal_f->f_magic == U803XTOCMAGIC;
1824 xcoff->full_aouthdr = TRUE;
1825 xcoff->toc = internal_a->o_toc;
1826 xcoff->sntoc = internal_a->o_sntoc;
1827 xcoff->snentry = internal_a->o_snentry;
1828 bfd_xcoff_text_align_power (abfd) = internal_a->o_algntext;
1829 bfd_xcoff_data_align_power (abfd) = internal_a->o_algndata;
1830 xcoff->modtype = internal_a->o_modtype;
1831 xcoff->cputype = internal_a->o_cputype;
1832 xcoff->maxdata = internal_a->o_maxdata;
1833 xcoff->maxstack = internal_a->o_maxstack;
1838 /* Set the flags field from the COFF header read in. */
1839 if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags))
1844 /* FIXME: I'm not sure this is ever executed, since peicode.h
1845 defines coff_mkobject_hook. */
1846 if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0)
1847 abfd->flags |= HAS_DEBUG;
1854 /* Determine the machine architecture and type. FIXME: This is target
1855 dependent because the magic numbers are defined in the target
1856 dependent header files. But there is no particular need for this.
1857 If the magic numbers were moved to a separate file, this function
1858 would be target independent and would also be much more successful
1859 at linking together COFF files for different architectures. */
1862 coff_set_arch_mach_hook (bfd *abfd, void * filehdr)
1864 unsigned long machine;
1865 enum bfd_architecture arch;
1866 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1868 /* Zero selects the default machine for an arch. */
1870 switch (internal_f->f_magic)
1872 #ifdef OR32_MAGIC_BIG
1873 case OR32_MAGIC_BIG:
1874 case OR32_MAGIC_LITTLE:
1875 arch = bfd_arch_or32;
1880 arch = bfd_arch_powerpc;
1886 case I386AIXMAGIC: /* Danbury PS/2 AIX C Compiler. */
1887 case LYNXCOFFMAGIC: /* Shadows the m68k Lynx number below, sigh. */
1888 arch = bfd_arch_i386;
1893 arch = bfd_arch_i386;
1894 machine = bfd_mach_x86_64;
1899 arch = bfd_arch_ia64;
1906 arch = bfd_arch_arm;
1907 machine = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
1908 if (machine == bfd_mach_arm_unknown)
1910 switch (internal_f->f_flags & F_ARM_ARCHITECTURE_MASK)
1912 case F_ARM_2: machine = bfd_mach_arm_2; break;
1913 case F_ARM_2a: machine = bfd_mach_arm_2a; break;
1914 case F_ARM_3: machine = bfd_mach_arm_3; break;
1916 case F_ARM_3M: machine = bfd_mach_arm_3M; break;
1917 case F_ARM_4: machine = bfd_mach_arm_4; break;
1918 case F_ARM_4T: machine = bfd_mach_arm_4T; break;
1919 /* The COFF header does not have enough bits available
1920 to cover all the different ARM architectures. So
1921 we interpret F_ARM_5, the highest flag value to mean
1922 "the highest ARM architecture known to BFD" which is
1923 currently the XScale. */
1924 case F_ARM_5: machine = bfd_mach_arm_XScale; break;
1932 #ifdef MC68KBCSMAGIC
1935 #ifdef APOLLOM68KMAGIC
1936 case APOLLOM68KMAGIC:
1938 #ifdef LYNXCOFFMAGIC
1941 arch = bfd_arch_m68k;
1942 machine = bfd_mach_m68020;
1947 arch = bfd_arch_maxq;
1948 switch (internal_f->f_flags & F_MACHMASK)
1951 machine = bfd_mach_maxq10;
1954 machine = bfd_mach_maxq20;
1965 arch = bfd_arch_m88k;
1971 arch = bfd_arch_z80;
1972 switch (internal_f->f_flags & F_MACHMASK)
1975 case bfd_mach_z80strict << 12:
1976 case bfd_mach_z80 << 12:
1977 case bfd_mach_z80full << 12:
1978 case bfd_mach_r800 << 12:
1979 machine = ((unsigned)internal_f->f_flags & F_MACHMASK) >> 12;
1988 arch = bfd_arch_z8k;
1989 switch (internal_f->f_flags & F_MACHMASK)
1992 machine = bfd_mach_z8001;
1995 machine = bfd_mach_z8002;
2004 arch = bfd_arch_i860;
2011 arch = bfd_arch_i960;
2012 switch (F_I960TYPE & internal_f->f_flags)
2016 machine = bfd_mach_i960_core;
2019 machine = bfd_mach_i960_kb_sb;
2022 machine = bfd_mach_i960_mc;
2025 machine = bfd_mach_i960_xa;
2028 machine = bfd_mach_i960_ca;
2031 machine = bfd_mach_i960_ka_sa;
2034 machine = bfd_mach_i960_jx;
2037 machine = bfd_mach_i960_hx;
2056 if (xcoff_data (abfd)->cputype != -1)
2057 cputype = xcoff_data (abfd)->cputype & 0xff;
2060 /* We did not get a value from the a.out header. If the
2061 file has not been stripped, we may be able to get the
2062 architecture information from the first symbol, if it
2063 is a .file symbol. */
2064 if (obj_raw_syment_count (abfd) == 0)
2069 struct internal_syment sym;
2070 bfd_size_type amt = bfd_coff_symesz (abfd);
2072 buf = bfd_malloc (amt);
2073 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
2074 || bfd_bread (buf, amt, abfd) != amt)
2079 bfd_coff_swap_sym_in (abfd, buf, & sym);
2080 if (sym.n_sclass == C_FILE)
2081 cputype = sym.n_type & 0xff;
2088 /* FIXME: We don't handle all cases here. */
2093 arch = bfd_xcoff_architecture (abfd);
2094 machine = bfd_xcoff_machine (abfd);
2098 arch = bfd_arch_powerpc;
2099 machine = bfd_mach_ppc_601;
2101 case 2: /* 64 bit PowerPC */
2102 arch = bfd_arch_powerpc;
2103 machine = bfd_mach_ppc_620;
2106 arch = bfd_arch_powerpc;
2107 machine = bfd_mach_ppc;
2110 arch = bfd_arch_rs6000;
2111 machine = bfd_mach_rs6k;
2120 arch = bfd_arch_we32k;
2126 arch = bfd_arch_h8300;
2127 machine = bfd_mach_h8300;
2128 /* !! FIXME this probably isn't the right place for this. */
2129 abfd->flags |= BFD_IS_RELAXABLE;
2135 arch = bfd_arch_h8300;
2136 machine = bfd_mach_h8300h;
2137 /* !! FIXME this probably isn't the right place for this. */
2138 abfd->flags |= BFD_IS_RELAXABLE;
2144 arch = bfd_arch_h8300;
2145 machine = bfd_mach_h8300s;
2146 /* !! FIXME this probably isn't the right place for this. */
2147 abfd->flags |= BFD_IS_RELAXABLE;
2153 arch = bfd_arch_h8300;
2154 machine = bfd_mach_h8300hn;
2155 /* !! FIXME this probably isn't the right place for this. */
2156 abfd->flags |= BFD_IS_RELAXABLE;
2162 arch = bfd_arch_h8300;
2163 machine = bfd_mach_h8300sn;
2164 /* !! FIXME this probably isn't the right place for this. */
2165 abfd->flags |= BFD_IS_RELAXABLE;
2169 #ifdef SH_ARCH_MAGIC_BIG
2170 case SH_ARCH_MAGIC_BIG:
2171 case SH_ARCH_MAGIC_LITTLE:
2173 case SH_ARCH_MAGIC_WINCE:
2179 #ifdef MIPS_ARCH_MAGIC_WINCE
2180 case MIPS_ARCH_MAGIC_WINCE:
2181 arch = bfd_arch_mips;
2187 arch = bfd_arch_h8500;
2193 #ifdef LYNXCOFFMAGIC
2196 arch = bfd_arch_sparc;
2202 arch = bfd_arch_tic30;
2207 #ifdef TICOFF_TARGET_ARCH
2208 /* This TI COFF section should be used by all new TI COFF v0 targets. */
2210 arch = TICOFF_TARGET_ARCH;
2211 machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags);
2217 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */
2218 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */
2221 switch (internal_f->f_target_id)
2225 arch = TICOFF_TARGET_ARCH;
2226 machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags);
2230 arch = bfd_arch_obscure;
2231 (*_bfd_error_handler)
2232 (_("Unrecognized TI COFF target id '0x%x'"),
2233 internal_f->f_target_id);
2239 #ifdef TIC80_ARCH_MAGIC
2240 case TIC80_ARCH_MAGIC:
2241 arch = bfd_arch_tic80;
2247 arch = bfd_arch_mcore;
2253 arch = bfd_arch_w65;
2257 default: /* Unreadable input file type. */
2258 arch = bfd_arch_obscure;
2262 bfd_default_set_arch_mach (abfd, arch, machine);
2266 #ifdef SYMNAME_IN_DEBUG
2269 symname_in_debug_hook (bfd * abfd ATTRIBUTE_UNUSED, struct internal_syment *sym)
2271 return SYMNAME_IN_DEBUG (sym) != 0;
2276 #define symname_in_debug_hook \
2277 (bfd_boolean (*) (bfd *, struct internal_syment *)) bfd_false
2284 #define FORCE_SYMNAMES_IN_STRINGS
2287 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
2290 coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED,
2291 combined_entry_type *table_base,
2292 combined_entry_type *symbol,
2293 unsigned int indaux,
2294 combined_entry_type *aux)
2296 int class = symbol->u.syment.n_sclass;
2298 if ((class == C_EXT || class == C_HIDEXT)
2299 && indaux + 1 == symbol->u.syment.n_numaux)
2301 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
2303 aux->u.auxent.x_csect.x_scnlen.p =
2304 table_base + aux->u.auxent.x_csect.x_scnlen.l;
2305 aux->fix_scnlen = 1;
2308 /* Return TRUE to indicate that the caller should not do any
2309 further work on this auxent. */
2313 /* Return FALSE to indicate that this auxent should be handled by
2321 /* We don't want to pointerize bal entries. */
2324 coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED,
2325 combined_entry_type *table_base ATTRIBUTE_UNUSED,
2326 combined_entry_type *symbol,
2327 unsigned int indaux,
2328 combined_entry_type *aux ATTRIBUTE_UNUSED)
2330 /* Return TRUE if we don't want to pointerize this aux entry, which
2331 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2333 && (symbol->u.syment.n_sclass == C_LEAFPROC
2334 || symbol->u.syment.n_sclass == C_LEAFSTAT
2335 || symbol->u.syment.n_sclass == C_LEAFEXT));
2340 #define coff_pointerize_aux_hook 0
2343 #endif /* ! RS6000COFF_C */
2345 /* Print an aux entry. This returns TRUE if it has printed it. */
2348 coff_print_aux (bfd *abfd ATTRIBUTE_UNUSED,
2349 FILE *file ATTRIBUTE_UNUSED,
2350 combined_entry_type *table_base ATTRIBUTE_UNUSED,
2351 combined_entry_type *symbol ATTRIBUTE_UNUSED,
2352 combined_entry_type *aux ATTRIBUTE_UNUSED,
2353 unsigned int indaux ATTRIBUTE_UNUSED)
2356 if ((symbol->u.syment.n_sclass == C_EXT
2357 || symbol->u.syment.n_sclass == C_HIDEXT)
2358 && indaux + 1 == symbol->u.syment.n_numaux)
2360 /* This is a csect entry. */
2361 fprintf (file, "AUX ");
2362 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
2364 BFD_ASSERT (! aux->fix_scnlen);
2366 fprintf (file, "val %5lld",
2367 (long long) aux->u.auxent.x_csect.x_scnlen.l);
2369 fprintf (file, "val %5ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
2374 fprintf (file, "indx ");
2375 if (! aux->fix_scnlen)
2377 fprintf (file, "%4lld",
2378 (long long) aux->u.auxent.x_csect.x_scnlen.l);
2380 fprintf (file, "%4ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
2383 fprintf (file, "%4ld",
2384 (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base));
2387 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2388 aux->u.auxent.x_csect.x_parmhash,
2389 (unsigned int) aux->u.auxent.x_csect.x_snhash,
2390 SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp),
2391 SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp),
2392 (unsigned int) aux->u.auxent.x_csect.x_smclas,
2393 aux->u.auxent.x_csect.x_stab,
2394 (unsigned int) aux->u.auxent.x_csect.x_snstab);
2399 /* Return FALSE to indicate that no special action was taken. */
2407 To write relocations, the back end steps though the
2408 canonical relocation table and create an
2409 @code{internal_reloc}. The symbol index to use is removed from
2410 the @code{offset} field in the symbol table supplied. The
2411 address comes directly from the sum of the section base
2412 address and the relocation offset; the type is dug directly
2413 from the howto field. Then the @code{internal_reloc} is
2414 swapped into the shape of an @code{external_reloc} and written
2422 /* AUX's ld wants relocations to be sorted. */
2424 compare_arelent_ptr (const void * x, const void * y)
2426 const arelent **a = (const arelent **) x;
2427 const arelent **b = (const arelent **) y;
2428 bfd_size_type aadr = (*a)->address;
2429 bfd_size_type badr = (*b)->address;
2431 return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
2434 #endif /* TARG_AUX */
2437 coff_write_relocs (bfd * abfd, int first_undef)
2441 for (s = abfd->sections; s != NULL; s = s->next)
2444 struct external_reloc dst;
2451 /* Sort relocations before we write them out. */
2454 amt = s->reloc_count;
2455 amt *= sizeof (arelent *);
2456 p = bfd_malloc (amt);
2457 if (p == NULL && s->reloc_count > 0)
2459 memcpy (p, s->orelocation, (size_t) amt);
2460 qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr);
2464 if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
2468 if (obj_pe (abfd) && s->reloc_count >= 0xffff)
2470 /* Encode real count here as first reloc. */
2471 struct internal_reloc n;
2473 memset (& n, 0, sizeof (n));
2474 /* Add one to count *this* reloc (grr). */
2475 n.r_vaddr = s->reloc_count + 1;
2476 coff_swap_reloc_out (abfd, &n, &dst);
2477 if (bfd_bwrite (& dst, (bfd_size_type) bfd_coff_relsz (abfd),
2478 abfd) != bfd_coff_relsz (abfd))
2483 for (i = 0; i < s->reloc_count; i++)
2485 struct internal_reloc n;
2488 memset (& n, 0, sizeof (n));
2490 /* Now we've renumbered the symbols we know where the
2491 undefined symbols live in the table. Check the reloc
2492 entries for symbols who's output bfd isn't the right one.
2493 This is because the symbol was undefined (which means
2494 that all the pointers are never made to point to the same
2495 place). This is a bad thing,'cause the symbols attached
2496 to the output bfd are indexed, so that the relocation
2497 entries know which symbol index they point to. So we
2498 have to look up the output symbol here. */
2500 if (q->sym_ptr_ptr[0]->the_bfd != abfd)
2503 const char *sname = q->sym_ptr_ptr[0]->name;
2504 asymbol **outsyms = abfd->outsymbols;
2506 for (j = first_undef; outsyms[j]; j++)
2508 const char *intable = outsyms[j]->name;
2510 if (strcmp (intable, sname) == 0)
2512 /* Got a hit, so repoint the reloc. */
2513 q->sym_ptr_ptr = outsyms + j;
2519 n.r_vaddr = q->address + s->vma;
2522 /* The 29k const/consth reloc pair is a real kludge. The consth
2523 part doesn't have a symbol; it has an offset. So rebuilt
2525 if (q->howto->type == R_IHCONST)
2526 n.r_symndx = q->addend;
2531 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2532 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q, s))
2534 if ((*q->sym_ptr_ptr)->section == bfd_abs_section_ptr
2535 && ((*q->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0)
2537 /* This is a relocation relative to the absolute symbol. */
2541 n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
2542 /* Check to see if the symbol reloc points to a symbol
2543 we don't have in our symbol table. */
2544 if (n.r_symndx > obj_conv_table_size (abfd))
2546 bfd_set_error (bfd_error_bad_value);
2547 _bfd_error_handler (_("%B: reloc against a non-existant symbol index: %ld"),
2554 #ifdef SWAP_OUT_RELOC_OFFSET
2555 n.r_offset = q->addend;
2559 /* Work out reloc type from what is required. */
2560 SELECT_RELOC (n, q->howto);
2562 n.r_type = q->howto->type;
2564 coff_swap_reloc_out (abfd, &n, &dst);
2566 if (bfd_bwrite (& dst, (bfd_size_type) bfd_coff_relsz (abfd),
2567 abfd) != bfd_coff_relsz (abfd))
2580 /* Set flags and magic number of a coff file from architecture and machine
2581 type. Result is TRUE if we can represent the arch&type, FALSE if not. */
2584 coff_set_flags (bfd * abfd,
2585 unsigned int *magicp ATTRIBUTE_UNUSED,
2586 unsigned short *flagsp ATTRIBUTE_UNUSED)
2588 switch (bfd_get_arch (abfd))
2593 switch (bfd_get_mach (abfd))
2596 case bfd_mach_z80strict:
2598 case bfd_mach_z80full:
2600 *flagsp = bfd_get_mach (abfd) << 12;
2612 switch (bfd_get_mach (abfd))
2614 case bfd_mach_z8001: *flagsp = F_Z8001; break;
2615 case bfd_mach_z8002: *flagsp = F_Z8002; break;
2616 default: return FALSE;
2627 *magicp = I960ROMAGIC;
2629 switch (bfd_get_mach (abfd))
2631 case bfd_mach_i960_core: flags = F_I960CORE; break;
2632 case bfd_mach_i960_kb_sb: flags = F_I960KB; break;
2633 case bfd_mach_i960_mc: flags = F_I960MC; break;
2634 case bfd_mach_i960_xa: flags = F_I960XA; break;
2635 case bfd_mach_i960_ca: flags = F_I960CA; break;
2636 case bfd_mach_i960_ka_sa: flags = F_I960KA; break;
2637 case bfd_mach_i960_jx: flags = F_I960JX; break;
2638 case bfd_mach_i960_hx: flags = F_I960HX; break;
2639 default: return FALSE;
2648 case bfd_arch_tic30:
2649 *magicp = TIC30MAGIC;
2653 #ifdef TICOFF_DEFAULT_MAGIC
2654 case TICOFF_TARGET_ARCH:
2655 /* If there's no indication of which version we want, use the default. */
2657 *magicp = TICOFF_DEFAULT_MAGIC;
2660 /* We may want to output in a different COFF version. */
2661 switch (abfd->xvec->name[4])
2664 *magicp = TICOFF0MAGIC;
2667 *magicp = TICOFF1MAGIC;
2670 *magicp = TICOFF2MAGIC;
2676 TICOFF_TARGET_MACHINE_SET (flagsp, bfd_get_mach (abfd));
2680 #ifdef TIC80_ARCH_MAGIC
2681 case bfd_arch_tic80:
2682 *magicp = TIC80_ARCH_MAGIC;
2689 * magicp = ARMPEMAGIC;
2691 * magicp = ARMMAGIC;
2694 if (APCS_SET (abfd))
2696 if (APCS_26_FLAG (abfd))
2697 * flagsp |= F_APCS26;
2699 if (APCS_FLOAT_FLAG (abfd))
2700 * flagsp |= F_APCS_FLOAT;
2702 if (PIC_FLAG (abfd))
2705 if (INTERWORK_SET (abfd) && INTERWORK_FLAG (abfd))
2706 * flagsp |= F_INTERWORK;
2707 switch (bfd_get_mach (abfd))
2709 case bfd_mach_arm_2: * flagsp |= F_ARM_2; break;
2710 case bfd_mach_arm_2a: * flagsp |= F_ARM_2a; break;
2711 case bfd_mach_arm_3: * flagsp |= F_ARM_3; break;
2712 case bfd_mach_arm_3M: * flagsp |= F_ARM_3M; break;
2713 case bfd_mach_arm_4: * flagsp |= F_ARM_4; break;
2714 case bfd_mach_arm_4T: * flagsp |= F_ARM_4T; break;
2715 case bfd_mach_arm_5: * flagsp |= F_ARM_5; break;
2716 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2717 See also the comment in coff_set_arch_mach_hook(). */
2718 case bfd_mach_arm_5T: * flagsp |= F_ARM_5; break;
2719 case bfd_mach_arm_5TE: * flagsp |= F_ARM_5; break;
2720 case bfd_mach_arm_XScale: * flagsp |= F_ARM_5; break;
2726 case bfd_arch_powerpc:
2731 #if defined(I386MAGIC) || defined(AMD64MAGIC)
2733 #if defined(I386MAGIC)
2734 *magicp = I386MAGIC;
2737 /* Just overwrite the usual value if we're doing Lynx. */
2738 *magicp = LYNXCOFFMAGIC;
2740 #if defined AMD64MAGIC
2741 *magicp = AMD64MAGIC;
2748 *magicp = I860MAGIC;
2754 *magicp = IA64MAGIC;
2760 #ifdef APOLLOM68KMAGIC
2761 *magicp = APOLLO_COFF_VERSION_NUMBER;
2763 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2764 #ifdef NAMES_HAVE_UNDERSCORE
2765 *magicp = MC68KBCSMAGIC;
2767 *magicp = MC68MAGIC;
2771 /* Just overwrite the usual value if we're doing Lynx. */
2772 *magicp = LYNXCOFFMAGIC;
2779 *magicp = MC88OMAGIC;
2784 case bfd_arch_h8300:
2785 switch (bfd_get_mach (abfd))
2787 case bfd_mach_h8300: *magicp = H8300MAGIC; return TRUE;
2788 case bfd_mach_h8300h: *magicp = H8300HMAGIC; return TRUE;
2789 case bfd_mach_h8300s: *magicp = H8300SMAGIC; return TRUE;
2790 case bfd_mach_h8300hn: *magicp = H8300HNMAGIC; return TRUE;
2791 case bfd_mach_h8300sn: *magicp = H8300SNMAGIC; return TRUE;
2797 #ifdef SH_ARCH_MAGIC_BIG
2799 #ifdef COFF_IMAGE_WITH_PE
2800 *magicp = SH_ARCH_MAGIC_WINCE;
2802 if (bfd_big_endian (abfd))
2803 *magicp = SH_ARCH_MAGIC_BIG;
2805 *magicp = SH_ARCH_MAGIC_LITTLE;
2810 #ifdef MIPS_ARCH_MAGIC_WINCE
2812 *magicp = MIPS_ARCH_MAGIC_WINCE;
2817 case bfd_arch_sparc:
2818 *magicp = SPARCMAGIC;
2820 /* Just overwrite the usual value if we're doing Lynx. */
2821 *magicp = LYNXCOFFMAGIC;
2827 case bfd_arch_h8500:
2828 *magicp = H8500MAGIC;
2834 case bfd_arch_we32k:
2835 *magicp = WE32KMAGIC;
2840 case bfd_arch_rs6000:
2842 case bfd_arch_powerpc:
2844 BFD_ASSERT (bfd_get_flavour (abfd) == bfd_target_xcoff_flavour);
2845 *magicp = bfd_xcoff_magic_number (abfd);
2850 case bfd_arch_mcore:
2851 * magicp = MCOREMAGIC;
2861 #ifdef OR32_MAGIC_BIG
2863 if (bfd_big_endian (abfd))
2864 * magicp = OR32_MAGIC_BIG;
2866 * magicp = OR32_MAGIC_LITTLE;
2872 * magicp = MAXQ20MAGIC;
2873 switch (bfd_get_mach (abfd))
2875 case bfd_mach_maxq10: * flagsp = F_MAXQ10; return TRUE;
2876 case bfd_mach_maxq20: * flagsp = F_MAXQ20; return TRUE;
2877 default: return FALSE;
2881 default: /* Unknown architecture. */
2882 /* Fall through to "return FALSE" below, to avoid
2883 "statement never reached" errors on the one below. */
2891 coff_set_arch_mach (bfd * abfd,
2892 enum bfd_architecture arch,
2893 unsigned long machine)
2896 unsigned short dummy2;
2898 if (! bfd_default_set_arch_mach (abfd, arch, machine))
2901 if (arch != bfd_arch_unknown
2902 && ! coff_set_flags (abfd, &dummy1, &dummy2))
2903 return FALSE; /* We can't represent this type. */
2905 return TRUE; /* We're easy... */
2908 #ifdef COFF_IMAGE_WITH_PE
2910 /* This is used to sort sections by VMA, as required by PE image
2914 sort_by_secaddr (const void * arg1, const void * arg2)
2916 const asection *a = *(const asection **) arg1;
2917 const asection *b = *(const asection **) arg2;
2919 if (a->vma < b->vma)
2921 else if (a->vma > b->vma)
2927 #endif /* COFF_IMAGE_WITH_PE */
2929 /* Calculate the file position for each section. */
2932 #define ALIGN_SECTIONS_IN_FILE
2934 #if defined(TIC80COFF) || defined(TICOFF)
2935 #undef ALIGN_SECTIONS_IN_FILE
2939 coff_compute_section_file_positions (bfd * abfd)
2942 asection *previous = NULL;
2943 file_ptr sofar = bfd_coff_filhsz (abfd);
2944 bfd_boolean align_adjust;
2945 #ifdef ALIGN_SECTIONS_IN_FILE
2950 /* On XCOFF, if we have symbols, set up the .debug section. */
2951 if (bfd_get_symcount (abfd) > 0)
2954 bfd_size_type i, symcount;
2958 symcount = bfd_get_symcount (abfd);
2959 for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++)
2961 coff_symbol_type *cf;
2963 cf = coff_symbol_from (abfd, *symp);
2965 && cf->native != NULL
2966 && SYMNAME_IN_DEBUG (&cf->native->u.syment))
2970 len = strlen (bfd_asymbol_name (*symp));
2971 if (len > SYMNMLEN || bfd_coff_force_symnames_in_strings (abfd))
2972 sz += len + 1 + bfd_coff_debug_string_prefix_length (abfd);
2979 dsec = bfd_make_section_old_way (abfd, DOT_DEBUG);
2983 dsec->flags |= SEC_HAS_CONTENTS;
2988 #ifdef COFF_IMAGE_WITH_PE
2991 if (coff_data (abfd)->link_info)
2993 page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
2995 /* If no file alignment has been set, default to one.
2996 This repairs 'ld -r' for arm-wince-pe target. */
3001 page_size = PE_DEF_FILE_ALIGNMENT;
3003 #ifdef COFF_PAGE_SIZE
3004 int page_size = COFF_PAGE_SIZE;
3008 if (bfd_get_start_address (abfd))
3009 /* A start address may have been added to the original file. In this
3010 case it will need an optional header to record it. */
3011 abfd->flags |= EXEC_P;
3013 if (abfd->flags & EXEC_P)
3014 sofar += bfd_coff_aoutsz (abfd);
3016 else if (xcoff_data (abfd)->full_aouthdr)
3017 sofar += bfd_coff_aoutsz (abfd);
3019 sofar += SMALL_AOUTSZ;
3022 sofar += abfd->section_count * bfd_coff_scnhsz (abfd);
3025 /* XCOFF handles overflows in the reloc and line number count fields
3026 by allocating a new section header to hold the correct counts. */
3027 for (current = abfd->sections; current != NULL; current = current->next)
3028 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3029 sofar += bfd_coff_scnhsz (abfd);
3032 #ifdef COFF_IMAGE_WITH_PE
3034 /* PE requires the sections to be in memory order when listed in
3035 the section headers. It also does not like empty loadable
3036 sections. The sections apparently do not have to be in the
3037 right order in the image file itself, but we do need to get the
3038 target_index values right. */
3041 asection **section_list;
3047 for (current = abfd->sections; current != NULL; current = current->next)
3050 /* We allocate an extra cell to simplify the final loop. */
3051 amt = sizeof (struct asection *) * (count + 1);
3052 section_list = bfd_malloc (amt);
3053 if (section_list == NULL)
3057 for (current = abfd->sections; current != NULL; current = current->next)
3059 section_list[i] = current;
3062 section_list[i] = NULL;
3064 qsort (section_list, count, sizeof (asection *), sort_by_secaddr);
3066 /* Rethread the linked list into sorted order; at the same time,
3067 assign target_index values. */
3069 abfd->sections = NULL;
3070 abfd->section_last = NULL;
3071 for (i = 0; i < count; i++)
3073 current = section_list[i];
3074 bfd_section_list_append (abfd, current);
3076 /* Later, if the section has zero size, we'll be throwing it
3077 away, so we don't want to number it now. Note that having
3078 a zero size and having real contents are different
3079 concepts: .bss has no contents, but (usually) non-zero
3081 if (current->size == 0)
3083 /* Discard. However, it still might have (valid) symbols
3084 in it, so arbitrarily set it to section 1 (indexing is
3085 1-based here; usually .text). __end__ and other
3086 contents of .endsection really have this happen.
3087 FIXME: This seems somewhat dubious. */
3088 current->target_index = 1;
3091 current->target_index = target_index++;
3094 free (section_list);
3096 #else /* ! COFF_IMAGE_WITH_PE */
3098 /* Set the target_index field. */
3102 for (current = abfd->sections; current != NULL; current = current->next)
3103 current->target_index = target_index++;
3105 #endif /* ! COFF_IMAGE_WITH_PE */
3107 align_adjust = FALSE;
3108 for (current = abfd->sections;
3110 current = current->next)
3112 #ifdef COFF_IMAGE_WITH_PE
3113 /* With PE we have to pad each section to be a multiple of its
3114 page size too, and remember both sizes. */
3115 if (coff_section_data (abfd, current) == NULL)
3117 bfd_size_type amt = sizeof (struct coff_section_tdata);
3119 current->used_by_bfd = bfd_zalloc (abfd, amt);
3120 if (current->used_by_bfd == NULL)
3123 if (pei_section_data (abfd, current) == NULL)
3125 bfd_size_type amt = sizeof (struct pei_section_tdata);
3127 coff_section_data (abfd, current)->tdata = bfd_zalloc (abfd, amt);
3128 if (coff_section_data (abfd, current)->tdata == NULL)
3131 if (pei_section_data (abfd, current)->virt_size == 0)
3132 pei_section_data (abfd, current)->virt_size = current->size;
3135 /* Only deal with sections which have contents. */
3136 if (!(current->flags & SEC_HAS_CONTENTS))
3139 #ifdef COFF_IMAGE_WITH_PE
3140 /* Make sure we skip empty sections in a PE image. */
3141 if (current->size == 0)
3145 /* Align the sections in the file to the same boundary on
3146 which they are aligned in virtual memory. I960 doesn't
3147 do this (FIXME) so we can stay in sync with Intel. 960
3148 doesn't yet page from files... */
3149 #ifdef ALIGN_SECTIONS_IN_FILE
3150 if ((abfd->flags & EXEC_P) != 0)
3152 /* Make sure this section is aligned on the right boundary - by
3153 padding the previous section up if necessary. */
3157 /* AIX loader checks the text section alignment of (vma - filepos)
3158 So even though the filepos may be aligned wrt the o_algntext, for
3159 AIX executables, this check fails. This shows up when a native
3160 AIX executable is stripped with gnu strip because the default vma
3161 of native is 0x10000150 but default for gnu is 0x10000140. Gnu
3162 stripped gnu excutable passes this check because the filepos is
3163 0x0140. This problem also show up with 64 bit shared objects. The
3164 data section must also be aligned. */
3165 if (!strcmp (current->name, _TEXT)
3166 || !strcmp (current->name, _DATA))
3171 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3173 align = 1 << current->alignment_power;
3174 pad = abs (current->vma - sofar) % align;
3185 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3188 if (previous != NULL)
3189 previous->size += sofar - old_sofar;
3194 /* In demand paged files the low order bits of the file offset
3195 must match the low order bits of the virtual address. */
3196 #ifdef COFF_PAGE_SIZE
3197 if ((abfd->flags & D_PAGED) != 0
3198 && (current->flags & SEC_ALLOC) != 0)
3199 sofar += (current->vma - (bfd_vma) sofar) % page_size;
3201 current->filepos = sofar;
3203 #ifdef COFF_IMAGE_WITH_PE
3204 /* Set the padded size. */
3205 current->size = (current->size + page_size -1) & -page_size;
3208 sofar += current->size;
3210 #ifdef ALIGN_SECTIONS_IN_FILE
3211 /* Make sure that this section is of the right size too. */
3212 if ((abfd->flags & EXEC_P) == 0)
3214 bfd_size_type old_size;
3216 old_size = current->size;
3217 current->size = BFD_ALIGN (current->size,
3218 1 << current->alignment_power);
3219 align_adjust = current->size != old_size;
3220 sofar += current->size - old_size;
3225 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3226 align_adjust = sofar != old_sofar;
3227 current->size += sofar - old_sofar;
3231 #ifdef COFF_IMAGE_WITH_PE
3232 /* For PE we need to make sure we pad out to the aligned
3233 size, in case the caller only writes out data to the
3235 if (pei_section_data (abfd, current)->virt_size < current->size)
3236 align_adjust = TRUE;
3240 /* Force .lib sections to start at zero. The vma is then
3241 incremented in coff_set_section_contents. This is right for
3243 if (strcmp (current->name, _LIB) == 0)
3244 bfd_set_section_vma (abfd, current, 0);
3250 /* It is now safe to write to the output file. If we needed an
3251 alignment adjustment for the last section, then make sure that
3252 there is a byte at offset sofar. If there are no symbols and no
3253 relocs, then nothing follows the last section. If we don't force
3254 the last byte out, then the file may appear to be truncated. */
3260 if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0
3261 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
3265 /* Make sure the relocations are aligned. We don't need to make
3266 sure that this byte exists, because it will only matter if there
3267 really are relocs. */
3268 sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER);
3270 obj_relocbase (abfd) = sofar;
3271 abfd->output_has_begun = TRUE;
3276 #ifdef COFF_IMAGE_WITH_PE
3278 static unsigned int pelength;
3279 static unsigned int peheader;
3282 coff_read_word (bfd *abfd, unsigned int *value)
3287 status = bfd_bread (b, (bfd_size_type) 2, abfd);
3295 *value = (unsigned int) b[0];
3297 *value = (unsigned int) (b[0] + (b[1] << 8));
3299 pelength += (unsigned int) status;
3305 coff_compute_checksum (bfd *abfd)
3307 bfd_boolean more_data;
3314 filepos = (file_ptr) 0;
3318 if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
3321 more_data = coff_read_word (abfd, &value);
3323 total = 0xffff & (total + (total >> 0x10));
3328 return (0xffff & (total + (total >> 0x10)));
3332 coff_apply_checksum (bfd *abfd)
3334 unsigned int computed;
3335 unsigned int checksum = 0;
3337 if (bfd_seek (abfd, 0x3c, SEEK_SET) != 0)
3340 if (!coff_read_word (abfd, &peheader))
3343 if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
3347 bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
3349 if (bfd_seek (abfd, peheader, SEEK_SET) != 0)
3352 computed = coff_compute_checksum (abfd);
3354 checksum = computed + pelength;
3356 if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
3359 bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
3364 #endif /* COFF_IMAGE_WITH_PE */
3367 coff_write_object_contents (bfd * abfd)
3370 bfd_boolean hasrelocs = FALSE;
3371 bfd_boolean haslinno = FALSE;
3372 bfd_boolean hasdebug = FALSE;
3374 file_ptr reloc_base;
3375 file_ptr lineno_base;
3377 unsigned long reloc_size = 0, reloc_count = 0;
3378 unsigned long lnno_size = 0;
3379 bfd_boolean long_section_names;
3380 asection *text_sec = NULL;
3381 asection *data_sec = NULL;
3382 asection *bss_sec = NULL;
3383 struct internal_filehdr internal_f;
3384 struct internal_aouthdr internal_a;
3385 #ifdef COFF_LONG_SECTION_NAMES
3386 size_t string_size = STRING_SIZE_SIZE;
3389 bfd_set_error (bfd_error_system_call);
3391 /* Make a pass through the symbol table to count line number entries and
3392 put them into the correct asections. */
3393 lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd);
3395 if (! abfd->output_has_begun)
3397 if (! coff_compute_section_file_positions (abfd))
3401 reloc_base = obj_relocbase (abfd);
3403 /* Work out the size of the reloc and linno areas. */
3405 for (current = abfd->sections; current != NULL; current =
3409 /* We store the actual reloc count in the first reloc's addr. */
3410 if (obj_pe (abfd) && current->reloc_count >= 0xffff)
3413 reloc_count += current->reloc_count;
3416 reloc_size = reloc_count * bfd_coff_relsz (abfd);
3418 lineno_base = reloc_base + reloc_size;
3419 sym_base = lineno_base + lnno_size;
3421 /* Indicate in each section->line_filepos its actual file address. */
3422 for (current = abfd->sections; current != NULL; current =
3425 if (current->lineno_count)
3427 current->line_filepos = lineno_base;
3428 current->moving_line_filepos = lineno_base;
3429 lineno_base += current->lineno_count * bfd_coff_linesz (abfd);
3432 current->line_filepos = 0;
3434 if (current->reloc_count)
3436 current->rel_filepos = reloc_base;
3437 reloc_base += current->reloc_count * bfd_coff_relsz (abfd);
3439 /* Extra reloc to hold real count. */
3440 if (obj_pe (abfd) && current->reloc_count >= 0xffff)
3441 reloc_base += bfd_coff_relsz (abfd);
3445 current->rel_filepos = 0;
3448 /* Write section headers to the file. */
3449 internal_f.f_nscns = 0;
3451 if ((abfd->flags & EXEC_P) != 0)
3452 scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
3455 scn_base = bfd_coff_filhsz (abfd);
3458 if (xcoff_data (abfd)->full_aouthdr)
3459 scn_base += bfd_coff_aoutsz (abfd);
3461 scn_base += SMALL_AOUTSZ;
3466 if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
3469 long_section_names = FALSE;
3470 for (current = abfd->sections;
3472 current = current->next)
3474 struct internal_scnhdr section;
3475 bfd_boolean is_reloc_section = FALSE;
3477 #ifdef COFF_IMAGE_WITH_PE
3478 if (strcmp (current->name, ".reloc") == 0)
3480 is_reloc_section = TRUE;
3482 pe_data (abfd)->has_reloc_section = 1;
3486 internal_f.f_nscns++;
3488 strncpy (section.s_name, current->name, SCNNMLEN);
3490 #ifdef COFF_LONG_SECTION_NAMES
3491 /* Handle long section names as in PE. This must be compatible
3492 with the code in coff_write_symbols and _bfd_coff_final_link. */
3496 len = strlen (current->name);
3499 memset (section.s_name, 0, SCNNMLEN);
3500 sprintf (section.s_name, "/%lu", (unsigned long) string_size);
3501 string_size += len + 1;
3502 long_section_names = TRUE;
3508 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3509 Ian Taylor <ian@cygnus.com>. */
3510 if (strcmp (current->name, _LIB) == 0)
3511 section.s_vaddr = 0;
3514 section.s_vaddr = current->vma;
3515 section.s_paddr = current->lma;
3516 section.s_size = current->size;
3517 #ifdef coff_get_section_load_page
3518 section.s_page = coff_get_section_load_page (current);
3522 section.s_paddr = 0;
3524 #ifdef COFF_IMAGE_WITH_PE
3525 /* Reminder: s_paddr holds the virtual size of the section. */
3526 if (coff_section_data (abfd, current) != NULL
3527 && pei_section_data (abfd, current) != NULL)
3528 section.s_paddr = pei_section_data (abfd, current)->virt_size;
3530 section.s_paddr = 0;
3533 /* If this section has no size or is unloadable then the scnptr
3535 if (current->size == 0
3536 || (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
3537 section.s_scnptr = 0;
3539 section.s_scnptr = current->filepos;
3541 section.s_relptr = current->rel_filepos;
3542 section.s_lnnoptr = current->line_filepos;
3543 section.s_nreloc = current->reloc_count;
3544 section.s_nlnno = current->lineno_count;
3545 #ifndef COFF_IMAGE_WITH_PE
3546 /* In PEI, relocs come in the .reloc section. */
3547 if (current->reloc_count != 0)
3550 if (current->lineno_count != 0)
3552 if ((current->flags & SEC_DEBUGGING) != 0
3553 && ! is_reloc_section)
3558 /* Indicate the use of an XCOFF overflow section header. */
3559 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3561 section.s_nreloc = 0xffff;
3562 section.s_nlnno = 0xffff;
3567 section.s_flags = sec_to_styp_flags (current->name, current->flags);
3569 if (!strcmp (current->name, _TEXT))
3571 else if (!strcmp (current->name, _DATA))
3573 else if (!strcmp (current->name, _BSS))
3577 section.s_align = (current->alignment_power
3578 ? 1 << current->alignment_power
3582 /* TI COFF puts the alignment power in bits 8-11 of the flags. */
3583 section.s_flags |= (current->alignment_power & 0xF) << 8;
3585 #ifdef COFF_ENCODE_ALIGNMENT
3586 COFF_ENCODE_ALIGNMENT(section, current->alignment_power);
3589 #ifdef COFF_IMAGE_WITH_PE
3590 /* Suppress output of the sections if they are null. ld
3591 includes the bss and data sections even if there is no size
3592 assigned to them. NT loader doesn't like it if these section
3593 headers are included if the sections themselves are not
3594 needed. See also coff_compute_section_file_positions. */
3595 if (section.s_size == 0)
3596 internal_f.f_nscns--;
3601 bfd_size_type amt = bfd_coff_scnhsz (abfd);
3603 if (coff_swap_scnhdr_out (abfd, §ion, &buff) == 0
3604 || bfd_bwrite (& buff, amt, abfd) != amt)
3609 /* PE stores COMDAT section information in the symbol table. If
3610 this section is supposed to have some COMDAT info, track down
3611 the symbol in the symbol table and modify it. */
3612 if ((current->flags & SEC_LINK_ONCE) != 0)
3614 unsigned int i, count;
3616 coff_symbol_type *csym = NULL;
3620 count = bfd_get_symcount (abfd);
3621 for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++)
3623 if ((*psym)->section != current)
3626 /* Remember the location of the first symbol in this
3628 if (psymsec == NULL)
3631 /* See if this is the section symbol. */
3632 if (strcmp ((*psym)->name, current->name) == 0)
3634 csym = coff_symbol_from (abfd, *psym);
3636 || csym->native == NULL
3637 || csym->native->u.syment.n_numaux < 1
3638 || csym->native->u.syment.n_sclass != C_STAT
3639 || csym->native->u.syment.n_type != T_NULL)
3642 /* Here *PSYM is the section symbol for CURRENT. */
3649 Note that we might not if we're converting the file from
3650 some other object file format. */
3653 combined_entry_type *aux;
3655 /* We don't touch the x_checksum field. The
3656 x_associated field is not currently supported. */
3658 aux = csym->native + 1;
3659 switch (current->flags & SEC_LINK_DUPLICATES)
3661 case SEC_LINK_DUPLICATES_DISCARD:
3662 aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY;
3665 case SEC_LINK_DUPLICATES_ONE_ONLY:
3666 aux->u.auxent.x_scn.x_comdat =
3667 IMAGE_COMDAT_SELECT_NODUPLICATES;
3670 case SEC_LINK_DUPLICATES_SAME_SIZE:
3671 aux->u.auxent.x_scn.x_comdat =
3672 IMAGE_COMDAT_SELECT_SAME_SIZE;
3675 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
3676 aux->u.auxent.x_scn.x_comdat =
3677 IMAGE_COMDAT_SELECT_EXACT_MATCH;
3681 /* The COMDAT symbol must be the first symbol from this
3682 section in the symbol table. In order to make this
3683 work, we move the COMDAT symbol before the first
3684 symbol we found in the search above. It's OK to
3685 rearrange the symbol table at this point, because
3686 coff_renumber_symbols is going to rearrange it
3687 further and fix up all the aux entries. */
3688 if (psym != psymsec)
3694 for (pcopy = psym; pcopy > psymsec; pcopy--)
3695 pcopy[0] = pcopy[-1];
3700 #endif /* COFF_WITH_PE */
3705 /* XCOFF handles overflows in the reloc and line number count fields
3706 by creating a new section header to hold the correct values. */
3707 for (current = abfd->sections; current != NULL; current = current->next)
3709 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3711 struct internal_scnhdr scnhdr;
3715 internal_f.f_nscns++;
3716 strncpy (&(scnhdr.s_name[0]), current->name, 8);
3717 scnhdr.s_paddr = current->reloc_count;
3718 scnhdr.s_vaddr = current->lineno_count;
3720 scnhdr.s_scnptr = 0;
3721 scnhdr.s_relptr = current->rel_filepos;
3722 scnhdr.s_lnnoptr = current->line_filepos;
3723 scnhdr.s_nreloc = current->target_index;
3724 scnhdr.s_nlnno = current->target_index;
3725 scnhdr.s_flags = STYP_OVRFLO;
3726 amt = bfd_coff_scnhsz (abfd);
3727 if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
3728 || bfd_bwrite (& buff, amt, abfd) != amt)
3735 /* OK, now set up the filehdr... */
3737 /* Don't include the internal abs section in the section count */
3739 /* We will NOT put a fucking timestamp in the header here. Every time you
3740 put it back, I will come in and take it out again. I'm sorry. This
3741 field does not belong here. We fill it with a 0 so it compares the
3742 same but is not a reasonable time. -- gnu@cygnus.com */
3743 internal_f.f_timdat = 0;
3744 internal_f.f_flags = 0;
3746 if (abfd->flags & EXEC_P)
3747 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3750 internal_f.f_opthdr = 0;
3753 if (xcoff_data (abfd)->full_aouthdr)
3754 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3756 internal_f.f_opthdr = SMALL_AOUTSZ;
3762 internal_f.f_flags |= F_RELFLG;
3764 internal_f.f_flags |= F_LNNO;
3765 if (abfd->flags & EXEC_P)
3766 internal_f.f_flags |= F_EXEC;
3767 #ifdef COFF_IMAGE_WITH_PE
3769 internal_f.f_flags |= IMAGE_FILE_DEBUG_STRIPPED;
3770 if (pe_data (abfd)->real_flags & IMAGE_FILE_LARGE_ADDRESS_AWARE)
3771 internal_f.f_flags |= IMAGE_FILE_LARGE_ADDRESS_AWARE;
3774 #ifndef COFF_WITH_pex64
3776 internal_f.f_flags |= IMAGE_FILE_32BIT_MACHINE;
3778 if (bfd_little_endian (abfd))
3779 internal_f.f_flags |= F_AR32WR;
3781 internal_f.f_flags |= F_AR32W;
3786 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
3787 but it doesn't hurt to set it internally. */
3788 internal_f.f_target_id = TI_TARGET_ID;
3790 #ifdef TIC80_TARGET_ID
3791 internal_f.f_target_id = TIC80_TARGET_ID;
3794 /* FIXME, should do something about the other byte orders and
3798 if ((abfd->flags & DYNAMIC) != 0)
3799 internal_f.f_flags |= F_SHROBJ;
3800 if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
3801 internal_f.f_flags |= F_DYNLOAD;
3804 memset (&internal_a, 0, sizeof internal_a);
3806 /* Set up architecture-dependent stuff. */
3808 unsigned int magic = 0;
3809 unsigned short flags = 0;
3811 coff_set_flags (abfd, &magic, &flags);
3812 internal_f.f_magic = magic;
3813 internal_f.f_flags |= flags;
3814 /* ...and the "opt"hdr... */
3816 #ifdef TICOFF_AOUT_MAGIC
3817 internal_a.magic = TICOFF_AOUT_MAGIC;
3818 #define __A_MAGIC_SET__
3821 internal_a.magic = TIC80_ARCH_MAGIC;
3822 #define __A_MAGIC_SET__
3825 /* FIXME: What are the a.out magic numbers for the i860? */
3826 internal_a.magic = 0;
3827 #define __A_MAGIC_SET__
3830 internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
3831 #define __A_MAGIC_SET__
3834 #define __A_MAGIC_SET__
3835 internal_a.magic = PAGEMAGICBCS;
3839 #define __A_MAGIC_SET__
3840 internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
3843 #if defined(M68) || defined(WE32K) || defined(M68K)
3844 #define __A_MAGIC_SET__
3846 internal_a.magic = LYNXCOFFMAGIC;
3848 #if defined(TARG_AUX)
3849 internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED :
3850 abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED :
3851 PAGEMAGICEXECSWAPPED);
3853 #if defined (PAGEMAGICPEXECPAGED)
3854 internal_a.magic = PAGEMAGICPEXECPAGED;
3856 #endif /* TARG_AUX */
3858 #endif /* M68 || WE32K || M68K */
3861 #define __A_MAGIC_SET__
3862 internal_a.magic = ZMAGIC;
3866 #define __A_MAGIC_SET__
3867 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3870 #if defined MCORE_PE
3871 #define __A_MAGIC_SET__
3872 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3876 #define __A_MAGIC_SET__
3878 internal_a.magic = LYNXCOFFMAGIC;
3880 internal_a.magic = IMAGE_NT_OPTIONAL_HDR64_MAGIC;
3882 internal_a.magic = ZMAGIC;
3887 #define __A_MAGIC_SET__
3888 internal_a.magic = PE32PMAGIC;
3892 #define __A_MAGIC_SET__
3894 internal_a.magic = LYNXCOFFMAGIC;
3899 #define __A_MAGIC_SET__
3900 internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
3901 (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
3902 RS6K_AOUTHDR_OMAGIC;
3905 #if defined(SH) && defined(COFF_WITH_PE)
3906 #define __A_MAGIC_SET__
3907 internal_a.magic = SH_PE_MAGIC;
3910 #if defined(MIPS) && defined(COFF_WITH_PE)
3911 #define __A_MAGIC_SET__
3912 internal_a.magic = MIPS_PE_MAGIC;
3916 #define __A_MAGIC_SET__
3917 internal_a.magic = NMAGIC; /* Assume separate i/d. */
3921 #define __A_MAGIC_SET__
3922 internal_a.magic = MAXQ20MAGIC;
3925 #ifndef __A_MAGIC_SET__
3926 #include "Your aouthdr magic number is not being set!"
3928 #undef __A_MAGIC_SET__
3932 /* FIXME: Does anybody ever set this to another value? */
3933 internal_a.vstamp = 0;
3935 /* Now should write relocs, strings, syms. */
3936 obj_sym_filepos (abfd) = sym_base;
3938 if (bfd_get_symcount (abfd) != 0)
3942 if (!coff_renumber_symbols (abfd, &firstundef))
3944 coff_mangle_symbols (abfd);
3945 if (! coff_write_symbols (abfd))
3947 if (! coff_write_linenumbers (abfd))
3949 if (! coff_write_relocs (abfd, firstundef))
3952 #ifdef COFF_LONG_SECTION_NAMES
3953 else if (long_section_names && ! obj_coff_strings_written (abfd))
3955 /* If we have long section names we have to write out the string
3956 table even if there are no symbols. */
3957 if (! coff_write_symbols (abfd))
3961 #ifdef COFF_IMAGE_WITH_PE
3963 else if ((abfd->flags & EXEC_P) != 0)
3967 /* PowerPC PE appears to require that all executable files be
3968 rounded up to the page size. */
3971 (file_ptr) BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1,
3973 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
3979 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3980 backend linker, and obj_raw_syment_count is not valid until after
3981 coff_write_symbols is called. */
3982 if (obj_raw_syment_count (abfd) != 0)
3984 internal_f.f_symptr = sym_base;
3986 /* AIX appears to require that F_RELFLG not be set if there are
3987 local symbols but no relocations. */
3988 internal_f.f_flags &=~ F_RELFLG;
3993 if (long_section_names)
3994 internal_f.f_symptr = sym_base;
3996 internal_f.f_symptr = 0;
3997 internal_f.f_flags |= F_LSYMS;
4002 internal_a.tsize = text_sec->size;
4003 internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
4007 internal_a.dsize = data_sec->size;
4008 internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
4012 internal_a.bsize = bss_sec->size;
4013 if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
4014 internal_a.data_start = bss_sec->vma;
4017 internal_a.entry = bfd_get_start_address (abfd);
4018 internal_f.f_nsyms = obj_raw_syment_count (abfd);
4021 if (xcoff_data (abfd)->full_aouthdr)
4024 asection *loader_sec;
4026 internal_a.vstamp = 1;
4028 internal_a.o_snentry = xcoff_data (abfd)->snentry;
4029 if (internal_a.o_snentry == 0)
4030 internal_a.entry = (bfd_vma) -1;
4032 if (text_sec != NULL)
4034 internal_a.o_sntext = text_sec->target_index;
4035 internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
4039 internal_a.o_sntext = 0;
4040 internal_a.o_algntext = 0;
4042 if (data_sec != NULL)
4044 internal_a.o_sndata = data_sec->target_index;
4045 internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
4049 internal_a.o_sndata = 0;
4050 internal_a.o_algndata = 0;
4052 loader_sec = bfd_get_section_by_name (abfd, ".loader");
4053 if (loader_sec != NULL)
4054 internal_a.o_snloader = loader_sec->target_index;
4056 internal_a.o_snloader = 0;
4057 if (bss_sec != NULL)
4058 internal_a.o_snbss = bss_sec->target_index;
4060 internal_a.o_snbss = 0;
4062 toc = xcoff_data (abfd)->toc;
4063 internal_a.o_toc = toc;
4064 internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
4066 internal_a.o_modtype = xcoff_data (abfd)->modtype;
4067 if (xcoff_data (abfd)->cputype != -1)
4068 internal_a.o_cputype = xcoff_data (abfd)->cputype;
4071 switch (bfd_get_arch (abfd))
4073 case bfd_arch_rs6000:
4074 internal_a.o_cputype = 4;
4076 case bfd_arch_powerpc:
4077 if (bfd_get_mach (abfd) == bfd_mach_ppc)
4078 internal_a.o_cputype = 3;
4080 internal_a.o_cputype = 1;
4086 internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
4087 internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
4091 /* Now write them. */
4092 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
4097 bfd_size_type amount = bfd_coff_filhsz (abfd);
4099 buff = bfd_malloc (amount);
4103 bfd_coff_swap_filehdr_out (abfd, & internal_f, buff);
4104 amount = bfd_bwrite (buff, amount, abfd);
4108 if (amount != bfd_coff_filhsz (abfd))
4112 if (abfd->flags & EXEC_P)
4114 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4115 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4117 bfd_size_type amount = bfd_coff_aoutsz (abfd);
4119 buff = bfd_malloc (amount);
4123 coff_swap_aouthdr_out (abfd, & internal_a, buff);
4124 amount = bfd_bwrite (buff, amount, abfd);
4128 if (amount != bfd_coff_aoutsz (abfd))
4131 #ifdef COFF_IMAGE_WITH_PE
4132 if (! coff_apply_checksum (abfd))
4142 /* XCOFF seems to always write at least a small a.out header. */
4143 coff_swap_aouthdr_out (abfd, & internal_a, & buff);
4144 if (xcoff_data (abfd)->full_aouthdr)
4145 size = bfd_coff_aoutsz (abfd);
4147 size = SMALL_AOUTSZ;
4148 if (bfd_bwrite (& buff, (bfd_size_type) size, abfd) != size)
4157 coff_set_section_contents (bfd * abfd,
4159 const void * location,
4161 bfd_size_type count)
4163 if (! abfd->output_has_begun) /* Set by bfd.c handler. */
4165 if (! coff_compute_section_file_positions (abfd))
4169 #if defined(_LIB) && !defined(TARG_AUX)
4170 /* The physical address field of a .lib section is used to hold the
4171 number of shared libraries in the section. This code counts the
4172 number of sections being written, and increments the lma field
4175 I have found no documentation on the contents of this section.
4176 Experimentation indicates that the section contains zero or more
4177 records, each of which has the following structure:
4179 - a (four byte) word holding the length of this record, in words,
4180 - a word that always seems to be set to "2",
4181 - the path to a shared library, null-terminated and then padded
4182 to a whole word boundary.
4184 bfd_assert calls have been added to alert if an attempt is made
4185 to write a section which doesn't follow these assumptions. The
4186 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4187 <robertl@arnet.com> (Thanks!).
4189 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4190 if (strcmp (section->name, _LIB) == 0)
4192 bfd_byte *rec, *recend;
4194 rec = (bfd_byte *) location;
4195 recend = rec + count;
4196 while (rec < recend)
4199 rec += bfd_get_32 (abfd, rec) * 4;
4202 BFD_ASSERT (rec == recend);
4206 /* Don't write out bss sections - one way to do this is to
4207 see if the filepos has not been set. */
4208 if (section->filepos == 0)
4211 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
4217 return bfd_bwrite (location, count, abfd) == count;
4221 buy_and_read (bfd *abfd, file_ptr where, bfd_size_type size)
4223 void * area = bfd_alloc (abfd, size);
4227 if (bfd_seek (abfd, where, SEEK_SET) != 0
4228 || bfd_bread (area, size, abfd) != size)
4237 Creating the linenumber table is done by reading in the entire
4238 coff linenumber table, and creating another table for internal use.
4240 A coff linenumber table is structured so that each function
4241 is marked as having a line number of 0. Each line within the
4242 function is an offset from the first line in the function. The
4243 base of the line number information for the table is stored in
4244 the symbol associated with the function.
4246 Note: The PE format uses line number 0 for a flag indicating a
4249 The information is copied from the external to the internal
4250 table, and each symbol which marks a function is marked by
4253 How does this work ?
4257 coff_sort_func_alent (const void * arg1, const void * arg2)
4259 const alent *al1 = *(const alent **) arg1;
4260 const alent *al2 = *(const alent **) arg2;
4261 const coff_symbol_type *s1 = (const coff_symbol_type *) (al1->u.sym);
4262 const coff_symbol_type *s2 = (const coff_symbol_type *) (al2->u.sym);
4264 if (s1->symbol.value < s2->symbol.value)
4266 else if (s1->symbol.value > s2->symbol.value)
4273 coff_slurp_line_table (bfd *abfd, asection *asect)
4275 LINENO *native_lineno;
4276 alent *lineno_cache;
4278 unsigned int counter;
4280 bfd_vma prev_offset = 0;
4282 unsigned int nbr_func;
4285 BFD_ASSERT (asect->lineno == NULL);
4287 amt = (bfd_size_type) bfd_coff_linesz (abfd) * asect->lineno_count;
4288 native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos, amt);
4289 if (native_lineno == NULL)
4291 (*_bfd_error_handler)
4292 (_("%B: warning: line number table read failed"), abfd);
4296 amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
4297 lineno_cache = bfd_alloc (abfd, amt);
4298 if (lineno_cache == NULL)
4301 cache_ptr = lineno_cache;
4302 src = native_lineno;
4305 for (counter = 0; counter < asect->lineno_count; counter++)
4307 struct internal_lineno dst;
4309 bfd_coff_swap_lineno_in (abfd, src, &dst);
4310 cache_ptr->line_number = dst.l_lnno;
4312 if (cache_ptr->line_number == 0)
4315 bfd_signed_vma symndx;
4316 coff_symbol_type *sym;
4320 symndx = dst.l_addr.l_symndx;
4322 || (bfd_vma) symndx >= obj_raw_syment_count (abfd))
4324 (*_bfd_error_handler)
4325 (_("%B: warning: illegal symbol index %ld in line numbers"),
4326 abfd, dst.l_addr.l_symndx);
4331 /* FIXME: We should not be casting between ints and
4332 pointers like this. */
4333 sym = ((coff_symbol_type *)
4334 ((symndx + obj_raw_syments (abfd))
4335 ->u.syment._n._n_n._n_zeroes));
4336 cache_ptr->u.sym = (asymbol *) sym;
4337 if (sym->lineno != NULL && ! warned)
4338 (*_bfd_error_handler)
4339 (_("%B: warning: duplicate line number information for `%s'"),
4340 abfd, bfd_asymbol_name (&sym->symbol));
4342 sym->lineno = cache_ptr;
4343 if (sym->symbol.value < prev_offset)
4345 prev_offset = sym->symbol.value;
4348 cache_ptr->u.offset = dst.l_addr.l_paddr
4349 - bfd_section_vma (abfd, asect);
4354 cache_ptr->line_number = 0;
4356 /* On some systems (eg AIX5.3) the lineno table may not be sorted. */
4359 /* Sort the table. */
4361 alent *n_lineno_cache;
4363 /* Create a table of functions. */
4364 func_table = bfd_malloc (nbr_func * sizeof (alent *));
4365 if (func_table != NULL)
4367 alent **p = func_table;
4370 for (i = 0; i < counter; i++)
4371 if (lineno_cache[i].line_number == 0)
4372 *p++ = &lineno_cache[i];
4374 /* Sort by functions. */
4375 qsort (func_table, nbr_func, sizeof (alent *), coff_sort_func_alent);
4377 /* Create the new sorted table. */
4378 n_lineno_cache = bfd_alloc (abfd, amt);
4379 if (n_lineno_cache != NULL)
4381 alent *n_cache_ptr = n_lineno_cache;
4383 for (i = 0; i < nbr_func; i++)
4385 coff_symbol_type *sym;
4386 alent *old_ptr = func_table[i];
4388 /* Copy the function entry and update it. */
4389 *n_cache_ptr = *old_ptr;
4390 sym = (coff_symbol_type *)n_cache_ptr->u.sym;
4391 sym->lineno = n_cache_ptr;
4395 /* Copy the line number entries. */
4396 while (old_ptr->line_number != 0)
4397 *n_cache_ptr++ = *old_ptr++;
4399 n_cache_ptr->line_number = 0;
4400 bfd_release (abfd, lineno_cache);
4401 lineno_cache = n_lineno_cache;
4407 asect->lineno = lineno_cache;
4408 bfd_release (abfd, native_lineno);
4412 /* Slurp in the symbol table, converting it to generic form. Note
4413 that if coff_relocate_section is defined, the linker will read
4414 symbols via coff_link_add_symbols, rather than via this routine. */
4417 coff_slurp_symbol_table (bfd * abfd)
4419 combined_entry_type *native_symbols;
4420 coff_symbol_type *cached_area;
4421 unsigned int *table_ptr;
4423 unsigned int number_of_symbols = 0;
4425 if (obj_symbols (abfd))
4428 /* Read in the symbol table. */
4429 if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
4432 /* Allocate enough room for all the symbols in cached form. */
4433 amt = obj_raw_syment_count (abfd);
4434 amt *= sizeof (coff_symbol_type);
4435 cached_area = bfd_alloc (abfd, amt);
4436 if (cached_area == NULL)
4439 amt = obj_raw_syment_count (abfd);
4440 amt *= sizeof (unsigned int);
4441 table_ptr = bfd_alloc (abfd, amt);
4443 if (table_ptr == NULL)
4447 coff_symbol_type *dst = cached_area;
4448 unsigned int last_native_index = obj_raw_syment_count (abfd);
4449 unsigned int this_index = 0;
4451 while (this_index < last_native_index)
4453 combined_entry_type *src = native_symbols + this_index;
4454 table_ptr[this_index] = number_of_symbols;
4455 dst->symbol.the_bfd = abfd;
4457 dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
4458 /* We use the native name field to point to the cached field. */
4459 src->u.syment._n._n_n._n_zeroes = (bfd_hostptr_t) dst;
4460 dst->symbol.section = coff_section_from_bfd_index (abfd,
4461 src->u.syment.n_scnum);
4462 dst->symbol.flags = 0;
4463 dst->done_lineno = FALSE;
4465 switch (src->u.syment.n_sclass)
4469 /* Fall through to next case. */
4476 case C_THUMBEXTFUNC:
4482 case C_SYSTEM: /* System Wide variable. */
4485 /* In PE, 0x68 (104) denotes a section symbol. */
4487 /* In PE, 0x69 (105) denotes a weak external symbol. */
4490 switch (coff_classify_symbol (abfd, &src->u.syment))
4492 case COFF_SYMBOL_GLOBAL:
4493 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
4494 #if defined COFF_WITH_PE
4495 /* PE sets the symbol to a value relative to the
4496 start of the section. */
4497 dst->symbol.value = src->u.syment.n_value;
4499 dst->symbol.value = (src->u.syment.n_value
4500 - dst->symbol.section->vma);
4502 if (ISFCN ((src->u.syment.n_type)))
4503 /* A function ext does not go at the end of a
4505 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4508 case COFF_SYMBOL_COMMON:
4509 dst->symbol.section = bfd_com_section_ptr;
4510 dst->symbol.value = src->u.syment.n_value;
4513 case COFF_SYMBOL_UNDEFINED:
4514 dst->symbol.section = bfd_und_section_ptr;
4515 dst->symbol.value = 0;
4518 case COFF_SYMBOL_PE_SECTION:
4519 dst->symbol.flags |= BSF_EXPORT | BSF_SECTION_SYM;
4520 dst->symbol.value = 0;
4523 case COFF_SYMBOL_LOCAL:
4524 dst->symbol.flags = BSF_LOCAL;
4525 #if defined COFF_WITH_PE
4526 /* PE sets the symbol to a value relative to the
4527 start of the section. */
4528 dst->symbol.value = src->u.syment.n_value;
4530 dst->symbol.value = (src->u.syment.n_value
4531 - dst->symbol.section->vma);
4533 if (ISFCN ((src->u.syment.n_type)))
4534 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4539 /* A symbol with a csect entry should not go at the end. */
4540 if (src->u.syment.n_numaux > 0)
4541 dst->symbol.flags |= BSF_NOT_AT_END;
4545 if (src->u.syment.n_sclass == C_NT_WEAK)
4546 dst->symbol.flags |= BSF_WEAK;
4548 if (src->u.syment.n_sclass == C_SECTION
4549 && src->u.syment.n_scnum > 0)
4550 dst->symbol.flags = BSF_LOCAL;
4552 if (src->u.syment.n_sclass == C_WEAKEXT)
4553 dst->symbol.flags |= BSF_WEAK;
4557 case C_STAT: /* Static. */
4559 case C_LEAFSTAT: /* Static leaf procedure. */
4562 case C_THUMBSTAT: /* Thumb static. */
4563 case C_THUMBLABEL: /* Thumb label. */
4564 case C_THUMBSTATFUNC:/* Thumb static function. */
4566 case C_LABEL: /* Label. */
4567 if (src->u.syment.n_scnum == N_DEBUG)
4568 dst->symbol.flags = BSF_DEBUGGING;
4570 dst->symbol.flags = BSF_LOCAL;
4572 /* Base the value as an index from the base of the
4573 section, if there is one. */
4574 if (dst->symbol.section)
4576 #if defined COFF_WITH_PE
4577 /* PE sets the symbol to a value relative to the
4578 start of the section. */
4579 dst->symbol.value = src->u.syment.n_value;
4581 dst->symbol.value = (src->u.syment.n_value
4582 - dst->symbol.section->vma);
4586 dst->symbol.value = src->u.syment.n_value;
4589 case C_MOS: /* Member of structure. */
4590 case C_EOS: /* End of structure. */
4591 case C_REGPARM: /* Register parameter. */
4592 case C_REG: /* register variable. */
4593 /* C_AUTOARG conflicts with TI COFF C_UEXT. */
4594 #if !defined (TIC80COFF) && !defined (TICOFF)
4596 case C_AUTOARG: /* 960-specific storage class. */
4599 case C_TPDEF: /* Type definition. */
4601 case C_AUTO: /* Automatic variable. */
4602 case C_FIELD: /* Bit field. */
4603 case C_ENTAG: /* Enumeration tag. */
4604 case C_MOE: /* Member of enumeration. */
4605 case C_MOU: /* Member of union. */
4606 case C_UNTAG: /* Union tag. */
4607 dst->symbol.flags = BSF_DEBUGGING;
4608 dst->symbol.value = (src->u.syment.n_value);
4611 case C_FILE: /* File name. */
4612 case C_STRTAG: /* Structure tag. */
4629 dst->symbol.flags = BSF_DEBUGGING;
4630 dst->symbol.value = (src->u.syment.n_value);
4634 case C_BINCL: /* Beginning of include file. */
4635 case C_EINCL: /* Ending of include file. */
4636 /* The value is actually a pointer into the line numbers
4637 of the file. We locate the line number entry, and
4638 set the section to the section which contains it, and
4639 the value to the index in that section. */
4643 dst->symbol.flags = BSF_DEBUGGING;
4644 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4645 if (sec->line_filepos <= (file_ptr) src->u.syment.n_value
4646 && ((file_ptr) (sec->line_filepos
4647 + sec->lineno_count * bfd_coff_linesz (abfd))
4648 > (file_ptr) src->u.syment.n_value))
4651 dst->symbol.value = 0;
4654 dst->symbol.section = sec;
4655 dst->symbol.value = ((src->u.syment.n_value
4656 - sec->line_filepos)
4657 / bfd_coff_linesz (abfd));
4664 dst->symbol.flags = BSF_DEBUGGING;
4666 /* The value is actually a symbol index. Save a pointer
4667 to the symbol instead of the index. FIXME: This
4668 should use a union. */
4669 src->u.syment.n_value =
4670 (long) (native_symbols + src->u.syment.n_value);
4671 dst->symbol.value = src->u.syment.n_value;
4676 case C_BLOCK: /* ".bb" or ".eb". */
4677 case C_FCN: /* ".bf" or ".ef" (or PE ".lf"). */
4678 case C_EFCN: /* Physical end of function. */
4679 #if defined COFF_WITH_PE
4680 /* PE sets the symbol to a value relative to the start
4682 dst->symbol.value = src->u.syment.n_value;
4683 if (strcmp (dst->symbol.name, ".bf") != 0)
4685 /* PE uses funny values for .ef and .lf; don't
4687 dst->symbol.flags = BSF_DEBUGGING;
4690 dst->symbol.flags = BSF_DEBUGGING | BSF_DEBUGGING_RELOC;
4692 /* Base the value as an index from the base of the
4694 dst->symbol.flags = BSF_LOCAL;
4695 dst->symbol.value = (src->u.syment.n_value
4696 - dst->symbol.section->vma);
4700 case C_STATLAB: /* Static load time label. */
4701 dst->symbol.value = src->u.syment.n_value;
4702 dst->symbol.flags = BSF_GLOBAL;
4706 /* PE DLLs sometimes have zeroed out symbols for some
4707 reason. Just ignore them without a warning. */
4708 if (src->u.syment.n_type == 0
4709 && src->u.syment.n_value == 0
4710 && src->u.syment.n_scnum == 0)
4713 case C_EXTDEF: /* External definition. */
4714 case C_ULABEL: /* Undefined label. */
4715 case C_USTATIC: /* Undefined static. */
4716 #ifndef COFF_WITH_PE
4717 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4718 class to represent a section symbol. */
4719 case C_LINE: /* line # reformatted as symbol table entry. */
4720 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4721 case C_ALIAS: /* Duplicate tag. */
4723 /* New storage classes for TI COFF. */
4724 #if defined(TIC80COFF) || defined(TICOFF)
4725 case C_UEXT: /* Tentative external definition. */
4727 case C_EXTLAB: /* External load time label. */
4728 case C_HIDDEN: /* Ext symbol in dmert public lib. */
4730 (*_bfd_error_handler)
4731 (_("%B: Unrecognized storage class %d for %s symbol `%s'"),
4732 abfd, src->u.syment.n_sclass,
4733 dst->symbol.section->name, dst->symbol.name);
4734 dst->symbol.flags = BSF_DEBUGGING;
4735 dst->symbol.value = (src->u.syment.n_value);
4741 dst->symbol.udata.i = 0;
4743 this_index += (src->u.syment.n_numaux) + 1;
4745 number_of_symbols++;
4749 obj_symbols (abfd) = cached_area;
4750 obj_raw_syments (abfd) = native_symbols;
4752 bfd_get_symcount (abfd) = number_of_symbols;
4753 obj_convert (abfd) = table_ptr;
4754 /* Slurp the line tables for each section too. */
4761 coff_slurp_line_table (abfd, p);
4769 /* Classify a COFF symbol. A couple of targets have globally visible
4770 symbols which are not class C_EXT, and this handles those. It also
4771 recognizes some special PE cases. */
4773 static enum coff_symbol_classification
4774 coff_classify_symbol (bfd *abfd,
4775 struct internal_syment *syment)
4777 /* FIXME: This partially duplicates the switch in
4778 coff_slurp_symbol_table. */
4779 switch (syment->n_sclass)
4788 case C_THUMBEXTFUNC:
4796 if (syment->n_scnum == 0)
4798 if (syment->n_value == 0)
4799 return COFF_SYMBOL_UNDEFINED;
4801 return COFF_SYMBOL_COMMON;
4803 return COFF_SYMBOL_GLOBAL;
4810 if (syment->n_sclass == C_STAT)
4812 if (syment->n_scnum == 0)
4813 /* The Microsoft compiler sometimes generates these if a
4814 small static function is inlined every time it is used.
4815 The function is discarded, but the symbol table entry
4817 return COFF_SYMBOL_LOCAL;
4819 #ifdef STRICT_PE_FORMAT
4820 /* This is correct for Microsoft generated objects, but it
4821 breaks gas generated objects. */
4822 if (syment->n_value == 0)
4825 char buf[SYMNMLEN + 1];
4827 sec = coff_section_from_bfd_index (abfd, syment->n_scnum);
4829 && (strcmp (bfd_get_section_name (abfd, sec),
4830 _bfd_coff_internal_syment_name (abfd, syment, buf))
4832 return COFF_SYMBOL_PE_SECTION;
4836 return COFF_SYMBOL_LOCAL;
4839 if (syment->n_sclass == C_SECTION)
4841 /* In some cases in a DLL generated by the Microsoft linker, the
4842 n_value field will contain garbage. FIXME: This should
4843 probably be handled by the swapping function instead. */
4844 syment->n_value = 0;
4845 if (syment->n_scnum == 0)
4846 return COFF_SYMBOL_UNDEFINED;
4847 return COFF_SYMBOL_PE_SECTION;
4849 #endif /* COFF_WITH_PE */
4851 /* If it is not a global symbol, we presume it is a local symbol. */
4852 if (syment->n_scnum == 0)
4854 char buf[SYMNMLEN + 1];
4856 (*_bfd_error_handler)
4857 (_("warning: %B: local symbol `%s' has no section"),
4858 abfd, _bfd_coff_internal_syment_name (abfd, syment, buf));
4861 return COFF_SYMBOL_LOCAL;
4868 Coff relocations are easily transformed into the internal BFD form
4871 Reading a coff relocation table is done in the following stages:
4873 o Read the entire coff relocation table into memory.
4875 o Process each relocation in turn; first swap it from the
4876 external to the internal form.
4878 o Turn the symbol referenced in the relocation's symbol index
4879 into a pointer into the canonical symbol table.
4880 This table is the same as the one returned by a call to
4881 @code{bfd_canonicalize_symtab}. The back end will call that
4882 routine and save the result if a canonicalization hasn't been done.
4884 o The reloc index is turned into a pointer to a howto
4885 structure, in a back end specific way. For instance, the 386
4886 and 960 use the @code{r_type} to directly produce an index
4887 into a howto table vector; the 88k subtracts a number from the
4888 @code{r_type} field and creates an addend field.
4892 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
4894 coff_symbol_type *coffsym = NULL; \
4896 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
4897 coffsym = (obj_symbols (abfd) \
4898 + (cache_ptr->sym_ptr_ptr - symbols)); \
4900 coffsym = coff_symbol_from (abfd, ptr); \
4901 if (coffsym != NULL \
4902 && coffsym->native->u.syment.n_scnum == 0) \
4903 cache_ptr->addend = 0; \
4904 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
4905 && ptr->section != NULL) \
4906 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
4908 cache_ptr->addend = 0; \
4913 coff_slurp_reloc_table (bfd * abfd, sec_ptr asect, asymbol ** symbols)
4915 RELOC *native_relocs;
4916 arelent *reloc_cache;
4921 if (asect->relocation)
4923 if (asect->reloc_count == 0)
4925 if (asect->flags & SEC_CONSTRUCTOR)
4927 if (!coff_slurp_symbol_table (abfd))
4930 amt = (bfd_size_type) bfd_coff_relsz (abfd) * asect->reloc_count;
4931 native_relocs = (RELOC *) buy_and_read (abfd, asect->rel_filepos, amt);
4932 amt = (bfd_size_type) asect->reloc_count * sizeof (arelent);
4933 reloc_cache = bfd_alloc (abfd, amt);
4935 if (reloc_cache == NULL || native_relocs == NULL)
4938 for (idx = 0; idx < asect->reloc_count; idx++)
4940 struct internal_reloc dst;
4941 struct external_reloc *src;
4942 #ifndef RELOC_PROCESSING
4946 cache_ptr = reloc_cache + idx;
4947 src = native_relocs + idx;
4950 coff_swap_reloc_in (abfd, src, &dst);
4952 #ifdef RELOC_PROCESSING
4953 RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
4955 cache_ptr->address = dst.r_vaddr;
4957 if (dst.r_symndx != -1)
4959 if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd))
4961 (*_bfd_error_handler)
4962 (_("%B: warning: illegal symbol index %ld in relocs"),
4963 abfd, dst.r_symndx);
4964 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4969 cache_ptr->sym_ptr_ptr = (symbols
4970 + obj_convert (abfd)[dst.r_symndx]);
4971 ptr = *(cache_ptr->sym_ptr_ptr);
4976 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4980 /* The symbols definitions that we have read in have been
4981 relocated as if their sections started at 0. But the offsets
4982 refering to the symbols in the raw data have not been
4983 modified, so we have to have a negative addend to compensate.
4985 Note that symbols which used to be common must be left alone. */
4987 /* Calculate any reloc addend by looking at the symbol. */
4988 CALC_ADDEND (abfd, ptr, dst, cache_ptr);
4990 cache_ptr->address -= asect->vma;
4991 /* !! cache_ptr->section = NULL;*/
4993 /* Fill in the cache_ptr->howto field from dst.r_type. */
4994 RTYPE2HOWTO (cache_ptr, &dst);
4995 #endif /* RELOC_PROCESSING */
4997 if (cache_ptr->howto == NULL)
4999 (*_bfd_error_handler)
5000 (_("%B: illegal relocation type %d at address 0x%lx"),
5001 abfd, dst.r_type, (long) dst.r_vaddr);
5002 bfd_set_error (bfd_error_bad_value);
5007 asect->relocation = reloc_cache;
5011 #ifndef coff_rtype_to_howto
5014 /* Get the howto structure for a reloc. This is only used if the file
5015 including this one defines coff_relocate_section to be
5016 _bfd_coff_generic_relocate_section, so it is OK if it does not
5017 always work. It is the responsibility of the including file to
5018 make sure it is reasonable if it is needed. */
5020 static reloc_howto_type *
5021 coff_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
5022 asection *sec ATTRIBUTE_UNUSED,
5023 struct internal_reloc *rel,
5024 struct coff_link_hash_entry *h ATTRIBUTE_UNUSED,
5025 struct internal_syment *sym ATTRIBUTE_UNUSED,
5026 bfd_vma *addendp ATTRIBUTE_UNUSED)
5030 genrel.howto = NULL;
5031 RTYPE2HOWTO (&genrel, rel);
5032 return genrel.howto;
5035 #else /* ! defined (RTYPE2HOWTO) */
5037 #define coff_rtype_to_howto NULL
5039 #endif /* ! defined (RTYPE2HOWTO) */
5040 #endif /* ! defined (coff_rtype_to_howto) */
5042 /* This is stupid. This function should be a boolean predicate. */
5045 coff_canonicalize_reloc (bfd * abfd,
5050 arelent *tblptr = section->relocation;
5051 unsigned int count = 0;
5053 if (section->flags & SEC_CONSTRUCTOR)
5055 /* This section has relocs made up by us, they are not in the
5056 file, so take them out of their chain and place them into
5057 the data area provided. */
5058 arelent_chain *chain = section->constructor_chain;
5060 for (count = 0; count < section->reloc_count; count++)
5062 *relptr++ = &chain->relent;
5063 chain = chain->next;
5068 if (! coff_slurp_reloc_table (abfd, section, symbols))
5071 tblptr = section->relocation;
5073 for (; count++ < section->reloc_count;)
5074 *relptr++ = tblptr++;
5077 return section->reloc_count;
5080 #ifndef coff_reloc16_estimate
5081 #define coff_reloc16_estimate dummy_reloc16_estimate
5084 dummy_reloc16_estimate (bfd *abfd ATTRIBUTE_UNUSED,
5085 asection *input_section ATTRIBUTE_UNUSED,
5086 arelent *reloc ATTRIBUTE_UNUSED,
5087 unsigned int shrink ATTRIBUTE_UNUSED,
5088 struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
5096 #ifndef coff_reloc16_extra_cases
5098 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5100 /* This works even if abort is not declared in any header file. */
5103 dummy_reloc16_extra_cases (bfd *abfd ATTRIBUTE_UNUSED,
5104 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
5105 struct bfd_link_order *link_order ATTRIBUTE_UNUSED,
5106 arelent *reloc ATTRIBUTE_UNUSED,
5107 bfd_byte *data ATTRIBUTE_UNUSED,
5108 unsigned int *src_ptr ATTRIBUTE_UNUSED,
5109 unsigned int *dst_ptr ATTRIBUTE_UNUSED)
5115 #ifndef coff_bfd_link_hash_table_free
5116 #define coff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
5119 /* If coff_relocate_section is defined, we can use the optimized COFF
5120 backend linker. Otherwise we must continue to use the old linker. */
5122 #ifdef coff_relocate_section
5124 #ifndef coff_bfd_link_hash_table_create
5125 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5127 #ifndef coff_bfd_link_add_symbols
5128 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5130 #ifndef coff_bfd_final_link
5131 #define coff_bfd_final_link _bfd_coff_final_link
5134 #else /* ! defined (coff_relocate_section) */
5136 #define coff_relocate_section NULL
5137 #ifndef coff_bfd_link_hash_table_create
5138 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5140 #ifndef coff_bfd_link_add_symbols
5141 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5143 #define coff_bfd_final_link _bfd_generic_final_link
5145 #endif /* ! defined (coff_relocate_section) */
5147 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5148 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5150 #ifndef coff_start_final_link
5151 #define coff_start_final_link NULL
5154 #ifndef coff_adjust_symndx
5155 #define coff_adjust_symndx NULL
5158 #ifndef coff_link_add_one_symbol
5159 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5162 #ifndef coff_link_output_has_begun
5165 coff_link_output_has_begun (bfd * abfd,
5166 struct coff_final_link_info * info ATTRIBUTE_UNUSED)
5168 return abfd->output_has_begun;
5172 #ifndef coff_final_link_postscript
5175 coff_final_link_postscript (bfd * abfd ATTRIBUTE_UNUSED,
5176 struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED)
5182 #ifndef coff_SWAP_aux_in
5183 #define coff_SWAP_aux_in coff_swap_aux_in
5185 #ifndef coff_SWAP_sym_in
5186 #define coff_SWAP_sym_in coff_swap_sym_in
5188 #ifndef coff_SWAP_lineno_in
5189 #define coff_SWAP_lineno_in coff_swap_lineno_in
5191 #ifndef coff_SWAP_aux_out
5192 #define coff_SWAP_aux_out coff_swap_aux_out
5194 #ifndef coff_SWAP_sym_out
5195 #define coff_SWAP_sym_out coff_swap_sym_out
5197 #ifndef coff_SWAP_lineno_out
5198 #define coff_SWAP_lineno_out coff_swap_lineno_out
5200 #ifndef coff_SWAP_reloc_out
5201 #define coff_SWAP_reloc_out coff_swap_reloc_out
5203 #ifndef coff_SWAP_filehdr_out
5204 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5206 #ifndef coff_SWAP_aouthdr_out
5207 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5209 #ifndef coff_SWAP_scnhdr_out
5210 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5212 #ifndef coff_SWAP_reloc_in
5213 #define coff_SWAP_reloc_in coff_swap_reloc_in
5215 #ifndef coff_SWAP_filehdr_in
5216 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5218 #ifndef coff_SWAP_aouthdr_in
5219 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5221 #ifndef coff_SWAP_scnhdr_in
5222 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5225 static const bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED =
5227 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5228 coff_SWAP_aux_out, coff_SWAP_sym_out,
5229 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5230 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5231 coff_SWAP_scnhdr_out,
5232 FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
5233 #ifdef COFF_LONG_FILENAMES
5238 #ifdef COFF_LONG_SECTION_NAMES
5243 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5244 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5249 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5254 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5255 coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
5256 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5257 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5258 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5259 coff_classify_symbol, coff_compute_section_file_positions,
5260 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5261 coff_adjust_symndx, coff_link_add_one_symbol,
5262 coff_link_output_has_begun, coff_final_link_postscript
5266 /* COFF0 differs in file/section header size and relocation entry size. */
5268 static const bfd_coff_backend_data ticoff0_swap_table =
5270 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5271 coff_SWAP_aux_out, coff_SWAP_sym_out,
5272 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5273 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5274 coff_SWAP_scnhdr_out,
5275 FILHSZ_V0, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ_V0, LINESZ, FILNMLEN,
5276 #ifdef COFF_LONG_FILENAMES
5281 #ifdef COFF_LONG_SECTION_NAMES
5286 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5287 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5292 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5297 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5298 coff_SWAP_reloc_in, ticoff0_bad_format_hook, coff_set_arch_mach_hook,
5299 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5300 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5301 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5302 coff_classify_symbol, coff_compute_section_file_positions,
5303 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5304 coff_adjust_symndx, coff_link_add_one_symbol,
5305 coff_link_output_has_begun, coff_final_link_postscript
5310 /* COFF1 differs in section header size. */
5312 static const bfd_coff_backend_data ticoff1_swap_table =
5314 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5315 coff_SWAP_aux_out, coff_SWAP_sym_out,
5316 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5317 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5318 coff_SWAP_scnhdr_out,
5319 FILHSZ, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
5320 #ifdef COFF_LONG_FILENAMES
5325 #ifdef COFF_LONG_SECTION_NAMES
5330 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5331 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5336 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5341 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5342 coff_SWAP_reloc_in, ticoff1_bad_format_hook, coff_set_arch_mach_hook,
5343 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5344 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5345 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5346 coff_classify_symbol, coff_compute_section_file_positions,
5347 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5348 coff_adjust_symndx, coff_link_add_one_symbol,
5349 coff_link_output_has_begun, coff_final_link_postscript
5353 #ifndef coff_close_and_cleanup
5354 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5357 #ifndef coff_bfd_free_cached_info
5358 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5361 #ifndef coff_get_section_contents
5362 #define coff_get_section_contents _bfd_generic_get_section_contents
5365 #ifndef coff_bfd_copy_private_symbol_data
5366 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5369 #ifndef coff_bfd_copy_private_header_data
5370 #define coff_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
5373 #ifndef coff_bfd_copy_private_section_data
5374 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5377 #ifndef coff_bfd_copy_private_bfd_data
5378 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5381 #ifndef coff_bfd_merge_private_bfd_data
5382 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5385 #ifndef coff_bfd_set_private_flags
5386 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5389 #ifndef coff_bfd_print_private_bfd_data
5390 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5393 #ifndef coff_bfd_is_local_label_name
5394 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5397 #ifndef coff_bfd_is_target_special_symbol
5398 #define coff_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
5401 #ifndef coff_read_minisymbols
5402 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5405 #ifndef coff_minisymbol_to_symbol
5406 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5409 /* The reloc lookup routine must be supplied by each individual COFF
5411 #ifndef coff_bfd_reloc_type_lookup
5412 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5414 #ifndef coff_bfd_reloc_name_lookup
5415 #define coff_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5418 #ifndef coff_bfd_get_relocated_section_contents
5419 #define coff_bfd_get_relocated_section_contents \
5420 bfd_generic_get_relocated_section_contents
5423 #ifndef coff_bfd_relax_section
5424 #define coff_bfd_relax_section bfd_generic_relax_section
5427 #ifndef coff_bfd_gc_sections
5428 #define coff_bfd_gc_sections bfd_generic_gc_sections
5431 #ifndef coff_bfd_merge_sections
5432 #define coff_bfd_merge_sections bfd_generic_merge_sections
5435 #ifndef coff_bfd_is_group_section
5436 #define coff_bfd_is_group_section bfd_generic_is_group_section
5439 #ifndef coff_bfd_discard_group
5440 #define coff_bfd_discard_group bfd_generic_discard_group
5443 #ifndef coff_section_already_linked
5444 #define coff_section_already_linked \
5445 _bfd_generic_section_already_linked
5448 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5449 const bfd_target VAR = \
5452 bfd_target_coff_flavour, \
5453 BFD_ENDIAN_BIG, /* Data byte order is big. */ \
5454 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5455 /* object flags */ \
5456 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5457 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5458 /* section flags */ \
5459 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5460 UNDER, /* Leading symbol underscore. */ \
5461 '/', /* AR_pad_char. */ \
5462 15, /* AR_max_namelen. */ \
5464 /* Data conversion functions. */ \
5465 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5466 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5467 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5469 /* Header conversion functions. */ \
5470 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5471 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5472 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5474 /* bfd_check_format. */ \
5475 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5476 _bfd_dummy_target }, \
5477 /* bfd_set_format. */ \
5478 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5479 /* bfd_write_contents. */ \
5480 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5483 BFD_JUMP_TABLE_GENERIC (coff), \
5484 BFD_JUMP_TABLE_COPY (coff), \
5485 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5486 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5487 BFD_JUMP_TABLE_SYMBOLS (coff), \
5488 BFD_JUMP_TABLE_RELOCS (coff), \
5489 BFD_JUMP_TABLE_WRITE (coff), \
5490 BFD_JUMP_TABLE_LINK (coff), \
5491 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5498 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5499 const bfd_target VAR = \
5502 bfd_target_coff_flavour, \
5503 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5504 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5505 /* object flags */ \
5506 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5507 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5508 /* section flags */ \
5509 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5510 UNDER, /* Leading symbol underscore. */ \
5511 '/', /* AR_pad_char. */ \
5512 15, /* AR_max_namelen. */ \
5514 /* Data conversion functions. */ \
5515 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5516 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5517 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5519 /* Header conversion functions. */ \
5520 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5521 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5522 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5524 /* bfd_check_format. */ \
5525 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5526 _bfd_dummy_target }, \
5527 /* bfd_set_format. */ \
5528 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5529 /* bfd_write_contents. */ \
5530 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5533 BFD_JUMP_TABLE_GENERIC (coff), \
5534 BFD_JUMP_TABLE_COPY (coff), \
5535 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5536 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5537 BFD_JUMP_TABLE_SYMBOLS (coff), \
5538 BFD_JUMP_TABLE_RELOCS (coff), \
5539 BFD_JUMP_TABLE_WRITE (coff), \
5540 BFD_JUMP_TABLE_LINK (coff), \
5541 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5548 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5549 const bfd_target VAR = \
5552 bfd_target_coff_flavour, \
5553 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5554 BFD_ENDIAN_LITTLE, /* Header byte order is little. */ \
5555 /* object flags */ \
5556 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5557 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5558 /* section flags */ \
5559 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5560 UNDER, /* Leading symbol underscore. */ \
5561 '/', /* AR_pad_char. */ \
5562 15, /* AR_max_namelen. */ \
5564 /* Data conversion functions. */ \
5565 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5566 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5567 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5568 /* Header conversion functions. */ \
5569 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5570 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5571 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5572 /* bfd_check_format. */ \
5573 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5574 _bfd_dummy_target }, \
5575 /* bfd_set_format. */ \
5576 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5577 /* bfd_write_contents. */ \
5578 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5581 BFD_JUMP_TABLE_GENERIC (coff), \
5582 BFD_JUMP_TABLE_COPY (coff), \
5583 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5584 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5585 BFD_JUMP_TABLE_SYMBOLS (coff), \
5586 BFD_JUMP_TABLE_RELOCS (coff), \
5587 BFD_JUMP_TABLE_WRITE (coff), \
5588 BFD_JUMP_TABLE_LINK (coff), \
5589 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \